feat(core): codegen ops (#13861)

Co-authored-by: Aaron O'Mullan <aaron.omullan@gmail.com>

34 files changed, 432 insertions, 527 deletions

diff --git a/ext/broadcast_channel/lib.rs b/ext/broadcast_channel/lib.rs
index 91ee67674..eff57c7df 100644
--- a/ext/broadcast_channel/lib.rs
+++ b/ext/broadcast_channel/lib.rs
@@ -8,8 +8,7 @@ pub use in_memory_broadcast_channel::InMemoryBroadcastChannelResource;
 use async_trait::async_trait;
 use deno_core::error::AnyError;
 use deno_core::include_js_files;
-use deno_core::op_async;
-use deno_core::op_sync;
+use deno_core::op;
 use deno_core::Extension;
 use deno_core::OpState;
 use deno_core::Resource;
@@ -43,11 +42,15 @@ pub type Message = (String, Vec<u8>);
 
 struct Unstable(bool); // --unstable
 
-pub fn op_broadcast_subscribe<BC: BroadcastChannel + 'static>(
+#[op]
+pub fn op_broadcast_subscribe<BC>(
   state: &mut OpState,
   _: (),
   _: (),
-) -> Result<ResourceId, AnyError> {
+) -> Result<ResourceId, AnyError>
+where
+  BC: BroadcastChannel + 'static,
+{
   let unstable = state.borrow::<Unstable>().0;
 
   if !unstable {
@@ -62,31 +65,43 @@ pub fn op_broadcast_subscribe<BC: BroadcastChannel + 'static>(
   Ok(state.resource_table.add(resource))
 }
 
-pub fn op_broadcast_unsubscribe<BC: BroadcastChannel + 'static>(
+#[op]
+pub fn op_broadcast_unsubscribe<BC>(
   state: &mut OpState,
   rid: ResourceId,
   _buf: (),
-) -> Result<(), AnyError> {
+) -> Result<(), AnyError>
+where
+  BC: BroadcastChannel + 'static,
+{
   let resource = state.resource_table.get::<BC::Resource>(rid)?;
   let bc = state.borrow::<BC>();
   bc.unsubscribe(&resource)
 }
 
-pub async fn op_broadcast_send<BC: BroadcastChannel + 'static>(
+#[op]
+pub async fn op_broadcast_send<BC>(
   state: Rc<RefCell<OpState>>,
   (rid, name): (ResourceId, String),
   buf: ZeroCopyBuf,
-) -> Result<(), AnyError> {
+) -> Result<(), AnyError>
+where
+  BC: BroadcastChannel + 'static,
+{
   let resource = state.borrow().resource_table.get::<BC::Resource>(rid)?;
   let bc = state.borrow().borrow::<BC>().clone();
   bc.send(&resource, name, buf.to_vec()).await
 }
 
-pub async fn op_broadcast_recv<BC: BroadcastChannel + 'static>(
+#[op]
+pub async fn op_broadcast_recv<BC>(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
   _: (),
-) -> Result<Option<Message>, AnyError> {
+) -> Result<Option<Message>, AnyError>
+where
+  BC: BroadcastChannel + 'static,
+{
   let resource = state.borrow().resource_table.get::<BC::Resource>(rid)?;
   let bc = state.borrow().borrow::<BC>().clone();
   bc.recv(&resource).await
@@ -102,16 +117,10 @@ pub fn init<BC: BroadcastChannel + 'static>(
       "01_broadcast_channel.js",
     ))
     .ops(vec![
-      (
-        "op_broadcast_subscribe",
-        op_sync(op_broadcast_subscribe::<BC>),
-      ),
-      (
-        "op_broadcast_unsubscribe",
-        op_sync(op_broadcast_unsubscribe::<BC>),
-      ),
-      ("op_broadcast_send", op_async(op_broadcast_send::<BC>)),
-      ("op_broadcast_recv", op_async(op_broadcast_recv::<BC>)),
+      op_broadcast_subscribe::decl::<BC>(),
+      op_broadcast_unsubscribe::decl::<BC>(),
+      op_broadcast_send::decl::<BC>(),
+      op_broadcast_recv::decl::<BC>(),
     ])
     .state(move |state| {
       state.put(bc.clone());
diff --git a/ext/crypto/decrypt.rs b/ext/crypto/decrypt.rs
index 801e72ea0..a8666de89 100644
--- a/ext/crypto/decrypt.rs
+++ b/ext/crypto/decrypt.rs
@@ -24,6 +24,7 @@ use ctr::Ctr;
 use deno_core::error::custom_error;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::OpState;
 use deno_core::ZeroCopyBuf;
 use rsa::pkcs1::FromRsaPrivateKey;
@@ -76,6 +77,7 @@ pub enum DecryptAlgorithm {
   },
 }
 
+#[op]
 pub async fn op_crypto_decrypt(
   _state: Rc<RefCell<OpState>>,
   opts: DecryptOptions,
diff --git a/ext/crypto/encrypt.rs b/ext/crypto/encrypt.rs
index 63f8af889..b93ca0952 100644
--- a/ext/crypto/encrypt.rs
+++ b/ext/crypto/encrypt.rs
@@ -16,6 +16,7 @@ use aes_gcm::AeadInPlace;
 use aes_gcm::NewAead;
 use aes_gcm::Nonce;
 use ctr::Ctr;
+use deno_core::op;
 
 use block_modes::BlockMode;
 use ctr::cipher::StreamCipher;
@@ -79,6 +80,8 @@ pub enum EncryptAlgorithm {
     key_length: usize,
   },
 }
+
+#[op]
 pub async fn op_crypto_encrypt(
   _state: Rc<RefCell<OpState>>,
   opts: EncryptOptions,
diff --git a/ext/crypto/export_key.rs b/ext/crypto/export_key.rs
index 891aea92a..8131f859d 100644
--- a/ext/crypto/export_key.rs
+++ b/ext/crypto/export_key.rs
@@ -1,5 +1,6 @@
 use deno_core::error::custom_error;
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::OpState;
 use deno_core::ZeroCopyBuf;
 use rsa::pkcs1::UIntBytes;
@@ -84,6 +85,7 @@ pub enum ExportKeyResult {
   },
 }
 
+#[op]
 pub fn op_crypto_export_key(
   _state: &mut OpState,
   opts: ExportKeyOptions,
diff --git a/ext/crypto/generate_key.rs b/ext/crypto/generate_key.rs
index 190a8b424..9fe1b62f4 100644
--- a/ext/crypto/generate_key.rs
+++ b/ext/crypto/generate_key.rs
@@ -3,6 +3,7 @@ use std::rc::Rc;
 
 use crate::shared::*;
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::OpState;
 use deno_core::ZeroCopyBuf;
 use elliptic_curve::rand_core::OsRng;
@@ -41,6 +42,7 @@ pub enum GenerateKeyOptions {
   },
 }
 
+#[op]
 pub async fn op_crypto_generate_key(
   _state: Rc<RefCell<OpState>>,
   opts: GenerateKeyOptions,
diff --git a/ext/crypto/import_key.rs b/ext/crypto/import_key.rs
index b929f38bb..3d29c9947 100644
--- a/ext/crypto/import_key.rs
+++ b/ext/crypto/import_key.rs
@@ -1,4 +1,5 @@
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::OpState;
 use deno_core::ZeroCopyBuf;
 use elliptic_curve::pkcs8::der::Decodable as Pkcs8Decodable;
@@ -81,11 +82,13 @@ pub enum ImportKeyResult {
   #[serde(rename_all = "camelCase")]
   Ec { raw_data: RawKeyData },
   #[serde(rename_all = "camelCase")]
+  #[allow(dead_code)]
   Aes { raw_data: RawKeyData },
   #[serde(rename_all = "camelCase")]
   Hmac { raw_data: RawKeyData },
 }
 
+#[op]
 pub fn op_crypto_import_key(
   _state: &mut OpState,
   opts: ImportKeyOptions,
diff --git a/ext/crypto/lib.rs b/ext/crypto/lib.rs
index 69381e139..3b33830d3 100644
--- a/ext/crypto/lib.rs
+++ b/ext/crypto/lib.rs
@@ -9,8 +9,8 @@ use deno_core::error::not_supported;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
 use deno_core::include_js_files;
-use deno_core::op_async;
-use deno_core::op_sync;
+use deno_core::op;
+
 use deno_core::Extension;
 use deno_core::OpState;
 use deno_core::ZeroCopyBuf;
@@ -88,22 +88,19 @@ pub fn init(maybe_seed: Option<u64>) -> Extension {
       "01_webidl.js",
     ))
     .ops(vec![
-      (
-        "op_crypto_get_random_values",
-        op_sync(op_crypto_get_random_values),
-      ),
-      ("op_crypto_generate_key", op_async(op_crypto_generate_key)),
-      ("op_crypto_sign_key", op_async(op_crypto_sign_key)),
-      ("op_crypto_verify_key", op_async(op_crypto_verify_key)),
-      ("op_crypto_derive_bits", op_async(op_crypto_derive_bits)),
-      ("op_crypto_import_key", op_sync(op_crypto_import_key)),
-      ("op_crypto_export_key", op_sync(op_crypto_export_key)),
-      ("op_crypto_encrypt", op_async(op_crypto_encrypt)),
-      ("op_crypto_decrypt", op_async(op_crypto_decrypt)),
-      ("op_crypto_subtle_digest", op_async(op_crypto_subtle_digest)),
-      ("op_crypto_random_uuid", op_sync(op_crypto_random_uuid)),
-      ("op_crypto_wrap_key", op_sync(op_crypto_wrap_key)),
-      ("op_crypto_unwrap_key", op_sync(op_crypto_unwrap_key)),
+      op_crypto_get_random_values::decl(),
+      op_crypto_generate_key::decl(),
+      op_crypto_sign_key::decl(),
+      op_crypto_verify_key::decl(),
+      op_crypto_derive_bits::decl(),
+      op_crypto_import_key::decl(),
+      op_crypto_export_key::decl(),
+      op_crypto_encrypt::decl(),
+      op_crypto_decrypt::decl(),
+      op_crypto_subtle_digest::decl(),
+      op_crypto_random_uuid::decl(),
+      op_crypto_wrap_key::decl(),
+      op_crypto_unwrap_key::decl(),
     ])
     .state(move |state| {
       if let Some(seed) = maybe_seed {
@@ -114,6 +111,7 @@ pub fn init(maybe_seed: Option<u64>) -> Extension {
     .build()
 }
 
+#[op]
 pub fn op_crypto_get_random_values(
   state: &mut OpState,
   mut zero_copy: ZeroCopyBuf,
@@ -170,6 +168,7 @@ pub struct SignArg {
   named_curve: Option<CryptoNamedCurve>,
 }
 
+#[op]
 pub async fn op_crypto_sign_key(
   _state: Rc<RefCell<OpState>>,
   args: SignArg,
@@ -324,6 +323,7 @@ pub struct VerifyArg {
   named_curve: Option<CryptoNamedCurve>,
 }
 
+#[op]
 pub async fn op_crypto_verify_key(
   _state: Rc<RefCell<OpState>>,
   args: VerifyArg,
@@ -484,6 +484,7 @@ pub struct DeriveKeyArg {
   info: Option<ZeroCopyBuf>,
 }
 
+#[op]
 pub async fn op_crypto_derive_bits(
   _state: Rc<RefCell<OpState>>,
   args: DeriveKeyArg,
@@ -789,6 +790,7 @@ impl<'a> TryFrom<rsa::pkcs8::der::asn1::Any<'a>>
   }
 }
 
+#[op]
 pub fn op_crypto_random_uuid(
   state: &mut OpState,
   _: (),
@@ -808,6 +810,7 @@ pub fn op_crypto_random_uuid(
   Ok(uuid.to_string())
 }
 
+#[op]
 pub async fn op_crypto_subtle_digest(
   _state: Rc<RefCell<OpState>>,
   algorithm: CryptoHash,
@@ -831,6 +834,7 @@ pub struct WrapUnwrapKeyArg {
   algorithm: Algorithm,
 }
 
+#[op]
 pub fn op_crypto_wrap_key(
   _state: &mut OpState,
   args: WrapUnwrapKeyArg,
@@ -860,6 +864,7 @@ pub fn op_crypto_wrap_key(
   }
 }
 
+#[op]
 pub fn op_crypto_unwrap_key(
   _state: &mut OpState,
   args: WrapUnwrapKeyArg,
diff --git a/ext/fetch/lib.rs b/ext/fetch/lib.rs
index e1859e8e3..7a0c9b16f 100644
--- a/ext/fetch/lib.rs
+++ b/ext/fetch/lib.rs
@@ -9,8 +9,8 @@ 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::op;
+
 use deno_core::url::Url;
 use deno_core::AsyncRefCell;
 use deno_core::AsyncResult;
@@ -100,12 +100,9 @@ where
       "26_fetch.js",
     ))
     .ops(vec![
-      ("op_fetch", op_sync(op_fetch::<FP>)),
-      ("op_fetch_send", op_async(op_fetch_send)),
-      (
-        "op_fetch_custom_client",
-        op_sync(op_fetch_custom_client::<FP>),
-      ),
+      op_fetch::decl::<FP>(),
+      op_fetch_send::decl(),
+      op_fetch_custom_client::decl::<FP>(),
     ])
     .state(move |state| {
       state.put::<Options>(options.clone());
@@ -192,6 +189,7 @@ pub struct FetchReturn {
   cancel_handle_rid: Option<ResourceId>,
 }
 
+#[op]
 pub fn op_fetch<FP>(
   state: &mut OpState,
   args: FetchArgs,
@@ -367,6 +365,7 @@ pub struct FetchResponse {
   response_rid: ResourceId,
 }
 
+#[op]
 pub async fn op_fetch_send(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
@@ -525,6 +524,7 @@ pub struct CreateHttpClientOptions {
   private_key: Option<String>,
 }
 
+#[op]
 pub fn op_fetch_custom_client<FP>(
   state: &mut OpState,
   args: CreateHttpClientOptions,
diff --git a/ext/ffi/lib.rs b/ext/ffi/lib.rs
index f2e7bb175..b4d8712f4 100644
--- a/ext/ffi/lib.rs
+++ b/ext/ffi/lib.rs
@@ -6,8 +6,8 @@ use deno_core::error::range_error;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
 use deno_core::include_js_files;
-use deno_core::op_async;
-use deno_core::op_sync;
+use deno_core::op;
+
 use deno_core::serde_json;
 use deno_core::serde_json::json;
 use deno_core::serde_json::Value;
@@ -140,27 +140,24 @@ pub fn init<P: FfiPermissions + 'static>(unstable: bool) -> Extension {
       "00_ffi.js",
     ))
     .ops(vec![
-      ("op_ffi_load", op_sync(op_ffi_load::<P>)),
-      ("op_ffi_get_static", op_sync(op_ffi_get_static)),
-      ("op_ffi_call", op_sync(op_ffi_call)),
-      ("op_ffi_call_nonblocking", op_async(op_ffi_call_nonblocking)),
-      ("op_ffi_call_ptr", op_sync(op_ffi_call_ptr)),
-      (
-        "op_ffi_call_ptr_nonblocking",
-        op_async(op_ffi_call_ptr_nonblocking),
-      ),
-      ("op_ffi_ptr_of", op_sync(op_ffi_ptr_of::<P>)),
-      ("op_ffi_buf_copy_into", op_sync(op_ffi_buf_copy_into::<P>)),
-      ("op_ffi_cstr_read", op_sync(op_ffi_cstr_read::<P>)),
-      ("op_ffi_read_u8", op_sync(op_ffi_read_u8::<P>)),
-      ("op_ffi_read_i8", op_sync(op_ffi_read_i8::<P>)),
-      ("op_ffi_read_u16", op_sync(op_ffi_read_u16::<P>)),
-      ("op_ffi_read_i16", op_sync(op_ffi_read_i16::<P>)),
-      ("op_ffi_read_u32", op_sync(op_ffi_read_u32::<P>)),
-      ("op_ffi_read_i32", op_sync(op_ffi_read_i32::<P>)),
-      ("op_ffi_read_u64", op_sync(op_ffi_read_u64::<P>)),
-      ("op_ffi_read_f32", op_sync(op_ffi_read_f32::<P>)),
-      ("op_ffi_read_f64", op_sync(op_ffi_read_f64::<P>)),
+      op_ffi_load::decl::<P>(),
+      op_ffi_get_static::decl(),
+      op_ffi_call::decl(),
+      op_ffi_call_nonblocking::decl(),
+      op_ffi_call_ptr::decl(),
+      op_ffi_call_ptr_nonblocking::decl(),
+      op_ffi_ptr_of::decl::<P>(),
+      op_ffi_buf_copy_into::decl::<P>(),
+      op_ffi_cstr_read::decl::<P>(),
+      op_ffi_read_u8::decl::<P>(),
+      op_ffi_read_i8::decl::<P>(),
+      op_ffi_read_u16::decl::<P>(),
+      op_ffi_read_i16::decl::<P>(),
+      op_ffi_read_u32::decl::<P>(),
+      op_ffi_read_i32::decl::<P>(),
+      op_ffi_read_u64::decl::<P>(),
+      op_ffi_read_f32::decl::<P>(),
+      op_ffi_read_f64::decl::<P>(),
     ])
     .state(move |state| {
       // Stolen from deno_webgpu, is there a better option?
@@ -464,6 +461,7 @@ pub(crate) fn format_error(e: dlopen::Error, path: String) -> String {
   }
 }
 
+#[op]
 fn op_ffi_load<FP>(
   state: &mut deno_core::OpState,
   args: FfiLoadArgs,
@@ -650,6 +648,7 @@ fn ffi_call(args: FfiCallArgs, symbol: &Symbol) -> Result<Value, AnyError> {
   })
 }
 
+#[op]
 fn op_ffi_call_ptr(
   _state: &mut deno_core::OpState,
   args: FfiCallPtrArgs,
@@ -659,6 +658,7 @@ fn op_ffi_call_ptr(
   ffi_call(args.into(), &symbol)
 }
 
+#[op]
 async fn op_ffi_call_ptr_nonblocking(
   _state: Rc<RefCell<deno_core::OpState>>,
   args: FfiCallPtrArgs,
@@ -678,6 +678,7 @@ struct FfiGetArgs {
   r#type: NativeType,
 }
 
+#[op]
 fn op_ffi_get_static(
   state: &mut deno_core::OpState,
   args: FfiGetArgs,
@@ -735,6 +736,7 @@ fn op_ffi_get_static(
   })
 }
 
+#[op]
 fn op_ffi_call(
   state: &mut deno_core::OpState,
   args: FfiCallArgs,
@@ -753,6 +755,7 @@ fn op_ffi_call(
 }
 
 /// A non-blocking FFI call.
+#[op]
 async fn op_ffi_call_nonblocking(
   state: Rc<RefCell<deno_core::OpState>>,
   args: FfiCallArgs,
@@ -773,6 +776,7 @@ async fn op_ffi_call_nonblocking(
     .unwrap()
 }
 
+#[op]
 fn op_ffi_ptr_of<FP>(
   state: &mut deno_core::OpState,
   buf: ZeroCopyBuf,
@@ -787,6 +791,7 @@ where
   Ok(U32x2::from(buf.as_ptr() as u64))
 }
 
+#[op]
 fn op_ffi_buf_copy_into<FP>(
   state: &mut deno_core::OpState,
   (src, mut dst, len): (U32x2, ZeroCopyBuf, usize),
@@ -809,6 +814,7 @@ where
   }
 }
 
+#[op]
 fn op_ffi_cstr_read<FP>(
   state: &mut deno_core::OpState,
   ptr: U32x2,
@@ -824,6 +830,7 @@ where
   Ok(unsafe { CStr::from_ptr(ptr) }.to_str()?.to_string())
 }
 
+#[op]
 fn op_ffi_read_u8<FP>(
   state: &mut deno_core::OpState,
   ptr: U32x2,
@@ -838,6 +845,7 @@ where
   Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const u8) })
 }
 
+#[op]
 fn op_ffi_read_i8<FP>(
   state: &mut deno_core::OpState,
   ptr: U32x2,
@@ -852,6 +860,7 @@ where
   Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const i8) })
 }
 
+#[op]
 fn op_ffi_read_u16<FP>(
   state: &mut deno_core::OpState,
   ptr: U32x2,
@@ -866,6 +875,7 @@ where
   Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const u16) })
 }
 
+#[op]
 fn op_ffi_read_i16<FP>(
   state: &mut deno_core::OpState,
   ptr: U32x2,
@@ -880,6 +890,7 @@ where
   Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const i16) })
 }
 
+#[op]
 fn op_ffi_read_u32<FP>(
   state: &mut deno_core::OpState,
   ptr: U32x2,
@@ -894,6 +905,7 @@ where
   Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const u32) })
 }
 
