23 files changed, 213 insertions, 269 deletions

diff --git a/runtime/ops/crypto.rs b/runtime/ops/crypto.rs
index 43a9d1126..432cc0185 100644
--- a/runtime/ops/crypto.rs
+++ b/runtime/ops/crypto.rs
@@ -10,7 +10,7 @@ pub fn init(rt: &mut deno_core::JsRuntime, maybe_seed: Option<u64>) {
     let mut state = op_state.borrow_mut();
     state.put::<StdRng>(rng);
   }
-  super::reg_json_sync(
+  super::reg_sync(
     rt,
     "op_crypto_get_random_values",
     op_crypto_get_random_values,
diff --git a/runtime/ops/fetch.rs b/runtime/ops/fetch.rs
index 3cb0c6c78..17656974a 100644
--- a/runtime/ops/fetch.rs
+++ b/runtime/ops/fetch.rs
@@ -20,19 +20,19 @@ pub fn init(
       ca_data,
     });
   }
-  super::reg_json_sync(rt, "op_fetch", deno_fetch::op_fetch::<Permissions>);
-  super::reg_json_async(rt, "op_fetch_send", deno_fetch::op_fetch_send);
-  super::reg_json_async(
+  super::reg_sync(rt, "op_fetch", deno_fetch::op_fetch::<Permissions>);
+  super::reg_async(rt, "op_fetch_send", deno_fetch::op_fetch_send);
+  super::reg_async(
     rt,
     "op_fetch_request_write",
     deno_fetch::op_fetch_request_write,
   );
-  super::reg_json_async(
+  super::reg_async(
     rt,
     "op_fetch_response_read",
     deno_fetch::op_fetch_response_read,
   );
-  super::reg_json_sync(
+  super::reg_sync(
     rt,
     "op_create_http_client",
     deno_fetch::op_create_http_client::<Permissions>,
diff --git a/runtime/ops/file.rs b/runtime/ops/file.rs
index e7f68b207..8f471ebbd 100644
--- a/runtime/ops/file.rs
+++ b/runtime/ops/file.rs
@@ -18,14 +18,6 @@ pub fn init(
       op_state.put(Location(location));
     }
   }
-  super::reg_json_sync(
-    rt,
-    "op_file_create_object_url",
-    op_file_create_object_url,
-  );
-  super::reg_json_sync(
-    rt,
-    "op_file_revoke_object_url",
-    op_file_revoke_object_url,
-  );
+  super::reg_sync(rt, "op_file_create_object_url", op_file_create_object_url);
+  super::reg_sync(rt, "op_file_revoke_object_url", op_file_revoke_object_url);
 }
diff --git a/runtime/ops/fs.rs b/runtime/ops/fs.rs
index aa3780624..19933dcb6 100644
--- a/runtime/ops/fs.rs
+++ b/runtime/ops/fs.rs
@@ -34,79 +34,79 @@ use deno_core::error::generic_error;
 use deno_core::error::not_supported;
 
 pub fn init(rt: &mut deno_core::JsRuntime) {
-  super::reg_json_sync(rt, "op_open_sync", op_open_sync);
-  super::reg_json_async(rt, "op_open_async", op_open_async);
+  super::reg_sync(rt, "op_open_sync", op_open_sync);
+  super::reg_async(rt, "op_open_async", op_open_async);
 
-  super::reg_json_sync(rt, "op_seek_sync", op_seek_sync);
-  super::reg_json_async(rt, "op_seek_async", op_seek_async);
+  super::reg_sync(rt, "op_seek_sync", op_seek_sync);
+  super::reg_async(rt, "op_seek_async", op_seek_async);
 
-  super::reg_json_sync(rt, "op_fdatasync_sync", op_fdatasync_sync);
-  super::reg_json_async(rt, "op_fdatasync_async", op_fdatasync_async);
+  super::reg_sync(rt, "op_fdatasync_sync", op_fdatasync_sync);
+  super::reg_async(rt, "op_fdatasync_async", op_fdatasync_async);
 
-  super::reg_json_sync(rt, "op_fsync_sync", op_fsync_sync);
-  super::reg_json_async(rt, "op_fsync_async", op_fsync_async);
+  super::reg_sync(rt, "op_fsync_sync", op_fsync_sync);
+  super::reg_async(rt, "op_fsync_async", op_fsync_async);
 
-  super::reg_json_sync(rt, "op_fstat_sync", op_fstat_sync);
-  super::reg_json_async(rt, "op_fstat_async", op_fstat_async);
+  super::reg_sync(rt, "op_fstat_sync", op_fstat_sync);
+  super::reg_async(rt, "op_fstat_async", op_fstat_async);
 
-  super::reg_json_sync(rt, "op_umask", op_umask);
-  super::reg_json_sync(rt, "op_chdir", op_chdir);
+  super::reg_sync(rt, "op_umask", op_umask);
+  super::reg_sync(rt, "op_chdir", op_chdir);
 
-  super::reg_json_sync(rt, "op_mkdir_sync", op_mkdir_sync);
-  super::reg_json_async(rt, "op_mkdir_async", op_mkdir_async);
+  super::reg_sync(rt, "op_mkdir_sync", op_mkdir_sync);
+  super::reg_async(rt, "op_mkdir_async", op_mkdir_async);
 
-  super::reg_json_sync(rt, "op_chmod_sync", op_chmod_sync);
-  super::reg_json_async(rt, "op_chmod_async", op_chmod_async);
+  super::reg_sync(rt, "op_chmod_sync", op_chmod_sync);
+  super::reg_async(rt, "op_chmod_async", op_chmod_async);
 
-  super::reg_json_sync(rt, "op_chown_sync", op_chown_sync);
-  super::reg_json_async(rt, "op_chown_async", op_chown_async);
+  super::reg_sync(rt, "op_chown_sync", op_chown_sync);
+  super::reg_async(rt, "op_chown_async", op_chown_async);
 
-  super::reg_json_sync(rt, "op_remove_sync", op_remove_sync);
-  super::reg_json_async(rt, "op_remove_async", op_remove_async);
+  super::reg_sync(rt, "op_remove_sync", op_remove_sync);
+  super::reg_async(rt, "op_remove_async", op_remove_async);
 
-  super::reg_json_sync(rt, "op_copy_file_sync", op_copy_file_sync);
-  super::reg_json_async(rt, "op_copy_file_async", op_copy_file_async);
+  super::reg_sync(rt, "op_copy_file_sync", op_copy_file_sync);
+  super::reg_async(rt, "op_copy_file_async", op_copy_file_async);
 
-  super::reg_json_sync(rt, "op_stat_sync", op_stat_sync);
-  super::reg_json_async(rt, "op_stat_async", op_stat_async);
+  super::reg_sync(rt, "op_stat_sync", op_stat_sync);
+  super::reg_async(rt, "op_stat_async", op_stat_async);
 
-  super::reg_json_sync(rt, "op_realpath_sync", op_realpath_sync);
-  super::reg_json_async(rt, "op_realpath_async", op_realpath_async);
+  super::reg_sync(rt, "op_realpath_sync", op_realpath_sync);
+  super::reg_async(rt, "op_realpath_async", op_realpath_async);
 
-  super::reg_json_sync(rt, "op_read_dir_sync", op_read_dir_sync);
-  super::reg_json_async(rt, "op_read_dir_async", op_read_dir_async);
+  super::reg_sync(rt, "op_read_dir_sync", op_read_dir_sync);
+  super::reg_async(rt, "op_read_dir_async", op_read_dir_async);
 
-  super::reg_json_sync(rt, "op_rename_sync", op_rename_sync);
-  super::reg_json_async(rt, "op_rename_async", op_rename_async);
+  super::reg_sync(rt, "op_rename_sync", op_rename_sync);
+  super::reg_async(rt, "op_rename_async", op_rename_async);
 
-  super::reg_json_sync(rt, "op_link_sync", op_link_sync);
-  super::reg_json_async(rt, "op_link_async", op_link_async);
+  super::reg_sync(rt, "op_link_sync", op_link_sync);
+  super::reg_async(rt, "op_link_async", op_link_async);
 
-  super::reg_json_sync(rt, "op_symlink_sync", op_symlink_sync);
-  super::reg_json_async(rt, "op_symlink_async", op_symlink_async);
+  super::reg_sync(rt, "op_symlink_sync", op_symlink_sync);
+  super::reg_async(rt, "op_symlink_async", op_symlink_async);
 
-  super::reg_json_sync(rt, "op_read_link_sync", op_read_link_sync);
-  super::reg_json_async(rt, "op_read_link_async", op_read_link_async);
+  super::reg_sync(rt, "op_read_link_sync", op_read_link_sync);
+  super::reg_async(rt, "op_read_link_async", op_read_link_async);
 
-  super::reg_json_sync(rt, "op_ftruncate_sync", op_ftruncate_sync);
-  super::reg_json_async(rt, "op_ftruncate_async", op_ftruncate_async);
+  super::reg_sync(rt, "op_ftruncate_sync", op_ftruncate_sync);
+  super::reg_async(rt, "op_ftruncate_async", op_ftruncate_async);
 
-  super::reg_json_sync(rt, "op_truncate_sync", op_truncate_sync);
-  super::reg_json_async(rt, "op_truncate_async", op_truncate_async);
+  super::reg_sync(rt, "op_truncate_sync", op_truncate_sync);
+  super::reg_async(rt, "op_truncate_async", op_truncate_async);
 
-  super::reg_json_sync(rt, "op_make_temp_dir_sync", op_make_temp_dir_sync);
-  super::reg_json_async(rt, "op_make_temp_dir_async", op_make_temp_dir_async);
+  super::reg_sync(rt, "op_make_temp_dir_sync", op_make_temp_dir_sync);
+  super::reg_async(rt, "op_make_temp_dir_async", op_make_temp_dir_async);
 
-  super::reg_json_sync(rt, "op_make_temp_file_sync", op_make_temp_file_sync);
-  super::reg_json_async(rt, "op_make_temp_file_async", op_make_temp_file_async);
+  super::reg_sync(rt, "op_make_temp_file_sync", op_make_temp_file_sync);
+  super::reg_async(rt, "op_make_temp_file_async", op_make_temp_file_async);
 
-  super::reg_json_sync(rt, "op_cwd", op_cwd);
+  super::reg_sync(rt, "op_cwd", op_cwd);
 
-  super::reg_json_sync(rt, "op_futime_sync", op_futime_sync);
-  super::reg_json_async(rt, "op_futime_async", op_futime_async);
+  super::reg_sync(rt, "op_futime_sync", op_futime_sync);
+  super::reg_async(rt, "op_futime_async", op_futime_async);
 
-  super::reg_json_sync(rt, "op_utime_sync", op_utime_sync);
-  super::reg_json_async(rt, "op_utime_async", op_utime_async);
+  super::reg_sync(rt, "op_utime_sync", op_utime_sync);
+  super::reg_async(rt, "op_utime_async", op_utime_async);
 }
 
 #[derive(Deserialize)]
diff --git a/runtime/ops/fs_events.rs b/runtime/ops/fs_events.rs
index 30ab69ba5..8bc9c4c57 100644
--- a/runtime/ops/fs_events.rs
+++ b/runtime/ops/fs_events.rs
@@ -28,8 +28,8 @@ use std::rc::Rc;
 use tokio::sync::mpsc;
 
 pub fn init(rt: &mut deno_core::JsRuntime) {
-  super::reg_json_sync(rt, "op_fs_events_open", op_fs_events_open);
-  super::reg_json_async(rt, "op_fs_events_poll", op_fs_events_poll);
+  super::reg_sync(rt, "op_fs_events_open", op_fs_events_open);
+  super::reg_async(rt, "op_fs_events_poll", op_fs_events_poll);
 }
 
 struct FsEventsResource {
diff --git a/runtime/ops/http.rs b/runtime/ops/http.rs
index 9cf4ff9d5..f209662c4 100644
--- a/runtime/ops/http.rs
+++ b/runtime/ops/http.rs
@@ -43,14 +43,14 @@ use tokio_rustls::server::TlsStream;
 use tokio_util::io::StreamReader;
 
 pub fn init(rt: &mut deno_core::JsRuntime) {
-  super::reg_json_sync(rt, "op_http_start", op_http_start);
+  super::reg_sync(rt, "op_http_start", op_http_start);
 
-  super::reg_json_async(rt, "op_http_request_next", op_http_request_next);
-  super::reg_json_async(rt, "op_http_request_read", op_http_request_read);
+  super::reg_async(rt, "op_http_request_next", op_http_request_next);
+  super::reg_async(rt, "op_http_request_read", op_http_request_read);
 
-  super::reg_json_sync(rt, "op_http_response", op_http_response);
-  super::reg_json_async(rt, "op_http_response_write", op_http_response_write);
-  super::reg_json_async(rt, "op_http_response_close", op_http_response_close);
+  super::reg_sync(rt, "op_http_response", op_http_response);
+  super::reg_async(rt, "op_http_response_write", op_http_response_write);
+  super::reg_async(rt, "op_http_response_close", op_http_response_close);
 }
 
 struct ServiceInner {
diff --git a/runtime/ops/io.rs b/runtime/ops/io.rs
index f8ab92704..0e4e3f42a 100644
--- a/runtime/ops/io.rs
+++ b/runtime/ops/io.rs
@@ -96,13 +96,13 @@ lazy_static::lazy_static! {
 }
 
 pub fn init(rt: &mut JsRuntime) {
-  super::reg_bin_async(rt, "op_read_async", op_read_async);
-  super::reg_bin_async(rt, "op_write_async", op_write_async);
+  super::reg_async(rt, "op_read_async", op_read_async);
+  super::reg_async(rt, "op_write_async", op_write_async);
 
-  super::reg_bin_sync(rt, "op_read_sync", op_read_sync);
-  super::reg_bin_sync(rt, "op_write_sync", op_write_sync);
+  super::reg_sync(rt, "op_read_sync", op_read_sync);
+  super::reg_sync(rt, "op_write_sync", op_write_sync);
 
-  super::reg_json_async(rt, "op_shutdown", op_shutdown);
+  super::reg_async(rt, "op_shutdown", op_shutdown);
 }
 
 pub fn get_stdio() -> (
diff --git a/runtime/ops/mod.rs b/runtime/ops/mod.rs
index d9bd2ba83..825950d65 100644
--- a/runtime/ops/mod.rs
+++ b/runtime/ops/mod.rs
@@ -27,59 +27,35 @@ pub mod websocket;
 pub mod worker_host;
 
 use crate::metrics::metrics_op;
-use deno_core::bin_op_async;
-use deno_core::bin_op_sync;
 use deno_core::error::AnyError;
-use deno_core::json_op_async;
-use deno_core::json_op_sync;
+use deno_core::op_async;
+use deno_core::op_sync;
 use deno_core::serde::de::DeserializeOwned;
 use deno_core::serde::Serialize;
 use deno_core::JsRuntime;
 use deno_core::OpState;
-use deno_core::ValueOrVector;
 use deno_core::ZeroCopyBuf;
 use std::cell::RefCell;
 use std::future::Future;
 use std::rc::Rc;
 
-pub fn reg_json_async<F, V, R, RV>(
-  rt: &mut JsRuntime,
-  name: &'static str,
-  op_fn: F,
-) where
+pub fn reg_async<F, V, R, RV>(rt: &mut JsRuntime, name: &'static str, op_fn: F)
+where
   F: Fn(Rc<RefCell<OpState>>, V, Option<ZeroCopyBuf>) -> R + 'static,
   V: DeserializeOwned,
   R: Future<Output = Result<RV, AnyError>> + 'static,
   RV: Serialize + 'static,
 {
-  rt.register_op(name, metrics_op(name, json_op_async(op_fn)));
+  rt.register_op(name, metrics_op(name, op_async(op_fn)));
 }
 
-pub fn reg_json_sync<F, V, R>(rt: &mut JsRuntime, name: &'static str, op_fn: F)
+pub fn reg_sync<F, V, R>(rt: &mut JsRuntime, name: &'static str, op_fn: F)
 where
   F: Fn(&mut OpState, V, Option<ZeroCopyBuf>) -> Result<R, AnyError> + 'static,
   V: DeserializeOwned,
   R: Serialize + 'static,
 {
-  rt.register_op(name, metrics_op(name, json_op_sync(op_fn)));
-}
-
-pub fn reg_bin_async<F, R, RV>(rt: &mut JsRuntime, name: &'static str, op_fn: F)
-where
-  F: Fn(Rc<RefCell<OpState>>, u32, Option<ZeroCopyBuf>) -> R + 'static,
-  R: Future<Output = Result<RV, AnyError>> + 'static,
-  RV: ValueOrVector,
-{
-  rt.register_op(name, metrics_op(name, bin_op_async(op_fn)));
-}
-
-pub fn reg_bin_sync<F, R>(rt: &mut JsRuntime, name: &'static str, op_fn: F)
-where
-  F:
-    Fn(&mut OpState, u32, Option<ZeroCopyBuf>) -> Result<R, AnyError> + 'static,
-  R: ValueOrVector,
-{
-  rt.register_op(name, metrics_op(name, bin_op_sync(op_fn)));
+  rt.register_op(name, metrics_op(name, op_sync(op_fn)));
 }
 
 /// `UnstableChecker` is a struct so it can be placed inside `GothamState`;
diff --git a/runtime/ops/net.rs b/runtime/ops/net.rs
index 934ff7926..ee762ed47 100644
--- a/runtime/ops/net.rs
+++ b/runtime/ops/net.rs
@@ -43,12 +43,12 @@ use crate::ops::io::UnixStreamResource;
 use std::path::Path;
 
 pub fn init(rt: &mut deno_core::JsRuntime) {
-  super::reg_json_async(rt, "op_accept", op_accept);
-  super::reg_json_async(rt, "op_connect", op_connect);
-  super::reg_json_sync(rt, "op_listen", op_listen);
-  super::reg_json_async(rt, "op_datagram_receive", op_datagram_receive);
-  super::reg_json_async(rt, "op_datagram_send", op_datagram_send);
-  super::reg_json_async(rt, "op_dns_resolve", op_dns_resolve);
+  super::reg_async(rt, "op_accept", op_accept);
+  super::reg_async(rt, "op_connect", op_connect);
+  super::reg_sync(rt, "op_listen", op_listen);
+  super::reg_async(rt, "op_datagram_receive", op_datagram_receive);
+  super::reg_async(rt, "op_datagram_send", op_datagram_send);
+  super::reg_async(rt, "op_dns_resolve", op_dns_resolve);
 }
 
 #[derive(Serialize)]
diff --git a/runtime/ops/os.rs b/runtime/ops/os.rs
index b13b54d22..b9511fcdc 100644
--- a/runtime/ops/os.rs
+++ b/runtime/ops/os.rs
@@ -12,17 +12,17 @@ use std::collections::HashMap;
 use std::env;
 
 pub fn init(rt: &mut deno_core::JsRuntime) {
-  super::reg_json_sync(rt, "op_exit", op_exit);
-  super::reg_json_sync(rt, "op_env", op_env);
-  super::reg_json_sync(rt, "op_exec_path", op_exec_path);
-  super::reg_json_sync(rt, "op_set_env", op_set_env);
-  super::reg_json_sync(rt, "op_get_env", op_get_env);
-  super::reg_json_sync(rt, "op_delete_env", op_delete_env);
-  super::reg_json_sync(rt, "op_hostname", op_hostname);
-  super::reg_json_sync(rt, "op_loadavg", op_loadavg);
-  super::reg_json_sync(rt, "op_os_release", op_os_release);
-  super::reg_json_sync(rt, "op_system_memory_info", op_system_memory_info);
-  super::reg_json_sync(rt, "op_system_cpu_info", op_system_cpu_info);
+  super::reg_sync(rt, "op_exit", op_exit);
+  super::reg_sync(rt, "op_env", op_env);
+  super::reg_sync(rt, "op_exec_path", op_exec_path);
+  super::reg_sync(rt, "op_set_env", op_set_env);
+  super::reg_sync(rt, "op_get_env", op_get_env);
+  super::reg_sync(rt, "op_delete_env", op_delete_env);
+  super::reg_sync(rt, "op_hostname", op_hostname);
+  super::reg_sync(rt, "op_loadavg", op_loadavg);
+  super::reg_sync(rt, "op_os_release", op_os_release);
+  super::reg_sync(rt, "op_system_memory_info", op_system_memory_info);
+  super::reg_sync(rt, "op_system_cpu_info", op_system_cpu_info);
 }
 
 fn op_exec_path(
diff --git a/runtime/ops/permissions.rs b/runtime/ops/permissions.rs
index 77d095d84..ce89def54 100644
--- a/runtime/ops/permissions.rs
+++ b/runtime/ops/permissions.rs
@@ -11,9 +11,9 @@ use serde::Deserialize;
 use std::path::Path;
 
 pub fn init(rt: &mut deno_core::JsRuntime) {
-  super::reg_json_sync(rt, "op_query_permission", op_query_permission);
-  super::reg_json_sync(rt, "op_revoke_permission", op_revoke_permission);
-  super::reg_json_sync(rt, "op_request_permission", op_request_permission);
+  super::reg_sync(rt, "op_query_permission", op_query_permission);
+  super::reg_sync(rt, "op_revoke_permission", op_revoke_permission);
+  super::reg_sync(rt, "op_request_permission", op_request_permission);
 }
 
 #[derive(Deserialize)]
diff --git a/runtime/ops/plugin.rs b/runtime/ops/plugin.rs
index d0fc989f4..c265c757f 100644
--- a/runtime/ops/plugin.rs
+++ b/runtime/ops/plugin.rs
@@ -23,7 +23,7 @@ use std::task::Context;
 use std::task::Poll;
 
 pub fn init(rt: &mut JsRuntime) {
-  super::reg_json_sync(rt, "op_open_plugin", op_open_plugin);
+  super::reg_sync(rt, "op_open_plugin", op_open_plugin);
 }
 
 pub fn op_open_plugin(
diff --git a/runtime/ops/process.rs b/runtime/ops/process.rs
index 4b49e21f3..bf074db2c 100644
--- a/runtime/ops/process.rs
+++ b/runtime/ops/process.rs
@@ -26,9 +26,9 @@ use tokio::process::Command;
 use std::os::unix::process::ExitStatusExt;
 
 pub fn init(rt: &mut deno_core::JsRuntime) {
-  super::reg_json_sync(rt, "op_run", op_run);
-  super::reg_json_async(rt, "op_run_status", op_run_status);
-  super::reg_json_sync(rt, "op_kill", op_kill);
+  super::reg_sync(rt, "op_run", op_run);
+  super::reg_async(rt, "op_run_status", op_run_status);
+  super::reg_sync(rt, "op_kill", op_kill);
 }
 
 fn clone_file(
diff --git a/runtime/ops/runtime.rs b/runtime/ops/runtime.rs
index d694cb9c9..d90e92593 100644
--- a/runtime/ops/runtime.rs
+++ b/runtime/ops/runtime.rs
@@ -17,8 +17,8 @@ pub fn init(rt: &mut deno_core::JsRuntime, main_module: ModuleSpecifier) {
     let mut state = op_state.borrow_mut();
     state.put::<ModuleSpecifier>(main_module);
   }
-  super::reg_json_sync(rt, "op_main_module", op_main_module);
-  super::reg_json_sync(rt, "op_metrics", op_metrics);
+  super::reg_sync(rt, "op_main_module", op_main_module);
+  super::reg_sync(rt, "op_metrics", op_metrics);
 }
 
 fn op_main_module(
diff --git a/runtime/ops/signal.rs b/runtime/ops/signal.rs
index 5235da612..2a19e4e98 100644
--- a/runtime/ops/signal.rs
+++ b/runtime/ops/signal.rs
@@ -25,9 +25,9 @@ use std::borrow::Cow;
 use tokio::signal::unix::{signal, Signal, SignalKind};
 
 pub fn init(rt: &mut deno_core::JsRuntime) {
-  super::reg_json_sync(rt, "op_signal_bind", op_signal_bind);
-  super::reg_json_sync(rt, "op_signal_unbind", op_signal_unbind);
-  super::reg_json_async(rt, "op_signal_poll", op_signal_poll);
+  super::reg_sync(rt, "op_signal_bind", op_signal_bind);
+  super::reg_sync(rt, "op_signal_unbind", op_signal_unbind);
+  super::reg_async(rt, "op_signal_poll", op_signal_poll);
 }
 
 #[cfg(unix)]
diff --git a/runtime/ops/timers.rs b/runtime/ops/timers.rs
index aee38cf8d..8e709440e 100644
--- a/runtime/ops/timers.rs
+++ b/runtime/ops/timers.rs
@@ -69,11 +69,11 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
     state.put::<GlobalTimer>(GlobalTimer::default());
     state.put::<StartTime>(StartTime::now());
   }
-  super::reg_json_sync(rt, "op_global_timer_stop", op_global_timer_stop);
-  super::reg_json_sync(rt, "op_global_timer_start", op_global_timer_start);
-  super::reg_json_async(rt, "op_global_timer", op_global_timer);
-  super::reg_json_sync(rt, "op_now", op_now);
-  super::reg_json_sync(rt, "op_sleep_sync", op_sleep_sync);
+  super::reg_sync(rt, "op_global_timer_stop", op_global_timer_stop);
+  super::reg_sync(rt, "op_global_timer_start", op_global_timer_start);
+  super::reg_async(rt, "op_global_timer", op_global_timer);
+  super::reg_sync(rt, "op_now", op_now);
+  super::reg_sync(rt, "op_sleep_sync", op_sleep_sync);
 }
 
 #[allow(clippy::unnecessary_wraps)]
diff --git a/runtime/ops/tls.rs b/runtime/ops/tls.rs
index 36762d66c..10293cf92 100644
--- a/runtime/ops/tls.rs
+++ b/runtime/ops/tls.rs
@@ -71,10 +71,10 @@ impl StoresClientSessions for ClientSessionMemoryCache {
 }
 
 pub fn init(rt: &mut deno_core::JsRuntime) {
-  super::reg_json_async(rt, "op_start_tls", op_start_tls);
-  super::reg_json_async(rt, "op_connect_tls", op_connect_tls);
-  super::reg_json_sync(rt, "op_listen_tls", op_listen_tls);
-  super::reg_json_async(rt, "op_accept_tls", op_accept_tls);
+  super::reg_async(rt, "op_start_tls", op_start_tls);
+  super::reg_async(rt, "op_connect_tls", op_connect_tls);
+  super::reg_sync(rt, "op_listen_tls", op_listen_tls);
+  super::reg_async(rt, "op_accept_tls", op_accept_tls);
 }
 
 #[derive(Deserialize)]
diff --git a/runtime/ops/tty.rs b/runtime/ops/tty.rs
index 9af72b5cd..a62a9ba02 100644
--- a/runtime/ops/tty.rs
+++ b/runtime/ops/tty.rs
@@ -44,9 +44,9 @@ fn get_windows_handle(
 }
 
 pub fn init(rt: &mut deno_core::JsRuntime) {
-  super::reg_json_sync(rt, "op_set_raw", op_set_raw);
-  super::reg_json_sync(rt, "op_isatty", op_isatty);
-  super::reg_json_sync(rt, "op_console_size", op_console_size);
+  super::reg_sync(rt, "op_set_raw", op_set_raw);
+  super::reg_sync(rt, "op_isatty", op_isatty);
+  super::reg_sync(rt, "op_console_size", op_console_size);
 }
 
 #[derive(Deserialize)]
diff --git a/runtime/ops/url.rs b/runtime/ops/url.rs
index 4add9132d..5168a7242 100644
--- a/runtime/ops/url.rs
+++ b/runtime/ops/url.rs
@@ -4,13 +4,9 @@ use deno_url::op_url_parse_search_params;
 use deno_url::op_url_stringify_search_params;
 
 pub fn init(rt: &mut deno_core::JsRuntime) {
-  super::reg_json_sync(rt, "op_url_parse", op_url_parse);
-  super::reg_json_sync(
-    rt,
-    "op_url_parse_search_params",
-    op_url_parse_search_params,
-  );
-  super::reg_json_sync(
+  super::reg_sync(rt, "op_url_parse", op_url_parse);
+  super::reg_sync(rt, "op_url_parse_search_params", op_url_parse_search_params);
+  super::reg_sync(
     rt,
     "op_url_stringify_search_params",
     op_url_stringify_search_params,
diff --git a/runtime/ops/web_worker.rs b/runtime/ops/web_worker.rs
index 5f63a03b7..68cef110c 100644
--- a/runtime/ops/web_worker.rs
+++ b/runtime/ops/web_worker.rs
@@ -12,7 +12,7 @@ pub fn init(
 ) {
   // Post message to host as guest worker.
   let sender_ = sender.clone();
-  super::reg_json_sync(
+  super::reg_sync(
     rt,
     "op_worker_post_message",
     move |_state, _args: (), buf| {
@@ -27,15 +27,11 @@ pub fn init(
   );
 
   // Notify host that guest worker closes.
-  super::reg_json_sync(
-    rt,
-    "op_worker_close",
-    move |_state, _args: (), _bufs| {
-      // Notify parent that we're finished
-      sender.clone().close_channel();
-      // Terminate execution of current worker
-      handle.terminate();
-      Ok(())
-    },
-  );
+  super::reg_sync(rt, "op_worker_close", move |_state, _args: (), _bufs| {
+    // Notify parent that we're finished
+    sender.clone().close_channel();
+    // Terminate execution of current worker
+    handle.terminate();
+    Ok(())
+  });
 }
diff --git a/runtime/ops/webgpu.rs b/runtime/ops/webgpu.rs
index d48913ce8..55c6d1817 100644
--- a/runtime/ops/webgpu.rs
+++ b/runtime/ops/webgpu.rs
@@ -10,40 +10,28 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
     state.put(Unstable(unstable));
   }
 
-  super::reg_json_async(
-    rt,
-    "op_webgpu_request_adapter",
-    op_webgpu_request_adapter,
-  );
-  super::reg_json_async(
-    rt,
-    "op_webgpu_request_device",
-    op_webgpu_request_device,
-  );
-  super::reg_json_sync(
-    rt,
-    "op_webgpu_create_query_set",
-    op_webgpu_create_query_set,
-  );
+  super::reg_async(rt, "op_webgpu_request_adapter", op_webgpu_request_adapter);
+  super::reg_async(rt, "op_webgpu_request_device", op_webgpu_request_device);
+  super::reg_sync(rt, "op_webgpu_create_query_set", op_webgpu_create_query_set);
 
   {
     // buffer
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_create_buffer",
       buffer::op_webgpu_create_buffer,
     );
-    super::reg_json_async(
+    super::reg_async(
       rt,
       "op_webgpu_buffer_get_map_async",
       buffer::op_webgpu_buffer_get_map_async,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_buffer_get_mapped_range",
       buffer::op_webgpu_buffer_get_mapped_range,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_buffer_unmap",
       buffer::op_webgpu_buffer_unmap,
@@ -51,12 +39,12 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
   }
   {
     // texture
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_create_texture",
       texture::op_webgpu_create_texture,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_create_texture_view",
       texture::op_webgpu_create_texture_view,
@@ -64,7 +52,7 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
   }
   {
     // sampler
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_create_sampler",
       sampler::op_webgpu_create_sampler,
@@ -72,17 +60,17 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
   }
   {
     // binding
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_create_bind_group_layout",
       binding::op_webgpu_create_bind_group_layout,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_create_pipeline_layout",
       binding::op_webgpu_create_pipeline_layout,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_create_bind_group",
       binding::op_webgpu_create_bind_group,
@@ -90,22 +78,22 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
   }
   {
     // pipeline
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_create_compute_pipeline",
       pipeline::op_webgpu_create_compute_pipeline,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_compute_pipeline_get_bind_group_layout",
       pipeline::op_webgpu_compute_pipeline_get_bind_group_layout,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_create_render_pipeline",
       pipeline::op_webgpu_create_render_pipeline,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pipeline_get_bind_group_layout",
       pipeline::op_webgpu_render_pipeline_get_bind_group_layout,
@@ -113,67 +101,67 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
   }
   {
     // command_encoder
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_create_command_encoder",
       command_encoder::op_webgpu_create_command_encoder,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_command_encoder_begin_render_pass",
       command_encoder::op_webgpu_command_encoder_begin_render_pass,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_command_encoder_begin_compute_pass",
       command_encoder::op_webgpu_command_encoder_begin_compute_pass,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_command_encoder_copy_buffer_to_buffer",
       command_encoder::op_webgpu_command_encoder_copy_buffer_to_buffer,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_command_encoder_copy_buffer_to_texture",
       command_encoder::op_webgpu_command_encoder_copy_buffer_to_texture,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_command_encoder_copy_texture_to_buffer",
       command_encoder::op_webgpu_command_encoder_copy_texture_to_buffer,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_command_encoder_copy_texture_to_texture",
       command_encoder::op_webgpu_command_encoder_copy_texture_to_texture,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_command_encoder_push_debug_group",
       command_encoder::op_webgpu_command_encoder_push_debug_group,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_command_encoder_pop_debug_group",
       command_encoder::op_webgpu_command_encoder_pop_debug_group,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_command_encoder_insert_debug_marker",
       command_encoder::op_webgpu_command_encoder_insert_debug_marker,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_command_encoder_write_timestamp",
       command_encoder::op_webgpu_command_encoder_write_timestamp,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_command_encoder_resolve_query_set",
       command_encoder::op_webgpu_command_encoder_resolve_query_set,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_command_encoder_finish",
       command_encoder::op_webgpu_command_encoder_finish,
@@ -181,102 +169,102 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
   }
   {
     // render_pass
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_set_viewport",
       render_pass::op_webgpu_render_pass_set_viewport,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_set_scissor_rect",
       render_pass::op_webgpu_render_pass_set_scissor_rect,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_set_blend_color",
       render_pass::op_webgpu_render_pass_set_blend_color,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_set_stencil_reference",
       render_pass::op_webgpu_render_pass_set_stencil_reference,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_begin_pipeline_statistics_query",
       render_pass::op_webgpu_render_pass_begin_pipeline_statistics_query,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_end_pipeline_statistics_query",
       render_pass::op_webgpu_render_pass_end_pipeline_statistics_query,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_write_timestamp",
       render_pass::op_webgpu_render_pass_write_timestamp,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_execute_bundles",
       render_pass::op_webgpu_render_pass_execute_bundles,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_end_pass",
       render_pass::op_webgpu_render_pass_end_pass,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_set_bind_group",
       render_pass::op_webgpu_render_pass_set_bind_group,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_push_debug_group",
       render_pass::op_webgpu_render_pass_push_debug_group,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_pop_debug_group",
       render_pass::op_webgpu_render_pass_pop_debug_group,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_insert_debug_marker",
       render_pass::op_webgpu_render_pass_insert_debug_marker,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_set_pipeline",
       render_pass::op_webgpu_render_pass_set_pipeline,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_set_index_buffer",
       render_pass::op_webgpu_render_pass_set_index_buffer,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_set_vertex_buffer",
       render_pass::op_webgpu_render_pass_set_vertex_buffer,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_draw",
       render_pass::op_webgpu_render_pass_draw,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_draw_indexed",
       render_pass::op_webgpu_render_pass_draw_indexed,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_draw_indirect",
       render_pass::op_webgpu_render_pass_draw_indirect,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_pass_draw_indexed_indirect",
       render_pass::op_webgpu_render_pass_draw_indexed_indirect,
@@ -284,42 +272,42 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
   }
   {
     // compute_pass
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_compute_pass_set_pipeline",
       compute_pass::op_webgpu_compute_pass_set_pipeline,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_compute_pass_dispatch",
       compute_pass::op_webgpu_compute_pass_dispatch,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_compute_pass_dispatch_indirect",
       compute_pass::op_webgpu_compute_pass_dispatch_indirect,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_compute_pass_end_pass",
       compute_pass::op_webgpu_compute_pass_end_pass,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_compute_pass_set_bind_group",
       compute_pass::op_webgpu_compute_pass_set_bind_group,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_compute_pass_push_debug_group",
       compute_pass::op_webgpu_compute_pass_push_debug_group,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_compute_pass_pop_debug_group",
       compute_pass::op_webgpu_compute_pass_pop_debug_group,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_compute_pass_insert_debug_marker",
       compute_pass::op_webgpu_compute_pass_insert_debug_marker,
@@ -327,62 +315,62 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
   }
   {
     // bundle
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_create_render_bundle_encoder",
       bundle::op_webgpu_create_render_bundle_encoder,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_bundle_encoder_finish",
       bundle::op_webgpu_render_bundle_encoder_finish,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_bundle_encoder_set_bind_group",
       bundle::op_webgpu_render_bundle_encoder_set_bind_group,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_bundle_encoder_push_debug_group",
       bundle::op_webgpu_render_bundle_encoder_push_debug_group,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_bundle_encoder_pop_debug_group",
       bundle::op_webgpu_render_bundle_encoder_pop_debug_group,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_bundle_encoder_insert_debug_marker",
       bundle::op_webgpu_render_bundle_encoder_insert_debug_marker,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_bundle_encoder_set_pipeline",
       bundle::op_webgpu_render_bundle_encoder_set_pipeline,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_bundle_encoder_set_index_buffer",
       bundle::op_webgpu_render_bundle_encoder_set_index_buffer,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_bundle_encoder_set_vertex_buffer",
       bundle::op_webgpu_render_bundle_encoder_set_vertex_buffer,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_bundle_encoder_draw",
       bundle::op_webgpu_render_bundle_encoder_draw,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_bundle_encoder_draw_indexed",
       bundle::op_webgpu_render_bundle_encoder_draw_indexed,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_render_bundle_encoder_draw_indirect",
       bundle::op_webgpu_render_bundle_encoder_draw_indirect,
@@ -390,17 +378,17 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
   }
   {
     // queue
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_queue_submit",
       queue::op_webgpu_queue_submit,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_write_buffer",
       queue::op_webgpu_write_buffer,
     );
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_write_texture",
       queue::op_webgpu_write_texture,
@@ -408,7 +396,7 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
   }
   {
     // shader
-    super::reg_json_sync(
+    super::reg_sync(
       rt,
       "op_webgpu_create_shader_module",
       shader::op_webgpu_create_shader_module,
diff --git a/runtime/ops/websocket.rs b/runtime/ops/websocket.rs
index 1563961d7..1c44f8b80 100644
--- a/runtime/ops/websocket.rs
+++ b/runtime/ops/websocket.rs
@@ -21,13 +21,13 @@ pub fn init(
       state.put::<WsCaData>(WsCaData(ca_data));
     }
   }
-  super::reg_json_sync(
+  super::reg_sync(
     rt,
     "op_ws_check_permission",
     op_ws_check_permission::<Permissions>,
   );
-  super::reg_json_async(rt, "op_ws_create", op_ws_create::<Permissions>);
-  super::reg_json_async(rt, "op_ws_send", op_ws_send);
-  super::reg_json_async(rt, "op_ws_close", op_ws_close);
-  super::reg_json_async(rt, "op_ws_next_event", op_ws_next_event);
+  super::reg_async(rt, "op_ws_create", op_ws_create::<Permissions>);
+  super::reg_async(rt, "op_ws_send", op_ws_send);
+  super::reg_async(rt, "op_ws_close", op_ws_close);
+  super::reg_async(rt, "op_ws_next_event", op_ws_next_event);
 }
diff --git a/runtime/ops/worker_host.rs b/runtime/ops/worker_host.rs
index 2f297fb08..92de420e3 100644
--- a/runtime/ops/worker_host.rs
+++ b/runtime/ops/worker_host.rs
@@ -80,15 +80,11 @@ pub fn init(
     let create_module_loader = CreateWebWorkerCbHolder(create_web_worker_cb);
     state.put::<CreateWebWorkerCbHolder>(create_module_loader);
   }
-  super::reg_json_sync(rt, "op_create_worker", op_create_worker);
-  super::reg_json_sync(
-    rt,
-    "op_host_terminate_worker",
-    op_host_terminate_worker,
-  );
-  super::reg_json_sync(rt, "op_host_post_message", op_host_post_message);
-  super::reg_json_async(rt, "op_host_get_message", op_host_get_message);
-  super::reg_json_sync(
+  super::reg_sync(rt, "op_create_worker", op_create_worker);
+  super::reg_sync(rt, "op_host_terminate_worker", op_host_terminate_worker);
+  super::reg_sync(rt, "op_host_post_message", op_host_post_message);
+  super::reg_async(rt, "op_host_get_message", op_host_get_message);
+  super::reg_sync(
     rt,
     "op_host_unhandled_error",
     move |_state, message: String, _zero_copy| {