core: introduce extensions (#9800)

Extensions allow declarative extensions to "JsRuntime" (ops, state, JS or middleware).

This allows for:
- `op_crates` to be plug-and-play & self-contained, reducing complexity leaked to consumers
- op middleware (like metrics_op) to be opt-in and for new middleware (unstable, tracing,...)
- `MainWorker` and `WebWorker` to be composable, allowing users to extend workers with their ops whilst benefiting from the other infrastructure (inspector, etc...)

In short extensions improve deno's modularity, reducing complexity and leaky abstractions for embedders and the internal codebase.

11 files changed, 556 insertions, 181 deletions

diff --git a/op_crates/console/lib.rs b/op_crates/console/lib.rs
index a972f6212..4d6a213f2 100644
--- a/op_crates/console/lib.rs
+++ b/op_crates/console/lib.rs
@@ -1,23 +1,15 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
 
-use deno_core::JsRuntime;
+use deno_core::include_js_files;
+use deno_core::Extension;
 use std::path::PathBuf;
 
-/// Load and execute the javascript code.
-pub fn init(isolate: &mut JsRuntime) {
-  let files = vec![
-    (
-      "deno:op_crates/console/01_colors.js",
-      include_str!("01_colors.js"),
-    ),
-    (
-      "deno:op_crates/console/02_console.js",
-      include_str!("02_console.js"),
-    ),
-  ];
-  for (url, source_code) in files {
-    isolate.execute(url, source_code).unwrap();
-  }
+pub fn init() -> Extension {
+  Extension::pure_js(include_js_files!(
+    prefix "deno:op_crates/console",
+    "01_colors.js",
+    "02_console.js",
+  ))
 }
 
 pub fn get_declaration() -> PathBuf {
diff --git a/op_crates/crypto/lib.rs b/op_crates/crypto/lib.rs
index 8b4d34a7c..d5b0a30bc 100644
--- a/op_crates/crypto/lib.rs
+++ b/op_crates/crypto/lib.rs
@@ -2,25 +2,36 @@
 
 use deno_core::error::null_opbuf;
 use deno_core::error::AnyError;
-use deno_core::JsRuntime;
+use deno_core::include_js_files;
+use deno_core::op_sync;
+use deno_core::Extension;
 use deno_core::OpState;
 use deno_core::ZeroCopyBuf;
 use rand::rngs::StdRng;
 use rand::thread_rng;
 use rand::Rng;
+use rand::SeedableRng;
 use std::path::PathBuf;
 
 pub use rand; // Re-export rand
 
-/// Execute this crates' JS source files.
-pub fn init(isolate: &mut JsRuntime) {
-  let files = vec![(
-    "deno:op_crates/crypto/01_crypto.js",
-    include_str!("01_crypto.js"),
-  )];
-  for (url, source_code) in files {
-    isolate.execute(url, source_code).unwrap();
-  }
+pub fn init(maybe_seed: Option<u64>) -> Extension {
+  Extension::with_ops(
+    include_js_files!(
+      prefix "deno:op_crates/crypto",
+      "01_crypto.js",
+    ),
+    vec![(
+      "op_crypto_get_random_values",
+      op_sync(op_crypto_get_random_values),
+    )],
+    Some(Box::new(move |state| {
+      if let Some(seed) = maybe_seed {
+        state.put(StdRng::seed_from_u64(seed));
+      }
+      Ok(())
+    })),
+  )
 }
 
 pub fn op_crypto_get_random_values(
diff --git a/op_crates/fetch/lib.rs b/op_crates/fetch/lib.rs
index ad96dea46..7033a416c 100644
--- a/op_crates/fetch/lib.rs
+++ b/op_crates/fetch/lib.rs
@@ -8,12 +8,15 @@ use deno_core::error::AnyError;
 use deno_core::futures::Future;
 use deno_core::futures::Stream;
 use deno_core::futures::StreamExt;
+use deno_core::include_js_files;
+use deno_core::op_async;
+use deno_core::op_sync;
 use deno_core::url::Url;
 use deno_core::AsyncRefCell;
 use deno_core::CancelFuture;
 use deno_core::CancelHandle;
 use deno_core::CancelTryFuture;
-use deno_core::JsRuntime;
+use deno_core::Extension;
 use deno_core::OpState;
 use deno_core::RcRef;
 use deno_core::Resource;
@@ -49,49 +52,41 @@ use tokio_util::io::StreamReader;
 
 pub use reqwest; // Re-export reqwest
 
-/// Execute this crates' JS source files.
-pub fn init(isolate: &mut JsRuntime) {
-  let files = vec![
-    (
-      "deno:op_crates/fetch/01_fetch_util.js",
-      include_str!("01_fetch_util.js"),
-    ),
-    (
-      "deno:op_crates/fetch/11_streams.js",
-      include_str!("11_streams.js"),
-    ),
-    (
-      "deno:op_crates/fetch/20_headers.js",
-      include_str!("20_headers.js"),
-    ),
-    (
-      "deno:op_crates/fetch/21_formdata.js",
-      include_str!("21_formdata.js"),
-    ),
-    (
-      "deno:op_crates/fetch/22_body.js",
-      include_str!("22_body.js"),
-    ),
-    (
-      "deno:op_crates/fetch/22_http_client.js",
-      include_str!("22_http_client.js"),
-    ),
-    (
-      "deno:op_crates/fetch/23_request.js",
-      include_str!("23_request.js"),
-    ),
-    (
-      "deno:op_crates/fetch/23_response.js",
-      include_str!("23_response.js"),
-    ),
-    (
-      "deno:op_crates/fetch/26_fetch.js",
-      include_str!("26_fetch.js"),
+pub fn init<P: FetchPermissions + 'static>(
+  user_agent: String,
+  ca_data: Option<Vec<u8>>,
+) -> Extension {
+  Extension::with_ops(
+    include_js_files!(
+      prefix "deno:op_crates/fetch",
+      "01_fetch_util.js",
+      "11_streams.js",
+      "20_headers.js",
+      "21_formdata.js",
+      "22_body.js",
+      "22_http_client.js",
+      "23_request.js",
+      "23_response.js",
+      "26_fetch.js",
     ),
-  ];
-  for (url, source_code) in files {
-    isolate.execute(url, source_code).expect(url);
-  }
+    vec![
+      ("op_fetch", op_sync(op_fetch::<P>)),
+      ("op_fetch_send", op_async(op_fetch_send)),
+      ("op_fetch_request_write", op_async(op_fetch_request_write)),
+      ("op_fetch_response_read", op_async(op_fetch_response_read)),
+      ("op_create_http_client", op_sync(op_create_http_client::<P>)),
+    ],
+    Some(Box::new(move |state| {
+      state.put::<reqwest::Client>({
+        create_http_client(user_agent.clone(), ca_data.clone()).unwrap()
+      });
+      state.put::<HttpClientDefaults>(HttpClientDefaults {
+        ca_data: ca_data.clone(),
+        user_agent: user_agent.clone(),
+      });
+      Ok(())
+    })),
+  )
 }
 
 pub struct HttpClientDefaults {
diff --git a/op_crates/file/lib.rs b/op_crates/file/lib.rs
index ea519046f..19bb8b19b 100644
--- a/op_crates/file/lib.rs
+++ b/op_crates/file/lib.rs
@@ -2,8 +2,10 @@
 
 use deno_core::error::null_opbuf;
 use deno_core::error::AnyError;
+use deno_core::include_js_files;
+use deno_core::op_sync;
 use deno_core::url::Url;
-use deno_core::JsRuntime;
+use deno_core::Extension;
 use deno_core::ModuleSpecifier;
 use deno_core::ZeroCopyBuf;
 use std::collections::HashMap;
@@ -82,22 +84,35 @@ pub fn op_file_revoke_object_url(
   Ok(())
 }
 
-/// Load and execute the javascript code.
-pub fn init(isolate: &mut JsRuntime) {
-  let files = vec![
-    ("deno:op_crates/file/01_file.js", include_str!("01_file.js")),
-    (
-      "deno:op_crates/file/02_filereader.js",
-      include_str!("02_filereader.js"),
+pub fn init(
+  blob_url_store: BlobUrlStore,
+  maybe_location: Option<Url>,
+) -> Extension {
+  Extension::with_ops(
+    include_js_files!(
+      prefix "deno:op_crates/file",
+      "01_file.js",
+      "02_filereader.js",
+      "03_blob_url.js",
     ),
-    (
-      "deno:op_crates/file/03_blob_url.js",
-      include_str!("03_blob_url.js"),
-    ),
-  ];
-  for (url, source_code) in files {
-    isolate.execute(url, source_code).unwrap();
-  }
+    vec![
+      (
+        "op_file_create_object_url",
+        op_sync(op_file_create_object_url),
+      ),
+      (
+        "op_file_revoke_object_url",
+        op_sync(op_file_revoke_object_url),
+      ),
+    ],
+    Some(Box::new(move |state| {
+      state.put(blob_url_store.clone());
+      if let Some(location) = maybe_location.clone() {
+        state.put(Location(location));
+      }
+      Ok(())
+    })),
+  )
 }
 
 pub fn get_declaration() -> PathBuf {
diff --git a/op_crates/timers/lib.rs b/op_crates/timers/lib.rs
index 047b6923c..6359b20f0 100644
--- a/op_crates/timers/lib.rs
+++ b/op_crates/timers/lib.rs
@@ -13,6 +13,9 @@ use deno_core::futures;
 use deno_core::futures::channel::oneshot;
 use deno_core::futures::FutureExt;
 use deno_core::futures::TryFutureExt;
+use deno_core::op_async;
+use deno_core::op_sync;
+use deno_core::Extension;
 use deno_core::OpState;
 use deno_core::ZeroCopyBuf;
 use std::cell::RefCell;
@@ -28,12 +31,34 @@ pub trait TimersPermission {
   fn check_unstable(&self, state: &OpState, api_name: &'static str);
 }
 
-pub fn init(rt: &mut deno_core::JsRuntime) {
-  rt.execute(
-    "deno:op_crates/timers/01_timers.js",
-    include_str!("01_timers.js"),
+pub struct NoTimersPermission;
+
+impl TimersPermission for NoTimersPermission {
+  fn allow_hrtime(&mut self) -> bool {
+    false
+  }
+  fn check_unstable(&self, _: &OpState, _: &'static str) {}
+}
+
+pub fn init<P: TimersPermission + 'static>() -> Extension {
+  Extension::with_ops(
+    vec![(
+      "deno:op_crates/timers/01_timers.js",
+      include_str!("01_timers.js"),
+    )],
+    vec![
+      ("op_global_timer_stop", op_sync(op_global_timer_stop)),
+      ("op_global_timer_start", op_sync(op_global_timer_start)),
+      ("op_global_timer", op_async(op_global_timer)),
+      ("op_now", op_sync(op_now::<P>)),
+      ("op_sleep_sync", op_sync(op_sleep_sync::<P>)),
+    ],
+    Some(Box::new(|state| {
+      state.put(GlobalTimer::default());
+      state.put(StartTime::now());
+      Ok(())
+    })),
   )
-  .unwrap();
 }
 
 pub type StartTime = Instant;
diff --git a/op_crates/url/benches/url_ops.rs b/op_crates/url/benches/url_ops.rs
index 0f584de90..8d5498540 100644
--- a/op_crates/url/benches/url_ops.rs
+++ b/op_crates/url/benches/url_ops.rs
@@ -1,21 +1,14 @@
 use bencher::{benchmark_group, benchmark_main, Bencher};
 
-use deno_core::op_sync;
 use deno_core::v8;
 use deno_core::JsRuntime;
+use deno_core::RuntimeOptions;
 
 fn create_js_runtime() -> JsRuntime {
-  let mut runtime = JsRuntime::new(Default::default());
-  runtime.register_op("op_url_parse", op_sync(deno_url::op_url_parse));
-  runtime.register_op(
-    "op_url_parse_search_params",
-    op_sync(deno_url::op_url_parse_search_params),
-  );
-  runtime.register_op(
-    "op_url_stringify_search_params",
-    op_sync(deno_url::op_url_stringify_search_params),
-  );
-  runtime.sync_ops_cache();
+  let mut runtime = JsRuntime::new(RuntimeOptions {
+    extensions: vec![deno_url::init()],
+    ..Default::default()
+  });
 
   runtime
     .execute(
@@ -23,7 +16,10 @@ fn create_js_runtime() -> JsRuntime {
       "globalThis.__bootstrap = (globalThis.__bootstrap || {});",
     )
     .unwrap();
-  deno_url::init(&mut runtime);
+
+  runtime.init_extension_js().unwrap();
+  runtime.init_extension_ops().unwrap();
+
   runtime
     .execute("setup", "const { URL } = globalThis.__bootstrap.url;")
     .unwrap();
diff --git a/op_crates/url/lib.rs b/op_crates/url/lib.rs
index 04663e411..49e34c47d 100644
--- a/op_crates/url/lib.rs
+++ b/op_crates/url/lib.rs
@@ -4,16 +4,39 @@ use deno_core::error::generic_error;
 use deno_core::error::type_error;
 use deno_core::error::uri_error;
 use deno_core::error::AnyError;
+use deno_core::include_js_files;
+use deno_core::op_sync;
 use deno_core::url::form_urlencoded;
 use deno_core::url::quirks;
 use deno_core::url::Url;
-use deno_core::JsRuntime;
+use deno_core::Extension;
 use deno_core::ZeroCopyBuf;
 use serde::Deserialize;
 use serde::Serialize;
 use std::panic::catch_unwind;
 use std::path::PathBuf;
 
+pub fn init() -> Extension {
+  Extension::with_ops(
+    include_js_files!(
+      prefix "deno:op_crates/url",
+      "00_url.js",
+    ),
+    vec![
+      ("op_url_parse", op_sync(op_url_parse)),
+      (
+        "op_url_parse_search_params",
+        op_sync(op_url_parse_search_params),
+      ),
+      (
+        "op_url_stringify_search_params",
+        op_sync(op_url_stringify_search_params),
+      ),
+    ],
+    None,
+  )
+}
+
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct UrlParseArgs {
@@ -146,14 +169,6 @@ pub fn op_url_stringify_search_params(
   Ok(search)
 }
 
-/// Load and execute the javascript code.
-pub fn init(isolate: &mut JsRuntime) {
-  let files = vec![("deno:op_crates/url/00_url.js", include_str!("00_url.js"))];
-  for (url, source_code) in files {
-    isolate.execute(url, source_code).unwrap();
-  }
-}
-
 pub fn get_declaration() -> PathBuf {
   PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_url.d.ts")
 }
diff --git a/op_crates/web/lib.rs b/op_crates/web/lib.rs
index a609dc4cd..7fd8221eb 100644
--- a/op_crates/web/lib.rs
+++ b/op_crates/web/lib.rs
@@ -1,47 +1,22 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
 
-use deno_core::JsRuntime;
+use deno_core::include_js_files;
+use deno_core::Extension;
 use std::path::PathBuf;
 
 /// Load and execute the javascript code.
-pub fn init(isolate: &mut JsRuntime) {
-  let files = vec![
-    (
-      "deno:op_crates/web/00_infra.js",
-      include_str!("00_infra.js"),
-    ),
-    (
-      "deno:op_crates/web/01_dom_exception.js",
-      include_str!("01_dom_exception.js"),
-    ),
-    (
-      "deno:op_crates/web/01_mimesniff.js",
-      include_str!("01_mimesniff.js"),
-    ),
-    (
-      "deno:op_crates/web/02_event.js",
-      include_str!("02_event.js"),
-    ),
-    (
-      "deno:op_crates/web/03_abort_signal.js",
-      include_str!("03_abort_signal.js"),
-    ),
-    (
-      "deno:op_crates/web/04_global_interfaces.js",
-      include_str!("04_global_interfaces.js"),
-    ),
-    (
-      "deno:op_crates/web/08_text_encoding.js",
-      include_str!("08_text_encoding.js"),
-    ),
-    (
-      "deno:op_crates/web/12_location.js",
-      include_str!("12_location.js"),
-    ),
-  ];
-  for (url, source_code) in files {
-    isolate.execute(url, source_code).unwrap();
-  }
+pub fn init() -> Extension {
+  Extension::pure_js(include_js_files!(
+    prefix "deno:op_crates/web",
+    "00_infra.js",
+    "01_dom_exception.js",
+    "01_mimesniff.js",
+    "02_event.js",
+    "03_abort_signal.js",
+    "04_global_interfaces.js",
+    "08_text_encoding.js",
+    "12_location.js",
+  ))
 }
 
 pub fn get_declaration() -> PathBuf {
diff --git a/op_crates/webgpu/lib.rs b/op_crates/webgpu/lib.rs
index 62ec08ce7..a9cbbb882 100644
--- a/op_crates/webgpu/lib.rs
+++ b/op_crates/webgpu/lib.rs
@@ -2,6 +2,11 @@
 
 use deno_core::error::AnyError;
 use deno_core::error::{bad_resource_id, not_supported};
+use deno_core::include_js_files;
+use deno_core::op_async;
+use deno_core::op_sync;
+use deno_core::Extension;
+use deno_core::OpFn;
 use deno_core::OpState;
 use deno_core::Resource;
 use deno_core::ResourceId;
@@ -89,21 +94,23 @@ impl Resource for WebGpuQuerySet {
   }
 }
 
-/// Execute this crates' JS source files.
-pub fn init(isolate: &mut deno_core::JsRuntime) {
-  let files = vec![
-    (
-      "deno:op_crates/webgpu/01_webgpu.js",
-      include_str!("01_webgpu.js"),
-    ),
-    (
-      "deno:op_crates/webgpu/02_idl_types.js",
-      include_str!("02_idl_types.js"),
+pub fn init(unstable: bool) -> Extension {
+  Extension::with_ops(
+    include_js_files!(
+      prefix "deno:op_crates/webgpu",
+      "01_webgpu.js",
+      "02_idl_types.js",
     ),
-  ];
-  for (url, source_code) in files {
-    isolate.execute(url, source_code).unwrap();
-  }
+    declare_webgpu_ops(),
+    Some(Box::new(move |state| {
+      // TODO: check & possibly streamline this
+      // Unstable might be able to be OpMiddleware
+      // let unstable_checker = state.borrow::<super::UnstableChecker>();
+      // let unstable = unstable_checker.unstable;
+      state.put(Unstable(unstable));
+      Ok(())
+    })),
+  )
 }
 
 pub fn get_declaration() -> PathBuf {
@@ -537,3 +544,328 @@ pub fn op_webgpu_create_query_set(
 
   Ok(WebGpuResult::rid_err(rid, maybe_err))
 }
+
+fn declare_webgpu_ops() -> Vec<(&'static str, Box<OpFn>)> {
+  vec![
+    // Request device/adapter
+    (
+      "op_webgpu_request_adapter",
+      op_async(op_webgpu_request_adapter),
+    ),
+    (
+      "op_webgpu_request_device",
+      op_async(op_webgpu_request_device),
+    ),
+    // Query Set
+    (
+      "op_webgpu_create_query_set",
+      op_sync(op_webgpu_create_query_set),
+    ),
+    // buffer
+    (
+      "op_webgpu_create_buffer",
+      op_sync(buffer::op_webgpu_create_buffer),
+    ),
+    (
+      "op_webgpu_buffer_get_mapped_range",
+      op_sync(buffer::op_webgpu_buffer_get_mapped_range),
+    ),
+    (
+      "op_webgpu_buffer_unmap",
+      op_sync(buffer::op_webgpu_buffer_unmap),
+    ),
+    // buffer async
+    (
+      "op_webgpu_buffer_get_map_async",
+      op_async(buffer::op_webgpu_buffer_get_map_async),
+    ),
+    // remaining sync ops
+
+    // texture
+    (
+      "op_webgpu_create_texture",
+      op_sync(texture::op_webgpu_create_texture),
+    ),
+    (
+      "op_webgpu_create_texture_view",
+      op_sync(texture::op_webgpu_create_texture_view),
+    ),
+    // sampler
+    (
+      "op_webgpu_create_sampler",
+      op_sync(sampler::op_webgpu_create_sampler),
+    ),
+    // binding
+    (
+      "op_webgpu_create_bind_group_layout",
+      op_sync(binding::op_webgpu_create_bind_group_layout),
+    ),
+    (
+      "op_webgpu_create_pipeline_layout",
+      op_sync(binding::op_webgpu_create_pipeline_layout),
+    ),
+    (
+      "op_webgpu_create_bind_group",
+      op_sync(binding::op_webgpu_create_bind_group),
+    ),
+    // pipeline
+    (
+      "op_webgpu_create_compute_pipeline",
+      op_sync(pipeline::op_webgpu_create_compute_pipeline),
+    ),
+    (
+      "op_webgpu_compute_pipeline_get_bind_group_layout",
+      op_sync(pipeline::op_webgpu_compute_pipeline_get_bind_group_layout),
+    ),
+    (
+      "op_webgpu_create_render_pipeline",
+      op_sync(pipeline::op_webgpu_create_render_pipeline),
+    ),
+    (
+      "op_webgpu_render_pipeline_get_bind_group_layout",
+      op_sync(pipeline::op_webgpu_render_pipeline_get_bind_group_layout),
+    ),
+    // command_encoder
+    (
+      "op_webgpu_create_command_encoder",
+      op_sync(command_encoder::op_webgpu_create_command_encoder),
+    ),
+    (
+      "op_webgpu_command_encoder_begin_render_pass",
+      op_sync(command_encoder::op_webgpu_command_encoder_begin_render_pass),
+    ),
+    (
+      "op_webgpu_command_encoder_begin_compute_pass",
+      op_sync(command_encoder::op_webgpu_command_encoder_begin_compute_pass),
+    ),
+    (
+      "op_webgpu_command_encoder_copy_buffer_to_buffer",
+      op_sync(command_encoder::op_webgpu_command_encoder_copy_buffer_to_buffer),
+    ),
+    (
+      "op_webgpu_command_encoder_copy_buffer_to_texture",
+      op_sync(
+        command_encoder::op_webgpu_command_encoder_copy_buffer_to_texture,
+      ),
+    ),
+    (
+      "op_webgpu_command_encoder_copy_texture_to_buffer",
+      op_sync(
+        command_encoder::op_webgpu_command_encoder_copy_texture_to_buffer,
+      ),
+    ),
+    (
+      "op_webgpu_command_encoder_copy_texture_to_texture",
+      op_sync(
+        command_encoder::op_webgpu_command_encoder_copy_texture_to_texture,
+      ),
+    ),
+    (
+      "op_webgpu_command_encoder_push_debug_group",
+      op_sync(command_encoder::op_webgpu_command_encoder_push_debug_group),
+    ),
+    (
+      "op_webgpu_command_encoder_pop_debug_group",
+      op_sync(command_encoder::op_webgpu_command_encoder_pop_debug_group),
+    ),
+    (
+      "op_webgpu_command_encoder_insert_debug_marker",
+      op_sync(command_encoder::op_webgpu_command_encoder_insert_debug_marker),
+    ),
+    (
+      "op_webgpu_command_encoder_write_timestamp",
+      op_sync(command_encoder::op_webgpu_command_encoder_write_timestamp),
+    ),
+    (
+      "op_webgpu_command_encoder_resolve_query_set",
+      op_sync(command_encoder::op_webgpu_command_encoder_resolve_query_set),
+    ),
+    (
+      "op_webgpu_command_encoder_finish",
+      op_sync(command_encoder::op_webgpu_command_encoder_finish),
+    ),
+    // render_pass
+    (
+      "op_webgpu_render_pass_set_viewport",
+      op_sync(render_pass::op_webgpu_render_pass_set_viewport),
+    ),
+    (
+      "op_webgpu_render_pass_set_scissor_rect",
+      op_sync(render_pass::op_webgpu_render_pass_set_scissor_rect),
+    ),
+    (
+      "op_webgpu_render_pass_set_blend_color",
+      op_sync(render_pass::op_webgpu_render_pass_set_blend_color),
+    ),
+    (
+      "op_webgpu_render_pass_set_stencil_reference",
+      op_sync(render_pass::op_webgpu_render_pass_set_stencil_reference),
+    ),
+    (
+      "op_webgpu_render_pass_begin_pipeline_statistics_query",
+      op_sync(
+        render_pass::op_webgpu_render_pass_begin_pipeline_statistics_query,
+      ),
+    ),
+    (
+      "op_webgpu_render_pass_end_pipeline_statistics_query",
+      op_sync(render_pass::op_webgpu_render_pass_end_pipeline_statistics_query),
+    ),
+    (
+      "op_webgpu_render_pass_write_timestamp",
+      op_sync(render_pass::op_webgpu_render_pass_write_timestamp),
+    ),
+    (
+      "op_webgpu_render_pass_execute_bundles",
+      op_sync(render_pass::op_webgpu_render_pass_execute_bundles),
+    ),
+    (
+      "op_webgpu_render_pass_end_pass",
+      op_sync(render_pass::op_webgpu_render_pass_end_pass),
+    ),
+    (
+      "op_webgpu_render_pass_set_bind_group",
+      op_sync(render_pass::op_webgpu_render_pass_set_bind_group),
+    ),
+    (
+      "op_webgpu_render_pass_push_debug_group",
+      op_sync(render_pass::op_webgpu_render_pass_push_debug_group),
+    ),
+    (
+      "op_webgpu_render_pass_pop_debug_group",
+      op_sync(render_pass::op_webgpu_render_pass_pop_debug_group),
+    ),
+    (
+      "op_webgpu_render_pass_insert_debug_marker",
+      op_sync(render_pass::op_webgpu_render_pass_insert_debug_marker),
+    ),
+    (
+      "op_webgpu_render_pass_set_pipeline",
+      op_sync(render_pass::op_webgpu_render_pass_set_pipeline),
+    ),
+    (
+      "op_webgpu_render_pass_set_index_buffer",
+      op_sync(render_pass::op_webgpu_render_pass_set_index_buffer),
+    ),
+    (
+      "op_webgpu_render_pass_set_vertex_buffer",
+      op_sync(render_pass::op_webgpu_render_pass_set_vertex_buffer),
+    ),
+    (
+      "op_webgpu_render_pass_draw",
+      op_sync(render_pass::op_webgpu_render_pass_draw),
+    ),
+    (
+      "op_webgpu_render_pass_draw_indexed",
+      op_sync(render_pass::op_webgpu_render_pass_draw_indexed),
+    ),
+    (
+      "op_webgpu_render_pass_draw_indirect",
+      op_sync(render_pass::op_webgpu_render_pass_draw_indirect),
+    ),
+    (
+      "op_webgpu_render_pass_draw_indexed_indirect",
+      op_sync(render_pass::op_webgpu_render_pass_draw_indexed_indirect),
+    ),
+    // compute_pass
+    (
+      "op_webgpu_compute_pass_set_pipeline",
+      op_sync(compute_pass::op_webgpu_compute_pass_set_pipeline),
+    ),
+    (
+      "op_webgpu_compute_pass_dispatch",
+      op_sync(compute_pass::op_webgpu_compute_pass_dispatch),
+    ),
+    (
+      "op_webgpu_compute_pass_dispatch_indirect",
+      op_sync(compute_pass::op_webgpu_compute_pass_dispatch_indirect),
+    ),
+    (
+      "op_webgpu_compute_pass_end_pass",
+      op_sync(compute_pass::op_webgpu_compute_pass_end_pass),
+    ),
+    (
+      "op_webgpu_compute_pass_set_bind_group",
+      op_sync(compute_pass::op_webgpu_compute_pass_set_bind_group),
+    ),
+    (
+      "op_webgpu_compute_pass_push_debug_group",
+      op_sync(compute_pass::op_webgpu_compute_pass_push_debug_group),
+    ),
+    (
+      "op_webgpu_compute_pass_pop_debug_group",
+      op_sync(compute_pass::op_webgpu_compute_pass_pop_debug_group),
+    ),
+    (
+      "op_webgpu_compute_pass_insert_debug_marker",
+      op_sync(compute_pass::op_webgpu_compute_pass_insert_debug_marker),
+    ),
+    // bundle
+    (
+      "op_webgpu_create_render_bundle_encoder",
+      op_sync(bundle::op_webgpu_create_render_bundle_encoder),
+    ),
+    (
+      "op_webgpu_render_bundle_encoder_finish",
+      op_sync(bundle::op_webgpu_render_bundle_encoder_finish),
+    ),
+    (
+      "op_webgpu_render_bundle_encoder_set_bind_group",
+      op_sync(bundle::op_webgpu_render_bundle_encoder_set_bind_group),
+    ),
+    (
+      "op_webgpu_render_bundle_encoder_push_debug_group",
+      op_sync(bundle::op_webgpu_render_bundle_encoder_push_debug_group),
+    ),
+    (
+      "op_webgpu_render_bundle_encoder_pop_debug_group",
+      op_sync(bundle::op_webgpu_render_bundle_encoder_pop_debug_group),
+    ),
+    (
+      "op_webgpu_render_bundle_encoder_insert_debug_marker",
+      op_sync(bundle::op_webgpu_render_bundle_encoder_insert_debug_marker),
+    ),
+    (
+      "op_webgpu_render_bundle_encoder_set_pipeline",
+      op_sync(bundle::op_webgpu_render_bundle_encoder_set_pipeline),
+    ),
+    (
+      "op_webgpu_render_bundle_encoder_set_index_buffer",
+      op_sync(bundle::op_webgpu_render_bundle_encoder_set_index_buffer),
+    ),
+    (
+      "op_webgpu_render_bundle_encoder_set_vertex_buffer",
+      op_sync(bundle::op_webgpu_render_bundle_encoder_set_vertex_buffer),
+    ),
+    (
+      "op_webgpu_render_bundle_encoder_draw",
+      op_sync(bundle::op_webgpu_render_bundle_encoder_draw),
+    ),
+    (
+      "op_webgpu_render_bundle_encoder_draw_indexed",
+      op_sync(bundle::op_webgpu_render_bundle_encoder_draw_indexed),
+    ),
+    (
+      "op_webgpu_render_bundle_encoder_draw_indirect",
+      op_sync(bundle::op_webgpu_render_bundle_encoder_draw_indirect),
+    ),
+    // queue
+    (
+      "op_webgpu_queue_submit",
+      op_sync(queue::op_webgpu_queue_submit),
+    ),
+    (
+      "op_webgpu_write_buffer",
+      op_sync(queue::op_webgpu_write_buffer),
+    ),
+    (
+      "op_webgpu_write_texture",
+      op_sync(queue::op_webgpu_write_texture),
+    ),
+    // shader
+    (
+      "op_webgpu_create_shader_module",
+      op_sync(shader::op_webgpu_create_shader_module),
+    ),
+  ]
+}
diff --git a/op_crates/webidl/lib.rs b/op_crates/webidl/lib.rs
index 7e617c7a7..a1a404dbd 100644
--- a/op_crates/webidl/lib.rs
+++ b/op_crates/webidl/lib.rs
@@ -1,14 +1,11 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
 
-use deno_core::JsRuntime;
+use deno_core::Extension;
 
 /// Load and execute the javascript code.
-pub fn init(isolate: &mut JsRuntime) {
-  let files = vec![(
+pub fn init() -> Extension {
+  Extension::pure_js(vec![(
     "deno:op_crates/webidl/00_webidl.js",
     include_str!("00_webidl.js"),
-  )];
-  for (url, source_code) in files {
-    isolate.execute(url, source_code).unwrap();
-  }
+  )])
 }
diff --git a/op_crates/websocket/lib.rs b/op_crates/websocket/lib.rs
index a2454b8e3..c682c6b2f 100644
--- a/op_crates/websocket/lib.rs
+++ b/op_crates/websocket/lib.rs
@@ -9,11 +9,14 @@ use deno_core::futures::stream::SplitSink;
 use deno_core::futures::stream::SplitStream;
 use deno_core::futures::SinkExt;
 use deno_core::futures::StreamExt;
+use deno_core::include_js_files;
+use deno_core::op_async;
+use deno_core::op_sync;
 use deno_core::url;
 use deno_core::AsyncRefCell;
 use deno_core::CancelFuture;
 use deno_core::CancelHandle;
-use deno_core::JsRuntime;
+use deno_core::Extension;
 use deno_core::OpState;
 use deno_core::RcRef;
 use deno_core::Resource;
@@ -333,14 +336,33 @@ pub async fn op_ws_next_event(
   Ok(res)
 }
 
-/// Load and execute the javascript code.
-pub fn init(isolate: &mut JsRuntime) {
-  isolate
-    .execute(
-      "deno:op_crates/websocket/01_websocket.js",
-      include_str!("01_websocket.js"),
-    )
-    .unwrap();
+pub fn init<P: WebSocketPermissions + 'static>(
+  user_agent: String,
+  ca_data: Option<Vec<u8>>,
+) -> Extension {
+  Extension::with_ops(
+    include_js_files!(
+      prefix "deno:op_crates/websocket",
+      "01_websocket.js",
+    ),
+    vec![
+      (
+        "op_ws_check_permission",
+        op_sync(op_ws_check_permission::<P>),
+      ),
+      ("op_ws_create", op_async(op_ws_create::<P>)),
+      ("op_ws_send", op_async(op_ws_send)),
+      ("op_ws_close", op_async(op_ws_close)),
+      ("op_ws_next_event", op_async(op_ws_next_event)),
+    ],
+    Some(Box::new(move |state| {
+      state.put::<WsUserAgent>(WsUserAgent(user_agent.clone()));
+      if let Some(ca_data) = ca_data.clone() {
+        state.put::<WsCaData>(WsCaData(ca_data));
+      }
+      Ok(())
+    })),
+  )
 }
 
 pub fn get_declaration() -> PathBuf {