+#[op]
 fn op_ffi_read_i32<FP>(
   state: &mut deno_core::OpState,
   ptr: U32x2,
@@ -908,6 +920,7 @@ where
   Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const i32) })
 }
 
+#[op]
 fn op_ffi_read_u64<FP>(
   state: &mut deno_core::OpState,
   ptr: U32x2,
@@ -924,6 +937,7 @@ where
   }))
 }
 
+#[op]
 fn op_ffi_read_f32<FP>(
   state: &mut deno_core::OpState,
   ptr: U32x2,
@@ -938,6 +952,7 @@ where
   Ok(unsafe { ptr::read_unaligned(u64::from(ptr) as *const f32) })
 }
 
+#[op]
 fn op_ffi_read_f64<FP>(
   state: &mut deno_core::OpState,
   ptr: U32x2,
diff --git a/ext/http/lib.rs b/ext/http/lib.rs
index ae5ddb9c3..a89c7a4a1 100644
--- a/ext/http/lib.rs
+++ b/ext/http/lib.rs
@@ -20,8 +20,8 @@ use deno_core::futures::FutureExt;
 use deno_core::futures::StreamExt;
 use deno_core::futures::TryFutureExt;
 use deno_core::include_js_files;
-use deno_core::op_async;
-use deno_core::op_sync;
+use deno_core::op;
+
 use deno_core::AsyncRefCell;
 use deno_core::ByteString;
 use deno_core::CancelFuture;
@@ -72,19 +72,13 @@ pub fn init() -> Extension {
       "01_http.js",
     ))
     .ops(vec![
-      ("op_http_accept", op_async(op_http_accept)),
-      ("op_http_read", op_async(op_http_read)),
-      ("op_http_write_headers", op_async(op_http_write_headers)),
-      ("op_http_write", op_async(op_http_write)),
-      ("op_http_shutdown", op_async(op_http_shutdown)),
-      (
-        "op_http_websocket_accept_header",
-        op_sync(op_http_websocket_accept_header),
-      ),
-      (
-        "op_http_upgrade_websocket",
-        op_async(op_http_upgrade_websocket),
-      ),
+      op_http_accept::decl(),
+      op_http_read::decl(),
+      op_http_write_headers::decl(),
+      op_http_write::decl(),
+      op_http_shutdown::decl(),
+      op_http_websocket_accept_header::decl(),
+      op_http_upgrade_websocket::decl(),
     ])
     .build()
 }
