refactor: convert ops to use serde_v8 (#10009)

This commit rewrites most of the ops to use "serde_v8" instead
of "json" serialization.

13 files changed, 255 insertions, 285 deletions

diff --git a/op_crates/webgpu/binding.rs b/op_crates/webgpu/binding.rs
index 296a968f1..fd4e75784 100644
--- a/op_crates/webgpu/binding.rs
+++ b/op_crates/webgpu/binding.rs
@@ -2,15 +2,13 @@
 
 use deno_core::error::bad_resource_id;
 use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use deno_core::{OpState, Resource};
 use serde::Deserialize;
 use std::borrow::Cow;
 
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
 
 pub(crate) struct WebGpuBindGroupLayout(
   pub(crate) wgpu_core::id::BindGroupLayoutId,
@@ -83,7 +81,7 @@ pub fn op_webgpu_create_bind_group_layout(
   state: &mut OpState,
   args: CreateBindGroupLayoutArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
@@ -207,10 +205,7 @@ pub fn op_webgpu_create_bind_group_layout(
     .resource_table
     .add(WebGpuBindGroupLayout(bind_group_layout));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from)
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -225,7 +220,7 @@ pub fn op_webgpu_create_pipeline_layout(
   state: &mut OpState,
   args: CreatePipelineLayoutArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
@@ -259,10 +254,7 @@ pub fn op_webgpu_create_pipeline_layout(
     .resource_table
     .add(super::pipeline::WebGpuPipelineLayout(pipeline_layout));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from)
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -288,7 +280,7 @@ pub fn op_webgpu_create_bind_group(
   state: &mut OpState,
   args: CreateBindGroupArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
@@ -356,8 +348,5 @@ pub fn op_webgpu_create_bind_group(
 
   let rid = state.resource_table.add(WebGpuBindGroup(bind_group));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from)
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
diff --git a/op_crates/webgpu/buffer.rs b/op_crates/webgpu/buffer.rs
index ade4122d5..19fc428cb 100644
--- a/op_crates/webgpu/buffer.rs
+++ b/op_crates/webgpu/buffer.rs
@@ -4,8 +4,6 @@ use deno_core::error::bad_resource_id;
 use deno_core::error::null_opbuf;
 use deno_core::error::AnyError;
 use deno_core::futures::channel::oneshot;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
 use deno_core::OpState;
 use deno_core::Resource;
 use deno_core::ResourceId;
@@ -17,7 +15,7 @@ use std::rc::Rc;
 use std::time::Duration;
 
 use super::error::DomExceptionOperationError;
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
 
 pub(crate) struct WebGpuBuffer(pub(crate) wgpu_core::id::BufferId);
 impl Resource for WebGpuBuffer {
@@ -47,7 +45,7 @@ pub fn op_webgpu_create_buffer(
   state: &mut OpState,
   args: CreateBufferArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
@@ -70,10 +68,7 @@ pub fn op_webgpu_create_buffer(
 
   let rid = state.resource_table.add(WebGpuBuffer(buffer));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from)
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -90,7 +85,7 @@ pub async fn op_webgpu_buffer_get_map_async(
   state: Rc<RefCell<OpState>>,
   args: BufferGetMapAsyncArgs,
   _bufs: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let (sender, receiver) = oneshot::channel::<Result<(), AnyError>>();
 
   let device;
@@ -164,7 +159,7 @@ pub async fn op_webgpu_buffer_get_map_async(
 
   tokio::try_join!(device_poll_fut, receiver_fut)?;
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -179,7 +174,7 @@ pub fn op_webgpu_buffer_get_mapped_range(
   state: &mut OpState,
   args: BufferGetMappedRangeArgs,
   zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let mut zero_copy = zero_copy.ok_or_else(null_opbuf)?;
   let instance = state.borrow::<super::Instance>();
   let buffer_resource = state
@@ -204,9 +199,7 @@ pub fn op_webgpu_buffer_get_mapped_range(
     .resource_table
     .add(WebGpuBufferMapped(slice_pointer, args.size as usize));
 
-  Ok(json!({
-    "rid": rid,
-  }))
+  Ok(WebGpuResult::rid(rid))
 }
 
 #[derive(Deserialize)]
@@ -220,7 +213,7 @@ pub fn op_webgpu_buffer_unmap(
   state: &mut OpState,
   args: BufferUnmapArgs,
   zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let mapped_resource = state
     .resource_table
     .take::<WebGpuBufferMapped>(args.mapped_rid)
@@ -242,5 +235,5 @@ pub fn op_webgpu_buffer_unmap(
 
   let maybe_err = gfx_select!(buffer => instance.buffer_unmap(buffer)).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
diff --git a/op_crates/webgpu/bundle.rs b/op_crates/webgpu/bundle.rs
index 58915b108..72abb18e6 100644
--- a/op_crates/webgpu/bundle.rs
+++ b/op_crates/webgpu/bundle.rs
@@ -3,8 +3,6 @@
 use deno_core::error::bad_resource_id;
 use deno_core::error::null_opbuf;
 use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use deno_core::{OpState, Resource};
@@ -13,7 +11,7 @@ use std::borrow::Cow;
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
 use super::texture::serialize_texture_format;
 
 struct WebGpuRenderBundleEncoder(
@@ -46,7 +44,7 @@ pub fn op_webgpu_create_render_bundle_encoder(
   state: &mut OpState,
   args: CreateRenderBundleEncoderArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let device_resource = state
     .resource_table
     .get::<super::WebGpuDevice>(args.device_rid)
@@ -85,10 +83,7 @@ pub fn op_webgpu_create_render_bundle_encoder(
       render_bundle_encoder,
     )));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from),
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -102,7 +97,7 @@ pub fn op_webgpu_render_bundle_encoder_finish(
   state: &mut OpState,
   args: RenderBundleEncoderFinishArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_bundle_encoder_resource = state
     .resource_table
     .take::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
@@ -124,10 +119,7 @@ pub fn op_webgpu_render_bundle_encoder_finish(
 
   let rid = state.resource_table.add(WebGpuRenderBundle(render_bundle));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from)
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -145,7 +137,7 @@ pub fn op_webgpu_render_bundle_encoder_set_bind_group(
   state: &mut OpState,
   args: RenderBundleEncoderSetBindGroupArgs,
   zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let zero_copy = zero_copy.ok_or_else(null_opbuf)?;
 
   let bind_group_resource = state
@@ -188,7 +180,7 @@ pub fn op_webgpu_render_bundle_encoder_set_bind_group(
     }
   };
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -202,7 +194,7 @@ pub fn op_webgpu_render_bundle_encoder_push_debug_group(
   state: &mut OpState,
   args: RenderBundleEncoderPushDebugGroupArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_bundle_encoder_resource = state
     .resource_table
     .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
@@ -216,7 +208,7 @@ pub fn op_webgpu_render_bundle_encoder_push_debug_group(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -229,7 +221,7 @@ pub fn op_webgpu_render_bundle_encoder_pop_debug_group(
   state: &mut OpState,
   args: RenderBundleEncoderPopDebugGroupArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_bundle_encoder_resource = state
     .resource_table
     .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
@@ -241,7 +233,7 @@ pub fn op_webgpu_render_bundle_encoder_pop_debug_group(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -255,7 +247,7 @@ pub fn op_webgpu_render_bundle_encoder_insert_debug_marker(
   state: &mut OpState,
   args: RenderBundleEncoderInsertDebugMarkerArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_bundle_encoder_resource = state
     .resource_table
     .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
@@ -269,7 +261,7 @@ pub fn op_webgpu_render_bundle_encoder_insert_debug_marker(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -283,7 +275,7 @@ pub fn op_webgpu_render_bundle_encoder_set_pipeline(
   state: &mut OpState,
   args: RenderBundleEncoderSetPipelineArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pipeline_resource = state
     .resource_table
     .get::<super::pipeline::WebGpuRenderPipeline>(args.pipeline)
@@ -298,7 +290,7 @@ pub fn op_webgpu_render_bundle_encoder_set_pipeline(
     render_pipeline_resource.0,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -315,7 +307,7 @@ pub fn op_webgpu_render_bundle_encoder_set_index_buffer(
   state: &mut OpState,
   args: RenderBundleEncoderSetIndexBufferArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let buffer_resource = state
     .resource_table
     .get::<super::buffer::WebGpuBuffer>(args.buffer)
@@ -335,7 +327,7 @@ pub fn op_webgpu_render_bundle_encoder_set_index_buffer(
       std::num::NonZeroU64::new(args.size),
     );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -352,7 +344,7 @@ pub fn op_webgpu_render_bundle_encoder_set_vertex_buffer(
   state: &mut OpState,
   args: RenderBundleEncoderSetVertexBufferArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let buffer_resource = state
     .resource_table
     .get::<super::buffer::WebGpuBuffer>(args.buffer)
@@ -370,7 +362,7 @@ pub fn op_webgpu_render_bundle_encoder_set_vertex_buffer(
     std::num::NonZeroU64::new(args.size),
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -387,7 +379,7 @@ pub fn op_webgpu_render_bundle_encoder_draw(
   state: &mut OpState,
   args: RenderBundleEncoderDrawArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_bundle_encoder_resource = state
     .resource_table
     .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
@@ -401,7 +393,7 @@ pub fn op_webgpu_render_bundle_encoder_draw(
     args.first_instance,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -419,7 +411,7 @@ pub fn op_webgpu_render_bundle_encoder_draw_indexed(
   state: &mut OpState,
   args: RenderBundleEncoderDrawIndexedArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_bundle_encoder_resource = state
     .resource_table
     .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
@@ -434,7 +426,7 @@ pub fn op_webgpu_render_bundle_encoder_draw_indexed(
     args.first_instance,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -449,7 +441,7 @@ pub fn op_webgpu_render_bundle_encoder_draw_indirect(
   state: &mut OpState,
   args: RenderBundleEncoderDrawIndirectArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let buffer_resource = state
     .resource_table
     .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)
@@ -465,5 +457,5 @@ pub fn op_webgpu_render_bundle_encoder_draw_indirect(
     args.indirect_offset,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
diff --git a/op_crates/webgpu/command_encoder.rs b/op_crates/webgpu/command_encoder.rs
index 801682f56..724ce72c4 100644
--- a/op_crates/webgpu/command_encoder.rs
+++ b/op_crates/webgpu/command_encoder.rs
@@ -2,8 +2,6 @@
 
 use deno_core::error::bad_resource_id;
 use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use deno_core::{OpState, Resource};
@@ -11,7 +9,7 @@ use serde::Deserialize;
 use std::borrow::Cow;
 use std::cell::RefCell;
 
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
 
 pub(crate) struct WebGpuCommandEncoder(
   pub(crate) wgpu_core::id::CommandEncoderId,
@@ -51,7 +49,7 @@ pub fn op_webgpu_create_command_encoder(
   state: &mut OpState,
   args: CreateCommandEncoderArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
@@ -73,10 +71,7 @@ pub fn op_webgpu_create_command_encoder(
     .resource_table
     .add(WebGpuCommandEncoder(command_encoder));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from),
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -117,7 +112,7 @@ pub fn op_webgpu_command_encoder_begin_render_pass(
   state: &mut OpState,
   args: CommandEncoderBeginRenderPassArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let command_encoder_resource = state
     .resource_table
     .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
@@ -236,9 +231,7 @@ pub fn op_webgpu_command_encoder_begin_render_pass(
       render_pass,
     )));
 
-  Ok(json!({
-    "rid": rid,
-  }))
+  Ok(WebGpuResult::rid(rid))
 }
 
 #[derive(Deserialize)]
@@ -252,7 +245,7 @@ pub fn op_webgpu_command_encoder_begin_compute_pass(
   state: &mut OpState,
   args: CommandEncoderBeginComputePassArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let command_encoder_resource = state
     .resource_table
     .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
@@ -273,9 +266,7 @@ pub fn op_webgpu_command_encoder_begin_compute_pass(
       compute_pass,
     )));
 
-  Ok(json!({
-    "rid": rid,
-  }))
+  Ok(WebGpuResult::rid(rid))
 }
 
 #[derive(Deserialize)]
@@ -293,7 +284,7 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_buffer(
   state: &mut OpState,
   args: CommandEncoderCopyBufferToBufferArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
@@ -320,7 +311,7 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_buffer(
     args.size
   )).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -362,7 +353,7 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_texture(
   state: &mut OpState,
   args: CommandEncoderCopyBufferToTextureArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
@@ -409,7 +400,7 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_texture(
     }
   )).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -425,7 +416,7 @@ pub fn op_webgpu_command_encoder_copy_texture_to_buffer(
   state: &mut OpState,
   args: CommandEncoderCopyTextureToBufferArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
@@ -471,7 +462,7 @@ pub fn op_webgpu_command_encoder_copy_texture_to_buffer(
     }
   )).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -487,7 +478,7 @@ pub fn op_webgpu_command_encoder_copy_texture_to_texture(
   state: &mut OpState,
   args: CommandEncoderCopyTextureToTextureArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
@@ -537,7 +528,7 @@ pub fn op_webgpu_command_encoder_copy_texture_to_texture(
     }
   )).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -551,7 +542,7 @@ pub fn op_webgpu_command_encoder_push_debug_group(
   state: &mut OpState,
   args: CommandEncoderPushDebugGroupArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
@@ -563,7 +554,7 @@ pub fn op_webgpu_command_encoder_push_debug_group(
     .command_encoder_push_debug_group(command_encoder, &args.group_label))
   .err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -576,7 +567,7 @@ pub fn op_webgpu_command_encoder_pop_debug_group(
   state: &mut OpState,
   args: CommandEncoderPopDebugGroupArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
@@ -586,7 +577,7 @@ pub fn op_webgpu_command_encoder_pop_debug_group(
 
   let maybe_err =  gfx_select!(command_encoder => instance.command_encoder_pop_debug_group(command_encoder)).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -600,7 +591,7 @@ pub fn op_webgpu_command_encoder_insert_debug_marker(
   state: &mut OpState,
   args: CommandEncoderInsertDebugMarkerArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
@@ -613,7 +604,7 @@ pub fn op_webgpu_command_encoder_insert_debug_marker(
     &args.marker_label
   )).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -628,7 +619,7 @@ pub fn op_webgpu_command_encoder_write_timestamp(
   state: &mut OpState,
   args: CommandEncoderWriteTimestampArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
@@ -648,7 +639,7 @@ pub fn op_webgpu_command_encoder_write_timestamp(
     ))
     .err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -666,7 +657,7 @@ pub fn op_webgpu_command_encoder_resolve_query_set(
   state: &mut OpState,
   args: CommandEncoderResolveQuerySetArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
@@ -693,7 +684,7 @@ pub fn op_webgpu_command_encoder_resolve_query_set(
     ))
     .err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -707,7 +698,7 @@ pub fn op_webgpu_command_encoder_finish(
   state: &mut OpState,
   args: CommandEncoderFinishArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let command_encoder_resource = state
     .resource_table
     .take::<WebGpuCommandEncoder>(args.command_encoder_rid)
@@ -728,8 +719,5 @@ pub fn op_webgpu_command_encoder_finish(
     .resource_table
     .add(WebGpuCommandBuffer(command_buffer));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from)
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
diff --git a/op_crates/webgpu/compute_pass.rs b/op_crates/webgpu/compute_pass.rs
index 2e1fb1ac1..e8ec642e9 100644
--- a/op_crates/webgpu/compute_pass.rs
+++ b/op_crates/webgpu/compute_pass.rs
@@ -3,8 +3,6 @@
 use deno_core::error::bad_resource_id;
 use deno_core::error::null_opbuf;
 use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use deno_core::{OpState, Resource};
@@ -12,7 +10,7 @@ use serde::Deserialize;
 use std::borrow::Cow;
 use std::cell::RefCell;
 
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
 
 pub(crate) struct WebGpuComputePass(
   pub(crate) RefCell<wgpu_core::command::ComputePass>,
@@ -34,7 +32,7 @@ pub fn op_webgpu_compute_pass_set_pipeline(
   state: &mut OpState,
   args: ComputePassSetPipelineArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let compute_pipeline_resource = state
     .resource_table
     .get::<super::pipeline::WebGpuComputePipeline>(args.pipeline)
@@ -49,7 +47,7 @@ pub fn op_webgpu_compute_pass_set_pipeline(
     compute_pipeline_resource.0,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -65,7 +63,7 @@ pub fn op_webgpu_compute_pass_dispatch(
   state: &mut OpState,
   args: ComputePassDispatchArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let compute_pass_resource = state
     .resource_table
     .get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -78,7 +76,7 @@ pub fn op_webgpu_compute_pass_dispatch(
     args.z,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -93,7 +91,7 @@ pub fn op_webgpu_compute_pass_dispatch_indirect(
   state: &mut OpState,
   args: ComputePassDispatchIndirectArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let buffer_resource = state
     .resource_table
     .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)
@@ -109,7 +107,7 @@ pub fn op_webgpu_compute_pass_dispatch_indirect(
     args.indirect_offset,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -124,7 +122,7 @@ pub fn op_webgpu_compute_pass_begin_pipeline_statistics_query(
   state: &mut OpState,
   args: ComputePassBeginPipelineStatisticsQueryArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let compute_pass_resource = state
     .resource_table
     .get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -142,7 +140,7 @@ pub fn op_webgpu_compute_pass_begin_pipeline_statistics_query(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -155,7 +153,7 @@ pub fn op_webgpu_compute_pass_end_pipeline_statistics_query(
   state: &mut OpState,
   args: ComputePassEndPipelineStatisticsQueryArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let compute_pass_resource = state
     .resource_table
     .get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -167,7 +165,7 @@ pub fn op_webgpu_compute_pass_end_pipeline_statistics_query(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -182,7 +180,7 @@ pub fn op_webgpu_compute_pass_write_timestamp(
   state: &mut OpState,
   args: ComputePassWriteTimestampArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let compute_pass_resource = state
     .resource_table
     .get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -200,7 +198,7 @@ pub fn op_webgpu_compute_pass_write_timestamp(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -214,7 +212,7 @@ pub fn op_webgpu_compute_pass_end_pass(
   state: &mut OpState,
   args: ComputePassEndPassArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let command_encoder_resource = state
     .resource_table
     .get::<super::command_encoder::WebGpuCommandEncoder>(
@@ -236,7 +234,7 @@ pub fn op_webgpu_compute_pass_end_pass(
     ))
     .err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -254,7 +252,7 @@ pub fn op_webgpu_compute_pass_set_bind_group(
   state: &mut OpState,
   args: ComputePassSetBindGroupArgs,
   zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let bind_group_resource = state
     .resource_table
     .get::<super::binding::WebGpuBindGroup>(args.bind_group)
@@ -283,7 +281,7 @@ pub fn op_webgpu_compute_pass_set_bind_group(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -297,7 +295,7 @@ pub fn op_webgpu_compute_pass_push_debug_group(
   state: &mut OpState,
   args: ComputePassPushDebugGroupArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let compute_pass_resource = state
     .resource_table
     .get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -312,7 +310,7 @@ pub fn op_webgpu_compute_pass_push_debug_group(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -325,7 +323,7 @@ pub fn op_webgpu_compute_pass_pop_debug_group(
   state: &mut OpState,
   args: ComputePassPopDebugGroupArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let compute_pass_resource = state
     .resource_table
     .get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -335,7 +333,7 @@ pub fn op_webgpu_compute_pass_pop_debug_group(
     &mut compute_pass_resource.0.borrow_mut(),
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -349,7 +347,7 @@ pub fn op_webgpu_compute_pass_insert_debug_marker(
   state: &mut OpState,
   args: ComputePassInsertDebugMarkerArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let compute_pass_resource = state
     .resource_table
     .get::<WebGpuComputePass>(args.compute_pass_rid)
@@ -364,5 +362,5 @@ pub fn op_webgpu_compute_pass_insert_debug_marker(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
diff --git a/op_crates/webgpu/error.rs b/op_crates/webgpu/error.rs
index 15036512e..57e2e675f 100644
--- a/op_crates/webgpu/error.rs
+++ b/op_crates/webgpu/error.rs
@@ -1,6 +1,8 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
 use deno_core::error::AnyError;
+use deno_core::ResourceId;
 use serde::Serialize;
+use std::convert::From;
 use std::fmt;
 use wgpu_core::binding_model::CreateBindGroupError;
 use wgpu_core::binding_model::CreateBindGroupLayoutError;
@@ -28,6 +30,45 @@ use wgpu_core::resource::CreateTextureError;
 use wgpu_core::resource::CreateTextureViewError;
 
 #[derive(Serialize)]
+pub struct WebGpuResult {
+  pub rid: Option<ResourceId>,
+  pub err: Option<WebGpuError>,
+}
+
+impl WebGpuResult {
+  pub fn rid(rid: ResourceId) -> Self {
+    Self {
+      rid: Some(rid),
+      err: None,
+    }
+  }
+
+  pub fn rid_err<T: Into<WebGpuError>>(
+    rid: ResourceId,
+    err: Option<T>,
+  ) -> Self {
+    Self {
+      rid: Some(rid),
+      err: err.map(|e| e.into()),
+    }
+  }
+
+  pub fn maybe_err<T: Into<WebGpuError>>(err: Option<T>) -> Self {
+    Self {
+      rid: None,
+      err: err.map(|e| e.into()),
+    }
+  }
+
+  pub fn empty() -> Self {
+    Self {
+      rid: None,
+      err: None,
+    }
+  }
+}
+
+#[derive(Serialize)]
 #[serde(tag = "type", content = "value")]
 #[serde(rename_all = "kebab-case")]
 pub enum WebGpuError {
diff --git a/op_crates/webgpu/lib.rs b/op_crates/webgpu/lib.rs
index b1c8a631d..0dd18ca8e 100644
--- a/op_crates/webgpu/lib.rs
+++ b/op_crates/webgpu/lib.rs
@@ -4,13 +4,12 @@
 
 use deno_core::error::AnyError;
 use deno_core::error::{bad_resource_id, not_supported};
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
 use deno_core::OpState;
 use deno_core::Resource;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use serde::Deserialize;
+use serde::Serialize;
 use std::borrow::Cow;
 use std::cell::RefCell;
 use std::path::PathBuf;
@@ -19,7 +18,7 @@ pub use wgpu_core;
 pub use wgpu_types;
 
 use error::DomExceptionOperationError;
-use error::WebGpuError;
+use error::WebGpuResult;
 
 #[macro_use]
 mod macros {
@@ -113,8 +112,8 @@ pub fn get_declaration() -> PathBuf {
   PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_webgpu.d.ts")
 }
 
-fn deserialize_features(features: &wgpu_types::Features) -> Vec<&str> {
-  let mut return_features: Vec<&str> = vec![];
+fn deserialize_features(features: &wgpu_types::Features) -> Vec<&'static str> {
+  let mut return_features: Vec<&'static str> = vec![];
 
   if features.contains(wgpu_types::Features::DEPTH_CLAMPING) {
     return_features.push("depth-clamping");
@@ -191,11 +190,27 @@ pub struct RequestAdapterArgs {
   power_preference: Option<String>,
 }
 
+#[derive(Serialize)]
+#[serde(untagged)]
+pub enum GpuAdapterDeviceOrErr {
+  Error { err: String },
+  Features(GpuAdapterDevice),
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GpuAdapterDevice {
+  rid: ResourceId,
+  name: Option<String>,
+  limits: wgpu_types::Limits,
+  features: Vec<&'static str>,
+}
+
 pub async fn op_webgpu_request_adapter(
   state: Rc<RefCell<OpState>>,
   args: RequestAdapterArgs,
   _bufs: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<GpuAdapterDeviceOrErr, AnyError> {
   let mut state = state.borrow_mut();
   check_unstable(&state, "navigator.gpu.requestAdapter");
   let instance = if let Some(instance) = state.try_borrow::<Instance>() {
@@ -231,9 +246,9 @@ pub async fn op_webgpu_request_adapter(
   let adapter = match res {
     Ok(adapter) => adapter,
     Err(err) => {
-      return Ok(json!({
-        "err": err.to_string()
-      }))
+      return Ok(GpuAdapterDeviceOrErr::Error {
+        err: err.to_string(),
+      })
     }
   };
   let name = gfx_select!(adapter => instance.adapter_get_info(adapter))?.name;
@@ -243,25 +258,13 @@ pub async fn op_webgpu_request_adapter(
   let adapter_limits =
     gfx_select!(adapter => instance.adapter_limits(adapter))?;
 
-  let limits = json!({
-    "maxBindGroups": adapter_limits.max_bind_groups,
-    "maxDynamicUniformBuffersPerPipelineLayout": adapter_limits.max_dynamic_uniform_buffers_per_pipeline_layout,
-    "maxDynamicStorageBuffersPerPipelineLayout": adapter_limits.max_dynamic_storage_buffers_per_pipeline_layout,
-    "maxSampledTexturesPerShaderStage": adapter_limits.max_sampled_textures_per_shader_stage,
-    "maxSamplersPerShaderStage": adapter_limits.max_samplers_per_shader_stage,
-    "maxStorageBuffersPerShaderStage": adapter_limits.max_storage_buffers_per_shader_stage,
-    "maxStorageTexturesPerShaderStage": adapter_limits.max_storage_textures_per_shader_stage,
-    "maxUniformBuffersPerShaderStage": adapter_limits.max_uniform_buffers_per_shader_stage,
-    "maxUniformBufferBindingSize": adapter_limits.max_uniform_buffer_binding_size
-  });
-
   let rid = state.resource_table.add(WebGpuAdapter(adapter));
 
-  Ok(json!({
-    "rid": rid,
-    "name": name,
-    "features": features,
-    "limits": limits
+  Ok(GpuAdapterDeviceOrErr::Features(GpuAdapterDevice {
+    rid,
+    name: Some(name),
+    features,
+    limits: adapter_limits,
   }))
 }
 
@@ -300,7 +303,7 @@ pub async fn op_webgpu_request_device(
   state: Rc<RefCell<OpState>>,
   args: RequestDeviceArgs,
   _bufs: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<GpuAdapterDevice, AnyError> {
   let mut state = state.borrow_mut();
   let adapter_resource = state
     .resource_table
@@ -437,25 +440,15 @@ pub async fn op_webgpu_request_device(
     gfx_select!(device => instance.device_features(device))?;
   let features = deserialize_features(&device_features);
   let limits = gfx_select!(device => instance.device_limits(device))?;
-  let json_limits = json!({
-     "maxBindGroups": limits.max_bind_groups,
-     "maxDynamicUniformBuffersPerPipelineLayout": limits.max_dynamic_uniform_buffers_per_pipeline_layout,
-     "maxDynamicStorageBuffersPerPipelineLayout": limits.max_dynamic_storage_buffers_per_pipeline_layout,
-     "maxSampledTexturesPerShaderStage": limits.max_sampled_textures_per_shader_stage,
-     "maxSamplersPerShaderStage": limits.max_samplers_per_shader_stage,
-     "maxStorageBuffersPerShaderStage": limits.max_storage_buffers_per_shader_stage,
-     "maxStorageTexturesPerShaderStage": limits.max_storage_textures_per_shader_stage,
-     "maxUniformBuffersPerShaderStage": limits.max_uniform_buffers_per_shader_stage,
-     "maxUniformBufferBindingSize": limits.max_uniform_buffer_binding_size,
-  });
 
   let rid = state.resource_table.add(WebGpuDevice(device));
 
-  Ok(json!({
-    "rid": rid,
-    "features": features,
-    "limits": json_limits,
-  }))
+  Ok(GpuAdapterDevice {
+    rid,
+    name: None,
+    features,
+    limits,
+  })
 }
 
 #[derive(Deserialize)]
@@ -473,7 +466,7 @@ pub fn op_webgpu_create_query_set(
   state: &mut OpState,
   args: CreateQuerySetArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let device_resource = state
     .resource_table
     .get::<WebGpuDevice>(args.device_rid)
@@ -544,8 +537,5 @@ pub fn op_webgpu_create_query_set(
 
   let rid = state.resource_table.add(WebGpuQuerySet(query_set));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from),
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
diff --git a/op_crates/webgpu/pipeline.rs b/op_crates/webgpu/pipeline.rs
index 10e300a57..8eb291b97 100644
--- a/op_crates/webgpu/pipeline.rs
+++ b/op_crates/webgpu/pipeline.rs
@@ -2,15 +2,14 @@
 
 use deno_core::error::bad_resource_id;
 use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use deno_core::{OpState, Resource};
 use serde::Deserialize;
+use serde::Serialize;
 use std::borrow::Cow;
 
-use super::error::WebGpuError;
+use super::error::{WebGpuError, WebGpuResult};
 
 pub(crate) struct WebGpuPipelineLayout(
   pub(crate) wgpu_core::id::PipelineLayoutId,
@@ -163,7 +162,7 @@ pub fn op_webgpu_create_compute_pipeline(
   state: &mut OpState,
   args: CreateComputePipelineArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
@@ -213,10 +212,7 @@ pub fn op_webgpu_create_compute_pipeline(
     .resource_table
     .add(WebGpuComputePipeline(compute_pipeline));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from),
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -226,11 +222,19 @@ pub struct ComputePipelineGetBindGroupLayoutArgs {
   index: u32,
 }
 
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PipelineLayout {
+  rid: ResourceId,
+  label: String,
+  err: Option<WebGpuError>,
+}
+
 pub fn op_webgpu_compute_pipeline_get_bind_group_layout(
   state: &mut OpState,
   args: ComputePipelineGetBindGroupLayoutArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<PipelineLayout, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let compute_pipeline_resource = state
     .resource_table
@@ -246,11 +250,11 @@ pub fn op_webgpu_compute_pipeline_get_bind_group_layout(
     .resource_table
     .add(super::binding::WebGpuBindGroupLayout(bind_group_layout));
 
-  Ok(json!({
-    "rid": rid,
-    "label": label,
-    "err": maybe_err.map(WebGpuError::from)
-  }))
+  Ok(PipelineLayout {
+    rid,
+    label,
+    err: maybe_err.map(WebGpuError::from),
+  })
 }
 
 #[derive(Deserialize)]
@@ -367,7 +371,7 @@ pub fn op_webgpu_create_render_pipeline(
   state: &mut OpState,
   args: CreateRenderPipelineArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
@@ -601,10 +605,7 @@ pub fn op_webgpu_create_render_pipeline(
     .resource_table
     .add(WebGpuRenderPipeline(render_pipeline));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from)
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -618,7 +619,7 @@ pub fn op_webgpu_render_pipeline_get_bind_group_layout(
   state: &mut OpState,
   args: RenderPipelineGetBindGroupLayoutArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<PipelineLayout, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let render_pipeline_resource = state
     .resource_table
@@ -634,9 +635,9 @@ pub fn op_webgpu_render_pipeline_get_bind_group_layout(
     .resource_table
     .add(super::binding::WebGpuBindGroupLayout(bind_group_layout));
 
-  Ok(json!({
-    "rid": rid,
-    "label": label,
-    "err": maybe_err.map(WebGpuError::from),
-  }))
+  Ok(PipelineLayout {
+    rid,
+    label,
+    err: maybe_err.map(WebGpuError::from),
+  })
 }
diff --git a/op_crates/webgpu/queue.rs b/op_crates/webgpu/queue.rs
index c96e2a158..93fd95502 100644
--- a/op_crates/webgpu/queue.rs
+++ b/op_crates/webgpu/queue.rs
@@ -3,14 +3,12 @@
 use deno_core::error::bad_resource_id;
 use deno_core::error::null_opbuf;
 use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
 use deno_core::OpState;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use serde::Deserialize;
 
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
 
 type WebGpuQueue = super::WebGpuDevice;
 
@@ -25,7 +23,7 @@ pub fn op_webgpu_queue_submit(
   state: &mut OpState,
   args: QueueSubmitArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let queue_resource = state
     .resource_table
@@ -46,7 +44,7 @@ pub fn op_webgpu_queue_submit(
   let maybe_err =
     gfx_select!(queue => instance.queue_submit(queue, &ids)).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -71,7 +69,7 @@ pub fn op_webgpu_write_buffer(
   state: &mut OpState,
   args: QueueWriteBufferArgs,
   zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let zero_copy = zero_copy.ok_or_else(null_opbuf)?;
   let instance = state.borrow::<super::Instance>();
   let buffer_resource = state
@@ -97,7 +95,7 @@ pub fn op_webgpu_write_buffer(
   ))
   .err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -113,7 +111,7 @@ pub fn op_webgpu_write_texture(
   state: &mut OpState,
   args: QueueWriteTextureArgs,
   zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let zero_copy = zero_copy.ok_or_else(null_opbuf)?;
   let instance = state.borrow::<super::Instance>();
   let texture_resource = state
@@ -157,5 +155,5 @@ pub fn op_webgpu_write_texture(
   ))
   .err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
diff --git a/op_crates/webgpu/render_pass.rs b/op_crates/webgpu/render_pass.rs
index bf3bd092d..38ebd6db8 100644
--- a/op_crates/webgpu/render_pass.rs
+++ b/op_crates/webgpu/render_pass.rs
@@ -3,8 +3,6 @@
 use deno_core::error::bad_resource_id;
 use deno_core::error::null_opbuf;
 use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use deno_core::{OpState, Resource};
@@ -12,7 +10,7 @@ use serde::Deserialize;
 use std::borrow::Cow;
 use std::cell::RefCell;
 
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
 
 pub(crate) struct WebGpuRenderPass(
   pub(crate) RefCell<wgpu_core::command::RenderPass>,
@@ -39,7 +37,7 @@ pub fn op_webgpu_render_pass_set_viewport(
   state: &mut OpState,
   args: RenderPassSetViewportArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pass_resource = state
     .resource_table
     .get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -55,7 +53,7 @@ pub fn op_webgpu_render_pass_set_viewport(
     args.max_depth,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -72,7 +70,7 @@ pub fn op_webgpu_render_pass_set_scissor_rect(
   state: &mut OpState,
   args: RenderPassSetScissorRectArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pass_resource = state
     .resource_table
     .get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -86,7 +84,7 @@ pub fn op_webgpu_render_pass_set_scissor_rect(
     args.height,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -109,7 +107,7 @@ pub fn op_webgpu_render_pass_set_blend_color(
   state: &mut OpState,
   args: RenderPassSetBlendColorArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pass_resource = state
     .resource_table
     .get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -125,7 +123,7 @@ pub fn op_webgpu_render_pass_set_blend_color(
     },
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -139,7 +137,7 @@ pub fn op_webgpu_render_pass_set_stencil_reference(
   state: &mut OpState,
   args: RenderPassSetStencilReferenceArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pass_resource = state
     .resource_table
     .get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -150,7 +148,7 @@ pub fn op_webgpu_render_pass_set_stencil_reference(
     args.reference,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -165,7 +163,7 @@ pub fn op_webgpu_render_pass_begin_pipeline_statistics_query(
   state: &mut OpState,
   args: RenderPassBeginPipelineStatisticsQueryArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pass_resource = state
     .resource_table
     .get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -183,7 +181,7 @@ pub fn op_webgpu_render_pass_begin_pipeline_statistics_query(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -196,7 +194,7 @@ pub fn op_webgpu_render_pass_end_pipeline_statistics_query(
   state: &mut OpState,
   args: RenderPassEndPipelineStatisticsQueryArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pass_resource = state
     .resource_table
     .get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -208,7 +206,7 @@ pub fn op_webgpu_render_pass_end_pipeline_statistics_query(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -223,7 +221,7 @@ pub fn op_webgpu_render_pass_write_timestamp(
   state: &mut OpState,
   args: RenderPassWriteTimestampArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pass_resource = state
     .resource_table
     .get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -241,7 +239,7 @@ pub fn op_webgpu_render_pass_write_timestamp(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -255,7 +253,7 @@ pub fn op_webgpu_render_pass_execute_bundles(
   state: &mut OpState,
   args: RenderPassExecuteBundlesArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let mut render_bundle_ids = vec![];
 
   for rid in &args.bundles {
@@ -279,7 +277,7 @@ pub fn op_webgpu_render_pass_execute_bundles(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -293,7 +291,7 @@ pub fn op_webgpu_render_pass_end_pass(
   state: &mut OpState,
   args: RenderPassEndPassArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let command_encoder_resource = state
     .resource_table
     .get::<super::command_encoder::WebGpuCommandEncoder>(
@@ -310,7 +308,7 @@ pub fn op_webgpu_render_pass_end_pass(
 
   let maybe_err =  gfx_select!(command_encoder => instance.command_encoder_run_render_pass(command_encoder, render_pass)).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
+  Ok(WebGpuResult::maybe_err(maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -328,7 +326,7 @@ pub fn op_webgpu_render_pass_set_bind_group(
   state: &mut OpState,
   args: RenderPassSetBindGroupArgs,
   zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let zero_copy = zero_copy.ok_or_else(null_opbuf)?;
   let bind_group_resource = state
     .resource_table
@@ -370,7 +368,7 @@ pub fn op_webgpu_render_pass_set_bind_group(
     }
   };
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -384,7 +382,7 @@ pub fn op_webgpu_render_pass_push_debug_group(
   state: &mut OpState,
   args: RenderPassPushDebugGroupArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pass_resource = state
     .resource_table
     .get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -399,7 +397,7 @@ pub fn op_webgpu_render_pass_push_debug_group(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -412,7 +410,7 @@ pub fn op_webgpu_render_pass_pop_debug_group(
   state: &mut OpState,
   args: RenderPassPopDebugGroupArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pass_resource = state
     .resource_table
     .get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -422,7 +420,7 @@ pub fn op_webgpu_render_pass_pop_debug_group(
     &mut render_pass_resource.0.borrow_mut(),
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -436,7 +434,7 @@ pub fn op_webgpu_render_pass_insert_debug_marker(
   state: &mut OpState,
   args: RenderPassInsertDebugMarkerArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pass_resource = state
     .resource_table
     .get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -451,7 +449,7 @@ pub fn op_webgpu_render_pass_insert_debug_marker(
     );
   }
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -465,7 +463,7 @@ pub fn op_webgpu_render_pass_set_pipeline(
   state: &mut OpState,
   args: RenderPassSetPipelineArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pipeline_resource = state
     .resource_table
     .get::<super::pipeline::WebGpuRenderPipeline>(args.pipeline)
@@ -480,7 +478,7 @@ pub fn op_webgpu_render_pass_set_pipeline(
     render_pipeline_resource.0,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -497,7 +495,7 @@ pub fn op_webgpu_render_pass_set_index_buffer(
   state: &mut OpState,
   args: RenderPassSetIndexBufferArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let buffer_resource = state
     .resource_table
     .get::<super::buffer::WebGpuBuffer>(args.buffer)
@@ -514,7 +512,7 @@ pub fn op_webgpu_render_pass_set_index_buffer(
     std::num::NonZeroU64::new(args.size),
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -531,7 +529,7 @@ pub fn op_webgpu_render_pass_set_vertex_buffer(
   state: &mut OpState,
   args: RenderPassSetVertexBufferArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let buffer_resource = state
     .resource_table
     .get::<super::buffer::WebGpuBuffer>(args.buffer)
@@ -549,7 +547,7 @@ pub fn op_webgpu_render_pass_set_vertex_buffer(
     std::num::NonZeroU64::new(args.size),
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -566,7 +564,7 @@ pub fn op_webgpu_render_pass_draw(
   state: &mut OpState,
   args: RenderPassDrawArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pass_resource = state
     .resource_table
     .get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -580,7 +578,7 @@ pub fn op_webgpu_render_pass_draw(
     args.first_instance,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -598,7 +596,7 @@ pub fn op_webgpu_render_pass_draw_indexed(
   state: &mut OpState,
   args: RenderPassDrawIndexedArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let render_pass_resource = state
     .resource_table
     .get::<WebGpuRenderPass>(args.render_pass_rid)
@@ -613,7 +611,7 @@ pub fn op_webgpu_render_pass_draw_indexed(
     args.first_instance,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -628,7 +626,7 @@ pub fn op_webgpu_render_pass_draw_indirect(
   state: &mut OpState,
   args: RenderPassDrawIndirectArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let buffer_resource = state
     .resource_table
     .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)
@@ -644,7 +642,7 @@ pub fn op_webgpu_render_pass_draw_indirect(
     args.indirect_offset,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
 
 #[derive(Deserialize)]
@@ -659,7 +657,7 @@ pub fn op_webgpu_render_pass_draw_indexed_indirect(
   state: &mut OpState,
   args: RenderPassDrawIndexedIndirectArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let buffer_resource = state
     .resource_table
     .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)
@@ -675,5 +673,5 @@ pub fn op_webgpu_render_pass_draw_indexed_indirect(
     args.indirect_offset,
   );
 
-  Ok(json!({}))
+  Ok(WebGpuResult::empty())
 }
diff --git a/op_crates/webgpu/sampler.rs b/op_crates/webgpu/sampler.rs
index b759d0c11..5e0ebc61e 100644
--- a/op_crates/webgpu/sampler.rs
+++ b/op_crates/webgpu/sampler.rs
@@ -2,15 +2,13 @@
 
 use deno_core::error::bad_resource_id;
 use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use deno_core::{OpState, Resource};
 use serde::Deserialize;
 use std::borrow::Cow;
 
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
 
 pub(crate) struct WebGpuSampler(pub(crate) wgpu_core::id::SamplerId);
 impl Resource for WebGpuSampler {
@@ -83,7 +81,7 @@ pub fn op_webgpu_create_sampler(
   state: &mut OpState,
   args: CreateSamplerArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
@@ -123,8 +121,5 @@ pub fn op_webgpu_create_sampler(
 
   let rid = state.resource_table.add(WebGpuSampler(sampler));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from)
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
diff --git a/op_crates/webgpu/shader.rs b/op_crates/webgpu/shader.rs
index 63578ce64..0e653b470 100644
--- a/op_crates/webgpu/shader.rs
+++ b/op_crates/webgpu/shader.rs
@@ -3,15 +3,13 @@
 use deno_core::error::bad_resource_id;
 use deno_core::error::null_opbuf;
 use deno_core::error::AnyError;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use deno_core::{OpState, Resource};
 use serde::Deserialize;
 use std::borrow::Cow;
 
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
 
 pub(crate) struct WebGpuShaderModule(pub(crate) wgpu_core::id::ShaderModuleId);
 impl Resource for WebGpuShaderModule {
@@ -33,7 +31,7 @@ pub fn op_webgpu_create_shader_module(
   state: &mut OpState,
   args: CreateShaderModuleArgs,
   zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
@@ -77,8 +75,5 @@ pub fn op_webgpu_create_shader_module(
 
   let rid = state.resource_table.add(WebGpuShaderModule(shader_module));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from)
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
diff --git a/op_crates/webgpu/texture.rs b/op_crates/webgpu/texture.rs
index 24824215c..28b8ca1a4 100644
--- a/op_crates/webgpu/texture.rs
+++ b/op_crates/webgpu/texture.rs
@@ -2,15 +2,13 @@
 
 use deno_core::error::AnyError;
 use deno_core::error::{bad_resource_id, not_supported};
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use deno_core::{OpState, Resource};
 use serde::Deserialize;
 use std::borrow::Cow;
 
-use super::error::WebGpuError;
+use super::error::WebGpuResult;
 pub(crate) struct WebGpuTexture(pub(crate) wgpu_core::id::TextureId);
 impl Resource for WebGpuTexture {
   fn name(&self) -> Cow<str> {
@@ -148,7 +146,7 @@ pub fn op_webgpu_create_texture(
   state: &mut OpState,
   args: CreateTextureArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
@@ -186,10 +184,7 @@ pub fn op_webgpu_create_texture(
 
   let rid = state.resource_table.add(WebGpuTexture(texture));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from)
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
 
 #[derive(Deserialize)]
@@ -210,7 +205,7 @@ pub fn op_webgpu_create_texture_view(
   state: &mut OpState,
   args: CreateTextureViewArgs,
   _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<WebGpuResult, AnyError> {
   let instance = state.borrow::<super::Instance>();
   let texture_resource = state
     .resource_table
@@ -250,8 +245,5 @@ pub fn op_webgpu_create_texture_view(
 
   let rid = state.resource_table.add(WebGpuTextureView(texture_view));
 
-  Ok(json!({
-    "rid": rid,
-    "err": maybe_err.map(WebGpuError::from)
-  }))
+  Ok(WebGpuResult::rid_err(rid, maybe_err))
 }