Rename crate_ops to extensions (#10431)

1 files changed, 0 insertions, 723 deletions

diff --git a/op_crates/webgpu/command_encoder.rs b/op_crates/webgpu/command_encoder.rs
deleted file mode 100644
index 724ce72c4..000000000
--- a/op_crates/webgpu/command_encoder.rs
+++ /dev/null
@@ -1,723 +0,0 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-
-use deno_core::error::bad_resource_id;
-use deno_core::error::AnyError;
-use deno_core::ResourceId;
-use deno_core::ZeroCopyBuf;
-use deno_core::{OpState, Resource};
-use serde::Deserialize;
-use std::borrow::Cow;
-use std::cell::RefCell;
-
-use super::error::WebGpuResult;
-
-pub(crate) struct WebGpuCommandEncoder(
-  pub(crate) wgpu_core::id::CommandEncoderId,
-);
-impl Resource for WebGpuCommandEncoder {
-  fn name(&self) -> Cow<str> {
-    "webGPUCommandEncoder".into()
-  }
-}
-
-pub(crate) struct WebGpuCommandBuffer(
-  pub(crate) wgpu_core::id::CommandBufferId,
-);
-impl Resource for WebGpuCommandBuffer {
-  fn name(&self) -> Cow<str> {
-    "webGPUCommandBuffer".into()
-  }
-}
-
-fn serialize_store_op(store_op: String) -> wgpu_core::command::StoreOp {
-  match store_op.as_str() {
-    "store" => wgpu_core::command::StoreOp::Store,
-    "clear" => wgpu_core::command::StoreOp::Clear,
-    _ => unreachable!(),
-  }
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CreateCommandEncoderArgs {
-  device_rid: ResourceId,
-  label: Option<String>,
-  _measure_execution_time: Option<bool>, // not yet implemented
-}
-
-pub fn op_webgpu_create_command_encoder(
-  state: &mut OpState,
-  args: CreateCommandEncoderArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<WebGpuResult, AnyError> {
-  let instance = state.borrow::<super::Instance>();
-  let device_resource = state
-    .resource_table
-    .get::<super::WebGpuDevice>(args.device_rid)
-    .ok_or_else(bad_resource_id)?;
-  let device = device_resource.0;
-
-  let descriptor = wgpu_types::CommandEncoderDescriptor {
-    label: args.label.map(Cow::from),
-  };
-
-  let (command_encoder, maybe_err) = gfx_select!(device => instance.device_create_command_encoder(
-    device,
-    &descriptor,
-    std::marker::PhantomData
-  ));
-
-  let rid = state
-    .resource_table
-    .add(WebGpuCommandEncoder(command_encoder));
-
-  Ok(WebGpuResult::rid_err(rid, maybe_err))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GpuRenderPassColorAttachment {
-  view: u32,
-  resolve_target: Option<u32>,
-  load_op: String,
-  load_value: Option<super::render_pass::GpuColor>,
-  store_op: Option<String>,
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct GpuRenderPassDepthStencilAttachment {
-  view: u32,
-  depth_load_op: String,
-  depth_load_value: Option<f32>,
-  depth_store_op: String,
-  depth_read_only: Option<bool>,
-  stencil_load_op: String,
-  stencil_load_value: Option<u32>,
-  stencil_store_op: String,
-  stencil_read_only: Option<bool>,
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CommandEncoderBeginRenderPassArgs {
-  command_encoder_rid: ResourceId,
-  label: Option<String>,
-  color_attachments: Vec<GpuRenderPassColorAttachment>,
-  depth_stencil_attachment: Option<GpuRenderPassDepthStencilAttachment>,
-  _occlusion_query_set: Option<u32>, // not yet implemented
-}
-
-pub fn op_webgpu_command_encoder_begin_render_pass(
-  state: &mut OpState,
-  args: CommandEncoderBeginRenderPassArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<WebGpuResult, AnyError> {
-  let command_encoder_resource = state
-    .resource_table
-    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
-    .ok_or_else(bad_resource_id)?;
-
-  let mut color_attachments = vec![];
-
-  for color_attachment in args.color_attachments {
-    let texture_view_resource = state
-      .resource_table
-      .get::<super::texture::WebGpuTextureView>(color_attachment.view)
-      .ok_or_else(bad_resource_id)?;
-
-    let attachment = wgpu_core::command::ColorAttachmentDescriptor {
-      attachment: texture_view_resource.0,
-      resolve_target: color_attachment
-        .resolve_target
-        .map(|rid| {
-          state
-            .resource_table
-            .get::<super::texture::WebGpuTextureView>(rid)
-            .ok_or_else(bad_resource_id)
-        })
-        .transpose()?
-        .map(|texture| texture.0),
-      channel: match color_attachment.load_op.as_str() {
-        "load" => wgpu_core::command::PassChannel {
-          load_op: wgpu_core::command::LoadOp::Load,
-          store_op: color_attachment
-            .store_op
-            .map_or(wgpu_core::command::StoreOp::Store, serialize_store_op),
-          clear_value: Default::default(),
-          read_only: false,
-        },
-        "clear" => {
-          let color = color_attachment.load_value.unwrap();
-          wgpu_core::command::PassChannel {
-            load_op: wgpu_core::command::LoadOp::Clear,
-            store_op: color_attachment
-              .store_op
-              .map_or(wgpu_core::command::StoreOp::Store, serialize_store_op),
-            clear_value: wgpu_types::Color {
-              r: color.r,
-              g: color.g,
-              b: color.b,
-              a: color.a,
-            },
-            read_only: false,
-          }
-        }
-        _ => unreachable!(),
-      },
-    };
-
-    color_attachments.push(attachment)
-  }
-
-  let mut depth_stencil_attachment = None;
-
-  if let Some(attachment) = args.depth_stencil_attachment {
-    let texture_view_resource = state
-      .resource_table
-      .get::<super::texture::WebGpuTextureView>(attachment.view)
-      .ok_or_else(bad_resource_id)?;
-
-    depth_stencil_attachment =
-      Some(wgpu_core::command::DepthStencilAttachmentDescriptor {
-        attachment: texture_view_resource.0,
-        depth: match attachment.depth_load_op.as_str() {
-          "load" => wgpu_core::command::PassChannel {
-            load_op: wgpu_core::command::LoadOp::Load,
-            store_op: serialize_store_op(attachment.depth_store_op),
-            clear_value: 0.0,
-            read_only: attachment.depth_read_only.unwrap_or(false),
-          },
-          "clear" => wgpu_core::command::PassChannel {
-            load_op: wgpu_core::command::LoadOp::Clear,
-            store_op: serialize_store_op(attachment.depth_store_op),
-            clear_value: attachment.depth_load_value.unwrap(),
-            read_only: attachment.depth_read_only.unwrap_or(false),
-          },
-          _ => unreachable!(),
-        },
-        stencil: match attachment.stencil_load_op.as_str() {
-          "load" => wgpu_core::command::PassChannel {
-            load_op: wgpu_core::command::LoadOp::Load,
-            store_op: serialize_store_op(attachment.stencil_store_op),
-            clear_value: 0,
-            read_only: attachment.stencil_read_only.unwrap_or(false),
-          },
-          "clear" => wgpu_core::command::PassChannel {
-            load_op: wgpu_core::command::LoadOp::Clear,
-            store_op: serialize_store_op(attachment.stencil_store_op),
-            clear_value: attachment.stencil_load_value.unwrap(),
-            read_only: attachment.stencil_read_only.unwrap_or(false),
-          },
-          _ => unreachable!(),
-        },
-      });
-  }
-
-  let descriptor = wgpu_core::command::RenderPassDescriptor {
-    label: args.label.map(Cow::from),
-    color_attachments: Cow::from(color_attachments),
-    depth_stencil_attachment: depth_stencil_attachment.as_ref(),
-  };
-
-  let render_pass = wgpu_core::command::RenderPass::new(
-    command_encoder_resource.0,
-    &descriptor,
-  );
-
-  let rid = state
-    .resource_table
-    .add(super::render_pass::WebGpuRenderPass(RefCell::new(
-      render_pass,
-    )));
-
-  Ok(WebGpuResult::rid(rid))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CommandEncoderBeginComputePassArgs {
-  command_encoder_rid: ResourceId,
-  label: Option<String>,
-}
-
-pub fn op_webgpu_command_encoder_begin_compute_pass(
-  state: &mut OpState,
-  args: CommandEncoderBeginComputePassArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<WebGpuResult, AnyError> {
-  let command_encoder_resource = state
-    .resource_table
-    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
-    .ok_or_else(bad_resource_id)?;
-
-  let descriptor = wgpu_core::command::ComputePassDescriptor {
-    label: args.label.map(Cow::from),
-  };
-
-  let compute_pass = wgpu_core::command::ComputePass::new(
-    command_encoder_resource.0,
-    &descriptor,
-  );
-
-  let rid = state
-    .resource_table
-    .add(super::compute_pass::WebGpuComputePass(RefCell::new(
-      compute_pass,
-    )));
-
-  Ok(WebGpuResult::rid(rid))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CommandEncoderCopyBufferToBufferArgs {
-  command_encoder_rid: ResourceId,
-  source: u32,
-  source_offset: u64,
-  destination: u32,
-  destination_offset: u64,
-  size: u64,
-}
-
-pub fn op_webgpu_command_encoder_copy_buffer_to_buffer(
-  state: &mut OpState,
-  args: CommandEncoderCopyBufferToBufferArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<WebGpuResult, AnyError> {
-  let instance = state.borrow::<super::Instance>();
-  let command_encoder_resource = state
-    .resource_table
-    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
-    .ok_or_else(bad_resource_id)?;
-  let command_encoder = command_encoder_resource.0;
-  let source_buffer_resource = state
-    .resource_table
-    .get::<super::buffer::WebGpuBuffer>(args.source)
-    .ok_or_else(bad_resource_id)?;
-  let source_buffer = source_buffer_resource.0;
-  let destination_buffer_resource = state
-    .resource_table
-    .get::<super::buffer::WebGpuBuffer>(args.destination)
-    .ok_or_else(bad_resource_id)?;
-  let destination_buffer = destination_buffer_resource.0;
-
-  let maybe_err =  gfx_select!(command_encoder => instance.command_encoder_copy_buffer_to_buffer(
-    command_encoder,
-    source_buffer,
-    args.source_offset,
-    destination_buffer,
-    args.destination_offset,
-    args.size
-  )).err();
-
-  Ok(WebGpuResult::maybe_err(maybe_err))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GpuImageCopyBuffer {
-  buffer: u32,
-  offset: Option<u64>,
-  bytes_per_row: Option<u32>,
-  rows_per_image: Option<u32>,
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GpuOrigin3D {
-  pub x: Option<u32>,
-  pub y: Option<u32>,
-  pub z: Option<u32>,
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GpuImageCopyTexture {
-  pub texture: u32,
-  pub mip_level: Option<u32>,
-  pub origin: Option<GpuOrigin3D>,
-  pub _aspect: Option<String>, // not yet implemented
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CommandEncoderCopyBufferToTextureArgs {
-  command_encoder_rid: ResourceId,
-  source: GpuImageCopyBuffer,
-  destination: GpuImageCopyTexture,
-  copy_size: super::texture::GpuExtent3D,
-}
-
-pub fn op_webgpu_command_encoder_copy_buffer_to_texture(
-  state: &mut OpState,
-  args: CommandEncoderCopyBufferToTextureArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<WebGpuResult, AnyError> {
-  let instance = state.borrow::<super::Instance>();
-  let command_encoder_resource = state
-    .resource_table
-    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
-    .ok_or_else(bad_resource_id)?;
-  let command_encoder = command_encoder_resource.0;
-  let source_buffer_resource = state
-    .resource_table
-    .get::<super::buffer::WebGpuBuffer>(args.source.buffer)
-    .ok_or_else(bad_resource_id)?;
-  let destination_texture_resource = state
-    .resource_table
-    .get::<super::texture::WebGpuTexture>(args.destination.texture)
-    .ok_or_else(bad_resource_id)?;
-
-  let source = wgpu_core::command::BufferCopyView {
-    buffer: source_buffer_resource.0,
-    layout: wgpu_types::TextureDataLayout {
-      offset: args.source.offset.unwrap_or(0),
-      bytes_per_row: args.source.bytes_per_row.unwrap_or(0),
-      rows_per_image: args.source.rows_per_image.unwrap_or(0),
-    },
-  };
-  let destination = wgpu_core::command::TextureCopyView {
-    texture: destination_texture_resource.0,
-    mip_level: args.destination.mip_level.unwrap_or(0),
-    origin: args
-      .destination
-      .origin
-      .map_or(Default::default(), |origin| wgpu_types::Origin3d {
-        x: origin.x.unwrap_or(0),
-        y: origin.y.unwrap_or(0),
-        z: origin.z.unwrap_or(0),
-      }),
-  };
-  let maybe_err = gfx_select!(command_encoder => instance.command_encoder_copy_buffer_to_texture(
-    command_encoder,
-    &source,
-    &destination,
-    &wgpu_types::Extent3d {
-      width: args.copy_size.width.unwrap_or(1),
-      height: args.copy_size.height.unwrap_or(1),
-      depth: args.copy_size.depth.unwrap_or(1),
-    }
-  )).err();
-
-  Ok(WebGpuResult::maybe_err(maybe_err))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CommandEncoderCopyTextureToBufferArgs {
-  command_encoder_rid: ResourceId,
-  source: GpuImageCopyTexture,
-  destination: GpuImageCopyBuffer,
-  copy_size: super::texture::GpuExtent3D,
-}
-
-pub fn op_webgpu_command_encoder_copy_texture_to_buffer(
-  state: &mut OpState,
-  args: CommandEncoderCopyTextureToBufferArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<WebGpuResult, AnyError> {
-  let instance = state.borrow::<super::Instance>();
-  let command_encoder_resource = state
-    .resource_table
-    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
-    .ok_or_else(bad_resource_id)?;
-  let command_encoder = command_encoder_resource.0;
-  let source_texture_resource = state
-    .resource_table
-    .get::<super::texture::WebGpuTexture>(args.source.texture)
-    .ok_or_else(bad_resource_id)?;
-  let destination_buffer_resource = state
-    .resource_table
-    .get::<super::buffer::WebGpuBuffer>(args.destination.buffer)
-    .ok_or_else(bad_resource_id)?;
-
-  let source = wgpu_core::command::TextureCopyView {
-    texture: source_texture_resource.0,
-    mip_level: args.source.mip_level.unwrap_or(0),
-    origin: args.source.origin.map_or(Default::default(), |origin| {
-      wgpu_types::Origin3d {
-        x: origin.x.unwrap_or(0),
-        y: origin.y.unwrap_or(0),
-        z: origin.z.unwrap_or(0),
-      }
-    }),
-  };
-  let destination = wgpu_core::command::BufferCopyView {
-    buffer: destination_buffer_resource.0,
-    layout: wgpu_types::TextureDataLayout {
-      offset: args.destination.offset.unwrap_or(0),
-      bytes_per_row: args.destination.bytes_per_row.unwrap_or(0),
-      rows_per_image: args.destination.rows_per_image.unwrap_or(0),
-    },
-  };
-  let maybe_err =  gfx_select!(command_encoder => instance.command_encoder_copy_texture_to_buffer(
-    command_encoder,
-    &source,
-    &destination,
-    &wgpu_types::Extent3d {
-      width: args.copy_size.width.unwrap_or(1),
-      height: args.copy_size.height.unwrap_or(1),
-      depth: args.copy_size.depth.unwrap_or(1),
-    }
-  )).err();
-
-  Ok(WebGpuResult::maybe_err(maybe_err))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CommandEncoderCopyTextureToTextureArgs {
-  command_encoder_rid: ResourceId,
-  source: GpuImageCopyTexture,
-  destination: GpuImageCopyTexture,
-  copy_size: super::texture::GpuExtent3D,
-}
-
-pub fn op_webgpu_command_encoder_copy_texture_to_texture(
-  state: &mut OpState,
-  args: CommandEncoderCopyTextureToTextureArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<WebGpuResult, AnyError> {
-  let instance = state.borrow::<super::Instance>();
-  let command_encoder_resource = state
-    .resource_table
-    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
-    .ok_or_else(bad_resource_id)?;
-  let command_encoder = command_encoder_resource.0;
-  let source_texture_resource = state
-    .resource_table
-    .get::<super::texture::WebGpuTexture>(args.source.texture)
-    .ok_or_else(bad_resource_id)?;
-  let destination_texture_resource = state
-    .resource_table
-    .get::<super::texture::WebGpuTexture>(args.destination.texture)
-    .ok_or_else(bad_resource_id)?;
-
-  let source = wgpu_core::command::TextureCopyView {
-    texture: source_texture_resource.0,
-    mip_level: args.source.mip_level.unwrap_or(0),
-    origin: args.source.origin.map_or(Default::default(), |origin| {
-      wgpu_types::Origin3d {
-        x: origin.x.unwrap_or(0),
-        y: origin.y.unwrap_or(0),
-        z: origin.z.unwrap_or(0),
-      }
-    }),
-  };
-  let destination = wgpu_core::command::TextureCopyView {
-    texture: destination_texture_resource.0,
-    mip_level: args.destination.mip_level.unwrap_or(0),
-    origin: args
-      .destination
-      .origin
-      .map_or(Default::default(), |origin| wgpu_types::Origin3d {
-        x: origin.x.unwrap_or(0),
-        y: origin.y.unwrap_or(0),
-        z: origin.z.unwrap_or(0),
-      }),
-  };
-  let maybe_err =  gfx_select!(command_encoder => instance.command_encoder_copy_texture_to_texture(
-    command_encoder,
-    &source,
-    &destination,
-    &wgpu_types::Extent3d {
-      width: args.copy_size.width.unwrap_or(1),
-      height: args.copy_size.height.unwrap_or(1),
-      depth: args.copy_size.depth.unwrap_or(1),
-    }
-  )).err();
-
-  Ok(WebGpuResult::maybe_err(maybe_err))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CommandEncoderPushDebugGroupArgs {
-  command_encoder_rid: ResourceId,
-  group_label: String,
-}
-
-pub fn op_webgpu_command_encoder_push_debug_group(
-  state: &mut OpState,
-  args: CommandEncoderPushDebugGroupArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<WebGpuResult, AnyError> {
-  let instance = state.borrow::<super::Instance>();
-  let command_encoder_resource = state
-    .resource_table
-    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
-    .ok_or_else(bad_resource_id)?;
-  let command_encoder = command_encoder_resource.0;
-
-  let maybe_err = gfx_select!(command_encoder => instance
-    .command_encoder_push_debug_group(command_encoder, &args.group_label))
-  .err();
-
-  Ok(WebGpuResult::maybe_err(maybe_err))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CommandEncoderPopDebugGroupArgs {
-  command_encoder_rid: ResourceId,
-}
-
-pub fn op_webgpu_command_encoder_pop_debug_group(
-  state: &mut OpState,
-  args: CommandEncoderPopDebugGroupArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<WebGpuResult, AnyError> {
-  let instance = state.borrow::<super::Instance>();
-  let command_encoder_resource = state
-    .resource_table
-    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
-    .ok_or_else(bad_resource_id)?;
-  let command_encoder = command_encoder_resource.0;
-
-  let maybe_err =  gfx_select!(command_encoder => instance.command_encoder_pop_debug_group(command_encoder)).err();
-
-  Ok(WebGpuResult::maybe_err(maybe_err))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CommandEncoderInsertDebugMarkerArgs {
-  command_encoder_rid: ResourceId,
-  marker_label: String,
-}
-
-pub fn op_webgpu_command_encoder_insert_debug_marker(
-  state: &mut OpState,
-  args: CommandEncoderInsertDebugMarkerArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<WebGpuResult, AnyError> {
-  let instance = state.borrow::<super::Instance>();
-  let command_encoder_resource = state
-    .resource_table
-    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
-    .ok_or_else(bad_resource_id)?;
-  let command_encoder = command_encoder_resource.0;
-
-  let maybe_err = gfx_select!(command_encoder => instance.command_encoder_insert_debug_marker(
-    command_encoder,
-    &args.marker_label
-  )).err();
-
-  Ok(WebGpuResult::maybe_err(maybe_err))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CommandEncoderWriteTimestampArgs {
-  command_encoder_rid: ResourceId,
-  query_set: u32,
-  query_index: u32,
-}
-
-pub fn op_webgpu_command_encoder_write_timestamp(
-  state: &mut OpState,
-  args: CommandEncoderWriteTimestampArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<WebGpuResult, AnyError> {
-  let instance = state.borrow::<super::Instance>();
-  let command_encoder_resource = state
-    .resource_table
-    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
-    .ok_or_else(bad_resource_id)?;
-  let command_encoder = command_encoder_resource.0;
-  let query_set_resource = state
-    .resource_table
-    .get::<super::WebGpuQuerySet>(args.query_set)
-    .ok_or_else(bad_resource_id)?;
-
-  let maybe_err =
-    gfx_select!(command_encoder => instance.command_encoder_write_timestamp(
-      command_encoder,
-      query_set_resource.0,
-      args.query_index
-    ))
-    .err();
-
-  Ok(WebGpuResult::maybe_err(maybe_err))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CommandEncoderResolveQuerySetArgs {
-  command_encoder_rid: ResourceId,
-  query_set: u32,
-  first_query: u32,
-  query_count: u32,
-  destination: u32,
-  destination_offset: u64,
-}
-
-pub fn op_webgpu_command_encoder_resolve_query_set(
-  state: &mut OpState,
-  args: CommandEncoderResolveQuerySetArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<WebGpuResult, AnyError> {
-  let instance = state.borrow::<super::Instance>();
-  let command_encoder_resource = state
-    .resource_table
-    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
-    .ok_or_else(bad_resource_id)?;
-  let command_encoder = command_encoder_resource.0;
-  let query_set_resource = state
-    .resource_table
-    .get::<super::WebGpuQuerySet>(args.query_set)
-    .ok_or_else(bad_resource_id)?;
-  let destination_resource = state
-    .resource_table
-    .get::<super::buffer::WebGpuBuffer>(args.destination)
-    .ok_or_else(bad_resource_id)?;
-
-  let maybe_err =
-    gfx_select!(command_encoder => instance.command_encoder_resolve_query_set(
-      command_encoder,
-      query_set_resource.0,
-      args.first_query,
-      args.query_count,
-      destination_resource.0,
-      args.destination_offset
-    ))
-    .err();
-
-  Ok(WebGpuResult::maybe_err(maybe_err))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CommandEncoderFinishArgs {
-  command_encoder_rid: ResourceId,
-  label: Option<String>,
-}
-
-pub fn op_webgpu_command_encoder_finish(
-  state: &mut OpState,
-  args: CommandEncoderFinishArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
-) -> Result<WebGpuResult, AnyError> {
-  let command_encoder_resource = state
-    .resource_table
-    .take::<WebGpuCommandEncoder>(args.command_encoder_rid)
-    .ok_or_else(bad_resource_id)?;
-  let command_encoder = command_encoder_resource.0;
-  let instance = state.borrow::<super::Instance>();
-
-  let descriptor = wgpu_types::CommandBufferDescriptor {
-    label: args.label.map(Cow::from),
-  };
-
-  let (command_buffer, maybe_err) = gfx_select!(command_encoder => instance.command_encoder_finish(
-    command_encoder,
-    &descriptor
-  ));
-
-  let rid = state
-    .resource_table
-    .add(WebGpuCommandBuffer(command_buffer));
-
-  Ok(WebGpuResult::rid_err(rid, maybe_err))
-}