@@ -371,6 +365,7 @@ struct NextRequestResponse(
   String,
 );
 
+#[op]
 async fn op_http_accept(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
@@ -501,6 +496,7 @@ struct RespondArgs(
   Vec<(ByteString, ByteString)>,
 );
 
+#[op]
 async fn op_http_write_headers(
   state: Rc<RefCell<OpState>>,
   args: RespondArgs,
@@ -697,6 +693,7 @@ async fn op_http_write_headers(
   }
 }
 
+#[op]
 async fn op_http_write(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
@@ -737,6 +734,7 @@ async fn op_http_write(
 /// Gracefully closes the write half of the HTTP stream. Note that this does not
 /// remove the HTTP stream resource from the resource table; it still has to be
 /// closed with `Deno.core.close()`.
+#[op]
 async fn op_http_shutdown(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
@@ -751,6 +749,7 @@ async fn op_http_shutdown(
   Ok(())
 }
 
+#[op]
 async fn op_http_read(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
@@ -799,6 +798,7 @@ async fn op_http_read(
   fut.try_or_cancel(cancel_handle).await
 }
 
+#[op]
 fn op_http_websocket_accept_header(
   _: &mut OpState,
   key: String,
@@ -811,6 +811,7 @@ fn op_http_websocket_accept_header(
   Ok(base64::encode(digest))
 }
 
+#[op]
 async fn op_http_upgrade_websocket(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
diff --git a/ext/net/lib.rs b/ext/net/lib.rs
index c9b888a65..84358210e 100644
--- a/ext/net/lib.rs
+++ b/ext/net/lib.rs
@@ -76,9 +76,6 @@ pub fn init<P: NetPermissions + 'static>(
   unstable: bool,
   unsafely_ignore_certificate_errors: Option<Vec<String>>,
 ) -> Extension {
-  let mut ops_to_register = vec![];
-  ops_to_register.extend(ops::init::<P>());
-  ops_to_register.extend(ops_tls::init::<P>());
   Extension::builder()
     .js(include_js_files!(
       prefix "deno:ext/net",
@@ -86,7 +83,7 @@ pub fn init<P: NetPermissions + 'static>(
       "02_tls.js",
       "04_net_unstable.js",
     ))
-    .ops(ops_to_register)
+    .ops([&ops::init::<P>()[..], &ops_tls::init::<P>()[..]].concat())
     .state(move |state| {
       state.put(DefaultTlsOptions {
         root_cert_store: root_cert_store.clone(),
diff --git a/ext/net/ops.rs b/ext/net/ops.rs
index 682ba0acb..2c9129ebf 100644
--- a/ext/net/ops.rs
+++ b/ext/net/ops.rs
@@ -9,8 +9,8 @@ use deno_core::error::custom_error;
 use deno_core::error::generic_error;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
-use deno_core::op_async;
-use deno_core::op_sync;
+use deno_core::op;
+
 use deno_core::AsyncRefCell;
 use deno_core::ByteString;
 use deno_core::CancelHandle;
@@ -52,14 +52,14 @@ use std::path::Path;
 
 pub fn init<P: NetPermissions + 'static>() -> Vec<OpPair> {
   vec![
-    ("op_net_accept", op_async(op_net_accept)),
-    ("op_net_connect", op_async(op_net_connect::<P>)),
-    ("op_net_listen", op_sync(op_net_listen::<P>)),
-    ("op_dgram_recv", op_async(op_dgram_recv)),
-    ("op_dgram_send", op_async(op_dgram_send::<P>)),
-    ("op_dns_resolve", op_async(op_dns_resolve::<P>)),
-    ("op_set_nodelay", op_sync(op_set_nodelay::<P>)),
-    ("op_set_keepalive", op_sync(op_set_keepalive::<P>)),
+    op_net_accept::decl(),
+    op_net_connect::decl::<P>(),
+    op_net_listen::decl::<P>(),
+    op_dgram_recv::decl(),
+    op_dgram_send::decl::<P>(),
+    op_dns_resolve::decl::<P>(),
+    op_set_nodelay::decl::<P>(),
+    op_set_keepalive::decl::<P>(),
   ]
 }
 
@@ -158,6 +158,7 @@ async fn accept_tcp(
   })
 }
 
+#[op]
 async fn op_net_accept(
   state: Rc<RefCell<OpState>>,
   args: AcceptArgs,
@@ -210,6 +211,7 @@ async fn receive_udp(
   })
 }
 
+#[op]
 async fn op_dgram_recv(
   state: Rc<RefCell<OpState>>,
   args: ReceiveArgs,
@@ -231,6 +233,7 @@ struct SendArgs {
   transport_args: ArgsEnum,
 }
 
+#[op]
 async fn op_dgram_send<NP>(
   state: Rc<RefCell<OpState>>,
   args: SendArgs,
@@ -299,6 +302,7 @@ pub struct ConnectArgs {
   transport_args: ArgsEnum,
 }
 
+#[op]
 pub async fn op_net_connect<NP>(
   state: Rc<RefCell<OpState>>,
   args: ConnectArgs,
@@ -474,6 +478,7 @@ fn listen_udp(
   Ok((rid, local_addr))
 }
 
+#[op]
 fn op_net_listen<NP>(
   state: &mut OpState,
   args: ListenArgs,
@@ -613,6 +618,7 @@ pub struct NameServer {
   port: u16,
 }
 
+#[op]
 pub async fn op_dns_resolve<NP>(
   state: Rc<RefCell<OpState>>,
   args: ResolveAddrArgs,
@@ -681,6 +687,7 @@ where
   Ok(results)
 }
 
+#[op]
 pub fn op_set_nodelay<NP>(
   state: &mut OpState,
   rid: ResourceId,
@@ -692,6 +699,7 @@ pub fn op_set_nodelay<NP>(
   resource.set_nodelay(nodelay)
 }
 
+#[op]
 pub fn op_set_keepalive<NP>(
   state: &mut OpState,
   rid: ResourceId,
@@ -877,7 +885,7 @@ mod tests {
   #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
   async fn tcp_set_no_delay() {
     let set_nodelay = Box::new(|state: &mut OpState, rid| {
-      op_set_nodelay::<TestPermission>(state, rid, true).unwrap();
+      op_set_nodelay::call::<TestPermission>(state, rid, true).unwrap();
     });
     let test_fn = Box::new(|socket: SockRef| {
       assert!(socket.nodelay().unwrap());
@@ -889,7 +897,7 @@ mod tests {
   #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
   async fn tcp_set_keepalive() {
     let set_keepalive = Box::new(|state: &mut OpState, rid| {
-      op_set_keepalive::<TestPermission>(state, rid, true).unwrap();
+      op_set_keepalive::call::<TestPermission>(state, rid, true).unwrap();
     });
     let test_fn = Box::new(|socket: SockRef| {
       assert!(!socket.nodelay().unwrap());
@@ -934,7 +942,7 @@ mod tests {
     };
 
     let connect_fut =
-      op_net_connect::<TestPermission>(conn_state, connect_args, ());
+      op_net_connect::call::<TestPermission>(conn_state, connect_args, ());
     let conn = connect_fut.await.unwrap();
 
     let rid = conn.rid;
diff --git a/ext/net/ops_tls.rs b/ext/net/ops_tls.rs
index 01f29b2ad..6289d963f 100644
--- a/ext/net/ops_tls.rs
+++ b/ext/net/ops_tls.rs
@@ -25,8 +25,8 @@ use deno_core::futures::task::Poll;
 use deno_core::futures::task::RawWaker;
 use deno_core::futures::task::RawWakerVTable;
 use deno_core::futures::task::Waker;
-use deno_core::op_async;
-use deno_core::op_sync;
+use deno_core::op;
+
 use deno_core::parking_lot::Mutex;
 use deno_core::AsyncRefCell;
 use deno_core::AsyncResult;
@@ -644,11 +644,11 @@ impl Write for ImplementWriteTrait<'_, TcpStream> {
 
 pub fn init<P: NetPermissions + 'static>() -> Vec<OpPair> {
   vec![
-    ("op_tls_start", op_async(op_tls_start::<P>)),
-    ("op_tls_connect", op_async(op_tls_connect::<P>)),
-    ("op_tls_listen", op_sync(op_tls_listen::<P>)),
-    ("op_tls_accept", op_async(op_tls_accept)),
-    ("op_tls_handshake", op_async(op_tls_handshake)),
+    op_tls_start::decl::<P>(),
+    op_tls_connect::decl::<P>(),
+    op_tls_listen::decl::<P>(),
+    op_tls_accept::decl(),
+    op_tls_handshake::decl(),
   ]
 }
 
@@ -765,6 +765,7 @@ pub struct StartTlsArgs {
   alpn_protocols: Option<Vec<String>>,
 }
 
+#[op]
 pub async fn op_tls_start<NP>(
   state: Rc<RefCell<OpState>>,
   args: StartTlsArgs,
@@ -857,6 +858,7 @@ where
   })
 }
 
+#[op]
 pub async fn op_tls_connect<NP>(
   state: Rc<RefCell<OpState>>,
   args: ConnectTlsArgs,
@@ -1016,6 +1018,7 @@ pub struct ListenTlsArgs {
   alpn_protocols: Option<Vec<String>>,
 }
 
+#[op]
 pub fn op_tls_listen<NP>(
   state: &mut OpState,
   args: ListenTlsArgs,
@@ -1112,6 +1115,7 @@ where
   })
 }
 
+#[op]
 pub async fn op_tls_accept(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
@@ -1163,6 +1167,7 @@ pub async fn op_tls_accept(
   })
 }
 
+#[op]
 pub async fn op_tls_handshake(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
diff --git a/ext/url/lib.rs b/ext/url/lib.rs
index f8d659f00..a82b3e702 100644
--- a/ext/url/lib.rs
+++ b/ext/url/lib.rs
@@ -7,7 +7,7 @@ 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::op;
 use deno_core::url::form_urlencoded;
 use deno_core::url::quirks;
 use deno_core::url::Url;
@@ -26,21 +26,12 @@ pub fn init() -> Extension {
       "01_urlpattern.js",
     ))
     .ops(vec![
-      ("op_url_parse", op_sync(op_url_parse)),
-      ("op_url_reparse", op_sync(op_url_reparse)),
-      (
-        "op_url_parse_search_params",
-        op_sync(op_url_parse_search_params),
-      ),
-      (
-        "op_url_stringify_search_params",
-        op_sync(op_url_stringify_search_params),
-      ),
-      ("op_urlpattern_parse", op_sync(op_urlpattern_parse)),
-      (
-        "op_urlpattern_process_match_input",
-        op_sync(op_urlpattern_process_match_input),
-      ),
+      op_url_parse::decl(),
+      op_url_reparse::decl(),
+      op_url_parse_search_params::decl(),
+      op_url_stringify_search_params::decl(),
+      op_urlpattern_parse::decl(),
+      op_urlpattern_process_match_input::decl(),
     ])
     .build()
 }
@@ -65,6 +56,7 @@ type UrlParts = String;
 
 /// Parse `UrlParseArgs::href` with an optional `UrlParseArgs::base_href`, or an
 /// optional part to "set" after parsing. Return `UrlParts`.
+#[op]
 pub fn op_url_parse(
   _state: &mut deno_core::OpState,
   href: String,
@@ -98,6 +90,7 @@ pub enum UrlSetter {
   Username = 9,
 }
 
+#[op]
 pub fn op_url_reparse(
   _state: &mut deno_core::OpState,
   href: String,
@@ -167,6 +160,7 @@ fn url_result(
   )
 }
 
+#[op]
 pub fn op_url_parse_search_params(
   _state: &mut deno_core::OpState,
   args: Option<String>,
@@ -186,6 +180,7 @@ pub fn op_url_parse_search_params(
   Ok(params)
 }
 
+#[op]
 pub fn op_url_stringify_search_params(
   _state: &mut deno_core::OpState,
   args: Vec<(String, String)>,
diff --git a/ext/url/urlpattern.rs b/ext/url/urlpattern.rs
index b9f53665f..4e6b4e4a0 100644
--- a/ext/url/urlpattern.rs
+++ b/ext/url/urlpattern.rs
@@ -1,11 +1,13 @@
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
+use deno_core::op;
 
 use urlpattern::quirks;
 use urlpattern::quirks::MatchInput;
 use urlpattern::quirks::StringOrInit;
 use urlpattern::quirks::UrlPattern;
 
+#[op]
 pub fn op_urlpattern_parse(
   _state: &mut deno_core::OpState,
   input: StringOrInit,
@@ -23,6 +25,7 @@ pub fn op_urlpattern_parse(
   Ok(pattern)
 }
 
+#[op]
 pub fn op_urlpattern_process_match_input(
   _state: &mut deno_core::OpState,
   input: StringOrInit,
diff --git a/ext/web/blob.rs b/ext/web/blob.rs
index 37e93c853..ad7f6c582 100644
--- a/ext/web/blob.rs
+++ b/ext/web/blob.rs
@@ -1,5 +1,7 @@
 use async_trait::async_trait;
 use deno_core::error::type_error;
+use deno_core::op;
+
 use deno_core::parking_lot::Mutex;
 use deno_core::url::Url;
 use deno_core::ZeroCopyBuf;
@@ -157,6 +159,7 @@ impl BlobPart for SlicedBlobPart {
   }
 }
 
+#[op]
 pub fn op_blob_create_part(
   state: &mut deno_core::OpState,
   data: ZeroCopyBuf,
@@ -175,6 +178,7 @@ pub struct SliceOptions {
   len: usize,
 }
 
+#[op]
 pub fn op_blob_slice_part(
   state: &mut deno_core::OpState,
   id: Uuid,
@@ -200,6 +204,7 @@ pub fn op_blob_slice_part(
   Ok(id)
 }
 
+#[op]
 pub async fn op_blob_read_part(
   state: Rc<RefCell<deno_core::OpState>>,
   id: Uuid,
@@ -215,6 +220,7 @@ pub async fn op_blob_read_part(
   Ok(ZeroCopyBuf::from(buf.to_vec()))
 }
 
+#[op]
 pub fn op_blob_remove_part(
   state: &mut deno_core::OpState,
   id: Uuid,
@@ -225,6 +231,7 @@ pub fn op_blob_remove_part(
   Ok(())
 }
 
+#[op]
 pub fn op_blob_create_object_url(
   state: &mut deno_core::OpState,
   media_type: String,
@@ -250,6 +257,7 @@ pub fn op_blob_create_object_url(
   Ok(url.to_string())
 }
 
+#[op]
 pub fn op_blob_revoke_object_url(
   state: &mut deno_core::OpState,
   url: String,
@@ -273,6 +281,7 @@ pub struct ReturnBlobPart {
   pub size: usize,
 }
 
+#[op]
 pub fn op_blob_from_object_url(
   state: &mut deno_core::OpState,
   url: String,
diff --git a/ext/web/compression.rs b/ext/web/compression.rs
index c84db7550..d38f65d6a 100644
--- a/ext/web/compression.rs
+++ b/ext/web/compression.rs
@@ -1,6 +1,7 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::OpState;
 use deno_core::Resource;
 use deno_core::ResourceId;
@@ -32,6 +33,7 @@ impl Resource for CompressionResource {
   }
 }
 
+#[op]
 pub fn op_compression_new(
   state: &mut OpState,
   format: String,
@@ -53,6 +55,7 @@ pub fn op_compression_new(
   Ok(state.resource_table.add(resource))
 }
 
+#[op]
 pub fn op_compression_write(
   state: &mut OpState,
   rid: ResourceId,
@@ -86,6 +89,7 @@ pub fn op_compression_write(
   Ok(out.into())
 }
 
+#[op]
 pub fn op_compression_finish(
   state: &mut OpState,
   rid: ResourceId,
diff --git a/ext/web/lib.rs b/ext/web/lib.rs
index f117bfb9d..6c278cbb0 100644
--- a/ext/web/lib.rs
+++ b/ext/web/lib.rs
@@ -9,8 +9,7 @@ use deno_core::error::range_error;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
 use deno_core::include_js_files;
-use deno_core::op_async;
-use deno_core::op_sync;
+use deno_core::op;
 use deno_core::url::Url;
 use deno_core::ByteString;
 use deno_core::Extension;
@@ -83,58 +82,31 @@ pub fn init<P: TimersPermission + 'static>(
       "15_performance.js",
     ))
     .ops(vec![
-      ("op_base64_decode", op_sync(op_base64_decode)),
-      ("op_base64_encode", op_sync(op_base64_encode)),
-      ("op_base64_atob", op_sync(op_base64_atob)),
-      ("op_base64_btoa", op_sync(op_base64_btoa)),
-      (
-        "op_encoding_normalize_label",
-        op_sync(op_encoding_normalize_label),
-      ),
-      ("op_encoding_new_decoder", op_sync(op_encoding_new_decoder)),
-      ("op_encoding_decode", op_sync(op_encoding_decode)),
-      ("op_encoding_encode_into", op_sync(op_encoding_encode_into)),
-      ("op_blob_create_part", op_sync(op_blob_create_part)),
-      ("op_blob_slice_part", op_sync(op_blob_slice_part)),
-      ("op_blob_read_part", op_async(op_blob_read_part)),
-      ("op_blob_remove_part", op_sync(op_blob_remove_part)),
-      (
-        "op_blob_create_object_url",
-        op_sync(op_blob_create_object_url),
-      ),
-      (
-        "op_blob_revoke_object_url",
-        op_sync(op_blob_revoke_object_url),
-      ),
-      ("op_blob_from_object_url", op_sync(op_blob_from_object_url)),
-      (
-        "op_message_port_create_entangled",
-        op_sync(op_message_port_create_entangled),
-      ),
-      (
-        "op_message_port_post_message",
-        op_sync(op_message_port_post_message),
-      ),
-      (
-        "op_message_port_recv_message",
-        op_async(op_message_port_recv_message),
-      ),
-      (
-        "op_compression_new",
-        op_sync(compression::op_compression_new),
-      ),
-      (
-        "op_compression_write",
-        op_sync(compression::op_compression_write),
-      ),
-      (
-        "op_compression_finish",
-        op_sync(compression::op_compression_finish),
-      ),
-      ("op_now", op_sync(op_now::<P>)),
-      ("op_timer_handle", op_sync(op_timer_handle)),
-      ("op_sleep", op_async(op_sleep)),
-      ("op_sleep_sync", op_sync(op_sleep_sync::<P>)),
+      op_base64_decode::decl(),
+      op_base64_encode::decl(),
+      op_base64_atob::decl(),
+      op_base64_btoa::decl(),
+      op_encoding_normalize_label::decl(),
+      op_encoding_new_decoder::decl(),
+      op_encoding_decode::decl(),
+      op_encoding_encode_into::decl(),
+      op_blob_create_part::decl(),
+      op_blob_slice_part::decl(),
+      op_blob_read_part::decl(),
+      op_blob_remove_part::decl(),
+      op_blob_create_object_url::decl(),
+      op_blob_revoke_object_url::decl(),
+      op_blob_from_object_url::decl(),
+      op_message_port_create_entangled::decl(),
+      op_message_port_post_message::decl(),
+      op_message_port_recv_message::decl(),
+      compression::op_compression_new::decl(),
+      compression::op_compression_write::decl(),
+      compression::op_compression_finish::decl(),
+      op_now::decl::<P>(),
+      op_timer_handle::decl(),
+      op_sleep::decl(),
+      op_sleep_sync::decl::<P>(),
     ])
     .state(move |state| {
       state.put(blob_store.clone());
@@ -147,6 +119,7 @@ pub fn init<P: TimersPermission + 'static>(
     .build()
 }
 
+#[op]
 fn op_base64_decode(
   _: &mut OpState,
   input: String,
@@ -157,6 +130,7 @@ fn op_base64_decode(
   Ok(b64_decode(&input)?.into())
 }
 
+#[op]
 fn op_base64_atob(
   _: &mut OpState,
   s: ByteString,
@@ -210,6 +184,7 @@ fn b64_decode(input: &[u8]) -> Result<Vec<u8>, AnyError> {
   Ok(out)
 }
 
+#[op]
 fn op_base64_encode(
   _: &mut OpState,
   s: ZeroCopyBuf,
@@ -218,6 +193,7 @@ fn op_base64_encode(
   Ok(b64_encode(&s))
 }
 
+#[op]
 fn op_base64_btoa(
   _: &mut OpState,
   s: ByteString,
@@ -240,6 +216,7 @@ struct DecoderOptions {
   fatal: bool,
 }
 
+#[op]
 fn op_encoding_normalize_label(
   _state: &mut OpState,
   label: String,
@@ -255,6 +232,7 @@ fn op_encoding_normalize_label(
   Ok(encoding.name().to_lowercase())
 }
 
+#[op]
 fn op_encoding_new_decoder(
   state: &mut OpState,
   options: DecoderOptions,
@@ -294,6 +272,7 @@ struct DecodeOptions {
   stream: bool,
 }
 
+#[op]
 fn op_encoding_decode(
   state: &mut OpState,
   data: ZeroCopyBuf,
@@ -357,6 +336,7 @@ struct EncodeIntoResult {
   written: usize,
 }
 
+#[op]
 fn op_encoding_encode_into(
   _state: &mut OpState,
   input: String,
diff --git a/ext/web/message_port.rs b/ext/web/message_port.rs
index 8734f9b65..7f2b18b3c 100644
--- a/ext/web/message_port.rs
+++ b/ext/web/message_port.rs
@@ -4,6 +4,8 @@ use std::rc::Rc;
 
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
+use deno_core::op;
+
 use deno_core::ZeroCopyBuf;
 use deno_core::{CancelFuture, Resource};
 use deno_core::{CancelHandle, OpState};
@@ -104,6 +106,7 @@ impl Resource for MessagePortResource {
   }
 }
 
+#[op]
 pub fn op_message_port_create_entangled(
   state: &mut OpState,
   _: (),
@@ -185,6 +188,7 @@ pub struct JsMessageData {
   transferables: Vec<JsTransferable>,
 }
 
+#[op]
 pub fn op_message_port_post_message(
   state: &mut OpState,
   rid: ResourceId,
@@ -203,6 +207,7 @@ pub fn op_message_port_post_message(
   resource.port.send(state, data)
 }
 
+#[op]
 pub async fn op_message_port_recv_message(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
diff --git a/ext/web/timers.rs b/ext/web/timers.rs
index 7f17aa969..9a78240f7 100644
--- a/ext/web/timers.rs
+++ b/ext/web/timers.rs
@@ -3,6 +3,8 @@
 //! This module helps deno implement timers and performance APIs.
 
 use deno_core::error::AnyError;
+use deno_core::op;
+
 use deno_core::CancelFuture;
 use deno_core::CancelHandle;
 use deno_core::OpState;
@@ -25,6 +27,7 @@ pub type StartTime = Instant;
 // since the start time of the deno runtime.
 // If the High precision flag is not set, the
 // nanoseconds are rounded on 2ms.
+#[op]
 pub fn op_now<TP>(
   state: &mut OpState,
   _argument: (),
@@ -64,6 +67,7 @@ impl Resource for TimerHandle {
 
 /// Creates a [`TimerHandle`] resource that can be used to cancel invocations of
 /// [`op_sleep`].
+#[op]
 pub fn op_timer_handle(
   state: &mut OpState,
   _: (),
@@ -77,6 +81,7 @@ pub fn op_timer_handle(
 
 /// Waits asynchronously until either `millis` milliseconds have passed or the
 /// [`TimerHandle`] resource given by `rid` has been canceled.
+#[op]
 pub async fn op_sleep(
   state: Rc<RefCell<OpState>>,
   millis: u64,
@@ -89,6 +94,7 @@ pub async fn op_sleep(
   Ok(())
 }
 
+#[op]
 pub fn op_sleep_sync<TP>(
   state: &mut OpState,
   millis: u64,
diff --git a/ext/webgpu/src/binding.rs b/ext/webgpu/src/binding.rs
index 9a8fa455f..7370f8034 100644
--- a/ext/webgpu/src/binding.rs
+++ b/ext/webgpu/src/binding.rs
@@ -1,6 +1,7 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::ResourceId;
 use deno_core::{OpState, Resource};
 use serde::Deserialize;
@@ -177,6 +178,7 @@ pub struct CreateBindGroupLayoutArgs {
   entries: Vec<GpuBindGroupLayoutEntry>,
 }
 
+#[op]
 pub fn op_webgpu_create_bind_group_layout(
   state: &mut OpState,
   args: CreateBindGroupLayoutArgs,
@@ -220,6 +222,7 @@ pub struct CreatePipelineLayoutArgs {
   bind_group_layouts: Vec<u32>,
 }
 
+#[op]
 pub fn op_webgpu_create_pipeline_layout(
   state: &mut OpState,
   args: CreatePipelineLayoutArgs,
@@ -271,6 +274,7 @@ pub struct CreateBindGroupArgs {
   entries: Vec<GpuBindGroupEntry>,
 }
 
+#[op]
 pub fn op_webgpu_create_bind_group(
   state: &mut OpState,
   args: CreateBindGroupArgs,
diff --git a/ext/webgpu/src/buffer.rs b/ext/webgpu/src/buffer.rs
index 3f2c07883..ce3a78d01 100644
--- a/ext/webgpu/src/buffer.rs
+++ b/ext/webgpu/src/buffer.rs
@@ -3,6 +3,8 @@
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
 use deno_core::futures::channel::oneshot;
+use deno_core::op;
+
 use deno_core::OpState;
 use deno_core::Resource;
 use deno_core::ResourceId;
@@ -40,6 +42,7 @@ pub struct CreateBufferArgs {
   mapped_at_creation: bool,
 }
 
+#[op]
 pub fn op_webgpu_create_buffer(
   state: &mut OpState,
   args: CreateBufferArgs,
@@ -76,6 +79,7 @@ pub struct BufferGetMapAsyncArgs {
   size: u64,
 }
 
+#[op]
 pub async fn op_webgpu_buffer_get_map_async(
   state: Rc<RefCell<OpState>>,
   args: BufferGetMapAsyncArgs,
@@ -167,6 +171,7 @@ pub struct BufferGetMappedRangeArgs {
   size: Option<u64>,
 }
 
+#[op]
 pub fn op_webgpu_buffer_get_mapped_range(
   state: &mut OpState,
   args: BufferGetMappedRangeArgs,
@@ -204,6 +209,7 @@ pub struct BufferUnmapArgs {
   mapped_rid: ResourceId,
 }
 
+#[op]
 pub fn op_webgpu_buffer_unmap(
   state: &mut OpState,
   args: BufferUnmapArgs,
diff --git a/ext/webgpu/src/bundle.rs b/ext/webgpu/src/bundle.rs
index ea327651a..4a0807302 100644
--- a/ext/webgpu/src/bundle.rs
+++ b/ext/webgpu/src/bundle.rs
@@ -1,6 +1,7 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use deno_core::{OpState, Resource};
@@ -39,6 +40,7 @@ pub struct CreateRenderBundleEncoderArgs {
   stencil_read_only: bool,
 }
 
+#[op]
 pub fn op_webgpu_create_render_bundle_encoder(
   state: &mut OpState,
   args: CreateRenderBundleEncoderArgs,
@@ -99,6 +101,7 @@ pub struct RenderBundleEncoderFinishArgs {
   label: Option<String>,
 }
 
+#[op]
 pub fn op_webgpu_render_bundle_encoder_finish(
   state: &mut OpState,
   args: RenderBundleEncoderFinishArgs,
@@ -135,6 +138,7 @@ pub struct RenderBundleEncoderSetBindGroupArgs {
   dynamic_offsets_data_length: usize,
 }
 
+#[op]
 pub fn op_webgpu_render_bundle_encoder_set_bind_group(
   state: &mut OpState,
   args: RenderBundleEncoderSetBindGroupArgs,
@@ -189,6 +193,7 @@ pub struct RenderBundleEncoderPushDebugGroupArgs {
   group_label: String,
 }
 
+#[op]
 pub fn op_webgpu_render_bundle_encoder_push_debug_group(
   state: &mut OpState,
   args: RenderBundleEncoderPushDebugGroupArgs,
@@ -218,6 +223,7 @@ pub struct RenderBundleEncoderPopDebugGroupArgs {
   render_bundle_encoder_rid: ResourceId,
 }
 
+#[op]
 pub fn op_webgpu_render_bundle_encoder_pop_debug_group(
   state: &mut OpState,
   args: RenderBundleEncoderPopDebugGroupArgs,
@@ -242,6 +248,7 @@ pub struct RenderBundleEncoderInsertDebugMarkerArgs {
   marker_label: String,
 }
 
+#[op]
 pub fn op_webgpu_render_bundle_encoder_insert_debug_marker(
   state: &mut OpState,
   args: RenderBundleEncoderInsertDebugMarkerArgs,
@@ -272,6 +279,7 @@ pub struct RenderBundleEncoderSetPipelineArgs {
   pipeline: ResourceId,
 }
 
+#[op]
 pub fn op_webgpu_render_bundle_encoder_set_pipeline(
   state: &mut OpState,
   args: RenderBundleEncoderSetPipelineArgs,
@@ -304,6 +312,7 @@ pub struct RenderBundleEncoderSetIndexBufferArgs {
   size: u64,
 }
 
+#[op]
 pub fn op_webgpu_render_bundle_encoder_set_index_buffer(
   state: &mut OpState,
   args: RenderBundleEncoderSetIndexBufferArgs,
@@ -340,6 +349,7 @@ pub struct RenderBundleEncoderSetVertexBufferArgs {
   size: u64,
 }
 
+#[op]
 pub fn op_webgpu_render_bundle_encoder_set_vertex_buffer(
   state: &mut OpState,
   args: RenderBundleEncoderSetVertexBufferArgs,
@@ -374,6 +384,7 @@ pub struct RenderBundleEncoderDrawArgs {
   first_instance: u32,
 }
 
+#[op]
 pub fn op_webgpu_render_bundle_encoder_draw(
   state: &mut OpState,
   args: RenderBundleEncoderDrawArgs,
@@ -406,6 +417,7 @@ pub struct RenderBundleEncoderDrawIndexedArgs {
   first_instance: u32,
 }
 
+#[op]
 pub fn op_webgpu_render_bundle_encoder_draw_indexed(
   state: &mut OpState,
   args: RenderBundleEncoderDrawIndexedArgs,
@@ -436,6 +448,7 @@ pub struct RenderBundleEncoderDrawIndirectArgs {
   indirect_offset: u64,
 }
 
+#[op]
 pub fn op_webgpu_render_bundle_encoder_draw_indirect(
   state: &mut OpState,
   args: RenderBundleEncoderDrawIndirectArgs,
diff --git a/ext/webgpu/src/command_encoder.rs b/ext/webgpu/src/command_encoder.rs
index 894b08f27..c81b2abf6 100644
--- a/ext/webgpu/src/command_encoder.rs
+++ b/ext/webgpu/src/command_encoder.rs
@@ -1,6 +1,7 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::ResourceId;
 use deno_core::{OpState, Resource};
 use serde::Deserialize;
@@ -36,6 +37,7 @@ pub struct CreateCommandEncoderArgs {
   _measure_execution_time: Option<bool>, // not yet implemented
 }
 
+#[op]
 pub fn op_webgpu_create_command_encoder(
   state: &mut OpState,
   args: CreateCommandEncoderArgs,
@@ -96,6 +98,7 @@ pub struct CommandEncoderBeginRenderPassArgs {
   _occlusion_query_set: Option<u32>, // not yet implemented
 }
 
+#[op]
 pub fn op_webgpu_command_encoder_begin_render_pass(
   state: &mut OpState,
   args: CommandEncoderBeginRenderPassArgs,
@@ -214,6 +217,7 @@ pub struct CommandEncoderBeginComputePassArgs {
   label: Option<String>,
 }
 
+#[op]
 pub fn op_webgpu_command_encoder_begin_compute_pass(
   state: &mut OpState,
   args: CommandEncoderBeginComputePassArgs,
@@ -252,6 +256,7 @@ pub struct CommandEncoderCopyBufferToBufferArgs {
   size: u64,
 }
 
+#[op]
 pub fn op_webgpu_command_encoder_copy_buffer_to_buffer(
   state: &mut OpState,
   args: CommandEncoderCopyBufferToBufferArgs,
@@ -310,6 +315,7 @@ pub struct CommandEncoderCopyBufferToTextureArgs {
   copy_size: wgpu_types::Extent3d,
 }
 
+#[op]
 pub fn op_webgpu_command_encoder_copy_buffer_to_texture(
   state: &mut OpState,
   args: CommandEncoderCopyBufferToTextureArgs,
@@ -360,6 +366,7 @@ pub struct CommandEncoderCopyTextureToBufferArgs {
   copy_size: wgpu_types::Extent3d,
 }
 
+#[op]
 pub fn op_webgpu_command_encoder_copy_texture_to_buffer(
   state: &mut OpState,
   args: CommandEncoderCopyTextureToBufferArgs,
@@ -414,6 +421,7 @@ pub struct CommandEncoderCopyTextureToTextureArgs {
   copy_size: wgpu_types::Extent3d,
 }
 
+#[op]
 pub fn op_webgpu_command_encoder_copy_texture_to_texture(
   state: &mut OpState,
   args: CommandEncoderCopyTextureToTextureArgs,
@@ -462,6 +470,7 @@ pub struct CommandEncoderClearBufferArgs {
   size: u64,
 }
 
+#[op]
 pub fn op_webgpu_command_encoder_clear_buffer(
   state: &mut OpState,
   args: CommandEncoderClearBufferArgs,
@@ -491,6 +500,7 @@ pub struct CommandEncoderPushDebugGroupArgs {
   group_label: String,
 }
 
+#[op]
 pub fn op_webgpu_command_encoder_push_debug_group(
   state: &mut OpState,
   args: CommandEncoderPushDebugGroupArgs,
@@ -512,6 +522,7 @@ pub struct CommandEncoderPopDebugGroupArgs {
   command_encoder_rid: ResourceId,
 }
 
+#[op]
 pub fn op_webgpu_command_encoder_pop_debug_group(
   state: &mut OpState,
   args: CommandEncoderPopDebugGroupArgs,
@@ -533,6 +544,7 @@ pub struct CommandEncoderInsertDebugMarkerArgs {
   marker_label: String,
 }
 
+#[op]
 pub fn op_webgpu_command_encoder_insert_debug_marker(
   state: &mut OpState,
   args: CommandEncoderInsertDebugMarkerArgs,
@@ -558,6 +570,7 @@ pub struct CommandEncoderWriteTimestampArgs {
   query_index: u32,
 }
 
+#[op]
 pub fn op_webgpu_command_encoder_write_timestamp(
   state: &mut OpState,
   args: CommandEncoderWriteTimestampArgs,
@@ -590,6 +603,7 @@ pub struct CommandEncoderResolveQuerySetArgs {
   destination_offset: u64,
 }
 
+#[op]
 pub fn op_webgpu_command_encoder_resolve_query_set(
   state: &mut OpState,
   args: CommandEncoderResolveQuerySetArgs,
@@ -624,6 +638,7 @@ pub struct CommandEncoderFinishArgs {
   label: Option<String>,
 }
 
+#[op]
 pub fn op_webgpu_command_encoder_finish(
   state: &mut OpState,
   args: CommandEncoderFinishArgs,
diff --git a/ext/webgpu/src/compute_pass.rs b/ext/webgpu/src/compute_pass.rs
index 03d9163cb..e6ebdc098 100644
--- a/ext/webgpu/src/compute_pass.rs
+++ b/ext/webgpu/src/compute_pass.rs
@@ -1,6 +1,7 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use deno_core::{OpState, Resource};
@@ -26,6 +27,7 @@ pub struct ComputePassSetPipelineArgs {
   pipeline: ResourceId,
 }
 
+#[op]
 pub fn op_webgpu_compute_pass_set_pipeline(
   state: &mut OpState,
   args: ComputePassSetPipelineArgs,
@@ -56,6 +58,7 @@ pub struct ComputePassDispatchArgs {
   z: u32,
 }
 
+#[op]
 pub fn op_webgpu_compute_pass_dispatch(
   state: &mut OpState,
   args: ComputePassDispatchArgs,
@@ -83,6 +86,7 @@ pub struct ComputePassDispatchIndirectArgs {
   indirect_offset: u64,
 }
 
+#[op]
 pub fn op_webgpu_compute_pass_dispatch_indirect(
   state: &mut OpState,
   args: ComputePassDispatchIndirectArgs,
@@ -112,6 +116,7 @@ pub struct ComputePassBeginPipelineStatisticsQueryArgs {
   query_index: u32,
 }
 
+#[op]
 pub fn op_webgpu_compute_pass_begin_pipeline_statistics_query(
   state: &mut OpState,
   args: ComputePassBeginPipelineStatisticsQueryArgs,
@@ -139,6 +144,7 @@ pub struct ComputePassEndPipelineStatisticsQueryArgs {
   compute_pass_rid: ResourceId,
 }
 
+#[op]
 pub fn op_webgpu_compute_pass_end_pipeline_statistics_query(
   state: &mut OpState,
   args: ComputePassEndPipelineStatisticsQueryArgs,
@@ -163,6 +169,7 @@ pub struct ComputePassWriteTimestampArgs {
   query_index: u32,
 }
 
+#[op]
 pub fn op_webgpu_compute_pass_write_timestamp(
   state: &mut OpState,
   args: ComputePassWriteTimestampArgs,
@@ -191,6 +198,7 @@ pub struct ComputePassEndPassArgs {
   compute_pass_rid: ResourceId,
 }
 
+#[op]
 pub fn op_webgpu_compute_pass_end_pass(
   state: &mut OpState,
   args: ComputePassEndPassArgs,
@@ -225,6 +233,7 @@ pub struct ComputePassSetBindGroupArgs {
   dynamic_offsets_data_length: usize,
 }
 
+#[op]
 pub fn op_webgpu_compute_pass_set_bind_group(
   state: &mut OpState,
   args: ComputePassSetBindGroupArgs,
@@ -278,6 +287,7 @@ pub struct ComputePassPushDebugGroupArgs {
   group_label: String,
 }
 
+#[op]
 pub fn op_webgpu_compute_pass_push_debug_group(
   state: &mut OpState,
   args: ComputePassPushDebugGroupArgs,
@@ -307,6 +317,7 @@ pub struct ComputePassPopDebugGroupArgs {
   compute_pass_rid: ResourceId,
 }
 
+#[op]
 pub fn op_webgpu_compute_pass_pop_debug_group(
   state: &mut OpState,
   args: ComputePassPopDebugGroupArgs,
@@ -330,6 +341,7 @@ pub struct ComputePassInsertDebugMarkerArgs {
   marker_label: String,
 }
 
+#[op]
 pub fn op_webgpu_compute_pass_insert_debug_marker(
   state: &mut OpState,
   args: ComputePassInsertDebugMarkerArgs,
diff --git a/ext/webgpu/src/lib.rs b/ext/webgpu/src/lib.rs
index 9d227a51e..d1eba20ba 100644
--- a/ext/webgpu/src/lib.rs
+++ b/ext/webgpu/src/lib.rs
@@ -2,10 +2,10 @@
 
 use deno_core::error::AnyError;
 use deno_core::include_js_files;
-use deno_core::op_async;
-use deno_core::op_sync;
+use deno_core::op;
+
 use deno_core::Extension;
-use deno_core::OpFn;
+use deno_core::OpPair;
 use deno_core::OpState;
 use deno_core::Resource;
 use deno_core::ResourceId;
@@ -241,6 +241,7 @@ pub struct GpuAdapterDevice {
   is_software: bool,
 }
 
+#[op]
 pub async fn op_webgpu_request_adapter(
   state: Rc<RefCell<OpState>>,
   args: RequestAdapterArgs,
@@ -439,6 +440,7 @@ impl From<GpuRequiredFeatures> for wgpu_types::Features {
   }
 }
 
+#[op]
 pub async fn op_webgpu_request_device(
   state: Rc<RefCell<OpState>>,
   args: RequestDeviceArgs,
@@ -539,6 +541,7 @@ impl From<GpuQueryType> for wgpu_types::QueryType {
   }
 }
 
+#[op]
 pub fn op_webgpu_create_query_set(
   state: &mut OpState,
   args: CreateQuerySetArgs,
@@ -562,347 +565,102 @@ pub fn op_webgpu_create_query_set(
   ) => state, WebGpuQuerySet)
 }
 
-fn declare_webgpu_ops() -> Vec<(&'static str, Box<OpFn>)> {
+fn declare_webgpu_ops() -> Vec<OpPair> {
   vec![
     // Request device/adapter
-    (
-      "op_webgpu_request_adapter",
-      op_async(op_webgpu_request_adapter),
-    ),
-    (
-      "op_webgpu_request_device",
-      op_async(op_webgpu_request_device),
-    ),
+    op_webgpu_request_adapter::decl(),
+    op_webgpu_request_device::decl(),
     // Query Set
-    (
-      "op_webgpu_create_query_set",
-      op_sync(op_webgpu_create_query_set),
-    ),
+    op_webgpu_create_query_set::decl(),
     // 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::op_webgpu_create_buffer::decl(),
+    buffer::op_webgpu_buffer_get_mapped_range::decl(),
+    buffer::op_webgpu_buffer_unmap::decl(),
     // buffer async
-    (
-      "op_webgpu_buffer_get_map_async",
-      op_async(buffer::op_webgpu_buffer_get_map_async),
-    ),
+    buffer::op_webgpu_buffer_get_map_async::decl(),
     // 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),
-    ),
+    texture::op_webgpu_create_texture::decl(),
+    texture::op_webgpu_create_texture_view::decl(),
     // sampler
-    (
-      "op_webgpu_create_sampler",
-      op_sync(sampler::op_webgpu_create_sampler),
-    ),
+    sampler::op_webgpu_create_sampler::decl(),
     // 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),
-    ),
+    binding::op_webgpu_create_bind_group_layout::decl(),
+    binding::op_webgpu_create_pipeline_layout::decl(),
+    binding::op_webgpu_create_bind_group::decl(),
     // 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),
-    ),
+    pipeline::op_webgpu_create_compute_pipeline::decl(),
+    pipeline::op_webgpu_compute_pipeline_get_bind_group_layout::decl(),
+    pipeline::op_webgpu_create_render_pipeline::decl(),
+    pipeline::op_webgpu_render_pipeline_get_bind_group_layout::decl(),
     // 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_clear_buffer",
-      op_sync(command_encoder::op_webgpu_command_encoder_clear_buffer),
-    ),
-    (
-      "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),
-    ),
+    command_encoder::op_webgpu_create_command_encoder::decl(),
+    command_encoder::op_webgpu_command_encoder_begin_render_pass::decl(),
+    command_encoder::op_webgpu_command_encoder_begin_compute_pass::decl(),
+    command_encoder::op_webgpu_command_encoder_copy_buffer_to_buffer::decl(),
+    command_encoder::op_webgpu_command_encoder_copy_buffer_to_texture::decl(),
+    command_encoder::op_webgpu_command_encoder_copy_texture_to_buffer::decl(),
+    command_encoder::op_webgpu_command_encoder_copy_texture_to_texture::decl(),
+    command_encoder::op_webgpu_command_encoder_clear_buffer::decl(),
+    command_encoder::op_webgpu_command_encoder_push_debug_group::decl(),
+    command_encoder::op_webgpu_command_encoder_pop_debug_group::decl(),
+    command_encoder::op_webgpu_command_encoder_insert_debug_marker::decl(),
+    command_encoder::op_webgpu_command_encoder_write_timestamp::decl(),
+    command_encoder::op_webgpu_command_encoder_resolve_query_set::decl(),
+    command_encoder::op_webgpu_command_encoder_finish::decl(),
     // 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_constant",
-      op_sync(render_pass::op_webgpu_render_pass_set_blend_constant),
-    ),
-    (
-      "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),
-    ),
+    render_pass::op_webgpu_render_pass_set_viewport::decl(),
+    render_pass::op_webgpu_render_pass_set_scissor_rect::decl(),
+    render_pass::op_webgpu_render_pass_set_blend_constant::decl(),
+    render_pass::op_webgpu_render_pass_set_stencil_reference::decl(),
+    render_pass::op_webgpu_render_pass_begin_pipeline_statistics_query::decl(),
+    render_pass::op_webgpu_render_pass_end_pipeline_statistics_query::decl(),
+    render_pass::op_webgpu_render_pass_write_timestamp::decl(),
+    render_pass::op_webgpu_render_pass_execute_bundles::decl(),
+    render_pass::op_webgpu_render_pass_end_pass::decl(),
+    render_pass::op_webgpu_render_pass_set_bind_group::decl(),
+    render_pass::op_webgpu_render_pass_push_debug_group::decl(),
+    render_pass::op_webgpu_render_pass_pop_debug_group::decl(),
+    render_pass::op_webgpu_render_pass_insert_debug_marker::decl(),
+    render_pass::op_webgpu_render_pass_set_pipeline::decl(),
+    render_pass::op_webgpu_render_pass_set_index_buffer::decl(),
+    render_pass::op_webgpu_render_pass_set_vertex_buffer::decl(),
+    render_pass::op_webgpu_render_pass_draw::decl(),
+    render_pass::op_webgpu_render_pass_draw_indexed::decl(),
+    render_pass::op_webgpu_render_pass_draw_indirect::decl(),
+    render_pass::op_webgpu_render_pass_draw_indexed_indirect::decl(),
     // 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_begin_pipeline_statistics_query",
-      op_sync(
-        compute_pass::op_webgpu_compute_pass_begin_pipeline_statistics_query,
-      ),
-    ),
-    (
-      "op_webgpu_compute_pass_end_pipeline_statistics_query",
-      op_sync(
-        compute_pass::op_webgpu_compute_pass_end_pipeline_statistics_query,
-      ),
-    ),
-    (
-      "op_webgpu_compute_pass_write_timestamp",
-      op_sync(compute_pass::op_webgpu_compute_pass_write_timestamp),
-    ),
-    (
-      "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),
-    ),
+    compute_pass::op_webgpu_compute_pass_set_pipeline::decl(),
+    compute_pass::op_webgpu_compute_pass_dispatch::decl(),
+    compute_pass::op_webgpu_compute_pass_dispatch_indirect::decl(),
+    compute_pass::op_webgpu_compute_pass_begin_pipeline_statistics_query::decl(
+    ),
+    compute_pass::op_webgpu_compute_pass_end_pipeline_statistics_query::decl(),
+    compute_pass::op_webgpu_compute_pass_write_timestamp::decl(),
+    compute_pass::op_webgpu_compute_pass_end_pass::decl(),
+    compute_pass::op_webgpu_compute_pass_set_bind_group::decl(),
+    compute_pass::op_webgpu_compute_pass_push_debug_group::decl(),
+    compute_pass::op_webgpu_compute_pass_pop_debug_group::decl(),
+    compute_pass::op_webgpu_compute_pass_insert_debug_marker::decl(),
     // 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),
-    ),
+    bundle::op_webgpu_create_render_bundle_encoder::decl(),
+    bundle::op_webgpu_render_bundle_encoder_finish::decl(),
+    bundle::op_webgpu_render_bundle_encoder_set_bind_group::decl(),
+    bundle::op_webgpu_render_bundle_encoder_push_debug_group::decl(),
+    bundle::op_webgpu_render_bundle_encoder_pop_debug_group::decl(),
+    bundle::op_webgpu_render_bundle_encoder_insert_debug_marker::decl(),
+    bundle::op_webgpu_render_bundle_encoder_set_pipeline::decl(),
+    bundle::op_webgpu_render_bundle_encoder_set_index_buffer::decl(),
+    bundle::op_webgpu_render_bundle_encoder_set_vertex_buffer::decl(),
+    bundle::op_webgpu_render_bundle_encoder_draw::decl(),
+    bundle::op_webgpu_render_bundle_encoder_draw_indexed::decl(),
+    bundle::op_webgpu_render_bundle_encoder_draw_indirect::decl(),
     // 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),
-    ),
+    queue::op_webgpu_queue_submit::decl(),
+    queue::op_webgpu_write_buffer::decl(),
+    queue::op_webgpu_write_texture::decl(),
     // shader
-    (
-      "op_webgpu_create_shader_module",
-      op_sync(shader::op_webgpu_create_shader_module),
-    ),
+    shader::op_webgpu_create_shader_module::decl(),
   ]
 }
diff --git a/ext/webgpu/src/pipeline.rs b/ext/webgpu/src/pipeline.rs
index 8327fb946..6ea2a5677 100644
--- a/ext/webgpu/src/pipeline.rs
+++ b/ext/webgpu/src/pipeline.rs
@@ -1,6 +1,7 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::ResourceId;
 use deno_core::{OpState, Resource};
 use serde::Deserialize;
@@ -57,6 +58,7 @@ pub struct CreateComputePipelineArgs {
   compute: GpuProgrammableStage,
 }
 
+#[op]
 pub fn op_webgpu_create_compute_pipeline(
   state: &mut OpState,
   args: CreateComputePipelineArgs,
@@ -126,6 +128,7 @@ pub struct PipelineLayout {
   err: Option<WebGpuError>,
 }
 
+#[op]
 pub fn op_webgpu_compute_pipeline_get_bind_group_layout(
   state: &mut OpState,
   args: ComputePipelineGetBindGroupLayoutArgs,
@@ -303,6 +306,7 @@ pub struct CreateRenderPipelineArgs {
   fragment: Option<GpuFragmentState>,
 }
 
+#[op]
 pub fn op_webgpu_create_render_pipeline(
   state: &mut OpState,
   args: CreateRenderPipelineArgs,
@@ -404,6 +408,7 @@ pub struct RenderPipelineGetBindGroupLayoutArgs {
   index: u32,
 }
 
+#[op]
 pub fn op_webgpu_render_pipeline_get_bind_group_layout(
   state: &mut OpState,
   args: RenderPipelineGetBindGroupLayoutArgs,
diff --git a/ext/webgpu/src/queue.rs b/ext/webgpu/src/queue.rs
index a662c4ead..3853f0025 100644
--- a/ext/webgpu/src/queue.rs
+++ b/ext/webgpu/src/queue.rs
@@ -3,6 +3,7 @@
 use std::num::NonZeroU32;
 
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::OpState;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
@@ -19,6 +20,7 @@ pub struct QueueSubmitArgs {
   command_buffers: Vec<ResourceId>,
 }
 
+#[op]
 pub fn op_webgpu_queue_submit(
   state: &mut OpState,
   args: QueueSubmitArgs,
@@ -73,6 +75,7 @@ pub struct QueueWriteBufferArgs {
   size: Option<usize>,
 }
 
+#[op]
 pub fn op_webgpu_write_buffer(
   state: &mut OpState,
   args: QueueWriteBufferArgs,
@@ -111,6 +114,7 @@ pub struct QueueWriteTextureArgs {
   size: wgpu_types::Extent3d,
 }
 
+#[op]
 pub fn op_webgpu_write_texture(
   state: &mut OpState,
   args: QueueWriteTextureArgs,
diff --git a/ext/webgpu/src/render_pass.rs b/ext/webgpu/src/render_pass.rs
index 469bf727e..822b4c8c9 100644
--- a/ext/webgpu/src/render_pass.rs
+++ b/ext/webgpu/src/render_pass.rs
@@ -2,6 +2,7 @@
 
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
 use deno_core::{OpState, Resource};
@@ -32,6 +33,7 @@ pub struct RenderPassSetViewportArgs {
   max_depth: f32,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_set_viewport(
   state: &mut OpState,
   args: RenderPassSetViewportArgs,
@@ -64,6 +66,7 @@ pub struct RenderPassSetScissorRectArgs {
   height: u32,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_set_scissor_rect(
   state: &mut OpState,
   args: RenderPassSetScissorRectArgs,
@@ -91,6 +94,7 @@ pub struct RenderPassSetBlendConstantArgs {
   color: wgpu_types::Color,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_set_blend_constant(
   state: &mut OpState,
   args: RenderPassSetBlendConstantArgs,
@@ -115,6 +119,7 @@ pub struct RenderPassSetStencilReferenceArgs {
   reference: u32,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_set_stencil_reference(
   state: &mut OpState,
   args: RenderPassSetStencilReferenceArgs,
@@ -140,6 +145,7 @@ pub struct RenderPassBeginPipelineStatisticsQueryArgs {
   query_index: u32,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_begin_pipeline_statistics_query(
   state: &mut OpState,
   args: RenderPassBeginPipelineStatisticsQueryArgs,
@@ -167,6 +173,7 @@ pub struct RenderPassEndPipelineStatisticsQueryArgs {
   render_pass_rid: ResourceId,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_end_pipeline_statistics_query(
   state: &mut OpState,
   args: RenderPassEndPipelineStatisticsQueryArgs,
@@ -191,6 +198,7 @@ pub struct RenderPassWriteTimestampArgs {
   query_index: u32,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_write_timestamp(
   state: &mut OpState,
   args: RenderPassWriteTimestampArgs,
@@ -219,6 +227,7 @@ pub struct RenderPassExecuteBundlesArgs {
   bundles: Vec<u32>,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_execute_bundles(
   state: &mut OpState,
   args: RenderPassExecuteBundlesArgs,
@@ -258,6 +267,7 @@ pub struct RenderPassEndPassArgs {
   render_pass_rid: ResourceId,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_end_pass(
   state: &mut OpState,
   args: RenderPassEndPassArgs,
@@ -289,6 +299,7 @@ pub struct RenderPassSetBindGroupArgs {
   dynamic_offsets_data_length: usize,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_set_bind_group(
   state: &mut OpState,
   args: RenderPassSetBindGroupArgs,
@@ -342,6 +353,7 @@ pub struct RenderPassPushDebugGroupArgs {
   group_label: String,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_push_debug_group(
   state: &mut OpState,
   args: RenderPassPushDebugGroupArgs,
@@ -371,6 +383,7 @@ pub struct RenderPassPopDebugGroupArgs {
   render_pass_rid: ResourceId,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_pop_debug_group(
   state: &mut OpState,
   args: RenderPassPopDebugGroupArgs,
@@ -394,6 +407,7 @@ pub struct RenderPassInsertDebugMarkerArgs {
   marker_label: String,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_insert_debug_marker(
   state: &mut OpState,
   args: RenderPassInsertDebugMarkerArgs,
@@ -424,6 +438,7 @@ pub struct RenderPassSetPipelineArgs {
   pipeline: u32,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_set_pipeline(
   state: &mut OpState,
   args: RenderPassSetPipelineArgs,
@@ -455,6 +470,7 @@ pub struct RenderPassSetIndexBufferArgs {
   size: Option<u64>,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_set_index_buffer(
   state: &mut OpState,
   args: RenderPassSetIndexBufferArgs,
@@ -496,6 +512,7 @@ pub struct RenderPassSetVertexBufferArgs {
   size: Option<u64>,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_set_vertex_buffer(
   state: &mut OpState,
   args: RenderPassSetVertexBufferArgs,
@@ -538,6 +555,7 @@ pub struct RenderPassDrawArgs {
   first_instance: u32,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_draw(
   state: &mut OpState,
   args: RenderPassDrawArgs,
@@ -569,6 +587,7 @@ pub struct RenderPassDrawIndexedArgs {
   first_instance: u32,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_draw_indexed(
   state: &mut OpState,
   args: RenderPassDrawIndexedArgs,
@@ -598,6 +617,7 @@ pub struct RenderPassDrawIndirectArgs {
   indirect_offset: u64,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_draw_indirect(
   state: &mut OpState,
   args: RenderPassDrawIndirectArgs,
@@ -627,6 +647,7 @@ pub struct RenderPassDrawIndexedIndirectArgs {
   indirect_offset: u64,
 }
 
+#[op]
 pub fn op_webgpu_render_pass_draw_indexed_indirect(
   state: &mut OpState,
   args: RenderPassDrawIndexedIndirectArgs,
diff --git a/ext/webgpu/src/sampler.rs b/ext/webgpu/src/sampler.rs
index c1cb0b411..3c0c43f53 100644
--- a/ext/webgpu/src/sampler.rs
+++ b/ext/webgpu/src/sampler.rs
@@ -1,6 +1,7 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::ResourceId;
 use deno_core::{OpState, Resource};
 use serde::Deserialize;
@@ -32,6 +33,7 @@ pub struct CreateSamplerArgs {
   max_anisotropy: u8,
 }
 
+#[op]
 pub fn op_webgpu_create_sampler(
   state: &mut OpState,
   args: CreateSamplerArgs,
diff --git a/ext/webgpu/src/shader.rs b/ext/webgpu/src/shader.rs
index 60290de8b..0173fffa2 100644
--- a/ext/webgpu/src/shader.rs
+++ b/ext/webgpu/src/shader.rs
@@ -1,6 +1,7 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::ResourceId;
 use deno_core::{OpState, Resource};
 use serde::Deserialize;
@@ -24,6 +25,7 @@ pub struct CreateShaderModuleArgs {
   _source_map: Option<()>, // not yet implemented
 }
 
+#[op]
 pub fn op_webgpu_create_shader_module(
   state: &mut OpState,
   args: CreateShaderModuleArgs,
diff --git a/ext/webgpu/src/texture.rs b/ext/webgpu/src/texture.rs
index 30d440e5c..482437478 100644
--- a/ext/webgpu/src/texture.rs
+++ b/ext/webgpu/src/texture.rs
@@ -1,6 +1,7 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 
 use deno_core::error::AnyError;
+use deno_core::op;
 use deno_core::ResourceId;
 use deno_core::{OpState, Resource};
 use serde::Deserialize;
@@ -34,6 +35,7 @@ pub struct CreateTextureArgs {
   usage: u32,
 }
 
+#[op]
 pub fn op_webgpu_create_texture(
   state: &mut OpState,
   args: CreateTextureArgs,
@@ -76,6 +78,7 @@ pub struct CreateTextureViewArgs {
   array_layer_count: Option<u32>,
 }
 
+#[op]
 pub fn op_webgpu_create_texture_view(
   state: &mut OpState,
   args: CreateTextureViewArgs,
diff --git a/ext/websocket/lib.rs b/ext/websocket/lib.rs
index 76ca92136..d712140b5 100644
--- a/ext/websocket/lib.rs
+++ b/ext/websocket/lib.rs
@@ -8,8 +8,8 @@ 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::op;
+
 use deno_core::url;
 use deno_core::AsyncRefCell;
 use deno_core::ByteString;
@@ -190,6 +190,7 @@ impl Resource for WsCancelResource {
 // This op is needed because creating a WS instance in JavaScript is a sync
 // operation and should throw error when permissions are not fulfilled,
 // but actual op that connects WS is async.
+#[op]
 pub fn op_ws_check_permission_and_cancel_handle<WP>(
   state: &mut OpState,
   url: String,
@@ -229,6 +230,7 @@ pub struct CreateResponse {
   extensions: String,
 }
 
+#[op]
 pub async fn op_ws_create<WP>(
   state: Rc<RefCell<OpState>>,
   args: CreateArgs,
@@ -378,6 +380,7 @@ pub enum SendValue {
   Ping,
 }
 
+#[op]
 pub async fn op_ws_send(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
@@ -406,6 +409,7 @@ pub struct CloseArgs {
   reason: Option<String>,
 }
 
+#[op]
 pub async fn op_ws_close(
   state: Rc<RefCell<OpState>>,
   args: CloseArgs,
@@ -440,6 +444,7 @@ pub enum NextEventResponse {
   Closed,
 }
 
+#[op]
 pub async fn op_ws_next_event(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
@@ -486,14 +491,11 @@ pub fn init<P: WebSocketPermissions + 'static>(
       "02_websocketstream.js",
     ))
     .ops(vec![
-      (
-        "op_ws_check_permission_and_cancel_handle",
-        op_sync(op_ws_check_permission_and_cancel_handle::<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)),
+      op_ws_check_permission_and_cancel_handle::decl::<P>(),
+      op_ws_create::decl::<P>(),
+      op_ws_send::decl(),
+      op_ws_close::decl(),
+      op_ws_next_event::decl(),
     ])
     .state(move |state| {
       state.put::<WsUserAgent>(WsUserAgent(user_agent.clone()));
diff --git a/ext/webstorage/lib.rs b/ext/webstorage/lib.rs
index 0aafefe62..c51301683 100644
--- a/ext/webstorage/lib.rs
+++ b/ext/webstorage/lib.rs
@@ -4,7 +4,7 @@
 
 use deno_core::error::AnyError;
 use deno_core::include_js_files;
-use deno_core::op_sync;
+use deno_core::op;
 use deno_core::Extension;
 use deno_core::OpState;
 use rusqlite::params;
@@ -26,16 +26,13 @@ pub fn init(origin_storage_dir: Option<PathBuf>) -> Extension {
       "01_webstorage.js",
     ))
     .ops(vec![
-      ("op_webstorage_length", op_sync(op_webstorage_length)),
-      ("op_webstorage_key", op_sync(op_webstorage_key)),
-      ("op_webstorage_set", op_sync(op_webstorage_set)),
-      ("op_webstorage_get", op_sync(op_webstorage_get)),
-      ("op_webstorage_remove", op_sync(op_webstorage_remove)),
-      ("op_webstorage_clear", op_sync(op_webstorage_clear)),
-      (
-        "op_webstorage_iterate_keys",
-        op_sync(op_webstorage_iterate_keys),
-      ),
+      op_webstorage_length::decl(),
+      op_webstorage_key::decl(),
+      op_webstorage_set::decl(),
+      op_webstorage_get::decl(),
+      op_webstorage_remove::decl(),
+      op_webstorage_clear::decl(),
+      op_webstorage_iterate_keys::decl(),
     ])
     .state(move |state| {
       if let Some(origin_storage_dir) = &origin_storage_dir {
@@ -103,6 +100,7 @@ fn get_webstorage(
   Ok(conn)
 }
 
+#[op]
 pub fn op_webstorage_length(
   state: &mut OpState,
   persistent: bool,
@@ -116,6 +114,7 @@ pub fn op_webstorage_length(
   Ok(length)
 }
 
+#[op]
 pub fn op_webstorage_key(
   state: &mut OpState,
   index: u32,
@@ -140,6 +139,7 @@ pub struct SetArgs {
   key_value: String,
 }
 
+#[op]
 pub fn op_webstorage_set(
   state: &mut OpState,
   args: SetArgs,
@@ -167,6 +167,7 @@ pub fn op_webstorage_set(
   Ok(())
 }
 
+#[op]
 pub fn op_webstorage_get(
   state: &mut OpState,
   key_name: String,
@@ -182,6 +183,7 @@ pub fn op_webstorage_get(
   Ok(val)
 }
 
+#[op]
 pub fn op_webstorage_remove(
   state: &mut OpState,
   key_name: String,
@@ -195,6 +197,7 @@ pub fn op_webstorage_remove(
   Ok(())
 }
 
+#[op]
 pub fn op_webstorage_clear(
   state: &mut OpState,
   persistent: bool,
@@ -208,6 +211,7 @@ pub fn op_webstorage_clear(
   Ok(())
 }
 
+#[op]
 pub fn op_webstorage_iterate_keys(
   state: &mut OpState,
   persistent: bool,