upgrade: Rust 1.51.0 (#9895)

42 files changed, 595 insertions, 633 deletions

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 451dbe98e..6a0fa4a54 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -74,7 +74,7 @@ jobs:
       - name: Install rust
         uses: hecrj/setup-rust-action@v1
         with:
-          rust-version: 1.50.0
+          rust-version: 1.51.0
 
       - name: Install clippy and rustfmt
         if: matrix.kind == 'lint'
diff --git a/cli/ast.rs b/cli/ast.rs
index 3979af0ce..bbd4df74d 100644
--- a/cli/ast.rs
+++ b/cli/ast.rs
@@ -59,11 +59,11 @@ pub struct Location {
   pub col: usize,
 }
 
-impl Into<Location> for swc_common::Loc {
-  fn into(self) -> Location {
+impl From<swc_common::Loc> for Location {
+  fn from(swc_loc: swc_common::Loc) -> Self {
     use swc_common::FileName::*;
 
-    let filename = match &self.file.name {
+    let filename = match &swc_loc.file.name {
       Real(path_buf) => path_buf.to_string_lossy().to_string(),
       Custom(str_) => str_.to_string(),
       _ => panic!("invalid filename"),
@@ -71,15 +71,15 @@ impl Into<Location> for swc_common::Loc {
 
     Location {
       filename,
-      line: self.line,
-      col: self.col_display,
+      line: swc_loc.line,
+      col: swc_loc.col_display,
     }
   }
 }
 
-impl Into<ModuleSpecifier> for Location {
-  fn into(self) -> ModuleSpecifier {
-    resolve_url_or_path(&self.filename).unwrap()
+impl From<Location> for ModuleSpecifier {
+  fn from(loc: Location) -> Self {
+    resolve_url_or_path(&loc.filename).unwrap()
   }
 }
 
@@ -174,10 +174,10 @@ fn get_ts_config(tsx: bool, dts: bool) -> TsConfig {
 pub fn get_syntax(media_type: &MediaType) -> Syntax {
   match media_type {
     MediaType::JavaScript => Syntax::Es(get_es_config(false)),
-    MediaType::JSX => Syntax::Es(get_es_config(true)),
+    MediaType::Jsx => Syntax::Es(get_es_config(true)),
     MediaType::TypeScript => Syntax::Typescript(get_ts_config(false, false)),
     MediaType::Dts => Syntax::Typescript(get_ts_config(false, true)),
-    MediaType::TSX => Syntax::Typescript(get_ts_config(true, false)),
+    MediaType::Tsx => Syntax::Typescript(get_ts_config(true, false)),
     _ => Syntax::Es(get_es_config(false)),
   }
 }
@@ -429,10 +429,10 @@ pub fn parse_with_source_map(
     comments.with_leading(module.span.lo, |comments| comments.to_vec());
 
   Ok(ParsedModule {
+    comments,
     leading_comments,
     module,
     source_map,
-    comments,
     source_file,
   })
 }
@@ -711,7 +711,7 @@ mod tests {
       }
     }
     "#;
-    let module = parse(specifier.as_str(), source, &MediaType::TSX)
+    let module = parse(specifier.as_str(), source, &MediaType::Tsx)
       .expect("could not parse module");
     let (code, _) = module
       .transpile(&EmitOptions::default())
diff --git a/cli/bench/http.rs b/cli/bench/http.rs
index af7eef942..f954223a0 100644
--- a/cli/bench/http.rs
+++ b/cli/bench/http.rs
@@ -1,9 +1,7 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
 
 use super::Result;
-use std::{
-  collections::HashMap, path::PathBuf, process::Command, time::Duration,
-};
+use std::{collections::HashMap, path::Path, process::Command, time::Duration};
 pub use test_util::{parse_wrk_output, WrkOutput as HttpBenchmarkResult};
 
 // Some of the benchmarks in this file have been renamed. In case the history
@@ -15,7 +13,7 @@ pub use test_util::{parse_wrk_output, WrkOutput as HttpBenchmarkResult};
 const DURATION: &str = "20s";
 
 pub(crate) fn benchmark(
-  target_path: &PathBuf,
+  target_path: &Path,
 ) -> Result<HashMap<String, HttpBenchmarkResult>> {
   let deno_exe = test_util::deno_exe_path();
   let deno_exe = deno_exe.to_str().unwrap();
diff --git a/cli/bench/lsp.rs b/cli/bench/lsp.rs
index 63e1821d4..da02db486 100644
--- a/cli/bench/lsp.rs
+++ b/cli/bench/lsp.rs
@@ -14,7 +14,7 @@ use std::collections::HashMap;
 use std::io::BufRead;
 use std::io::Read;
 use std::io::Write;
-use std::path::PathBuf;
+use std::path::Path;
 use std::process::ChildStdin;
 use std::process::ChildStdout;
 use std::process::Command;
@@ -135,7 +135,7 @@ impl Drop for LspClient {
 }
 
 impl LspClient {
-  fn new(deno_exe: &PathBuf) -> Result<Self, AnyError> {
+  fn new(deno_exe: &Path) -> Result<Self, AnyError> {
     let mut child = Command::new(deno_exe)
       .arg("lsp")
       .stdin(Stdio::piped())
@@ -244,7 +244,7 @@ impl LspClient {
 /// A benchmark that opens a 8000+ line TypeScript document, adds a function to
 /// the end of the document and does a level of hovering and gets quick fix
 /// code actions.
-fn bench_big_file_edits(deno_exe: &PathBuf) -> Result<Duration, AnyError> {
+fn bench_big_file_edits(deno_exe: &Path) -> Result<Duration, AnyError> {
   let mut client = LspClient::new(deno_exe)?;
 
   let params: Value = serde_json::from_slice(FIXTURE_INIT_JSON)?;
@@ -302,7 +302,7 @@ fn bench_big_file_edits(deno_exe: &PathBuf) -> Result<Duration, AnyError> {
 }
 
 /// A test that starts up the LSP, opens a single line document, and exits.
-fn bench_startup_shutdown(deno_exe: &PathBuf) -> Result<Duration, AnyError> {
+fn bench_startup_shutdown(deno_exe: &Path) -> Result<Duration, AnyError> {
   let mut client = LspClient::new(deno_exe)?;
 
   let params: Value = serde_json::from_slice(FIXTURE_INIT_JSON)?;
@@ -338,7 +338,7 @@ fn bench_startup_shutdown(deno_exe: &PathBuf) -> Result<Duration, AnyError> {
 
 /// Generate benchmarks for the LSP server.
 pub(crate) fn benchmarks(
-  deno_exe: &PathBuf,
+  deno_exe: &Path,
 ) -> Result<HashMap<String, u64>, AnyError> {
   println!("-> Start benchmarking lsp");
   let mut exec_times = HashMap::new();
diff --git a/cli/bench/main.rs b/cli/bench/main.rs
index 8a91b86d6..8890ec79c 100644
--- a/cli/bench/main.rs
+++ b/cli/bench/main.rs
@@ -8,6 +8,7 @@ use std::collections::HashMap;
 use std::convert::From;
 use std::env;
 use std::fs;
+use std::path::Path;
 use std::path::PathBuf;
 use std::process::Command;
 use std::process::Stdio;
@@ -126,8 +127,8 @@ const EXEC_TIME_BENCHMARKS: &[(&str, &[&str], Option<i32>)] = &[
 const RESULT_KEYS: &[&str] =
   &["mean", "stddev", "user", "system", "min", "max"];
 fn run_exec_time(
-  deno_exe: &PathBuf,
-  target_dir: &PathBuf,
+  deno_exe: &Path,
+  target_dir: &Path,
 ) -> Result<HashMap<String, HashMap<String, f64>>> {
   let hyperfine_exe = test_util::prebuilt_tool_path("hyperfine");
 
@@ -218,7 +219,7 @@ fn rlib_size(target_dir: &std::path::Path, prefix: &str) -> u64 {
 
 const BINARY_TARGET_FILES: &[&str] =
   &["CLI_SNAPSHOT.bin", "COMPILER_SNAPSHOT.bin"];
-fn get_binary_sizes(target_dir: &PathBuf) -> Result<HashMap<String, u64>> {
+fn get_binary_sizes(target_dir: &Path) -> Result<HashMap<String, u64>> {
   let mut sizes = HashMap::<String, u64>::new();
   let mut mtimes = HashMap::<String, SystemTime>::new();
 
@@ -276,7 +277,7 @@ const BUNDLES: &[(&str, &str)] = &[
   ("file_server", "./test_util/std/http/file_server.ts"),
   ("gist", "./test_util/std/examples/gist.ts"),
 ];
-fn bundle_benchmark(deno_exe: &PathBuf) -> Result<HashMap<String, u64>> {
+fn bundle_benchmark(deno_exe: &Path) -> Result<HashMap<String, u64>> {
   let mut sizes = HashMap::<String, u64>::new();
 
   for (name, url) in BUNDLES {
@@ -304,7 +305,7 @@ fn bundle_benchmark(deno_exe: &PathBuf) -> Result<HashMap<String, u64>> {
   Ok(sizes)
 }
 
-fn run_throughput(deno_exe: &PathBuf) -> Result<HashMap<String, f64>> {
+fn run_throughput(deno_exe: &Path) -> Result<HashMap<String, f64>> {
   let mut m = HashMap::<String, f64>::new();
 
   m.insert("100M_tcp".to_string(), throughput::tcp(deno_exe, 100)?);
@@ -315,7 +316,7 @@ fn run_throughput(deno_exe: &PathBuf) -> Result<HashMap<String, f64>> {
   Ok(m)
 }
 
-fn run_http(target_dir: &PathBuf, new_data: &mut BenchResult) -> Result<()> {
+fn run_http(target_dir: &Path, new_data: &mut BenchResult) -> Result<()> {
   let stats = http::benchmark(target_dir)?;
 
   new_data.req_per_sec = stats
@@ -332,7 +333,7 @@ fn run_http(target_dir: &PathBuf, new_data: &mut BenchResult) -> Result<()> {
 }
 
 fn run_strace_benchmarks(
-  deno_exe: &PathBuf,
+  deno_exe: &Path,
   new_data: &mut BenchResult,
 ) -> Result<()> {
   use std::io::Read;
@@ -372,7 +373,7 @@ fn run_strace_benchmarks(
   Ok(())
 }
 
-fn run_max_mem_benchmark(deno_exe: &PathBuf) -> Result<HashMap<String, u64>> {
+fn run_max_mem_benchmark(deno_exe: &Path) -> Result<HashMap<String, u64>> {
   let mut results = HashMap::<String, u64>::new();
 
   for (name, args, return_code) in EXEC_TIME_BENCHMARKS {
diff --git a/cli/bench/throughput.rs b/cli/bench/throughput.rs
index 83032e7a1..de18089bb 100644
--- a/cli/bench/throughput.rs
+++ b/cli/bench/throughput.rs
@@ -2,7 +2,7 @@
 
 use super::Result;
 use std::{
-  path::PathBuf,
+  path::Path,
   process::Command,
   time::{Duration, Instant},
 };
@@ -11,7 +11,7 @@ const MB: usize = 1024 * 1024;
 const SERVER_ADDR: &str = "0.0.0.0:4544";
 const CLIENT_ADDR: &str = "127.0.0.1 4544";
 
-pub(crate) fn cat(deno_exe: &PathBuf, megs: usize) -> f64 {
+pub(crate) fn cat(deno_exe: &Path, megs: usize) -> f64 {
   let size = megs * MB;
   let shell_cmd = format!(
     "{} run --allow-read cli/tests/cat.ts /dev/zero | head -c {}",
@@ -28,7 +28,7 @@ pub(crate) fn cat(deno_exe: &PathBuf, megs: usize) -> f64 {
   (end - start).as_secs_f64()
 }
 
-pub(crate) fn tcp(deno_exe: &PathBuf, megs: usize) -> Result<f64> {
+pub(crate) fn tcp(deno_exe: &Path, megs: usize) -> Result<f64> {
   let size = megs * MB;
 
   // The GNU flavor of `nc` requires the `-N` flag to shutdown the network socket after EOF on stdin
diff --git a/cli/file_fetcher.rs b/cli/file_fetcher.rs
index 4223654dc..3803c93c9 100644
--- a/cli/file_fetcher.rs
+++ b/cli/file_fetcher.rs
@@ -223,8 +223,8 @@ pub fn map_content_type(
       | "application/node" => {
         map_js_like_extension(specifier, MediaType::JavaScript)
       }
-      "text/jsx" => MediaType::JSX,
-      "text/tsx" => MediaType::TSX,
+      "text/jsx" => MediaType::Jsx,
+      "text/tsx" => MediaType::Tsx,
       "application/json" | "text/json" => MediaType::Json,
       "application/wasm" => MediaType::Wasm,
       // Handle plain and possibly webassembly
@@ -264,8 +264,8 @@ fn map_js_like_extension(
     None => default,
     Some(os_str) => match os_str.to_str() {
       None => default,
-      Some("jsx") => MediaType::JSX,
-      Some("tsx") => MediaType::TSX,
+      Some("jsx") => MediaType::Jsx,
+      Some("tsx") => MediaType::Tsx,
       // Because DTS files do not have a separate media type, or a unique
       // extension, we have to "guess" at those things that we consider that
       // look like TypeScript, and end with `.d.ts` are DTS files.
@@ -685,8 +685,8 @@ mod tests {
       ("data:text/plain,Hello%2C%20Deno!", true, MediaType::Unknown, "text/plain", "Hello, Deno!"),
       ("data:,Hello%2C%20Deno!", true, MediaType::Unknown, "", "Hello, Deno!"),
       ("data:application/javascript,console.log(\"Hello, Deno!\");%0A", true, MediaType::JavaScript, "application/javascript", "console.log(\"Hello, Deno!\");\n"),
-      ("data:text/jsx;base64,ZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24oKSB7CiAgcmV0dXJuIDxkaXY+SGVsbG8gRGVubyE8L2Rpdj4KfQo=", true, MediaType::JSX, "text/jsx;base64", "export default function() {\n  return <div>Hello Deno!</div>\n}\n"),
-      ("data:text/tsx;base64,ZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24oKSB7CiAgcmV0dXJuIDxkaXY+SGVsbG8gRGVubyE8L2Rpdj4KfQo=", true, MediaType::TSX, "text/tsx;base64", "export default function() {\n  return <div>Hello Deno!</div>\n}\n"),
+      ("data:text/jsx;base64,ZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24oKSB7CiAgcmV0dXJuIDxkaXY+SGVsbG8gRGVubyE8L2Rpdj4KfQo=", true, MediaType::Jsx, "text/jsx;base64", "export default function() {\n  return <div>Hello Deno!</div>\n}\n"),
+      ("data:text/tsx;base64,ZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24oKSB7CiAgcmV0dXJuIDxkaXY+SGVsbG8gRGVubyE8L2Rpdj4KfQo=", true, MediaType::Tsx, "text/tsx;base64", "export default function() {\n  return <div>Hello Deno!</div>\n}\n"),
     ];
 
     for (
@@ -744,10 +744,10 @@ mod tests {
     let fixtures = vec![
       // Extension only
       (file_url!("/foo/bar.ts"), None, MediaType::TypeScript, None),
-      (file_url!("/foo/bar.tsx"), None, MediaType::TSX, None),
+      (file_url!("/foo/bar.tsx"), None, MediaType::Tsx, None),
       (file_url!("/foo/bar.d.ts"), None, MediaType::Dts, None),
       (file_url!("/foo/bar.js"), None, MediaType::JavaScript, None),
-      (file_url!("/foo/bar.jsx"), None, MediaType::JSX, None),
+      (file_url!("/foo/bar.jsx"), None, MediaType::Jsx, None),
       (file_url!("/foo/bar.json"), None, MediaType::Json, None),
       (file_url!("/foo/bar.wasm"), None, MediaType::Wasm, None),
       (file_url!("/foo/bar.cjs"), None, MediaType::JavaScript, None),
@@ -823,13 +823,13 @@ mod tests {
       (
         "https://deno.land/x/mod",
         Some("text/jsx".to_string()),
-        MediaType::JSX,
+        MediaType::Jsx,
         None,
       ),
       (
         "https://deno.land/x/mod",
         Some("text/tsx".to_string()),
-        MediaType::TSX,
+        MediaType::Tsx,
         None,
       ),
       (
@@ -860,25 +860,25 @@ mod tests {
       (
         "https://deno.land/x/mod.tsx",
         Some("application/typescript".to_string()),
-        MediaType::TSX,
+        MediaType::Tsx,
         None,
       ),
       (
         "https://deno.land/x/mod.tsx",
         Some("application/javascript".to_string()),
-        MediaType::TSX,
+        MediaType::Tsx,
         None,
       ),
       (
         "https://deno.land/x/mod.jsx",
         Some("application/javascript".to_string()),
-        MediaType::JSX,
+        MediaType::Jsx,
         None,
       ),
       (
         "https://deno.land/x/mod.jsx",
         Some("application/x-typescript".to_string()),
-        MediaType::JSX,
+        MediaType::Jsx,
         None,
       ),
       (
diff --git a/cli/fs_util.rs b/cli/fs_util.rs
index 04cdfff75..584d62598 100644
--- a/cli/fs_util.rs
+++ b/cli/fs_util.rs
@@ -248,7 +248,7 @@ mod tests {
 
   #[test]
   fn test_collect_files() {
-    fn create_files(dir_path: &PathBuf, files: &[&str]) {
+    fn create_files(dir_path: &Path, files: &[&str]) {
       std::fs::create_dir(dir_path).expect("Failed to create directory");
       for f in files {
         let path = dir_path.join(f);
diff --git a/cli/lsp/analysis.rs b/cli/lsp/analysis.rs
index 4c087cfa2..3359fc666 100644
--- a/cli/lsp/analysis.rs
+++ b/cli/lsp/analysis.rs
@@ -274,7 +274,7 @@ pub fn analyze_dependencies(
           let resolved_import =
             resolve_import(&import, specifier, maybe_import_map);
           if media_type == &MediaType::JavaScript
-            || media_type == &MediaType::JSX
+            || media_type == &MediaType::Jsx
           {
             maybe_type = Some(resolved_import)
           } else {
@@ -297,11 +297,7 @@ pub fn analyze_dependencies(
     let maybe_resolved_type_dependency =
       // Check for `@deno-types` pragmas that affect the import
       if let Some(comment) = desc.leading_comments.last() {
-        if let Some(deno_types) = parse_deno_types(&comment.text).as_ref() {
-          Some(resolve_import(deno_types, specifier, maybe_import_map))
-        } else {
-          None
-        }
+        parse_deno_types(&comment.text).as_ref().map(|deno_types| resolve_import(deno_types, specifier, maybe_import_map))
       } else {
         None
       };
diff --git a/cli/lsp/diagnostics.rs b/cli/lsp/diagnostics.rs
index f720299d7..d4ec3d494 100644
--- a/cli/lsp/diagnostics.rs
+++ b/cli/lsp/diagnostics.rs
@@ -461,31 +461,27 @@ fn get_diagnostic_message(diagnostic: &diagnostics::Diagnostic) -> String {
 fn to_lsp_related_information(
   related_information: &Option<Vec<diagnostics::Diagnostic>>,
 ) -> Option<Vec<lsp::DiagnosticRelatedInformation>> {
-  if let Some(related) = related_information {
-    Some(
-      related
-        .iter()
-        .filter_map(|ri| {
-          if let (Some(source), Some(start), Some(end)) =
-            (&ri.source, &ri.start, &ri.end)
-          {
-            let uri = lsp::Url::parse(&source).unwrap();
-            Some(lsp::DiagnosticRelatedInformation {
-              location: lsp::Location {
-                uri,
-                range: to_lsp_range(start, end),
-              },
-              message: get_diagnostic_message(&ri),
-            })
-          } else {
-            None
-          }
-        })
-        .collect(),
-    )
-  } else {
-    None
-  }
+  related_information.as_ref().map(|related| {
+    related
+      .iter()
+      .filter_map(|ri| {
+        if let (Some(source), Some(start), Some(end)) =
+          (&ri.source, &ri.start, &ri.end)
+        {
+          let uri = lsp::Url::parse(&source).unwrap();
+          Some(lsp::DiagnosticRelatedInformation {
+            location: lsp::Location {
+              uri,
+              range: to_lsp_range(start, end),
+            },
+            message: get_diagnostic_message(&ri),
+          })
+        } else {
+          None
+        }
+      })
+      .collect()
+  })
 }
 
 fn ts_json_to_diagnostics(
diff --git a/cli/lsp/documents.rs b/cli/lsp/documents.rs
index da393fbac..47a23eb49 100644
--- a/cli/lsp/documents.rs
+++ b/cli/lsp/documents.rs
@@ -154,7 +154,7 @@ impl DocumentCache {
   }
 
   pub fn len(&self) -> usize {
-    self.docs.iter().count()
+    self.docs.len()
   }
 
   pub fn line_index(&self, specifier: &ModuleSpecifier) -> Option<LineIndex> {
diff --git a/cli/lsp/tsc.rs b/cli/lsp/tsc.rs
index 7569036f5..d3fec5d64 100644
--- a/cli/lsp/tsc.rs
+++ b/cli/lsp/tsc.rs
@@ -166,11 +166,7 @@ pub async fn get_asset(
       .request(state_snapshot, RequestMethod::GetAsset(specifier.clone()))
       .await?;
     let maybe_text: Option<String> = serde_json::from_value(res)?;
-    let maybe_asset = if let Some(text) = maybe_text {
-      Some(AssetDocument::new(text))
-    } else {
-      None
-    };
+    let maybe_asset = maybe_text.map(AssetDocument::new);
     Ok(maybe_asset)
   }
 }
@@ -183,7 +179,7 @@ fn display_parts_to_string(parts: &[SymbolDisplayPart]) -> String {
     .join("")
 }
 
-fn get_tag_body_text(tag: &JSDocTagInfo) -> Option<String> {
+fn get_tag_body_text(tag: &JsDocTagInfo) -> Option<String> {
   tag.text.as_ref().map(|text| match tag.name.as_str() {
     "example" => {
       let caption_regex =
@@ -209,7 +205,7 @@ fn get_tag_body_text(tag: &JSDocTagInfo) -> Option<String> {
   })
 }
 
-fn get_tag_documentation(tag: &JSDocTagInfo) -> String {
+fn get_tag_documentation(tag: &JsDocTagInfo) -> String {
   match tag.name.as_str() {
     "augments" | "extends" | "param" | "template" => {
       if let Some(text) = &tag.text {
@@ -439,7 +435,7 @@ pub struct SymbolDisplayPart {
 
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct JSDocTagInfo {
+pub struct JsDocTagInfo {
   name: String,
   text: Option<String>,
 }
@@ -452,7 +448,7 @@ pub struct QuickInfo {
   text_span: TextSpan,
   display_parts: Option<Vec<SymbolDisplayPart>>,
   documentation: Option<Vec<SymbolDisplayPart>>,
-  tags: Option<Vec<JSDocTagInfo>>,
+  tags: Option<Vec<JsDocTagInfo>>,
 }
 
 impl QuickInfo {
@@ -536,10 +532,11 @@ impl DocumentSpan {
     let origin_selection_range =
       if let Some(original_context_span) = &self.original_context_span {
         Some(original_context_span.to_range(line_index))
-      } else if let Some(original_text_span) = &self.original_text_span {
-        Some(original_text_span.to_range(line_index))
       } else {
-        None
+        self
+          .original_text_span
+          .as_ref()
+          .map(|original_text_span| original_text_span.to_range(line_index))
       };
     let link = lsp::LocationLink {
       origin_selection_range,
@@ -927,7 +924,7 @@ pub struct CompletionEntryDetails {
   kind_modifiers: String,
   display_parts: Vec<SymbolDisplayPart>,
   documentation: Option<Vec<SymbolDisplayPart>>,
-  tags: Option<Vec<JSDocTagInfo>>,
+  tags: Option<Vec<JsDocTagInfo>>,
   code_actions: Option<Vec<CodeAction>>,
   source: Option<Vec<SymbolDisplayPart>>,
 }
@@ -1261,7 +1258,7 @@ pub struct SignatureHelpItem {
   separator_display_parts: Vec<SymbolDisplayPart>,
   parameters: Vec<SignatureHelpParameter>,
   documentation: Vec<SymbolDisplayPart>,
-  tags: Vec<JSDocTagInfo>,
+  tags: Vec<JsDocTagInfo>,
 }
 
 impl SignatureHelpItem {
@@ -1328,12 +1325,9 @@ impl SelectionRange {
   ) -> lsp::SelectionRange {
     lsp::SelectionRange {
       range: self.text_span.to_range(line_index),
-      parent: match &self.parent {
-        Some(parent_selection) => {
-          Some(Box::new(parent_selection.to_selection_range(line_index)))
-        }
-        None => None,
-      },
+      parent: self.parent.as_ref().map(|parent_selection| {
+        Box::new(parent_selection.to_selection_range(line_index))
+      }),
     }
   }
 }
@@ -1345,6 +1339,7 @@ struct Response {
 }
 
 struct State<'a> {
+  #[allow(unused)]
   asset: Option<String>,
   last_id: usize,
   response: Option<Response>,
diff --git a/cli/main.rs b/cli/main.rs
index c73da5e06..c2fa20c1c 100644
--- a/cli/main.rs
+++ b/cli/main.rs
@@ -497,11 +497,11 @@ async fn eval_command(
     media_type: if ext.as_str() == "ts" {
       MediaType::TypeScript
     } else if ext.as_str() == "tsx" {
-      MediaType::TSX
+      MediaType::Tsx
     } else if ext.as_str() == "js" {
       MediaType::JavaScript
     } else {
-      MediaType::JSX
+      MediaType::Jsx
     },
     source: String::from_utf8(source_code)?,
     specifier: main_module.clone(),
diff --git a/cli/media_type.rs b/cli/media_type.rs
index 922784902..c83716f67 100644
--- a/cli/media_type.rs
+++ b/cli/media_type.rs
@@ -14,10 +14,10 @@ use std::path::PathBuf;
 #[derive(Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Debug)]
 pub enum MediaType {
   JavaScript = 0,
-  JSX = 1,
+  Jsx = 1,
   TypeScript = 2,
   Dts = 3,
-  TSX = 4,
+  Tsx = 4,
   Json = 5,
   Wasm = 6,
   TsBuildInfo = 7,
@@ -29,10 +29,10 @@ impl fmt::Display for MediaType {
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     let value = match self {
       MediaType::JavaScript => "JavaScript",
-      MediaType::JSX => "JSX",
+      MediaType::Jsx => "JSX",
       MediaType::TypeScript => "TypeScript",
       MediaType::Dts => "Dts",
-      MediaType::TSX => "TSX",
+      MediaType::Tsx => "TSX",
       MediaType::Json => "Json",
       MediaType::Wasm => "Wasm",
       MediaType::TsBuildInfo => "TsBuildInfo",
@@ -103,9 +103,9 @@ impl MediaType {
           }
           MediaType::TypeScript
         }
-        Some("tsx") => MediaType::TSX,
+        Some("tsx") => MediaType::Tsx,
         Some("js") => MediaType::JavaScript,
-        Some("jsx") => MediaType::JSX,
+        Some("jsx") => MediaType::Jsx,
         Some("mjs") => MediaType::JavaScript,
         Some("cjs") => MediaType::JavaScript,
         Some("json") => MediaType::Json,
@@ -124,10 +124,10 @@ impl MediaType {
   pub fn as_ts_extension(&self) -> &str {
     match self {
       MediaType::JavaScript => ".js",
-      MediaType::JSX => ".jsx",
+      MediaType::Jsx => ".jsx",
       MediaType::TypeScript => ".ts",
       MediaType::Dts => ".d.ts",
-      MediaType::TSX => ".tsx",
+      MediaType::Tsx => ".tsx",
       MediaType::Json => ".json",
       // TypeScript doesn't have an "unknown", so we will treat WASM as JS for
       // mapping purposes, though in reality, it is unlikely to ever be passed
@@ -149,10 +149,10 @@ impl MediaType {
   pub fn as_ts_script_kind(&self) -> i32 {
     match self {
       MediaType::JavaScript => 1,
-      MediaType::JSX => 2,
+      MediaType::Jsx => 2,
       MediaType::TypeScript => 3,
       MediaType::Dts => 3,
-      MediaType::TSX => 4,
+      MediaType::Tsx => 4,
       MediaType::Json => 5,
       _ => 0,
     }
@@ -166,10 +166,10 @@ impl Serialize for MediaType {
   {
     let value = match self {
       MediaType::JavaScript => 0_i32,
-      MediaType::JSX => 1_i32,
+      MediaType::Jsx => 1_i32,
       MediaType::TypeScript => 2_i32,
       MediaType::Dts => 3_i32,
-      MediaType::TSX => 4_i32,
+      MediaType::Tsx => 4_i32,
       MediaType::Json => 5_i32,
       MediaType::Wasm => 6_i32,
       MediaType::TsBuildInfo => 7_i32,
@@ -208,13 +208,13 @@ mod tests {
       MediaType::from(Path::new("foo/bar.ts")),
       MediaType::TypeScript
     );
-    assert_eq!(MediaType::from(Path::new("foo/bar.tsx")), MediaType::TSX);
+    assert_eq!(MediaType::from(Path::new("foo/bar.tsx")), MediaType::Tsx);
     assert_eq!(MediaType::from(Path::new("foo/bar.d.ts")), MediaType::Dts);
     assert_eq!(
       MediaType::from(Path::new("foo/bar.js")),
       MediaType::JavaScript
     );
-    assert_eq!(MediaType::from(Path::new("foo/bar.jsx")), MediaType::JSX);
+    assert_eq!(MediaType::from(Path::new("foo/bar.jsx")), MediaType::Jsx);
     assert_eq!(MediaType::from(Path::new("foo/bar.json")), MediaType::Json);
     assert_eq!(MediaType::from(Path::new("foo/bar.wasm")), MediaType::Wasm);
     assert_eq!(
@@ -256,10 +256,10 @@ mod tests {
   #[test]
   fn test_serialization() {
     assert_eq!(json!(MediaType::JavaScript), json!(0));
-    assert_eq!(json!(MediaType::JSX), json!(1));
+    assert_eq!(json!(MediaType::Jsx), json!(1));
     assert_eq!(json!(MediaType::TypeScript), json!(2));
     assert_eq!(json!(MediaType::Dts), json!(3));
-    assert_eq!(json!(MediaType::TSX), json!(4));
+    assert_eq!(json!(MediaType::Tsx), json!(4));
     assert_eq!(json!(MediaType::Json), json!(5));
     assert_eq!(json!(MediaType::Wasm), json!(6));
     assert_eq!(json!(MediaType::TsBuildInfo), json!(7));
@@ -270,10 +270,10 @@ mod tests {
   #[test]
   fn test_display() {
     assert_eq!(MediaType::JavaScript.to_string(), "JavaScript");
-    assert_eq!(MediaType::JSX.to_string(), "JSX");
+    assert_eq!(MediaType::Jsx.to_string(), "JSX");
     assert_eq!(MediaType::TypeScript.to_string(), "TypeScript");
     assert_eq!(MediaType::Dts.to_string(), "Dts");
-    assert_eq!(MediaType::TSX.to_string(), "TSX");
+    assert_eq!(MediaType::Tsx.to_string(), "TSX");
     assert_eq!(MediaType::Json.to_string(), "Json");
     assert_eq!(MediaType::Wasm.to_string(), "Wasm");
     assert_eq!(MediaType::TsBuildInfo.to_string(), "TsBuildInfo");
diff --git a/cli/module_graph.rs b/cli/module_graph.rs
index ad6d01589..f70fc1c41 100644
--- a/cli/module_graph.rs
+++ b/cli/module_graph.rs
@@ -197,12 +197,10 @@ pub fn parse_ts_reference(comment: &str) -> Option<TypeScriptReference> {
     Some(TypeScriptReference::Path(
       captures.get(1).unwrap().as_str().to_string(),
     ))
-  } else if let Some(captures) = TYPES_REFERENCE_RE.captures(comment) {
-    Some(TypeScriptReference::Types(
-      captures.get(1).unwrap().as_str().to_string(),
-    ))
   } else {
-    None
+    TYPES_REFERENCE_RE.captures(comment).map(|captures| {
+      TypeScriptReference::Types(captures.get(1).unwrap().as_str().to_string())
+    })
   }
 }
 
@@ -300,17 +298,14 @@ impl Module {
         module.is_parsed = true;
       }
     }
-    module.maybe_types = if let Some(ref specifier) = cached_module.maybe_types
-    {
-      Some((
+    module.maybe_types = cached_module.maybe_types.map(|specifier| {
+      (
         specifier.clone(),
         module
           .resolve_import(&specifier, None)
           .expect("could not resolve module"),
-      ))
-    } else {
-      None
-    };
+      )
+    });
     module
   }
 
@@ -348,7 +343,7 @@ impl Module {
             let specifier =
               self.resolve_import(&import, Some(location.clone()))?;
             if self.media_type == MediaType::JavaScript
-              || self.media_type == MediaType::JSX
+              || self.media_type == MediaType::Jsx
             {
               // TODO(kitsonk) we need to specifically update the cache when
               // this value changes
@@ -1073,8 +1068,8 @@ impl Graph {
           for (_, module_slot) in self.modules.iter_mut() {
             if let ModuleSlot::Module(module) = module_slot {
               if !(emit_options.check_js
-                || module.media_type == MediaType::JSX
-                || module.media_type == MediaType::TSX
+                || module.media_type == MediaType::Jsx
+                || module.media_type == MediaType::Tsx
                 || module.media_type == MediaType::TypeScript)
               {
                 emitted_files
@@ -1274,9 +1269,9 @@ impl Graph {
       let mut specifiers = HashSet::<&ModuleSpecifier>::new();
       for (_, module_slot) in self.modules.iter() {
         if let ModuleSlot::Module(module) = module_slot {
-          if module.media_type == MediaType::JSX
+          if module.media_type == MediaType::Jsx
             || module.media_type == MediaType::TypeScript
-            || module.media_type == MediaType::TSX
+            || module.media_type == MediaType::Tsx
           {
             specifiers.insert(&module.specifier);
           }
@@ -1418,7 +1413,7 @@ impl Graph {
     self.modules.iter().all(|(_, m)| {
       if let ModuleSlot::Module(m) = m {
         let needs_emit = match m.media_type {
-          MediaType::TypeScript | MediaType::TSX | MediaType::JSX => true,
+          MediaType::TypeScript | MediaType::Tsx | MediaType::Jsx => true,
           MediaType::JavaScript => check_js,
           _ => false,
         };
@@ -1462,7 +1457,7 @@ impl Graph {
     let check_js = config.get_check_js();
     self.modules.iter().any(|(_, m)| match m {
       ModuleSlot::Module(m) => match m.media_type {
-        MediaType::TypeScript | MediaType::TSX | MediaType::JSX => true,
+        MediaType::TypeScript | MediaType::Tsx | MediaType::Jsx => true,
         MediaType::JavaScript => check_js,
         _ => false,
       },
@@ -1618,8 +1613,8 @@ impl Graph {
         // if we don't have check_js enabled, we won't touch non TypeScript or JSX
         // modules
         if !(emit_options.check_js
-          || module.media_type == MediaType::JSX
-          || module.media_type == MediaType::TSX
+          || module.media_type == MediaType::Jsx
+          || module.media_type == MediaType::Tsx
           || module.media_type == MediaType::TypeScript)
         {
           continue;
@@ -1734,11 +1729,8 @@ impl GraphBuilder {
     maybe_import_map: Option<ImportMap>,
     maybe_lockfile: Option<Arc<Mutex<Lockfile>>>,
   ) -> Self {
-    let internal_import_map = if let Some(import_map) = maybe_import_map {
-      Some(Arc::new(Mutex::new(import_map)))
-    } else {
-      None
-    };
+    let internal_import_map =
+      maybe_import_map.map(|import_map| Arc::new(Mutex::new(import_map)));
     GraphBuilder {
       graph: Graph::new(handler, maybe_lockfile),
       maybe_import_map: internal_import_map,
@@ -2069,8 +2061,8 @@ pub mod tests {
     let source = "console.log(42);".to_string();
     let maybe_version = Some(get_version(&source, &version::deno(), b""));
     let module = Module {
-      source,
       maybe_version,
+      source,
       ..Module::default()
     };
     assert!(module.is_emit_valid(b""));
@@ -2079,8 +2071,8 @@ pub mod tests {
     let old_source = "console.log(43);";
     let maybe_version = Some(get_version(old_source, &version::deno(), b""));
     let module = Module {
-      source,
       maybe_version,
+      source,
       ..Module::default()
     };
     assert!(!module.is_emit_valid(b""));
@@ -2088,8 +2080,8 @@ pub mod tests {
     let source = "console.log(42);".to_string();
     let maybe_version = Some(get_version(&source, "0.0.0", b""));
     let module = Module {
-      source,
       maybe_version,
+      source,
       ..Module::default()
     };
     assert!(!module.is_emit_valid(b""));
diff --git a/cli/program_state.rs b/cli/program_state.rs
index bced6a9bc..ebe223ab0 100644
--- a/cli/program_state.rs
+++ b/cli/program_state.rs
@@ -110,13 +110,9 @@ impl ProgramState {
       };
 
     let maybe_inspect_host = flags.inspect.or(flags.inspect_brk);
-    let maybe_inspector_server = match maybe_inspect_host {
-      Some(host) => Some(Arc::new(InspectorServer::new(
-        host,
-        version::get_user_agent(),
-      ))),
-      None => None,
-    };
+    let maybe_inspector_server = maybe_inspect_host.map(|host| {
+      Arc::new(InspectorServer::new(host, version::get_user_agent()))
+    });
 
     let coverage_dir = flags
       .coverage_dir
diff --git a/cli/source_maps.rs b/cli/source_maps.rs
index 3fa265761..8bc070418 100644
--- a/cli/source_maps.rs
+++ b/cli/source_maps.rs
@@ -48,11 +48,7 @@ pub fn apply_source_map<G: SourceMapGetter>(
   // source file map.
   let end_column = match js_error.end_column {
     Some(ec) => {
-      if let Some(sc) = start_column {
-        Some(ec - (js_error.start_column.unwrap() - sc))
-      } else {
-        None
-      }
+      start_column.map(|sc| ec - (js_error.start_column.unwrap() - sc))
     }
     _ => None,
   };
diff --git a/cli/tools/coverage.rs b/cli/tools/coverage.rs
index 9e97688a3..9a197eabd 100644
--- a/cli/tools/coverage.rs
+++ b/cli/tools/coverage.rs
@@ -157,11 +157,8 @@ impl CoverageReporter for LcovCoverageReporter {
   ) {
     // TODO(caspervonb) cleanup and reduce duplication between reporters, pre-compute line coverage
     // elsewhere.
-    let maybe_source_map = if let Some(source_map) = maybe_source_map {
-      Some(SourceMap::from_slice(&source_map).unwrap())
-    } else {
-      None
-    };
+    let maybe_source_map = maybe_source_map
+      .map(|source_map| SourceMap::from_slice(&source_map).unwrap());
 
     let url = Url::parse(&script_coverage.url).unwrap();
     let file_path = url.to_file_path().unwrap();
@@ -374,11 +371,8 @@ impl CoverageReporter for PrettyCoverageReporter {
     maybe_source_map: Option<Vec<u8>>,
     maybe_original_source: Option<String>,
   ) {
-    let maybe_source_map = if let Some(source_map) = maybe_source_map {
-      Some(SourceMap::from_slice(&source_map).unwrap())
-    } else {
-      None
-    };
+    let maybe_source_map = maybe_source_map
+      .map(|source_map| SourceMap::from_slice(&source_map).unwrap());
 
     let mut ignored_spans: Vec<Span> = Vec::new();
     for item in ast::lex("", script_source, &MediaType::JavaScript) {
diff --git a/cli/tools/installer.rs b/cli/tools/installer.rs
index 20b0b17ef..a616db7ef 100644
--- a/cli/tools/installer.rs
+++ b/cli/tools/installer.rs
@@ -14,6 +14,7 @@ use std::io;
 use std::io::Write;
 #[cfg(not(windows))]
 use std::os::unix::fs::PermissionsExt;
+use std::path::Path;
 use std::path::PathBuf;
 
 lazy_static! {
@@ -318,7 +319,7 @@ pub fn install(
   Ok(())
 }
 
-fn is_in_path(dir: &PathBuf) -> bool {
+fn is_in_path(dir: &Path) -> bool {
   if let Some(paths) = env::var_os("PATH") {
     for p in env::split_paths(&paths) {
       if *dir == p {
diff --git a/cli/tools/test_runner.rs b/cli/tools/test_runner.rs
index e91cad011..df792bd53 100644
--- a/cli/tools/test_runner.rs
+++ b/cli/tools/test_runner.rs
@@ -6,7 +6,6 @@ use deno_core::error::AnyError;
 use deno_core::serde_json::json;
 use deno_core::url::Url;
 use std::path::Path;
-use std::path::PathBuf;
 
 fn is_supported(p: &Path) -> bool {
   use std::path::Component;
@@ -34,7 +33,7 @@ fn is_supported(p: &Path) -> bool {
 
 pub fn prepare_test_modules_urls(
   include: Vec<String>,
-  root_path: &PathBuf,
+  root_path: &Path,
 ) -> Result<Vec<Url>, AnyError> {
   let (include_paths, include_urls): (Vec<String>, Vec<String>) =
     include.into_iter().partition(|n| !is_remote_url(n));
diff --git a/cli/tsc.rs b/cli/tsc.rs
index 78a472dfa..4026f9329 100644
--- a/cli/tsc.rs
+++ b/cli/tsc.rs
@@ -134,9 +134,9 @@ fn get_tsc_media_type(specifier: &ModuleSpecifier) -> MediaType {
         }
         MediaType::TypeScript
       }
-      Some("tsx") => MediaType::TSX,
+      Some("tsx") => MediaType::Tsx,
       Some("js") => MediaType::JavaScript,
-      Some("jsx") => MediaType::JSX,
+      Some("jsx") => MediaType::Jsx,
       _ => MediaType::Unknown,
     },
   }
@@ -634,10 +634,10 @@ mod tests {
   fn test_get_tsc_media_type() {
     let fixtures = vec![
       ("file:///a.ts", MediaType::TypeScript),
-      ("file:///a.tsx", MediaType::TSX),
+      ("file:///a.tsx", MediaType::Tsx),
       ("file:///a.d.ts", MediaType::Dts),
       ("file:///a.js", MediaType::JavaScript),
-      ("file:///a.jsx", MediaType::JSX),
+      ("file:///a.jsx", MediaType::Jsx),
       ("file:///a.cjs", MediaType::Unknown),
       ("file:///a.mjs", MediaType::Unknown),
       ("file:///a.json", MediaType::Unknown),
diff --git a/cli/tsc_config.rs b/cli/tsc_config.rs
index 54ed34bf1..b89b3bf61 100644
--- a/cli/tsc_config.rs
+++ b/cli/tsc_config.rs
@@ -175,7 +175,7 @@ fn jsonc_to_serde(j: JsonValue) -> Value {
 
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct TSConfigJson {
+struct TsConfigJson {
   compiler_options: Option<HashMap<String, Value>>,
   exclude: Option<Vec<String>>,
   extends: Option<String>,
@@ -221,7 +221,7 @@ pub fn parse_config(
 ) -> Result<(Value, Option<IgnoredCompilerOptions>), AnyError> {
   assert!(!config_text.is_empty());
   let jsonc = jsonc_parser::parse_to_value(config_text)?.unwrap();
-  let config: TSConfigJson = serde_json::from_value(jsonc_to_serde(jsonc))?;
+  let config: TsConfigJson = serde_json::from_value(jsonc_to_serde(jsonc))?;
 
   if let Some(compiler_options) = config.compiler_options {
     parse_compiler_options(&compiler_options, Some(path.to_owned()), false)
diff --git a/core/ops_bin.rs b/core/ops_bin.rs
index 053150bfd..3e13c23d5 100644
--- a/core/ops_bin.rs
+++ b/core/ops_bin.rs
@@ -39,12 +39,12 @@ pub struct ResponseHeader {
   pub result: u32,
 }
 
-impl Into<[u8; 16]> for ResponseHeader {
-  fn into(self) -> [u8; 16] {
+impl From<ResponseHeader> for [u8; 16] {
+  fn from(r: ResponseHeader) -> Self {
     let mut resp_header = [0u8; 16];
-    resp_header[0..8].copy_from_slice(&self.request_id.to_le_bytes());
-    resp_header[8..12].copy_from_slice(&self.status.to_le_bytes());
-    resp_header[12..16].copy_from_slice(&self.result.to_le_bytes());
+    resp_header[0..8].copy_from_slice(&r.request_id.to_le_bytes());
+    resp_header[8..12].copy_from_slice(&r.status.to_le_bytes());
+    resp_header[12..16].copy_from_slice(&r.result.to_le_bytes());
     resp_header
   }
 }
diff --git a/core/runtime.rs b/core/runtime.rs
index c7a945717..9fa626636 100644
--- a/core/runtime.rs
+++ b/core/runtime.rs
@@ -201,8 +201,8 @@ impl JsRuntime {
     DENO_INIT.call_once(|| {
       // Include 10MB ICU data file.
       #[repr(C, align(16))]
-      struct ICUData([u8; 10413584]);
-      static ICU_DATA: ICUData = ICUData(*include_bytes!("icudtl.dat"));
+      struct IcuData([u8; 10413584]);
+      static ICU_DATA: IcuData = IcuData(*include_bytes!("icudtl.dat"));
       v8::icu::set_common_data(&ICU_DATA.0).unwrap();
       unsafe { v8_init() };
     });
diff --git a/op_crates/webgpu/binding.rs b/op_crates/webgpu/binding.rs
index a004d1f45..512ba1608 100644
--- a/op_crates/webgpu/binding.rs
+++ b/op_crates/webgpu/binding.rs
@@ -10,19 +10,19 @@ use deno_core::{OpState, Resource};
 use serde::Deserialize;
 use std::borrow::Cow;
 
-use super::error::WebGPUError;
+use super::error::WebGpuError;
 
-pub(crate) struct WebGPUBindGroupLayout(
+pub(crate) struct WebGpuBindGroupLayout(
   pub(crate) wgpu_core::id::BindGroupLayoutId,
 );
-impl Resource for WebGPUBindGroupLayout {
+impl Resource for WebGpuBindGroupLayout {
   fn name(&self) -> Cow<str> {
     "webGPUBindGroupLayout".into()
   }
 }
 
-pub(crate) struct WebGPUBindGroup(pub(crate) wgpu_core::id::BindGroupId);
-impl Resource for WebGPUBindGroup {
+pub(crate) struct WebGpuBindGroup(pub(crate) wgpu_core::id::BindGroupId);
+impl Resource for WebGpuBindGroup {
   fn name(&self) -> Cow<str> {
     "webGPUBindGroup".into()
   }
@@ -30,7 +30,7 @@ impl Resource for WebGPUBindGroup {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUBufferBindingLayout {
+struct GpuBufferBindingLayout {
   #[serde(rename = "type")]
   kind: Option<String>,
   has_dynamic_offset: Option<bool>,
@@ -39,14 +39,14 @@ struct GPUBufferBindingLayout {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUSamplerBindingLayout {
+struct GpuSamplerBindingLayout {
   #[serde(rename = "type")]
   kind: Option<String>,
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUTextureBindingLayout {
+struct GpuTextureBindingLayout {
   sample_type: Option<String>,
   view_dimension: Option<String>,
   multisampled: Option<bool>,
@@ -54,7 +54,7 @@ struct GPUTextureBindingLayout {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUStorageTextureBindingLayout {
+struct GpuStorageTextureBindingLayout {
   access: String,
   format: String,
   view_dimension: Option<String>,
@@ -62,13 +62,13 @@ struct GPUStorageTextureBindingLayout {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUBindGroupLayoutEntry {
+struct GpuBindGroupLayoutEntry {
   binding: u32,
   visibility: u32,
-  buffer: Option<GPUBufferBindingLayout>,
-  sampler: Option<GPUSamplerBindingLayout>,
-  texture: Option<GPUTextureBindingLayout>,
-  storage_texture: Option<GPUStorageTextureBindingLayout>,
+  buffer: Option<GpuBufferBindingLayout>,
+  sampler: Option<GpuSamplerBindingLayout>,
+  texture: Option<GpuTextureBindingLayout>,
+  storage_texture: Option<GpuStorageTextureBindingLayout>,
 }
 
 #[derive(Deserialize)]
@@ -76,7 +76,7 @@ struct GPUBindGroupLayoutEntry {
 pub struct CreateBindGroupLayoutArgs {
   device_rid: ResourceId,
   label: Option<String>,
-  entries: Vec<GPUBindGroupLayoutEntry>,
+  entries: Vec<GpuBindGroupLayoutEntry>,
 }
 
 pub fn op_webgpu_create_bind_group_layout(
@@ -87,7 +87,7 @@ pub fn op_webgpu_create_bind_group_layout(
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
-    .get::<super::WebGPUDevice>(args.device_rid)
+    .get::<super::WebGpuDevice>(args.device_rid)
     .ok_or_else(bad_resource_id)?;
   let device = device_resource.0;
 
@@ -205,11 +205,11 @@ pub fn op_webgpu_create_bind_group_layout(
 
   let rid = state
     .resource_table
-    .add(WebGPUBindGroupLayout(bind_group_layout));
+    .add(WebGpuBindGroupLayout(bind_group_layout));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from)
+    "err": maybe_err.map(WebGpuError::from)
   }))
 }
 
@@ -229,7 +229,7 @@ pub fn op_webgpu_create_pipeline_layout(
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
-    .get::<super::WebGPUDevice>(args.device_rid)
+    .get::<super::WebGpuDevice>(args.device_rid)
     .ok_or_else(bad_resource_id)?;
   let device = device_resource.0;
 
@@ -238,7 +238,7 @@ pub fn op_webgpu_create_pipeline_layout(
   for rid in &args.bind_group_layouts {
     let bind_group_layout = state
       .resource_table
-      .get::<WebGPUBindGroupLayout>(*rid)
+      .get::<WebGpuBindGroupLayout>(*rid)
       .ok_or_else(bad_resource_id)?;
     bind_group_layouts.push(bind_group_layout.0);
   }
@@ -257,17 +257,17 @@ pub fn op_webgpu_create_pipeline_layout(
 
   let rid = state
     .resource_table
-    .add(super::pipeline::WebGPUPipelineLayout(pipeline_layout));
+    .add(super::pipeline::WebGpuPipelineLayout(pipeline_layout));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from)
+    "err": maybe_err.map(WebGpuError::from)
   }))
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUBindGroupEntry {
+struct GpuBindGroupEntry {
   binding: u32,
   kind: String,
   resource: u32,
@@ -281,7 +281,7 @@ pub struct CreateBindGroupArgs {
   device_rid: ResourceId,
   label: Option<String>,
   layout: u32,
-  entries: Vec<GPUBindGroupEntry>,
+  entries: Vec<GpuBindGroupEntry>,
 }
 
 pub fn op_webgpu_create_bind_group(
@@ -292,7 +292,7 @@ pub fn op_webgpu_create_bind_group(
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
-    .get::<super::WebGPUDevice>(args.device_rid)
+    .get::<super::WebGpuDevice>(args.device_rid)
     .ok_or_else(bad_resource_id)?;
   let device = device_resource.0;
 
@@ -305,14 +305,14 @@ pub fn op_webgpu_create_bind_group(
         "GPUSampler" => {
           let sampler_resource = state
             .resource_table
-            .get::<super::sampler::WebGPUSampler>(entry.resource)
+            .get::<super::sampler::WebGpuSampler>(entry.resource)
             .ok_or_else(bad_resource_id)?;
           wgpu_core::binding_model::BindingResource::Sampler(sampler_resource.0)
         }
         "GPUTextureView" => {
           let texture_view_resource = state
             .resource_table
-            .get::<super::texture::WebGPUTextureView>(entry.resource)
+            .get::<super::texture::WebGpuTextureView>(entry.resource)
             .ok_or_else(bad_resource_id)?;
           wgpu_core::binding_model::BindingResource::TextureView(
             texture_view_resource.0,
@@ -321,7 +321,7 @@ pub fn op_webgpu_create_bind_group(
         "GPUBufferBinding" => {
           let buffer_resource = state
             .resource_table
-            .get::<super::buffer::WebGPUBuffer>(entry.resource)
+            .get::<super::buffer::WebGpuBuffer>(entry.resource)
             .ok_or_else(bad_resource_id)?;
           wgpu_core::binding_model::BindingResource::Buffer(
             wgpu_core::binding_model::BufferBinding {
@@ -339,7 +339,7 @@ pub fn op_webgpu_create_bind_group(
 
   let bind_group_layout = state
     .resource_table
-    .get::<WebGPUBindGroupLayout>(args.layout)
+    .get::<WebGpuBindGroupLayout>(args.layout)
     .ok_or_else(bad_resource_id)?;
 
   let descriptor = wgpu_core::binding_model::BindGroupDescriptor {
@@ -354,10 +354,10 @@ pub fn op_webgpu_create_bind_group(
     std::marker::PhantomData
   ));
 
-  let rid = state.resource_table.add(WebGPUBindGroup(bind_group));
+  let rid = state.resource_table.add(WebGpuBindGroup(bind_group));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from)
+    "err": maybe_err.map(WebGpuError::from)
   }))
 }
diff --git a/op_crates/webgpu/buffer.rs b/op_crates/webgpu/buffer.rs
index 6845279d6..91a44f214 100644
--- a/op_crates/webgpu/buffer.rs
+++ b/op_crates/webgpu/buffer.rs
@@ -15,18 +15,18 @@ use std::cell::RefCell;
 use std::rc::Rc;
 use std::time::Duration;
 
-use super::error::DOMExceptionOperationError;
-use super::error::WebGPUError;
+use super::error::DomExceptionOperationError;
+use super::error::WebGpuError;
 
-pub(crate) struct WebGPUBuffer(pub(crate) wgpu_core::id::BufferId);
-impl Resource for WebGPUBuffer {
+pub(crate) struct WebGpuBuffer(pub(crate) wgpu_core::id::BufferId);
+impl Resource for WebGpuBuffer {
   fn name(&self) -> Cow<str> {
     "webGPUBuffer".into()
   }
 }
 
-struct WebGPUBufferMapped(*mut u8, usize);
-impl Resource for WebGPUBufferMapped {
+struct WebGpuBufferMapped(*mut u8, usize);
+impl Resource for WebGpuBufferMapped {
   fn name(&self) -> Cow<str> {
     "webGPUBufferMapped".into()
   }
@@ -50,7 +50,7 @@ pub fn op_webgpu_create_buffer(
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
-    .get::<super::WebGPUDevice>(args.device_rid)
+    .get::<super::WebGpuDevice>(args.device_rid)
     .ok_or_else(bad_resource_id)?;
   let device = device_resource.0;
 
@@ -67,11 +67,11 @@ pub fn op_webgpu_create_buffer(
     std::marker::PhantomData
   ));
 
-  let rid = state.resource_table.add(WebGPUBuffer(buffer));
+  let rid = state.resource_table.add(WebGpuBuffer(buffer));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from)
+    "err": maybe_err.map(WebGpuError::from)
   }))
 }
 
@@ -98,12 +98,12 @@ pub async fn op_webgpu_buffer_get_map_async(
     let instance = state_.borrow::<super::Instance>();
     let buffer_resource = state_
       .resource_table
-      .get::<WebGPUBuffer>(args.buffer_rid)
+      .get::<WebGpuBuffer>(args.buffer_rid)
       .ok_or_else(bad_resource_id)?;
     let buffer = buffer_resource.0;
     let device_resource = state_
       .resource_table
-      .get::<super::WebGPUDevice>(args.device_rid)
+      .get::<super::WebGpuDevice>(args.device_rid)
       .ok_or_else(bad_resource_id)?;
     device = device_resource.0;
 
@@ -182,7 +182,7 @@ pub fn op_webgpu_buffer_get_mapped_range(
   let instance = state.borrow::<super::Instance>();
   let buffer_resource = state
     .resource_table
-    .get::<WebGPUBuffer>(args.buffer_rid)
+    .get::<WebGpuBuffer>(args.buffer_rid)
     .ok_or_else(bad_resource_id)?;
   let buffer = buffer_resource.0;
 
@@ -191,7 +191,7 @@ pub fn op_webgpu_buffer_get_mapped_range(
     args.offset,
     std::num::NonZeroU64::new(args.size)
   ))
-  .map_err(|e| DOMExceptionOperationError::new(&e.to_string()))?;
+  .map_err(|e| DomExceptionOperationError::new(&e.to_string()))?;
 
   let slice = unsafe {
     std::slice::from_raw_parts_mut(slice_pointer, args.size as usize)
@@ -200,7 +200,7 @@ pub fn op_webgpu_buffer_get_mapped_range(
 
   let rid = state
     .resource_table
-    .add(WebGPUBufferMapped(slice_pointer, args.size as usize));
+    .add(WebGpuBufferMapped(slice_pointer, args.size as usize));
 
   Ok(json!({
     "rid": rid,
@@ -221,12 +221,12 @@ pub fn op_webgpu_buffer_unmap(
 ) -> Result<Value, AnyError> {
   let mapped_resource = state
     .resource_table
-    .take::<WebGPUBufferMapped>(args.mapped_rid)
+    .take::<WebGpuBufferMapped>(args.mapped_rid)
     .ok_or_else(bad_resource_id)?;
   let instance = state.borrow::<super::Instance>();
   let buffer_resource = state
     .resource_table
-    .get::<WebGPUBuffer>(args.buffer_rid)
+    .get::<WebGpuBuffer>(args.buffer_rid)
     .ok_or_else(bad_resource_id)?;
   let buffer = buffer_resource.0;
 
@@ -240,5 +240,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(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
diff --git a/op_crates/webgpu/bundle.rs b/op_crates/webgpu/bundle.rs
index 4ef64d883..406b886cc 100644
--- a/op_crates/webgpu/bundle.rs
+++ b/op_crates/webgpu/bundle.rs
@@ -12,20 +12,20 @@ use std::borrow::Cow;
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use super::error::WebGPUError;
+use super::error::WebGpuError;
 use super::texture::serialize_texture_format;
 
-struct WebGPURenderBundleEncoder(
+struct WebGpuRenderBundleEncoder(
   RefCell<wgpu_core::command::RenderBundleEncoder>,
 );
-impl Resource for WebGPURenderBundleEncoder {
+impl Resource for WebGpuRenderBundleEncoder {
   fn name(&self) -> Cow<str> {
     "webGPURenderBundleEncoder".into()
   }
 }
 
-pub(crate) struct WebGPURenderBundle(pub(crate) wgpu_core::id::RenderBundleId);
-impl Resource for WebGPURenderBundle {
+pub(crate) struct WebGpuRenderBundle(pub(crate) wgpu_core::id::RenderBundleId);
+impl Resource for WebGpuRenderBundle {
   fn name(&self) -> Cow<str> {
     "webGPURenderBundle".into()
   }
@@ -48,7 +48,7 @@ pub fn op_webgpu_create_render_bundle_encoder(
 ) -> Result<Value, AnyError> {
   let device_resource = state
     .resource_table
-    .get::<super::WebGPUDevice>(args.device_rid)
+    .get::<super::WebGpuDevice>(args.device_rid)
     .ok_or_else(bad_resource_id)?;
   let device = device_resource.0;
 
@@ -80,13 +80,13 @@ pub fn op_webgpu_create_render_bundle_encoder(
 
   let rid = state
     .resource_table
-    .add(WebGPURenderBundleEncoder(RefCell::new(
+    .add(WebGpuRenderBundleEncoder(RefCell::new(
       render_bundle_encoder,
     )));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from),
+    "err": maybe_err.map(WebGpuError::from),
   }))
 }
 
@@ -104,7 +104,7 @@ pub fn op_webgpu_render_bundle_encoder_finish(
 ) -> Result<Value, AnyError> {
   let render_bundle_encoder_resource = state
     .resource_table
-    .take::<WebGPURenderBundleEncoder>(args.render_bundle_encoder_rid)
+    .take::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
     .ok_or_else(bad_resource_id)?;
   let render_bundle_encoder = Rc::try_unwrap(render_bundle_encoder_resource)
     .ok()
@@ -121,11 +121,11 @@ pub fn op_webgpu_render_bundle_encoder_finish(
     std::marker::PhantomData
   ));
 
-  let rid = state.resource_table.add(WebGPURenderBundle(render_bundle));
+  let rid = state.resource_table.add(WebGpuRenderBundle(render_bundle));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from)
+    "err": maybe_err.map(WebGpuError::from)
   }))
 }
 
@@ -147,11 +147,11 @@ pub fn op_webgpu_render_bundle_encoder_set_bind_group(
 ) -> Result<Value, AnyError> {
   let bind_group_resource = state
     .resource_table
-    .get::<super::binding::WebGPUBindGroup>(args.bind_group)
+    .get::<super::binding::WebGpuBindGroup>(args.bind_group)
     .ok_or_else(bad_resource_id)?;
   let render_bundle_encoder_resource = state
     .resource_table
-    .get::<WebGPURenderBundleEncoder>(args.render_bundle_encoder_rid)
+    .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
     .ok_or_else(bad_resource_id)?;
 
   // I know this might look like it can be easily deduplicated, but it can not
@@ -202,7 +202,7 @@ pub fn op_webgpu_render_bundle_encoder_push_debug_group(
 ) -> Result<Value, AnyError> {
   let render_bundle_encoder_resource = state
     .resource_table
-    .get::<WebGPURenderBundleEncoder>(args.render_bundle_encoder_rid)
+    .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -229,7 +229,7 @@ pub fn op_webgpu_render_bundle_encoder_pop_debug_group(
 ) -> Result<Value, AnyError> {
   let render_bundle_encoder_resource = state
     .resource_table
-    .get::<WebGPURenderBundleEncoder>(args.render_bundle_encoder_rid)
+    .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -255,7 +255,7 @@ pub fn op_webgpu_render_bundle_encoder_insert_debug_marker(
 ) -> Result<Value, AnyError> {
   let render_bundle_encoder_resource = state
     .resource_table
-    .get::<WebGPURenderBundleEncoder>(args.render_bundle_encoder_rid)
+    .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -283,11 +283,11 @@ pub fn op_webgpu_render_bundle_encoder_set_pipeline(
 ) -> Result<Value, AnyError> {
   let render_pipeline_resource = state
     .resource_table
-    .get::<super::pipeline::WebGPURenderPipeline>(args.pipeline)
+    .get::<super::pipeline::WebGpuRenderPipeline>(args.pipeline)
     .ok_or_else(bad_resource_id)?;
   let render_bundle_encoder_resource = state
     .resource_table
-    .get::<WebGPURenderBundleEncoder>(args.render_bundle_encoder_rid)
+    .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::bundle_ffi::wgpu_render_bundle_set_pipeline(
@@ -315,11 +315,11 @@ pub fn op_webgpu_render_bundle_encoder_set_index_buffer(
 ) -> Result<Value, AnyError> {
   let buffer_resource = state
     .resource_table
-    .get::<super::buffer::WebGPUBuffer>(args.buffer)
+    .get::<super::buffer::WebGpuBuffer>(args.buffer)
     .ok_or_else(bad_resource_id)?;
   let render_bundle_encoder_resource = state
     .resource_table
-    .get::<WebGPURenderBundleEncoder>(args.render_bundle_encoder_rid)
+    .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
     .ok_or_else(bad_resource_id)?;
 
   render_bundle_encoder_resource
@@ -352,11 +352,11 @@ pub fn op_webgpu_render_bundle_encoder_set_vertex_buffer(
 ) -> Result<Value, AnyError> {
   let buffer_resource = state
     .resource_table
-    .get::<super::buffer::WebGPUBuffer>(args.buffer)
+    .get::<super::buffer::WebGpuBuffer>(args.buffer)
     .ok_or_else(bad_resource_id)?;
   let render_bundle_encoder_resource = state
     .resource_table
-    .get::<WebGPURenderBundleEncoder>(args.render_bundle_encoder_rid)
+    .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::bundle_ffi::wgpu_render_bundle_set_vertex_buffer(
@@ -387,7 +387,7 @@ pub fn op_webgpu_render_bundle_encoder_draw(
 ) -> Result<Value, AnyError> {
   let render_bundle_encoder_resource = state
     .resource_table
-    .get::<WebGPURenderBundleEncoder>(args.render_bundle_encoder_rid)
+    .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::bundle_ffi::wgpu_render_bundle_draw(
@@ -419,7 +419,7 @@ pub fn op_webgpu_render_bundle_encoder_draw_indexed(
 ) -> Result<Value, AnyError> {
   let render_bundle_encoder_resource = state
     .resource_table
-    .get::<WebGPURenderBundleEncoder>(args.render_bundle_encoder_rid)
+    .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::bundle_ffi::wgpu_render_bundle_draw_indexed(
@@ -449,11 +449,11 @@ pub fn op_webgpu_render_bundle_encoder_draw_indirect(
 ) -> Result<Value, AnyError> {
   let buffer_resource = state
     .resource_table
-    .get::<super::buffer::WebGPUBuffer>(args.indirect_buffer)
+    .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)
     .ok_or_else(bad_resource_id)?;
   let render_bundle_encoder_resource = state
     .resource_table
-    .get::<WebGPURenderBundleEncoder>(args.render_bundle_encoder_rid)
+    .get::<WebGpuRenderBundleEncoder>(args.render_bundle_encoder_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::bundle_ffi::wgpu_render_bundle_draw_indirect(
diff --git a/op_crates/webgpu/command_encoder.rs b/op_crates/webgpu/command_encoder.rs
index 43d1d68f0..5ca26ccd0 100644
--- a/op_crates/webgpu/command_encoder.rs
+++ b/op_crates/webgpu/command_encoder.rs
@@ -11,21 +11,21 @@ use serde::Deserialize;
 use std::borrow::Cow;
 use std::cell::RefCell;
 
-use super::error::WebGPUError;
+use super::error::WebGpuError;
 
-pub(crate) struct WebGPUCommandEncoder(
+pub(crate) struct WebGpuCommandEncoder(
   pub(crate) wgpu_core::id::CommandEncoderId,
 );
-impl Resource for WebGPUCommandEncoder {
+impl Resource for WebGpuCommandEncoder {
   fn name(&self) -> Cow<str> {
     "webGPUCommandEncoder".into()
   }
 }
 
-pub(crate) struct WebGPUCommandBuffer(
+pub(crate) struct WebGpuCommandBuffer(
   pub(crate) wgpu_core::id::CommandBufferId,
 );
-impl Resource for WebGPUCommandBuffer {
+impl Resource for WebGpuCommandBuffer {
   fn name(&self) -> Cow<str> {
     "webGPUCommandBuffer".into()
   }
@@ -55,7 +55,7 @@ pub fn op_webgpu_create_command_encoder(
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
-    .get::<super::WebGPUDevice>(args.device_rid)
+    .get::<super::WebGpuDevice>(args.device_rid)
     .ok_or_else(bad_resource_id)?;
   let device = device_resource.0;
 
@@ -71,27 +71,27 @@ pub fn op_webgpu_create_command_encoder(
 
   let rid = state
     .resource_table
-    .add(WebGPUCommandEncoder(command_encoder));
+    .add(WebGpuCommandEncoder(command_encoder));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from),
+    "err": maybe_err.map(WebGpuError::from),
   }))
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct GPURenderPassColorAttachment {
+pub struct GpuRenderPassColorAttachment {
   view: u32,
   resolve_target: Option<u32>,
   load_op: String,
-  load_value: Option<super::render_pass::GPUColor>,
+  load_value: Option<super::render_pass::GpuColor>,
   store_op: Option<String>,
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPURenderPassDepthStencilAttachment {
+struct GpuRenderPassDepthStencilAttachment {
   view: u32,
   depth_load_op: String,
   depth_load_value: Option<f32>,
@@ -108,8 +108,8 @@ struct GPURenderPassDepthStencilAttachment {
 pub struct CommandEncoderBeginRenderPassArgs {
   command_encoder_rid: ResourceId,
   label: Option<String>,
-  color_attachments: Vec<GPURenderPassColorAttachment>,
-  depth_stencil_attachment: Option<GPURenderPassDepthStencilAttachment>,
+  color_attachments: Vec<GpuRenderPassColorAttachment>,
+  depth_stencil_attachment: Option<GpuRenderPassDepthStencilAttachment>,
   _occlusion_query_set: Option<u32>, // not yet implemented
 }
 
@@ -120,7 +120,7 @@ pub fn op_webgpu_command_encoder_begin_render_pass(
 ) -> Result<Value, AnyError> {
   let command_encoder_resource = state
     .resource_table
-    .get::<WebGPUCommandEncoder>(args.command_encoder_rid)
+    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
     .ok_or_else(bad_resource_id)?;
 
   let mut color_attachments = vec![];
@@ -128,7 +128,7 @@ pub fn op_webgpu_command_encoder_begin_render_pass(
   for color_attachment in args.color_attachments {
     let texture_view_resource = state
       .resource_table
-      .get::<super::texture::WebGPUTextureView>(color_attachment.view)
+      .get::<super::texture::WebGpuTextureView>(color_attachment.view)
       .ok_or_else(bad_resource_id)?;
 
     let attachment = wgpu_core::command::ColorAttachmentDescriptor {
@@ -138,7 +138,7 @@ pub fn op_webgpu_command_encoder_begin_render_pass(
         .map(|rid| {
           state
             .resource_table
-            .get::<super::texture::WebGPUTextureView>(rid)
+            .get::<super::texture::WebGpuTextureView>(rid)
             .ok_or_else(bad_resource_id)
         })
         .transpose()?
@@ -180,7 +180,7 @@ pub fn op_webgpu_command_encoder_begin_render_pass(
   if let Some(attachment) = args.depth_stencil_attachment {
     let texture_view_resource = state
       .resource_table
-      .get::<super::texture::WebGPUTextureView>(attachment.view)
+      .get::<super::texture::WebGpuTextureView>(attachment.view)
       .ok_or_else(bad_resource_id)?;
 
     depth_stencil_attachment =
@@ -232,7 +232,7 @@ pub fn op_webgpu_command_encoder_begin_render_pass(
 
   let rid = state
     .resource_table
-    .add(super::render_pass::WebGPURenderPass(RefCell::new(
+    .add(super::render_pass::WebGpuRenderPass(RefCell::new(
       render_pass,
     )));
 
@@ -255,7 +255,7 @@ pub fn op_webgpu_command_encoder_begin_compute_pass(
 ) -> Result<Value, AnyError> {
   let command_encoder_resource = state
     .resource_table
-    .get::<WebGPUCommandEncoder>(args.command_encoder_rid)
+    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
     .ok_or_else(bad_resource_id)?;
 
   let descriptor = wgpu_core::command::ComputePassDescriptor {
@@ -269,7 +269,7 @@ pub fn op_webgpu_command_encoder_begin_compute_pass(
 
   let rid = state
     .resource_table
-    .add(super::compute_pass::WebGPUComputePass(RefCell::new(
+    .add(super::compute_pass::WebGpuComputePass(RefCell::new(
       compute_pass,
     )));
 
@@ -297,17 +297,17 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_buffer(
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
-    .get::<WebGPUCommandEncoder>(args.command_encoder_rid)
+    .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)
+    .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)
+    .get::<super::buffer::WebGpuBuffer>(args.destination)
     .ok_or_else(bad_resource_id)?;
   let destination_buffer = destination_buffer_resource.0;
 
@@ -320,12 +320,12 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_buffer(
     args.size
   )).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGPUError::from) }))
+  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct GPUImageCopyBuffer {
+pub struct GpuImageCopyBuffer {
   buffer: u32,
   offset: Option<u64>,
   bytes_per_row: Option<u32>,
@@ -334,7 +334,7 @@ pub struct GPUImageCopyBuffer {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct GPUOrigin3D {
+pub struct GpuOrigin3D {
   pub x: Option<u32>,
   pub y: Option<u32>,
   pub z: Option<u32>,
@@ -342,10 +342,10 @@ pub struct GPUOrigin3D {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct GPUImageCopyTexture {
+pub struct GpuImageCopyTexture {
   pub texture: u32,
   pub mip_level: Option<u32>,
-  pub origin: Option<GPUOrigin3D>,
+  pub origin: Option<GpuOrigin3D>,
   pub _aspect: Option<String>, // not yet implemented
 }
 
@@ -353,9 +353,9 @@ pub struct GPUImageCopyTexture {
 #[serde(rename_all = "camelCase")]
 pub struct CommandEncoderCopyBufferToTextureArgs {
   command_encoder_rid: ResourceId,
-  source: GPUImageCopyBuffer,
-  destination: GPUImageCopyTexture,
-  copy_size: super::texture::GPUExtent3D,
+  source: GpuImageCopyBuffer,
+  destination: GpuImageCopyTexture,
+  copy_size: super::texture::GpuExtent3D,
 }
 
 pub fn op_webgpu_command_encoder_copy_buffer_to_texture(
@@ -366,16 +366,16 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_texture(
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
-    .get::<WebGPUCommandEncoder>(args.command_encoder_rid)
+    .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)
+    .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)
+    .get::<super::texture::WebGpuTexture>(args.destination.texture)
     .ok_or_else(bad_resource_id)?;
 
   let source = wgpu_core::command::BufferCopyView {
@@ -409,16 +409,16 @@ pub fn op_webgpu_command_encoder_copy_buffer_to_texture(
     }
   )).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGPUError::from) }))
+  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CommandEncoderCopyTextureToBufferArgs {
   command_encoder_rid: ResourceId,
-  source: GPUImageCopyTexture,
-  destination: GPUImageCopyBuffer,
-  copy_size: super::texture::GPUExtent3D,
+  source: GpuImageCopyTexture,
+  destination: GpuImageCopyBuffer,
+  copy_size: super::texture::GpuExtent3D,
 }
 
 pub fn op_webgpu_command_encoder_copy_texture_to_buffer(
@@ -429,16 +429,16 @@ pub fn op_webgpu_command_encoder_copy_texture_to_buffer(
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
-    .get::<WebGPUCommandEncoder>(args.command_encoder_rid)
+    .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)
+    .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)
+    .get::<super::buffer::WebGpuBuffer>(args.destination.buffer)
     .ok_or_else(bad_resource_id)?;
 
   let source = wgpu_core::command::TextureCopyView {
@@ -471,16 +471,16 @@ pub fn op_webgpu_command_encoder_copy_texture_to_buffer(
     }
   )).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGPUError::from) }))
+  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CommandEncoderCopyTextureToTextureArgs {
   command_encoder_rid: ResourceId,
-  source: GPUImageCopyTexture,
-  destination: GPUImageCopyTexture,
-  copy_size: super::texture::GPUExtent3D,
+  source: GpuImageCopyTexture,
+  destination: GpuImageCopyTexture,
+  copy_size: super::texture::GpuExtent3D,
 }
 
 pub fn op_webgpu_command_encoder_copy_texture_to_texture(
@@ -491,16 +491,16 @@ pub fn op_webgpu_command_encoder_copy_texture_to_texture(
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
-    .get::<WebGPUCommandEncoder>(args.command_encoder_rid)
+    .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)
+    .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)
+    .get::<super::texture::WebGpuTexture>(args.destination.texture)
     .ok_or_else(bad_resource_id)?;
 
   let source = wgpu_core::command::TextureCopyView {
@@ -537,7 +537,7 @@ pub fn op_webgpu_command_encoder_copy_texture_to_texture(
     }
   )).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGPUError::from) }))
+  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
 
 #[derive(Deserialize)]
@@ -555,7 +555,7 @@ pub fn op_webgpu_command_encoder_push_debug_group(
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
-    .get::<WebGPUCommandEncoder>(args.command_encoder_rid)
+    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
     .ok_or_else(bad_resource_id)?;
   let command_encoder = command_encoder_resource.0;
 
@@ -563,7 +563,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(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
 
 #[derive(Deserialize)]
@@ -580,13 +580,13 @@ pub fn op_webgpu_command_encoder_pop_debug_group(
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
-    .get::<WebGPUCommandEncoder>(args.command_encoder_rid)
+    .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(json!({ "err": maybe_err.map(WebGPUError::from) }))
+  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
 
 #[derive(Deserialize)]
@@ -604,7 +604,7 @@ pub fn op_webgpu_command_encoder_insert_debug_marker(
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
-    .get::<WebGPUCommandEncoder>(args.command_encoder_rid)
+    .get::<WebGpuCommandEncoder>(args.command_encoder_rid)
     .ok_or_else(bad_resource_id)?;
   let command_encoder = command_encoder_resource.0;
 
@@ -613,7 +613,7 @@ pub fn op_webgpu_command_encoder_insert_debug_marker(
     &args.marker_label
   )).err();
 
-  Ok(json!({ "err": maybe_err.map(WebGPUError::from) }))
+  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
 
 #[derive(Deserialize)]
@@ -632,12 +632,12 @@ pub fn op_webgpu_command_encoder_write_timestamp(
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
-    .get::<WebGPUCommandEncoder>(args.command_encoder_rid)
+    .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)
+    .get::<super::WebGpuQuerySet>(args.query_set)
     .ok_or_else(bad_resource_id)?;
 
   let maybe_err =
@@ -648,7 +648,7 @@ pub fn op_webgpu_command_encoder_write_timestamp(
     ))
     .err();
 
-  Ok(json!({ "err": maybe_err.map(WebGPUError::from) }))
+  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
 
 #[derive(Deserialize)]
@@ -670,16 +670,16 @@ pub fn op_webgpu_command_encoder_resolve_query_set(
   let instance = state.borrow::<super::Instance>();
   let command_encoder_resource = state
     .resource_table
-    .get::<WebGPUCommandEncoder>(args.command_encoder_rid)
+    .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)
+    .get::<super::WebGpuQuerySet>(args.query_set)
     .ok_or_else(bad_resource_id)?;
   let destination_resource = state
     .resource_table
-    .get::<super::buffer::WebGPUBuffer>(args.destination)
+    .get::<super::buffer::WebGpuBuffer>(args.destination)
     .ok_or_else(bad_resource_id)?;
 
   let maybe_err =
@@ -693,7 +693,7 @@ pub fn op_webgpu_command_encoder_resolve_query_set(
     ))
     .err();
 
-  Ok(json!({ "err": maybe_err.map(WebGPUError::from) }))
+  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
 
 #[derive(Deserialize)]
@@ -710,7 +710,7 @@ pub fn op_webgpu_command_encoder_finish(
 ) -> Result<Value, AnyError> {
   let command_encoder_resource = state
     .resource_table
-    .take::<WebGPUCommandEncoder>(args.command_encoder_rid)
+    .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>();
@@ -726,10 +726,10 @@ pub fn op_webgpu_command_encoder_finish(
 
   let rid = state
     .resource_table
-    .add(WebGPUCommandBuffer(command_buffer));
+    .add(WebGpuCommandBuffer(command_buffer));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from)
+    "err": maybe_err.map(WebGpuError::from)
   }))
 }
diff --git a/op_crates/webgpu/compute_pass.rs b/op_crates/webgpu/compute_pass.rs
index 9e1285dcb..b9d5b12d3 100644
--- a/op_crates/webgpu/compute_pass.rs
+++ b/op_crates/webgpu/compute_pass.rs
@@ -11,12 +11,12 @@ use serde::Deserialize;
 use std::borrow::Cow;
 use std::cell::RefCell;
 
-use super::error::WebGPUError;
+use super::error::WebGpuError;
 
-pub(crate) struct WebGPUComputePass(
+pub(crate) struct WebGpuComputePass(
   pub(crate) RefCell<wgpu_core::command::ComputePass>,
 );
-impl Resource for WebGPUComputePass {
+impl Resource for WebGpuComputePass {
   fn name(&self) -> Cow<str> {
     "webGPUComputePass".into()
   }
@@ -36,11 +36,11 @@ pub fn op_webgpu_compute_pass_set_pipeline(
 ) -> Result<Value, AnyError> {
   let compute_pipeline_resource = state
     .resource_table
-    .get::<super::pipeline::WebGPUComputePipeline>(args.pipeline)
+    .get::<super::pipeline::WebGpuComputePipeline>(args.pipeline)
     .ok_or_else(bad_resource_id)?;
   let compute_pass_resource = state
     .resource_table
-    .get::<WebGPUComputePass>(args.compute_pass_rid)
+    .get::<WebGpuComputePass>(args.compute_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::compute_ffi::wgpu_compute_pass_set_pipeline(
@@ -67,7 +67,7 @@ pub fn op_webgpu_compute_pass_dispatch(
 ) -> Result<Value, AnyError> {
   let compute_pass_resource = state
     .resource_table
-    .get::<WebGPUComputePass>(args.compute_pass_rid)
+    .get::<WebGpuComputePass>(args.compute_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::compute_ffi::wgpu_compute_pass_dispatch(
@@ -95,11 +95,11 @@ pub fn op_webgpu_compute_pass_dispatch_indirect(
 ) -> Result<Value, AnyError> {
   let buffer_resource = state
     .resource_table
-    .get::<super::buffer::WebGPUBuffer>(args.indirect_buffer)
+    .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)
     .ok_or_else(bad_resource_id)?;
   let compute_pass_resource = state
     .resource_table
-    .get::<WebGPUComputePass>(args.compute_pass_rid)
+    .get::<WebGpuComputePass>(args.compute_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::compute_ffi::wgpu_compute_pass_dispatch_indirect(
@@ -126,11 +126,11 @@ pub fn op_webgpu_compute_pass_begin_pipeline_statistics_query(
 ) -> Result<Value, AnyError> {
   let compute_pass_resource = state
     .resource_table
-    .get::<WebGPUComputePass>(args.compute_pass_rid)
+    .get::<WebGpuComputePass>(args.compute_pass_rid)
     .ok_or_else(bad_resource_id)?;
   let query_set_resource = state
     .resource_table
-    .get::<super::WebGPUQuerySet>(args.query_set)
+    .get::<super::WebGpuQuerySet>(args.query_set)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -157,7 +157,7 @@ pub fn op_webgpu_compute_pass_end_pipeline_statistics_query(
 ) -> Result<Value, AnyError> {
   let compute_pass_resource = state
     .resource_table
-    .get::<WebGPUComputePass>(args.compute_pass_rid)
+    .get::<WebGpuComputePass>(args.compute_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -184,11 +184,11 @@ pub fn op_webgpu_compute_pass_write_timestamp(
 ) -> Result<Value, AnyError> {
   let compute_pass_resource = state
     .resource_table
-    .get::<WebGPUComputePass>(args.compute_pass_rid)
+    .get::<WebGpuComputePass>(args.compute_pass_rid)
     .ok_or_else(bad_resource_id)?;
   let query_set_resource = state
     .resource_table
-    .get::<super::WebGPUQuerySet>(args.query_set)
+    .get::<super::WebGpuQuerySet>(args.query_set)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -216,14 +216,14 @@ pub fn op_webgpu_compute_pass_end_pass(
 ) -> Result<Value, AnyError> {
   let command_encoder_resource = state
     .resource_table
-    .get::<super::command_encoder::WebGPUCommandEncoder>(
+    .get::<super::command_encoder::WebGpuCommandEncoder>(
       args.command_encoder_rid,
     )
     .ok_or_else(bad_resource_id)?;
   let command_encoder = command_encoder_resource.0;
   let compute_pass_resource = state
     .resource_table
-    .take::<WebGPUComputePass>(args.compute_pass_rid)
+    .take::<WebGpuComputePass>(args.compute_pass_rid)
     .ok_or_else(bad_resource_id)?;
   let compute_pass = &compute_pass_resource.0.borrow();
   let instance = state.borrow::<super::Instance>();
@@ -235,7 +235,7 @@ pub fn op_webgpu_compute_pass_end_pass(
     ))
     .err();
 
-  Ok(json!({ "err": maybe_err.map(WebGPUError::from) }))
+  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
 
 #[derive(Deserialize)]
@@ -256,11 +256,11 @@ pub fn op_webgpu_compute_pass_set_bind_group(
 ) -> Result<Value, AnyError> {
   let bind_group_resource = state
     .resource_table
-    .get::<super::binding::WebGPUBindGroup>(args.bind_group)
+    .get::<super::binding::WebGpuBindGroup>(args.bind_group)
     .ok_or_else(bad_resource_id)?;
   let compute_pass_resource = state
     .resource_table
-    .get::<WebGPUComputePass>(args.compute_pass_rid)
+    .get::<WebGpuComputePass>(args.compute_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -298,7 +298,7 @@ pub fn op_webgpu_compute_pass_push_debug_group(
 ) -> Result<Value, AnyError> {
   let compute_pass_resource = state
     .resource_table
-    .get::<WebGPUComputePass>(args.compute_pass_rid)
+    .get::<WebGpuComputePass>(args.compute_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -326,7 +326,7 @@ pub fn op_webgpu_compute_pass_pop_debug_group(
 ) -> Result<Value, AnyError> {
   let compute_pass_resource = state
     .resource_table
-    .get::<WebGPUComputePass>(args.compute_pass_rid)
+    .get::<WebGpuComputePass>(args.compute_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::compute_ffi::wgpu_compute_pass_pop_debug_group(
@@ -350,7 +350,7 @@ pub fn op_webgpu_compute_pass_insert_debug_marker(
 ) -> Result<Value, AnyError> {
   let compute_pass_resource = state
     .resource_table
-    .get::<WebGPUComputePass>(args.compute_pass_rid)
+    .get::<WebGpuComputePass>(args.compute_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
diff --git a/op_crates/webgpu/error.rs b/op_crates/webgpu/error.rs
index e793dabfa..52741d984 100644
--- a/op_crates/webgpu/error.rs
+++ b/op_crates/webgpu/error.rs
@@ -29,81 +29,81 @@ use wgpu_core::resource::CreateTextureViewError;
 #[derive(Serialize)]
 #[serde(tag = "type", content = "value")]
 #[serde(rename_all = "kebab-case")]
-pub enum WebGPUError {
+pub enum WebGpuError {
   Lost,
   OutOfMemory,
   Validation(String),
 }
 
-impl From<CreateBufferError> for WebGPUError {
+impl From<CreateBufferError> for WebGpuError {
   fn from(err: CreateBufferError) -> Self {
     match err {
       CreateBufferError::Device(err) => err.into(),
       CreateBufferError::AccessError(err) => err.into(),
-      err => WebGPUError::Validation(err.to_string()),
+      err => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
-impl From<DeviceError> for WebGPUError {
+impl From<DeviceError> for WebGpuError {
   fn from(err: DeviceError) -> Self {
     match err {
-      DeviceError::Lost => WebGPUError::Lost,
-      DeviceError::OutOfMemory => WebGPUError::OutOfMemory,
-      DeviceError::Invalid => WebGPUError::Validation(err.to_string()),
+      DeviceError::Lost => WebGpuError::Lost,
+      DeviceError::OutOfMemory => WebGpuError::OutOfMemory,
+      DeviceError::Invalid => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
-impl From<BufferAccessError> for WebGPUError {
+impl From<BufferAccessError> for WebGpuError {
   fn from(err: BufferAccessError) -> Self {
     match err {
       BufferAccessError::Device(err) => err.into(),
-      err => WebGPUError::Validation(err.to_string()),
+      err => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
-impl From<CreateBindGroupLayoutError> for WebGPUError {
+impl From<CreateBindGroupLayoutError> for WebGpuError {
   fn from(err: CreateBindGroupLayoutError) -> Self {
     match err {
       CreateBindGroupLayoutError::Device(err) => err.into(),
-      err => WebGPUError::Validation(err.to_string()),
+      err => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
-impl From<CreatePipelineLayoutError> for WebGPUError {
+impl From<CreatePipelineLayoutError> for WebGpuError {
   fn from(err: CreatePipelineLayoutError) -> Self {
     match err {
       CreatePipelineLayoutError::Device(err) => err.into(),
-      err => WebGPUError::Validation(err.to_string()),
+      err => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
-impl From<CreateBindGroupError> for WebGPUError {
+impl From<CreateBindGroupError> for WebGpuError {
   fn from(err: CreateBindGroupError) -> Self {
     match err {
       CreateBindGroupError::Device(err) => err.into(),
-      err => WebGPUError::Validation(err.to_string()),
+      err => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
-impl From<RenderBundleError> for WebGPUError {
+impl From<RenderBundleError> for WebGpuError {
   fn from(err: RenderBundleError) -> Self {
-    WebGPUError::Validation(err.to_string())
+    WebGpuError::Validation(err.to_string())
   }
 }
 
-impl From<CreateRenderBundleError> for WebGPUError {
+impl From<CreateRenderBundleError> for WebGpuError {
   fn from(err: CreateRenderBundleError) -> Self {
-    WebGPUError::Validation(err.to_string())
+    WebGpuError::Validation(err.to_string())
   }
 }
 
-impl From<CommandAllocatorError> for WebGPUError {
+impl From<CommandAllocatorError> for WebGpuError {
   fn from(err: CommandAllocatorError) -> Self {
     match err {
       CommandAllocatorError::Device(err) => err.into(),
@@ -111,142 +111,142 @@ impl From<CommandAllocatorError> for WebGPUError {
   }
 }
 
-impl From<CopyError> for WebGPUError {
+impl From<CopyError> for WebGpuError {
   fn from(err: CopyError) -> Self {
-    WebGPUError::Validation(err.to_string())
+    WebGpuError::Validation(err.to_string())
   }
 }
 
-impl From<CommandEncoderError> for WebGPUError {
+impl From<CommandEncoderError> for WebGpuError {
   fn from(err: CommandEncoderError) -> Self {
-    WebGPUError::Validation(err.to_string())
+    WebGpuError::Validation(err.to_string())
   }
 }
 
-impl From<QueryError> for WebGPUError {
+impl From<QueryError> for WebGpuError {
   fn from(err: QueryError) -> Self {
-    WebGPUError::Validation(err.to_string())
+    WebGpuError::Validation(err.to_string())
   }
 }
 
-impl From<ComputePassError> for WebGPUError {
+impl From<ComputePassError> for WebGpuError {
   fn from(err: ComputePassError) -> Self {
-    WebGPUError::Validation(err.to_string())
+    WebGpuError::Validation(err.to_string())
   }
 }
 
-impl From<CreateComputePipelineError> for WebGPUError {
+impl From<CreateComputePipelineError> for WebGpuError {
   fn from(err: CreateComputePipelineError) -> Self {
     match err {
       CreateComputePipelineError::Device(err) => err.into(),
-      err => WebGPUError::Validation(err.to_string()),
+      err => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
-impl From<GetBindGroupLayoutError> for WebGPUError {
+impl From<GetBindGroupLayoutError> for WebGpuError {
   fn from(err: GetBindGroupLayoutError) -> Self {
-    WebGPUError::Validation(err.to_string())
+    WebGpuError::Validation(err.to_string())
   }
 }
 
-impl From<CreateRenderPipelineError> for WebGPUError {
+impl From<CreateRenderPipelineError> for WebGpuError {
   fn from(err: CreateRenderPipelineError) -> Self {
     match err {
       CreateRenderPipelineError::Device(err) => err.into(),
-      err => WebGPUError::Validation(err.to_string()),
+      err => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
-impl From<RenderPassError> for WebGPUError {
+impl From<RenderPassError> for WebGpuError {
   fn from(err: RenderPassError) -> Self {
-    WebGPUError::Validation(err.to_string())
+    WebGpuError::Validation(err.to_string())
   }
 }
 
-impl From<CreateSamplerError> for WebGPUError {
+impl From<CreateSamplerError> for WebGpuError {
   fn from(err: CreateSamplerError) -> Self {
     match err {
       CreateSamplerError::Device(err) => err.into(),
-      err => WebGPUError::Validation(err.to_string()),
+      err => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
-impl From<CreateShaderModuleError> for WebGPUError {
+impl From<CreateShaderModuleError> for WebGpuError {
   fn from(err: CreateShaderModuleError) -> Self {
     match err {
       CreateShaderModuleError::Device(err) => err.into(),
-      err => WebGPUError::Validation(err.to_string()),
+      err => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
-impl From<CreateTextureError> for WebGPUError {
+impl From<CreateTextureError> for WebGpuError {
   fn from(err: CreateTextureError) -> Self {
     match err {
       CreateTextureError::Device(err) => err.into(),
-      err => WebGPUError::Validation(err.to_string()),
+      err => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
-impl From<CreateTextureViewError> for WebGPUError {
+impl From<CreateTextureViewError> for WebGpuError {
   fn from(err: CreateTextureViewError) -> Self {
-    WebGPUError::Validation(err.to_string())
+    WebGpuError::Validation(err.to_string())
   }
 }
 
-impl From<CreateQuerySetError> for WebGPUError {
+impl From<CreateQuerySetError> for WebGpuError {
   fn from(err: CreateQuerySetError) -> Self {
     match err {
       CreateQuerySetError::Device(err) => err.into(),
-      err => WebGPUError::Validation(err.to_string()),
+      err => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
-impl From<QueueSubmitError> for WebGPUError {
+impl From<QueueSubmitError> for WebGpuError {
   fn from(err: QueueSubmitError) -> Self {
     match err {
       QueueSubmitError::Queue(err) => err.into(),
-      err => WebGPUError::Validation(err.to_string()),
+      err => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
-impl From<QueueWriteError> for WebGPUError {
+impl From<QueueWriteError> for WebGpuError {
   fn from(err: QueueWriteError) -> Self {
     match err {
       QueueWriteError::Queue(err) => err.into(),
-      err => WebGPUError::Validation(err.to_string()),
+      err => WebGpuError::Validation(err.to_string()),
     }
   }
 }
 
 #[derive(Debug)]
-pub struct DOMExceptionOperationError {
+pub struct DomExceptionOperationError {
   pub msg: String,
 }
 
-impl DOMExceptionOperationError {
+impl DomExceptionOperationError {
   pub fn new(msg: &str) -> Self {
-    DOMExceptionOperationError {
+    DomExceptionOperationError {
       msg: msg.to_string(),
     }
   }
 }
 
-impl fmt::Display for DOMExceptionOperationError {
+impl fmt::Display for DomExceptionOperationError {
   fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
     f.pad(&self.msg)
   }
 }
 
-impl std::error::Error for DOMExceptionOperationError {}
+impl std::error::Error for DomExceptionOperationError {}
 
 pub fn get_error_class_name(e: &AnyError) -> Option<&'static str> {
-  e.downcast_ref::<DOMExceptionOperationError>()
+  e.downcast_ref::<DomExceptionOperationError>()
     .map(|_| "DOMExceptionOperationError")
 }
diff --git a/op_crates/webgpu/lib.rs b/op_crates/webgpu/lib.rs
index 046472905..5c3b99329 100644
--- a/op_crates/webgpu/lib.rs
+++ b/op_crates/webgpu/lib.rs
@@ -18,8 +18,8 @@ use std::rc::Rc;
 pub use wgpu_core;
 pub use wgpu_types;
 
-use error::DOMExceptionOperationError;
-use error::WebGPUError;
+use error::DomExceptionOperationError;
+use error::WebGpuError;
 
 #[macro_use]
 mod macros {
@@ -71,22 +71,22 @@ fn check_unstable(state: &OpState, api_name: &str) {
 
 type Instance = wgpu_core::hub::Global<wgpu_core::hub::IdentityManagerFactory>;
 
-struct WebGPUAdapter(wgpu_core::id::AdapterId);
-impl Resource for WebGPUAdapter {
+struct WebGpuAdapter(wgpu_core::id::AdapterId);
+impl Resource for WebGpuAdapter {
   fn name(&self) -> Cow<str> {
     "webGPUAdapter".into()
   }
 }
 
-struct WebGPUDevice(wgpu_core::id::DeviceId);
-impl Resource for WebGPUDevice {
+struct WebGpuDevice(wgpu_core::id::DeviceId);
+impl Resource for WebGpuDevice {
   fn name(&self) -> Cow<str> {
     "webGPUDevice".into()
   }
 }
 
-struct WebGPUQuerySet(wgpu_core::id::QuerySetId);
-impl Resource for WebGPUQuerySet {
+struct WebGpuQuerySet(wgpu_core::id::QuerySetId);
+impl Resource for WebGpuQuerySet {
   fn name(&self) -> Cow<str> {
     "webGPUQuerySet".into()
   }
@@ -255,7 +255,7 @@ pub async fn op_webgpu_request_adapter(
     "maxUniformBufferBindingSize": adapter_limits.max_uniform_buffer_binding_size
   });
 
-  let rid = state.resource_table.add(WebGPUAdapter(adapter));
+  let rid = state.resource_table.add(WebGpuAdapter(adapter));
 
   Ok(json!({
     "rid": rid,
@@ -267,7 +267,7 @@ pub async fn op_webgpu_request_adapter(
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPULimits {
+struct GpuLimits {
   _max_texture_dimension1d: Option<u32>,
   _max_texture_dimension2d: Option<u32>,
   _max_texture_dimension3d: Option<u32>,
@@ -293,7 +293,7 @@ pub struct RequestDeviceArgs {
   adapter_rid: ResourceId,
   label: Option<String>,
   non_guaranteed_features: Option<Vec<String>>,
-  non_guaranteed_limits: Option<GPULimits>,
+  non_guaranteed_limits: Option<GpuLimits>,
 }
 
 pub async fn op_webgpu_request_device(
@@ -304,7 +304,7 @@ pub async fn op_webgpu_request_device(
   let mut state = state.borrow_mut();
   let adapter_resource = state
     .resource_table
-    .get::<WebGPUAdapter>(args.adapter_rid)
+    .get::<WebGpuAdapter>(args.adapter_rid)
     .ok_or_else(bad_resource_id)?;
   let adapter = adapter_resource.0;
   let instance = state.borrow::<Instance>();
@@ -430,7 +430,7 @@ pub async fn op_webgpu_request_device(
     std::marker::PhantomData
   ));
   if let Some(err) = maybe_err {
-    return Err(DOMExceptionOperationError::new(&err.to_string()).into());
+    return Err(DomExceptionOperationError::new(&err.to_string()).into());
   }
 
   let device_features =
@@ -449,7 +449,7 @@ pub async fn op_webgpu_request_device(
      "maxUniformBufferBindingSize": limits.max_uniform_buffer_binding_size,
   });
 
-  let rid = state.resource_table.add(WebGPUDevice(device));
+  let rid = state.resource_table.add(WebGpuDevice(device));
 
   Ok(json!({
     "rid": rid,
@@ -476,7 +476,7 @@ pub fn op_webgpu_create_query_set(
 ) -> Result<Value, AnyError> {
   let device_resource = state
     .resource_table
-    .get::<WebGPUDevice>(args.device_rid)
+    .get::<WebGpuDevice>(args.device_rid)
     .ok_or_else(bad_resource_id)?;
   let device = device_resource.0;
   let instance = &state.borrow::<Instance>();
@@ -542,10 +542,10 @@ pub fn op_webgpu_create_query_set(
     std::marker::PhantomData
   ));
 
-  let rid = state.resource_table.add(WebGPUQuerySet(query_set));
+  let rid = state.resource_table.add(WebGpuQuerySet(query_set));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from),
+    "err": maybe_err.map(WebGpuError::from),
   }))
 }
diff --git a/op_crates/webgpu/pipeline.rs b/op_crates/webgpu/pipeline.rs
index d63bc7692..5e9d4534b 100644
--- a/op_crates/webgpu/pipeline.rs
+++ b/op_crates/webgpu/pipeline.rs
@@ -10,30 +10,30 @@ use deno_core::{OpState, Resource};
 use serde::Deserialize;
 use std::borrow::Cow;
 
-use super::error::WebGPUError;
+use super::error::WebGpuError;
 
-pub(crate) struct WebGPUPipelineLayout(
+pub(crate) struct WebGpuPipelineLayout(
   pub(crate) wgpu_core::id::PipelineLayoutId,
 );
-impl Resource for WebGPUPipelineLayout {
+impl Resource for WebGpuPipelineLayout {
   fn name(&self) -> Cow<str> {
     "webGPUPipelineLayout".into()
   }
 }
 
-pub(crate) struct WebGPUComputePipeline(
+pub(crate) struct WebGpuComputePipeline(
   pub(crate) wgpu_core::id::ComputePipelineId,
 );
-impl Resource for WebGPUComputePipeline {
+impl Resource for WebGpuComputePipeline {
   fn name(&self) -> Cow<str> {
     "webGPUComputePipeline".into()
   }
 }
 
-pub(crate) struct WebGPURenderPipeline(
+pub(crate) struct WebGpuRenderPipeline(
   pub(crate) wgpu_core::id::RenderPipelineId,
 );
-impl Resource for WebGPURenderPipeline {
+impl Resource for WebGpuRenderPipeline {
   fn name(&self) -> Cow<str> {
     "webGPURenderPipeline".into()
   }
@@ -64,7 +64,7 @@ fn serialize_stencil_operation(
 }
 
 fn serialize_stencil_face_state(
-  state: GPUStencilFaceState,
+  state: GpuStencilFaceState,
 ) -> wgpu_types::StencilFaceState {
   wgpu_types::StencilFaceState {
     compare: state
@@ -114,7 +114,7 @@ fn serialize_blend_factor(blend_factor: &str) -> wgpu_types::BlendFactor {
 }
 
 fn serialize_blend_component(
-  blend: GPUBlendComponent,
+  blend: GpuBlendComponent,
 ) -> wgpu_types::BlendState {
   wgpu_types::BlendState {
     src_factor: blend
@@ -145,7 +145,7 @@ fn serialize_blend_component(
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUProgrammableStage {
+struct GpuProgrammableStage {
   module: u32,
   entry_point: String,
 }
@@ -156,7 +156,7 @@ pub struct CreateComputePipelineArgs {
   device_rid: ResourceId,
   label: Option<String>,
   layout: Option<u32>,
-  compute: GPUProgrammableStage,
+  compute: GpuProgrammableStage,
 }
 
 pub fn op_webgpu_create_compute_pipeline(
@@ -167,14 +167,14 @@ pub fn op_webgpu_create_compute_pipeline(
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
-    .get::<super::WebGPUDevice>(args.device_rid)
+    .get::<super::WebGpuDevice>(args.device_rid)
     .ok_or_else(bad_resource_id)?;
   let device = device_resource.0;
 
   let pipeline_layout = if let Some(rid) = args.layout {
     let id = state
       .resource_table
-      .get::<WebGPUPipelineLayout>(rid)
+      .get::<WebGpuPipelineLayout>(rid)
       .ok_or_else(bad_resource_id)?;
     Some(id.0)
   } else {
@@ -183,7 +183,7 @@ pub fn op_webgpu_create_compute_pipeline(
 
   let compute_shader_module_resource = state
     .resource_table
-    .get::<super::shader::WebGPUShaderModule>(args.compute.module)
+    .get::<super::shader::WebGpuShaderModule>(args.compute.module)
     .ok_or_else(bad_resource_id)?;
 
   let descriptor = wgpu_core::pipeline::ComputePipelineDescriptor {
@@ -211,11 +211,11 @@ pub fn op_webgpu_create_compute_pipeline(
 
   let rid = state
     .resource_table
-    .add(WebGPUComputePipeline(compute_pipeline));
+    .add(WebGpuComputePipeline(compute_pipeline));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from),
+    "err": maybe_err.map(WebGpuError::from),
   }))
 }
 
@@ -234,7 +234,7 @@ pub fn op_webgpu_compute_pipeline_get_bind_group_layout(
   let instance = state.borrow::<super::Instance>();
   let compute_pipeline_resource = state
     .resource_table
-    .get::<WebGPUComputePipeline>(args.compute_pipeline_rid)
+    .get::<WebGpuComputePipeline>(args.compute_pipeline_rid)
     .ok_or_else(bad_resource_id)?;
   let compute_pipeline = compute_pipeline_resource.0;
 
@@ -244,18 +244,18 @@ pub fn op_webgpu_compute_pipeline_get_bind_group_layout(
 
   let rid = state
     .resource_table
-    .add(super::binding::WebGPUBindGroupLayout(bind_group_layout));
+    .add(super::binding::WebGpuBindGroupLayout(bind_group_layout));
 
   Ok(json!({
     "rid": rid,
     "label": label,
-    "err": maybe_err.map(WebGPUError::from)
+    "err": maybe_err.map(WebGpuError::from)
   }))
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUPrimitiveState {
+struct GpuPrimitiveState {
   topology: Option<String>,
   strip_index_format: Option<String>,
   front_face: Option<String>,
@@ -264,7 +264,7 @@ struct GPUPrimitiveState {
 
 #[derive(Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
-struct GPUBlendComponent {
+struct GpuBlendComponent {
   src_factor: Option<String>,
   dst_factor: Option<String>,
   operation: Option<String>,
@@ -272,22 +272,22 @@ struct GPUBlendComponent {
 
 #[derive(Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
-struct GPUBlendState {
-  color: GPUBlendComponent,
-  alpha: GPUBlendComponent,
+struct GpuBlendState {
+  color: GpuBlendComponent,
+  alpha: GpuBlendComponent,
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUColorTargetState {
+struct GpuColorTargetState {
   format: String,
-  blend: Option<GPUBlendState>,
+  blend: Option<GpuBlendState>,
   write_mask: Option<u32>,
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUStencilFaceState {
+struct GpuStencilFaceState {
   compare: Option<String>,
   fail_op: Option<String>,
   depth_fail_op: Option<String>,
@@ -296,12 +296,12 @@ struct GPUStencilFaceState {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUDepthStencilState {
+struct GpuDepthStencilState {
   format: String,
   depth_write_enabled: Option<bool>,
   depth_compare: Option<String>,
-  stencil_front: Option<GPUStencilFaceState>,
-  stencil_back: Option<GPUStencilFaceState>,
+  stencil_front: Option<GpuStencilFaceState>,
+  stencil_back: Option<GpuStencilFaceState>,
   stencil_read_mask: Option<u32>,
   stencil_write_mask: Option<u32>,
   depth_bias: Option<i32>,
@@ -312,7 +312,7 @@ struct GPUDepthStencilState {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUVertexAttribute {
+struct GpuVertexAttribute {
   format: String,
   offset: u64,
   shader_location: u32,
@@ -320,23 +320,23 @@ struct GPUVertexAttribute {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUVertexBufferLayout {
+struct GpuVertexBufferLayout {
   array_stride: u64,
   step_mode: Option<String>,
-  attributes: Vec<GPUVertexAttribute>,
+  attributes: Vec<GpuVertexAttribute>,
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUVertexState {
+struct GpuVertexState {
   module: u32,
   entry_point: String,
-  buffers: Option<Vec<Option<GPUVertexBufferLayout>>>,
+  buffers: Option<Vec<Option<GpuVertexBufferLayout>>>,
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUMultisampleState {
+struct GpuMultisampleState {
   count: Option<u32>,
   mask: Option<u64>, // against spec, but future proof
   alpha_to_coverage_enabled: Option<bool>,
@@ -344,8 +344,8 @@ struct GPUMultisampleState {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUFragmentState {
-  targets: Vec<GPUColorTargetState>,
+struct GpuFragmentState {
+  targets: Vec<GpuColorTargetState>,
   module: u32,
   entry_point: String,
 }
@@ -356,11 +356,11 @@ pub struct CreateRenderPipelineArgs {
   device_rid: ResourceId,
   label: Option<String>,
   layout: Option<u32>,
-  vertex: GPUVertexState,
-  primitive: Option<GPUPrimitiveState>,
-  depth_stencil: Option<GPUDepthStencilState>,
-  multisample: Option<GPUMultisampleState>,
-  fragment: Option<GPUFragmentState>,
+  vertex: GpuVertexState,
+  primitive: Option<GpuPrimitiveState>,
+  depth_stencil: Option<GpuDepthStencilState>,
+  multisample: Option<GpuMultisampleState>,
+  fragment: Option<GpuFragmentState>,
 }
 
 pub fn op_webgpu_create_render_pipeline(
@@ -371,14 +371,14 @@ pub fn op_webgpu_create_render_pipeline(
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
-    .get::<super::WebGPUDevice>(args.device_rid)
+    .get::<super::WebGpuDevice>(args.device_rid)
     .ok_or_else(bad_resource_id)?;
   let device = device_resource.0;
 
   let layout = if let Some(rid) = args.layout {
     let pipeline_layout_resource = state
       .resource_table
-      .get::<WebGPUPipelineLayout>(rid)
+      .get::<WebGpuPipelineLayout>(rid)
       .ok_or_else(bad_resource_id)?;
     Some(pipeline_layout_resource.0)
   } else {
@@ -387,7 +387,7 @@ pub fn op_webgpu_create_render_pipeline(
 
   let vertex_shader_module_resource = state
     .resource_table
-    .get::<super::shader::WebGPUShaderModule>(args.vertex.module)
+    .get::<super::shader::WebGpuShaderModule>(args.vertex.module)
     .ok_or_else(bad_resource_id)?;
 
   let descriptor = wgpu_core::pipeline::RenderPipelineDescriptor {
@@ -400,63 +400,61 @@ pub fn op_webgpu_create_render_pipeline(
       },
       buffers: Cow::from(if let Some(buffers) = args.vertex.buffers {
         let mut return_buffers = vec![];
-        for buffer in buffers {
-          if let Some(buffer) = buffer {
-            return_buffers.push(wgpu_core::pipeline::VertexBufferLayout {
-              array_stride: buffer.array_stride,
-              step_mode: match buffer.step_mode {
-                Some(step_mode) => match step_mode.as_str() {
-                  "vertex" => wgpu_types::InputStepMode::Vertex,
-                  "instance" => wgpu_types::InputStepMode::Instance,
-                  _ => unreachable!(),
-                },
-                None => wgpu_types::InputStepMode::Vertex,
+        for buffer in buffers.into_iter().flatten() {
+          return_buffers.push(wgpu_core::pipeline::VertexBufferLayout {
+            array_stride: buffer.array_stride,
+            step_mode: match buffer.step_mode {
+              Some(step_mode) => match step_mode.as_str() {
+                "vertex" => wgpu_types::InputStepMode::Vertex,
+                "instance" => wgpu_types::InputStepMode::Instance,
+                _ => unreachable!(),
               },
-              attributes: Cow::from(
-                buffer
-                  .attributes
-                  .iter()
-                  .map(|attribute| wgpu_types::VertexAttribute {
-                    format: match attribute.format.as_str() {
-                      "uchar2" => wgpu_types::VertexFormat::Uchar2,
-                      "uchar4" => wgpu_types::VertexFormat::Uchar4,
-                      "char2" => wgpu_types::VertexFormat::Char2,
-                      "char4" => wgpu_types::VertexFormat::Char4,
-                      "uchar2norm" => wgpu_types::VertexFormat::Uchar2Norm,
-                      "uchar4norm" => wgpu_types::VertexFormat::Uchar4,
-                      "char2norm" => wgpu_types::VertexFormat::Char2Norm,
-                      "char4norm" => wgpu_types::VertexFormat::Char4Norm,
-                      "ushort2" => wgpu_types::VertexFormat::Ushort2,
-                      "ushort4" => wgpu_types::VertexFormat::Ushort4,
-                      "short2" => wgpu_types::VertexFormat::Short2,
-                      "short4" => wgpu_types::VertexFormat::Short4,
-                      "ushort2norm" => wgpu_types::VertexFormat::Ushort2Norm,
-                      "ushort4norm" => wgpu_types::VertexFormat::Ushort4Norm,
-                      "short2norm" => wgpu_types::VertexFormat::Short2Norm,
-                      "short4norm" => wgpu_types::VertexFormat::Short4Norm,
-                      "half2" => wgpu_types::VertexFormat::Half2,
-                      "half4" => wgpu_types::VertexFormat::Half4,
-                      "float" => wgpu_types::VertexFormat::Float,
-                      "float2" => wgpu_types::VertexFormat::Float2,
-                      "float3" => wgpu_types::VertexFormat::Float3,
-                      "float4" => wgpu_types::VertexFormat::Float4,
-                      "uint" => wgpu_types::VertexFormat::Uint,
-                      "uint2" => wgpu_types::VertexFormat::Uint2,
-                      "uint3" => wgpu_types::VertexFormat::Uint3,
-                      "uint4" => wgpu_types::VertexFormat::Uint4,
-                      "int" => wgpu_types::VertexFormat::Int,
-                      "int2" => wgpu_types::VertexFormat::Int2,
-                      "int3" => wgpu_types::VertexFormat::Int3,
-                      "int4" => wgpu_types::VertexFormat::Int4,
-                      _ => unreachable!(),
-                    },
-                    offset: attribute.offset,
-                    shader_location: attribute.shader_location,
-                  })
-                  .collect::<Vec<wgpu_types::VertexAttribute>>(),
-              ),
-            })
-          }
+              None => wgpu_types::InputStepMode::Vertex,
+            },
+            attributes: Cow::from(
+              buffer
+                .attributes
+                .iter()
+                .map(|attribute| wgpu_types::VertexAttribute {
+                  format: match attribute.format.as_str() {
+                    "uchar2" => wgpu_types::VertexFormat::Uchar2,
+                    "uchar4" => wgpu_types::VertexFormat::Uchar4,
+                    "char2" => wgpu_types::VertexFormat::Char2,
+                    "char4" => wgpu_types::VertexFormat::Char4,
+                    "uchar2norm" => wgpu_types::VertexFormat::Uchar2Norm,
+                    "uchar4norm" => wgpu_types::VertexFormat::Uchar4,
+                    "char2norm" => wgpu_types::VertexFormat::Char2Norm,
+                    "char4norm" => wgpu_types::VertexFormat::Char4Norm,
+                    "ushort2" => wgpu_types::VertexFormat::Ushort2,
+                    "ushort4" => wgpu_types::VertexFormat::Ushort4,
+                    "short2" => wgpu_types::VertexFormat::Short2,
+                    "short4" => wgpu_types::VertexFormat::Short4,
+                    "ushort2norm" => wgpu_types::VertexFormat::Ushort2Norm,
+                    "ushort4norm" => wgpu_types::VertexFormat::Ushort4Norm,
+                    "short2norm" => wgpu_types::VertexFormat::Short2Norm,
+                    "short4norm" => wgpu_types::VertexFormat::Short4Norm,
+                    "half2" => wgpu_types::VertexFormat::Half2,
+                    "half4" => wgpu_types::VertexFormat::Half4,
+                    "float" => wgpu_types::VertexFormat::Float,
+                    "float2" => wgpu_types::VertexFormat::Float2,
+                    "float3" => wgpu_types::VertexFormat::Float3,
+                    "float4" => wgpu_types::VertexFormat::Float4,
+                    "uint" => wgpu_types::VertexFormat::Uint,
+                    "uint2" => wgpu_types::VertexFormat::Uint2,
+                    "uint3" => wgpu_types::VertexFormat::Uint3,
+                    "uint4" => wgpu_types::VertexFormat::Uint4,
+                    "int" => wgpu_types::VertexFormat::Int,
+                    "int2" => wgpu_types::VertexFormat::Int2,
+                    "int3" => wgpu_types::VertexFormat::Int3,
+                    "int4" => wgpu_types::VertexFormat::Int4,
+                    _ => unreachable!(),
+                  },
+                  offset: attribute.offset,
+                  shader_location: attribute.shader_location,
+                })
+                .collect::<Vec<wgpu_types::VertexAttribute>>(),
+            ),
+          });
         }
         return_buffers
       } else {
@@ -540,7 +538,7 @@ pub fn op_webgpu_create_render_pipeline(
     fragment: args.fragment.map(|fragment| {
       let fragment_shader_module_resource = state
         .resource_table
-        .get::<super::shader::WebGPUShaderModule>(fragment.module)
+        .get::<super::shader::WebGpuShaderModule>(fragment.module)
         .ok_or_else(bad_resource_id)
         .unwrap();
 
@@ -601,11 +599,11 @@ pub fn op_webgpu_create_render_pipeline(
 
   let rid = state
     .resource_table
-    .add(WebGPURenderPipeline(render_pipeline));
+    .add(WebGpuRenderPipeline(render_pipeline));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from)
+    "err": maybe_err.map(WebGpuError::from)
   }))
 }
 
@@ -624,7 +622,7 @@ pub fn op_webgpu_render_pipeline_get_bind_group_layout(
   let instance = state.borrow::<super::Instance>();
   let render_pipeline_resource = state
     .resource_table
-    .get::<WebGPURenderPipeline>(args.render_pipeline_rid)
+    .get::<WebGpuRenderPipeline>(args.render_pipeline_rid)
     .ok_or_else(bad_resource_id)?;
   let render_pipeline = render_pipeline_resource.0;
 
@@ -634,11 +632,11 @@ pub fn op_webgpu_render_pipeline_get_bind_group_layout(
 
   let rid = state
     .resource_table
-    .add(super::binding::WebGPUBindGroupLayout(bind_group_layout));
+    .add(super::binding::WebGpuBindGroupLayout(bind_group_layout));
 
   Ok(json!({
     "rid": rid,
     "label": label,
-    "err": maybe_err.map(WebGPUError::from),
+    "err": maybe_err.map(WebGpuError::from),
   }))
 }
diff --git a/op_crates/webgpu/queue.rs b/op_crates/webgpu/queue.rs
index d878d5fcb..bbfb782de 100644
--- a/op_crates/webgpu/queue.rs
+++ b/op_crates/webgpu/queue.rs
@@ -9,9 +9,9 @@ use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use serde::Deserialize;
 
-use super::error::WebGPUError;
+use super::error::WebGpuError;
 
-type WebGPUQueue = super::WebGPUDevice;
+type WebGpuQueue = super::WebGpuDevice;
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -28,7 +28,7 @@ pub fn op_webgpu_queue_submit(
   let instance = state.borrow::<super::Instance>();
   let queue_resource = state
     .resource_table
-    .get::<WebGPUQueue>(args.queue_rid)
+    .get::<WebGpuQueue>(args.queue_rid)
     .ok_or_else(bad_resource_id)?;
   let queue = queue_resource.0;
 
@@ -37,7 +37,7 @@ pub fn op_webgpu_queue_submit(
   for rid in args.command_buffers {
     let buffer_resource = state
       .resource_table
-      .get::<super::command_encoder::WebGPUCommandBuffer>(rid)
+      .get::<super::command_encoder::WebGpuCommandBuffer>(rid)
       .ok_or_else(bad_resource_id)?;
     ids.push(buffer_resource.0);
   }
@@ -45,12 +45,12 @@ 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(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct GPUImageDataLayout {
+struct GpuImageDataLayout {
   offset: Option<u64>,
   bytes_per_row: Option<u32>,
   rows_per_image: Option<u32>,
@@ -74,12 +74,12 @@ pub fn op_webgpu_write_buffer(
   let instance = state.borrow::<super::Instance>();
   let buffer_resource = state
     .resource_table
-    .get::<super::buffer::WebGPUBuffer>(args.buffer)
+    .get::<super::buffer::WebGpuBuffer>(args.buffer)
     .ok_or_else(bad_resource_id)?;
   let buffer = buffer_resource.0;
   let queue_resource = state
     .resource_table
-    .get::<WebGPUQueue>(args.queue_rid)
+    .get::<WebGpuQueue>(args.queue_rid)
     .ok_or_else(bad_resource_id)?;
   let queue = queue_resource.0;
 
@@ -95,16 +95,16 @@ pub fn op_webgpu_write_buffer(
   ))
   .err();
 
-  Ok(json!({ "err": maybe_err.map(WebGPUError::from) }))
+  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct QueueWriteTextureArgs {
   queue_rid: ResourceId,
-  destination: super::command_encoder::GPUImageCopyTexture,
-  data_layout: GPUImageDataLayout,
-  size: super::texture::GPUExtent3D,
+  destination: super::command_encoder::GpuImageCopyTexture,
+  data_layout: GpuImageDataLayout,
+  size: super::texture::GpuExtent3D,
 }
 
 pub fn op_webgpu_write_texture(
@@ -115,11 +115,11 @@ pub fn op_webgpu_write_texture(
   let instance = state.borrow::<super::Instance>();
   let texture_resource = state
     .resource_table
-    .get::<super::texture::WebGPUTexture>(args.destination.texture)
+    .get::<super::texture::WebGpuTexture>(args.destination.texture)
     .ok_or_else(bad_resource_id)?;
   let queue_resource = state
     .resource_table
-    .get::<WebGPUQueue>(args.queue_rid)
+    .get::<WebGpuQueue>(args.queue_rid)
     .ok_or_else(bad_resource_id)?;
   let queue = queue_resource.0;
 
@@ -154,5 +154,5 @@ pub fn op_webgpu_write_texture(
   ))
   .err();
 
-  Ok(json!({ "err": maybe_err.map(WebGPUError::from) }))
+  Ok(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
diff --git a/op_crates/webgpu/render_pass.rs b/op_crates/webgpu/render_pass.rs
index 4829f2b1c..5c614024e 100644
--- a/op_crates/webgpu/render_pass.rs
+++ b/op_crates/webgpu/render_pass.rs
@@ -11,12 +11,12 @@ use serde::Deserialize;
 use std::borrow::Cow;
 use std::cell::RefCell;
 
-use super::error::WebGPUError;
+use super::error::WebGpuError;
 
-pub(crate) struct WebGPURenderPass(
+pub(crate) struct WebGpuRenderPass(
   pub(crate) RefCell<wgpu_core::command::RenderPass>,
 );
-impl Resource for WebGPURenderPass {
+impl Resource for WebGpuRenderPass {
   fn name(&self) -> Cow<str> {
     "webGPURenderPass".into()
   }
@@ -41,7 +41,7 @@ pub fn op_webgpu_render_pass_set_viewport(
 ) -> Result<Value, AnyError> {
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::render_ffi::wgpu_render_pass_set_viewport(
@@ -74,7 +74,7 @@ pub fn op_webgpu_render_pass_set_scissor_rect(
 ) -> Result<Value, AnyError> {
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::render_ffi::wgpu_render_pass_set_scissor_rect(
@@ -90,7 +90,7 @@ pub fn op_webgpu_render_pass_set_scissor_rect(
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct GPUColor {
+pub struct GpuColor {
   pub r: f64,
   pub g: f64,
   pub b: f64,
@@ -101,7 +101,7 @@ pub struct GPUColor {
 #[serde(rename_all = "camelCase")]
 pub struct RenderPassSetBlendColorArgs {
   render_pass_rid: ResourceId,
-  color: GPUColor,
+  color: GpuColor,
 }
 
 pub fn op_webgpu_render_pass_set_blend_color(
@@ -111,7 +111,7 @@ pub fn op_webgpu_render_pass_set_blend_color(
 ) -> Result<Value, AnyError> {
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::render_ffi::wgpu_render_pass_set_blend_color(
@@ -141,7 +141,7 @@ pub fn op_webgpu_render_pass_set_stencil_reference(
 ) -> Result<Value, AnyError> {
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::render_ffi::wgpu_render_pass_set_stencil_reference(
@@ -167,11 +167,11 @@ pub fn op_webgpu_render_pass_begin_pipeline_statistics_query(
 ) -> Result<Value, AnyError> {
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
   let query_set_resource = state
     .resource_table
-    .get::<super::WebGPUQuerySet>(args.query_set)
+    .get::<super::WebGpuQuerySet>(args.query_set)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -198,7 +198,7 @@ pub fn op_webgpu_render_pass_end_pipeline_statistics_query(
 ) -> Result<Value, AnyError> {
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -225,11 +225,11 @@ pub fn op_webgpu_render_pass_write_timestamp(
 ) -> Result<Value, AnyError> {
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
   let query_set_resource = state
     .resource_table
-    .get::<super::WebGPUQuerySet>(args.query_set)
+    .get::<super::WebGpuQuerySet>(args.query_set)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -260,14 +260,14 @@ pub fn op_webgpu_render_pass_execute_bundles(
   for rid in &args.bundles {
     let render_bundle_resource = state
       .resource_table
-      .get::<super::bundle::WebGPURenderBundle>(*rid)
+      .get::<super::bundle::WebGpuRenderBundle>(*rid)
       .ok_or_else(bad_resource_id)?;
     render_bundle_ids.push(render_bundle_resource.0);
   }
 
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -295,21 +295,21 @@ pub fn op_webgpu_render_pass_end_pass(
 ) -> Result<Value, AnyError> {
   let command_encoder_resource = state
     .resource_table
-    .get::<super::command_encoder::WebGPUCommandEncoder>(
+    .get::<super::command_encoder::WebGpuCommandEncoder>(
       args.command_encoder_rid,
     )
     .ok_or_else(bad_resource_id)?;
   let command_encoder = command_encoder_resource.0;
   let render_pass_resource = state
     .resource_table
-    .take::<WebGPURenderPass>(args.render_pass_rid)
+    .take::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
   let render_pass = &render_pass_resource.0.borrow();
   let instance = state.borrow::<super::Instance>();
 
   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(json!({ "err": maybe_err.map(WebGpuError::from) }))
 }
 
 #[derive(Deserialize)]
@@ -330,11 +330,11 @@ pub fn op_webgpu_render_pass_set_bind_group(
 ) -> Result<Value, AnyError> {
   let bind_group_resource = state
     .resource_table
-    .get::<super::binding::WebGPUBindGroup>(args.bind_group)
+    .get::<super::binding::WebGpuBindGroup>(args.bind_group)
     .ok_or_else(bad_resource_id)?;
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   // I know this might look like it can be easily deduplicated, but it can not
@@ -385,7 +385,7 @@ pub fn op_webgpu_render_pass_push_debug_group(
 ) -> Result<Value, AnyError> {
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -413,7 +413,7 @@ pub fn op_webgpu_render_pass_pop_debug_group(
 ) -> Result<Value, AnyError> {
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::render_ffi::wgpu_render_pass_pop_debug_group(
@@ -437,7 +437,7 @@ pub fn op_webgpu_render_pass_insert_debug_marker(
 ) -> Result<Value, AnyError> {
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   unsafe {
@@ -466,11 +466,11 @@ pub fn op_webgpu_render_pass_set_pipeline(
 ) -> Result<Value, AnyError> {
   let render_pipeline_resource = state
     .resource_table
-    .get::<super::pipeline::WebGPURenderPipeline>(args.pipeline)
+    .get::<super::pipeline::WebGpuRenderPipeline>(args.pipeline)
     .ok_or_else(bad_resource_id)?;
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::render_ffi::wgpu_render_pass_set_pipeline(
@@ -498,11 +498,11 @@ pub fn op_webgpu_render_pass_set_index_buffer(
 ) -> Result<Value, AnyError> {
   let buffer_resource = state
     .resource_table
-    .get::<super::buffer::WebGPUBuffer>(args.buffer)
+    .get::<super::buffer::WebGpuBuffer>(args.buffer)
     .ok_or_else(bad_resource_id)?;
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   render_pass_resource.0.borrow_mut().set_index_buffer(
@@ -532,11 +532,11 @@ pub fn op_webgpu_render_pass_set_vertex_buffer(
 ) -> Result<Value, AnyError> {
   let buffer_resource = state
     .resource_table
-    .get::<super::buffer::WebGPUBuffer>(args.buffer)
+    .get::<super::buffer::WebGpuBuffer>(args.buffer)
     .ok_or_else(bad_resource_id)?;
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::render_ffi::wgpu_render_pass_set_vertex_buffer(
@@ -567,7 +567,7 @@ pub fn op_webgpu_render_pass_draw(
 ) -> Result<Value, AnyError> {
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::render_ffi::wgpu_render_pass_draw(
@@ -599,7 +599,7 @@ pub fn op_webgpu_render_pass_draw_indexed(
 ) -> Result<Value, AnyError> {
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::render_ffi::wgpu_render_pass_draw_indexed(
@@ -629,11 +629,11 @@ pub fn op_webgpu_render_pass_draw_indirect(
 ) -> Result<Value, AnyError> {
   let buffer_resource = state
     .resource_table
-    .get::<super::buffer::WebGPUBuffer>(args.indirect_buffer)
+    .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)
     .ok_or_else(bad_resource_id)?;
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::render_ffi::wgpu_render_pass_draw_indirect(
@@ -660,11 +660,11 @@ pub fn op_webgpu_render_pass_draw_indexed_indirect(
 ) -> Result<Value, AnyError> {
   let buffer_resource = state
     .resource_table
-    .get::<super::buffer::WebGPUBuffer>(args.indirect_buffer)
+    .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)
     .ok_or_else(bad_resource_id)?;
   let render_pass_resource = state
     .resource_table
-    .get::<WebGPURenderPass>(args.render_pass_rid)
+    .get::<WebGpuRenderPass>(args.render_pass_rid)
     .ok_or_else(bad_resource_id)?;
 
   wgpu_core::command::render_ffi::wgpu_render_pass_draw_indexed_indirect(
diff --git a/op_crates/webgpu/sampler.rs b/op_crates/webgpu/sampler.rs
index 74d46e896..fdff70b77 100644
--- a/op_crates/webgpu/sampler.rs
+++ b/op_crates/webgpu/sampler.rs
@@ -10,10 +10,10 @@ use deno_core::{OpState, Resource};
 use serde::Deserialize;
 use std::borrow::Cow;
 
-use super::error::WebGPUError;
+use super::error::WebGpuError;
 
-pub(crate) struct WebGPUSampler(pub(crate) wgpu_core::id::SamplerId);
-impl Resource for WebGPUSampler {
+pub(crate) struct WebGpuSampler(pub(crate) wgpu_core::id::SamplerId);
+impl Resource for WebGpuSampler {
   fn name(&self) -> Cow<str> {
     "webGPUSampler".into()
   }
@@ -87,7 +87,7 @@ pub fn op_webgpu_create_sampler(
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
-    .get::<super::WebGPUDevice>(args.device_rid)
+    .get::<super::WebGpuDevice>(args.device_rid)
     .ok_or_else(bad_resource_id)?;
   let device = device_resource.0;
 
@@ -121,10 +121,10 @@ pub fn op_webgpu_create_sampler(
     std::marker::PhantomData
   ));
 
-  let rid = state.resource_table.add(WebGPUSampler(sampler));
+  let rid = state.resource_table.add(WebGpuSampler(sampler));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from)
+    "err": maybe_err.map(WebGpuError::from)
   }))
 }
diff --git a/op_crates/webgpu/shader.rs b/op_crates/webgpu/shader.rs
index 28ad4ef62..8a0613862 100644
--- a/op_crates/webgpu/shader.rs
+++ b/op_crates/webgpu/shader.rs
@@ -10,10 +10,10 @@ use deno_core::{OpState, Resource};
 use serde::Deserialize;
 use std::borrow::Cow;
 
-use super::error::WebGPUError;
+use super::error::WebGpuError;
 
-pub(crate) struct WebGPUShaderModule(pub(crate) wgpu_core::id::ShaderModuleId);
-impl Resource for WebGPUShaderModule {
+pub(crate) struct WebGpuShaderModule(pub(crate) wgpu_core::id::ShaderModuleId);
+impl Resource for WebGpuShaderModule {
   fn name(&self) -> Cow<str> {
     "webGPUShaderModule".into()
   }
@@ -36,7 +36,7 @@ pub fn op_webgpu_create_shader_module(
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
-    .get::<super::WebGPUDevice>(args.device_rid)
+    .get::<super::WebGpuDevice>(args.device_rid)
     .ok_or_else(bad_resource_id)?;
   let device = device_resource.0;
 
@@ -69,10 +69,10 @@ pub fn op_webgpu_create_shader_module(
     std::marker::PhantomData
   ));
 
-  let rid = state.resource_table.add(WebGPUShaderModule(shader_module));
+  let rid = state.resource_table.add(WebGpuShaderModule(shader_module));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from)
+    "err": maybe_err.map(WebGpuError::from)
   }))
 }
diff --git a/op_crates/webgpu/texture.rs b/op_crates/webgpu/texture.rs
index 8a5d48bd9..2dcff5027 100644
--- a/op_crates/webgpu/texture.rs
+++ b/op_crates/webgpu/texture.rs
@@ -10,16 +10,16 @@ use deno_core::{OpState, Resource};
 use serde::Deserialize;
 use std::borrow::Cow;
 
-use super::error::WebGPUError;
-pub(crate) struct WebGPUTexture(pub(crate) wgpu_core::id::TextureId);
-impl Resource for WebGPUTexture {
+use super::error::WebGpuError;
+pub(crate) struct WebGpuTexture(pub(crate) wgpu_core::id::TextureId);
+impl Resource for WebGpuTexture {
   fn name(&self) -> Cow<str> {
     "webGPUTexture".into()
   }
 }
 
-pub(crate) struct WebGPUTextureView(pub(crate) wgpu_core::id::TextureViewId);
-impl Resource for WebGPUTextureView {
+pub(crate) struct WebGpuTextureView(pub(crate) wgpu_core::id::TextureViewId);
+impl Resource for WebGpuTextureView {
   fn name(&self) -> Cow<str> {
     "webGPUTextureView".into()
   }
@@ -125,7 +125,7 @@ pub fn serialize_dimension(
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct GPUExtent3D {
+pub struct GpuExtent3D {
   pub width: Option<u32>,
   pub height: Option<u32>,
   pub depth: Option<u32>,
@@ -136,7 +136,7 @@ pub struct GPUExtent3D {
 pub struct CreateTextureArgs {
   device_rid: ResourceId,
   label: Option<String>,
-  size: GPUExtent3D,
+  size: GpuExtent3D,
   mip_level_count: Option<u32>,
   sample_count: Option<u32>,
   dimension: Option<String>,
@@ -152,7 +152,7 @@ pub fn op_webgpu_create_texture(
   let instance = state.borrow::<super::Instance>();
   let device_resource = state
     .resource_table
-    .get::<super::WebGPUDevice>(args.device_rid)
+    .get::<super::WebGpuDevice>(args.device_rid)
     .ok_or_else(bad_resource_id)?;
   let device = device_resource.0;
 
@@ -184,11 +184,11 @@ pub fn op_webgpu_create_texture(
     std::marker::PhantomData
   ));
 
-  let rid = state.resource_table.add(WebGPUTexture(texture));
+  let rid = state.resource_table.add(WebGpuTexture(texture));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from)
+    "err": maybe_err.map(WebGpuError::from)
   }))
 }
 
@@ -214,7 +214,7 @@ pub fn op_webgpu_create_texture_view(
   let instance = state.borrow::<super::Instance>();
   let texture_resource = state
     .resource_table
-    .get::<WebGPUTexture>(args.texture_rid)
+    .get::<WebGpuTexture>(args.texture_rid)
     .ok_or_else(bad_resource_id)?;
   let texture = texture_resource.0;
 
@@ -248,10 +248,10 @@ pub fn op_webgpu_create_texture_view(
     std::marker::PhantomData
   ));
 
-  let rid = state.resource_table.add(WebGPUTextureView(texture_view));
+  let rid = state.resource_table.add(WebGpuTextureView(texture_view));
 
   Ok(json!({
     "rid": rid,
-    "err": maybe_err.map(WebGPUError::from)
+    "err": maybe_err.map(WebGpuError::from)
   }))
 }
diff --git a/runtime/ops/fetch.rs b/runtime/ops/fetch.rs
index 9ab86858d..3cb0c6c78 100644
--- a/runtime/ops/fetch.rs
+++ b/runtime/ops/fetch.rs
@@ -16,8 +16,8 @@ pub fn init(
         .unwrap()
     });
     state.put::<HttpClientDefaults>(HttpClientDefaults {
-      ca_data,
       user_agent,
+      ca_data,
     });
   }
   super::reg_json_sync(rt, "op_fetch", deno_fetch::op_fetch::<Permissions>);
diff --git a/runtime/ops/io.rs b/runtime/ops/io.rs
index 1260452b6..75076f716 100644
--- a/runtime/ops/io.rs
+++ b/runtime/ops/io.rs
@@ -140,14 +140,14 @@ fn get_stdio_stream(
 use nix::sys::termios;
 
 #[derive(Default)]
-pub struct TTYMetadata {
+pub struct TtyMetadata {
   #[cfg(unix)]
   pub mode: Option<termios::Termios>,
 }
 
 #[derive(Default)]
 pub struct FileMetadata {
-  pub tty: TTYMetadata,
+  pub tty: TtyMetadata,
 }
 
 #[derive(Debug)]
diff --git a/runtime/ops/net.rs b/runtime/ops/net.rs
index c501da96d..4d335c886 100644
--- a/runtime/ops/net.rs
+++ b/runtime/ops/net.rs
@@ -504,21 +504,21 @@ fn op_listen(
 #[serde(untagged)]
 enum DnsReturnRecord {
   A(String),
-  AAAA(String),
-  ANAME(String),
-  CNAME(String),
-  MX {
+  Aaaa(String),
+  Aname(String),
+  Cname(String),
+  Mx {
     preference: u16,
     exchange: String,
   },
-  PTR(String),
-  SRV {
+  Ptr(String),
+  Srv {
     priority: u16,
     weight: u16,
     port: u16,
     target: String,
   },
-  TXT(Vec<String>),
+  Txt(Vec<String>),
 }
 
 #[derive(Deserialize)]
@@ -610,24 +610,24 @@ fn rdata_to_return_record(
       AAAA => r
         .as_aaaa()
         .map(ToString::to_string)
-        .map(DnsReturnRecord::AAAA),
+        .map(DnsReturnRecord::Aaaa),
       ANAME => r
         .as_aname()
         .map(ToString::to_string)
-        .map(DnsReturnRecord::ANAME),
+        .map(DnsReturnRecord::Aname),
       CNAME => r
         .as_cname()
         .map(ToString::to_string)
-        .map(DnsReturnRecord::CNAME),
-      MX => r.as_mx().map(|mx| DnsReturnRecord::MX {
+        .map(DnsReturnRecord::Cname),
+      MX => r.as_mx().map(|mx| DnsReturnRecord::Mx {
         preference: mx.preference(),
         exchange: mx.exchange().to_string(),
       }),
       PTR => r
         .as_ptr()
         .map(ToString::to_string)
-        .map(DnsReturnRecord::PTR),
-      SRV => r.as_srv().map(|srv| DnsReturnRecord::SRV {
+        .map(DnsReturnRecord::Ptr),
+      SRV => r.as_srv().map(|srv| DnsReturnRecord::Srv {
         priority: srv.priority(),
         weight: srv.weight(),
         port: srv.port(),
@@ -641,7 +641,7 @@ fn rdata_to_return_record(
             bytes.iter().map(|&b| b as char).collect::<String>()
           })
           .collect();
-        DnsReturnRecord::TXT(texts)
+        DnsReturnRecord::Txt(texts)
       }),
       // TODO(magurotuna): Other record types are not supported
       _ => todo!(),
@@ -674,21 +674,21 @@ mod tests {
   fn rdata_to_return_record_aaaa() {
     let func = rdata_to_return_record(RecordType::AAAA);
     let rdata = RData::AAAA(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
-    assert_eq!(func(&rdata), Some(DnsReturnRecord::AAAA("::1".to_string())));
+    assert_eq!(func(&rdata), Some(DnsReturnRecord::Aaaa("::1".to_string())));
   }
 
   #[test]
   fn rdata_to_return_record_aname() {
     let func = rdata_to_return_record(RecordType::ANAME);
     let rdata = RData::ANAME(Name::new());
-    assert_eq!(func(&rdata), Some(DnsReturnRecord::ANAME("".to_string())));
+    assert_eq!(func(&rdata), Some(DnsReturnRecord::Aname("".to_string())));
   }
 
   #[test]
   fn rdata_to_return_record_cname() {
     let func = rdata_to_return_record(RecordType::CNAME);
     let rdata = RData::CNAME(Name::new());
-    assert_eq!(func(&rdata), Some(DnsReturnRecord::CNAME("".to_string())));
+    assert_eq!(func(&rdata), Some(DnsReturnRecord::Cname("".to_string())));
   }
 
   #[test]
@@ -697,7 +697,7 @@ mod tests {
     let rdata = RData::MX(MX::new(10, Name::new()));
     assert_eq!(
       func(&rdata),
-      Some(DnsReturnRecord::MX {
+      Some(DnsReturnRecord::Mx {
         preference: 10,
         exchange: "".to_string()
       })
@@ -708,7 +708,7 @@ mod tests {
   fn rdata_to_return_record_ptr() {
     let func = rdata_to_return_record(RecordType::PTR);
     let rdata = RData::PTR(Name::new());
-    assert_eq!(func(&rdata), Some(DnsReturnRecord::PTR("".to_string())));
+    assert_eq!(func(&rdata), Some(DnsReturnRecord::Ptr("".to_string())));
   }
 
   #[test]
@@ -717,7 +717,7 @@ mod tests {
     let rdata = RData::SRV(SRV::new(1, 2, 3, Name::new()));
     assert_eq!(
       func(&rdata),
-      Some(DnsReturnRecord::SRV {
+      Some(DnsReturnRecord::Srv {
         priority: 1,
         weight: 2,
         port: 3,
@@ -737,7 +737,7 @@ mod tests {
     ]));
     assert_eq!(
       func(&rdata),
-      Some(DnsReturnRecord::TXT(vec![
+      Some(DnsReturnRecord::Txt(vec![
         "foo".to_string(),
         "bar".to_string(),
         "£".to_string(),
diff --git a/runtime/ops/tls.rs b/runtime/ops/tls.rs
index 5104e49f8..52c9d322a 100644
--- a/runtime/ops/tls.rs
+++ b/runtime/ops/tls.rs
@@ -79,7 +79,7 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct ConnectTLSArgs {
+pub struct ConnectTlsArgs {
   transport: String,
   hostname: String,
   port: u16,
@@ -88,7 +88,7 @@ pub struct ConnectTLSArgs {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct StartTLSArgs {
+struct StartTlsArgs {
   rid: ResourceId,
   cert_file: Option<String>,
   hostname: String,
@@ -96,7 +96,7 @@ struct StartTLSArgs {
 
 async fn op_start_tls(
   state: Rc<RefCell<OpState>>,
-  args: StartTLSArgs,
+  args: StartTlsArgs,
   _zero_copy: BufVec,
 ) -> Result<Value, AnyError> {
   let rid = args.rid;
@@ -166,7 +166,7 @@ async fn op_start_tls(
 
 async fn op_connect_tls(
   state: Rc<RefCell<OpState>>,
-  args: ConnectTLSArgs,
+  args: ConnectTlsArgs,
   _zero_copy: BufVec,
 ) -> Result<Value, AnyError> {
   {
diff --git a/test_util/src/lib.rs b/test_util/src/lib.rs
index 544015413..b02181170 100644
--- a/test_util/src/lib.rs
+++ b/test_util/src/lib.rs
@@ -964,7 +964,7 @@ impl HttpServerCount {
             break;
           }
         } else {
-          panic!(maybe_line.unwrap_err());
+          panic!("{}", maybe_line.unwrap_err());
         }
       }
       self.test_server = Some(test_server);