refactor(deno): remove concept of bin & json ops (#10145)

44 files changed, 333 insertions, 389 deletions

diff --git a/runtime/js/11_timers.js b/runtime/js/11_timers.js
index eef1d39b2..cfd9ad72d 100644
--- a/runtime/js/11_timers.js
+++ b/runtime/js/11_timers.js
@@ -6,23 +6,23 @@
   const core = window.Deno.core;
 
   function opStopGlobalTimer() {
-    core.jsonOpSync("op_global_timer_stop");
+    core.opSync("op_global_timer_stop");
   }
 
   function opStartGlobalTimer(timeout) {
-    return core.jsonOpSync("op_global_timer_start", timeout);
+    return core.opSync("op_global_timer_start", timeout);
   }
 
   async function opWaitGlobalTimer() {
-    await core.jsonOpAsync("op_global_timer");
+    await core.opAsync("op_global_timer");
   }
 
   function opNow() {
-    return core.jsonOpSync("op_now");
+    return core.opSync("op_now");
   }
 
   function sleepSync(millis = 0) {
-    return core.jsonOpSync("op_sleep_sync", millis);
+    return core.opSync("op_sleep_sync", millis);
   }
 
   // Derived from https://github.com/vadimg/js_bintrees. MIT Licensed.
diff --git a/runtime/js/11_workers.js b/runtime/js/11_workers.js
index b11195713..2c602ab60 100644
--- a/runtime/js/11_workers.js
+++ b/runtime/js/11_workers.js
@@ -17,7 +17,7 @@
     permissions,
     name,
   ) {
-    return core.jsonOpSync("op_create_worker", {
+    return core.opSync("op_create_worker", {
       hasSourceCode,
       name,
       permissions,
@@ -28,15 +28,15 @@
   }
 
   function hostTerminateWorker(id) {
-    core.jsonOpSync("op_host_terminate_worker", id);
+    core.opSync("op_host_terminate_worker", id);
   }
 
   function hostPostMessage(id, data) {
-    core.jsonOpSync("op_host_post_message", id, data);
+    core.opSync("op_host_post_message", id, data);
   }
 
   function hostGetMessage(id) {
-    return core.jsonOpAsync("op_host_get_message", id);
+    return core.opAsync("op_host_get_message", id);
   }
 
   const encoder = new TextEncoder();
@@ -268,7 +268,7 @@
             if (globalThis instanceof Window) {
               throw new Error("Unhandled error event reached main worker.");
             } else {
-              core.jsonOpSync(
+              core.opSync(
                 "op_host_unhandled_error",
                 event.error.message,
               );
@@ -287,7 +287,7 @@
             if (globalThis instanceof Window) {
               throw new Error("Unhandled error event reached main worker.");
             } else {
-              core.jsonOpSync(
+              core.opSync(
                 "op_host_unhandled_error",
                 event.error.message,
               );
diff --git a/runtime/js/12_io.js b/runtime/js/12_io.js
index a6b6aeebd..8df3de92f 100644
--- a/runtime/js/12_io.js
+++ b/runtime/js/12_io.js
@@ -81,7 +81,7 @@
       return 0;
     }
 
-    const nread = core.binOpSync("op_read_sync", rid, buffer);
+    const nread = core.opSync("op_read_sync", rid, buffer);
 
     return nread === 0 ? null : nread;
   }
@@ -94,17 +94,17 @@
       return 0;
     }
 
-    const nread = await core.binOpAsync("op_read_async", rid, buffer);
+    const nread = await core.opAsync("op_read_async", rid, buffer);
 
     return nread === 0 ? null : nread;
   }
 
   function writeSync(rid, data) {
-    return core.binOpSync("op_write_sync", rid, data);
+    return core.opSync("op_write_sync", rid, data);
   }
 
   async function write(rid, data) {
-    return await core.binOpAsync("op_write_async", rid, data);
+    return await core.opAsync("op_write_async", rid, data);
   }
 
   const READ_PER_ITER = 32 * 1024;
diff --git a/runtime/js/30_fs.js b/runtime/js/30_fs.js
index af2aebd3e..72126e6bb 100644
--- a/runtime/js/30_fs.js
+++ b/runtime/js/30_fs.js
@@ -7,11 +7,11 @@
   const build = window.__bootstrap.build.build;
 
   function chmodSync(path, mode) {
-    core.jsonOpSync("op_chmod_sync", { path: pathFromURL(path), mode });
+    core.opSync("op_chmod_sync", { path: pathFromURL(path), mode });
   }
 
   async function chmod(path, mode) {
-    await core.jsonOpAsync("op_chmod_async", { path: pathFromURL(path), mode });
+    await core.opAsync("op_chmod_async", { path: pathFromURL(path), mode });
   }
 
   function chownSync(
@@ -19,7 +19,7 @@
     uid,
     gid,
   ) {
-    core.jsonOpSync("op_chown_sync", { path: pathFromURL(path), uid, gid });
+    core.opSync("op_chown_sync", { path: pathFromURL(path), uid, gid });
   }
 
   async function chown(
@@ -27,7 +27,7 @@
     uid,
     gid,
   ) {
-    await core.jsonOpAsync(
+    await core.opAsync(
       "op_chown_async",
       { path: pathFromURL(path), uid, gid },
     );
@@ -37,7 +37,7 @@
     fromPath,
     toPath,
   ) {
-    core.jsonOpSync("op_copy_file_sync", {
+    core.opSync("op_copy_file_sync", {
       from: pathFromURL(fromPath),
       to: pathFromURL(toPath),
     });
@@ -47,34 +47,34 @@
     fromPath,
     toPath,
   ) {
-    await core.jsonOpAsync("op_copy_file_async", {
+    await core.opAsync("op_copy_file_async", {
       from: pathFromURL(fromPath),
       to: pathFromURL(toPath),
     });
   }
 
   function cwd() {
-    return core.jsonOpSync("op_cwd");
+    return core.opSync("op_cwd");
   }
 
   function chdir(directory) {
-    core.jsonOpSync("op_chdir", directory);
+    core.opSync("op_chdir", directory);
   }
 
   function makeTempDirSync(options = {}) {
-    return core.jsonOpSync("op_make_temp_dir_sync", options);
+    return core.opSync("op_make_temp_dir_sync", options);
   }
 
   function makeTempDir(options = {}) {
-    return core.jsonOpAsync("op_make_temp_dir_async", options);
+    return core.opAsync("op_make_temp_dir_async", options);
   }
 
   function makeTempFileSync(options = {}) {
-    return core.jsonOpSync("op_make_temp_file_sync", options);
+    return core.opSync("op_make_temp_file_sync", options);
   }
 
   function makeTempFile(options = {}) {
-    return core.jsonOpAsync("op_make_temp_file_async", options);
+    return core.opAsync("op_make_temp_file_async", options);
   }
 
   function mkdirArgs(path, options) {
@@ -91,24 +91,24 @@
   }
 
   function mkdirSync(path, options) {
-    core.jsonOpSync("op_mkdir_sync", mkdirArgs(path, options));
+    core.opSync("op_mkdir_sync", mkdirArgs(path, options));
   }
 
   async function mkdir(
     path,
     options,
   ) {
-    await core.jsonOpAsync("op_mkdir_async", mkdirArgs(path, options));
+    await core.opAsync("op_mkdir_async", mkdirArgs(path, options));
   }
 
   function readDirSync(path) {
-    return core.jsonOpSync("op_read_dir_sync", pathFromURL(path))[
+    return core.opSync("op_read_dir_sync", pathFromURL(path))[
       Symbol.iterator
     ]();
   }
 
   function readDir(path) {
-    const array = core.jsonOpAsync(
+    const array = core.opAsync(
       "op_read_dir_async",
       pathFromURL(path),
     );
@@ -120,26 +120,26 @@
   }
 
   function readLinkSync(path) {
-    return core.jsonOpSync("op_read_link_sync", pathFromURL(path));
+    return core.opSync("op_read_link_sync", pathFromURL(path));
   }
 
   function readLink(path) {
-    return core.jsonOpAsync("op_read_link_async", pathFromURL(path));
+    return core.opAsync("op_read_link_async", pathFromURL(path));
   }
 
   function realPathSync(path) {
-    return core.jsonOpSync("op_realpath_sync", path);
+    return core.opSync("op_realpath_sync", path);
   }
 
   function realPath(path) {
-    return core.jsonOpAsync("op_realpath_async", path);
+    return core.opAsync("op_realpath_async", path);
   }
 
   function removeSync(
     path,
     options = {},
   ) {
-    core.jsonOpSync("op_remove_sync", {
+    core.opSync("op_remove_sync", {
       path: pathFromURL(path),
       recursive: !!options.recursive,
     });
@@ -149,18 +149,18 @@
     path,
     options = {},
   ) {
-    await core.jsonOpAsync("op_remove_async", {
+    await core.opAsync("op_remove_async", {
       path: pathFromURL(path),
       recursive: !!options.recursive,
     });
   }
 
   function renameSync(oldpath, newpath) {
-    core.jsonOpSync("op_rename_sync", { oldpath, newpath });
+    core.opSync("op_rename_sync", { oldpath, newpath });
   }
 
   async function rename(oldpath, newpath) {
-    await core.jsonOpAsync("op_rename_async", { oldpath, newpath });
+    await core.opAsync("op_rename_async", { oldpath, newpath });
   }
 
   function parseFileInfo(response) {
@@ -189,15 +189,15 @@
   }
 
   function fstatSync(rid) {
-    return parseFileInfo(core.jsonOpSync("op_fstat_sync", rid));
+    return parseFileInfo(core.opSync("op_fstat_sync", rid));
   }
 
   async function fstat(rid) {
-    return parseFileInfo(await core.jsonOpAsync("op_fstat_async", rid));
+    return parseFileInfo(await core.opAsync("op_fstat_async", rid));
   }
 
   async function lstat(path) {
-    const res = await core.jsonOpAsync("op_stat_async", {
+    const res = await core.opAsync("op_stat_async", {
       path: pathFromURL(path),
       lstat: true,
     });
@@ -205,7 +205,7 @@
   }
 
   function lstatSync(path) {
-    const res = core.jsonOpSync("op_stat_sync", {
+    const res = core.opSync("op_stat_sync", {
       path: pathFromURL(path),
       lstat: true,
     });
@@ -213,7 +213,7 @@
   }
 
   async function stat(path) {
-    const res = await core.jsonOpAsync("op_stat_async", {
+    const res = await core.opAsync("op_stat_async", {
       path: pathFromURL(path),
       lstat: false,
     });
@@ -221,7 +221,7 @@
   }
 
   function statSync(path) {
-    const res = core.jsonOpSync("op_stat_sync", {
+    const res = core.opSync("op_stat_sync", {
       path: pathFromURL(path),
       lstat: false,
     });
@@ -237,31 +237,31 @@
   }
 
   function ftruncateSync(rid, len) {
-    core.jsonOpSync("op_ftruncate_sync", { rid, len: coerceLen(len) });
+    core.opSync("op_ftruncate_sync", { rid, len: coerceLen(len) });
   }
 
   async function ftruncate(rid, len) {
-    await core.jsonOpAsync("op_ftruncate_async", { rid, len: coerceLen(len) });
+    await core.opAsync("op_ftruncate_async", { rid, len: coerceLen(len) });
   }
 
   function truncateSync(path, len) {
-    core.jsonOpSync("op_truncate_sync", { path, len: coerceLen(len) });
+    core.opSync("op_truncate_sync", { path, len: coerceLen(len) });
   }
 
   async function truncate(path, len) {
-    await core.jsonOpAsync("op_truncate_async", { path, len: coerceLen(len) });
+    await core.opAsync("op_truncate_async", { path, len: coerceLen(len) });
   }
 
   function umask(mask) {
-    return core.jsonOpSync("op_umask", mask);
+    return core.opSync("op_umask", mask);
   }
 
   function linkSync(oldpath, newpath) {
-    core.jsonOpSync("op_link_sync", { oldpath, newpath });
+    core.opSync("op_link_sync", { oldpath, newpath });
   }
 
   async function link(oldpath, newpath) {
-    await core.jsonOpAsync("op_link_async", { oldpath, newpath });
+    await core.opAsync("op_link_async", { oldpath, newpath });
   }
 
   function toUnixTimeFromEpoch(value) {
@@ -290,7 +290,7 @@
     atime,
     mtime,
   ) {
-    core.jsonOpSync("op_futime_sync", {
+    core.opSync("op_futime_sync", {
       rid,
       atime: toUnixTimeFromEpoch(atime),
       mtime: toUnixTimeFromEpoch(mtime),
@@ -302,7 +302,7 @@
     atime,
     mtime,
   ) {
-    await core.jsonOpAsync("op_futime_async", {
+    await core.opAsync("op_futime_async", {
       rid,
       atime: toUnixTimeFromEpoch(atime),
       mtime: toUnixTimeFromEpoch(mtime),
@@ -314,7 +314,7 @@
     atime,
     mtime,
   ) {
-    core.jsonOpSync("op_utime_sync", {
+    core.opSync("op_utime_sync", {
       path,
       atime: toUnixTimeFromEpoch(atime),
       mtime: toUnixTimeFromEpoch(mtime),
@@ -326,7 +326,7 @@
     atime,
     mtime,
   ) {
-    await core.jsonOpAsync("op_utime_async", {
+    await core.opAsync("op_utime_async", {
       path,
       atime: toUnixTimeFromEpoch(atime),
       mtime: toUnixTimeFromEpoch(mtime),
@@ -338,7 +338,7 @@
     newpath,
     options,
   ) {
-    core.jsonOpSync("op_symlink_sync", { oldpath, newpath, options });
+    core.opSync("op_symlink_sync", { oldpath, newpath, options });
   }
 
   async function symlink(
@@ -346,23 +346,23 @@
     newpath,
     options,
   ) {
-    await core.jsonOpAsync("op_symlink_async", { oldpath, newpath, options });
+    await core.opAsync("op_symlink_async", { oldpath, newpath, options });
   }
 
   function fdatasyncSync(rid) {
-    core.jsonOpSync("op_fdatasync_sync", rid);
+    core.opSync("op_fdatasync_sync", rid);
   }
 
   async function fdatasync(rid) {
-    await core.jsonOpAsync("op_fdatasync_async", rid);
+    await core.opAsync("op_fdatasync_async", rid);
   }
 
   function fsyncSync(rid) {
-    core.jsonOpSync("op_fsync_sync", rid);
+    core.opSync("op_fsync_sync", rid);
   }
 
   async function fsync(rid) {
-    await core.jsonOpAsync("op_fsync_async", rid);
+    await core.opAsync("op_fsync_async", rid);
   }
 
   window.__bootstrap.fs = {
diff --git a/runtime/js/30_metrics.js b/runtime/js/30_metrics.js
index ed062fce3..ecc1cfc64 100644
--- a/runtime/js/30_metrics.js
+++ b/runtime/js/30_metrics.js
@@ -5,7 +5,7 @@
   const core = window.Deno.core;
 
   function metrics() {
-    const { combined, ops } = core.jsonOpSync("op_metrics");
+    const { combined, ops } = core.opSync("op_metrics");
     if (ops) {
       combined.ops = ops;
     }
diff --git a/runtime/js/30_net.js b/runtime/js/30_net.js
index 56fb94f26..2d4b1e48e 100644
--- a/runtime/js/30_net.js
+++ b/runtime/js/30_net.js
@@ -7,23 +7,23 @@
   const { read, write } = window.__bootstrap.io;
 
   function shutdown(rid) {
-    return core.jsonOpAsync("op_shutdown", rid);
+    return core.opAsync("op_shutdown", rid);
   }
 
   function opAccept(rid, transport) {
-    return core.jsonOpAsync("op_accept", { rid, transport });
+    return core.opAsync("op_accept", { rid, transport });
   }
 
   function opListen(args) {
-    return core.jsonOpSync("op_listen", args);
+    return core.opSync("op_listen", args);
   }
 
   function opConnect(args) {
-    return core.jsonOpAsync("op_connect", args);
+    return core.opAsync("op_connect", args);
   }
 
   function opReceive(rid, transport, zeroCopy) {
-    return core.jsonOpAsync(
+    return core.opAsync(
       "op_datagram_receive",
       { rid, transport },
       zeroCopy,
@@ -31,11 +31,11 @@
   }
 
   function opSend(args, zeroCopy) {
-    return core.jsonOpAsync("op_datagram_send", args, zeroCopy);
+    return core.opAsync("op_datagram_send", args, zeroCopy);
   }
 
   function resolveDns(query, recordType, options) {
-    return core.jsonOpAsync("op_dns_resolve", { query, recordType, options });
+    return core.opAsync("op_dns_resolve", { query, recordType, options });
   }
 
   class Conn {
diff --git a/runtime/js/30_os.js b/runtime/js/30_os.js
index 0ce831775..2d11d6fde 100644
--- a/runtime/js/30_os.js
+++ b/runtime/js/30_os.js
@@ -5,23 +5,23 @@
   const core = window.Deno.core;
 
   function loadavg() {
-    return core.jsonOpSync("op_loadavg");
+    return core.opSync("op_loadavg");
   }
 
   function hostname() {
-    return core.jsonOpSync("op_hostname");
+    return core.opSync("op_hostname");
   }
 
   function osRelease() {
-    return core.jsonOpSync("op_os_release");
+    return core.opSync("op_os_release");
   }
 
   function systemMemoryInfo() {
-    return core.jsonOpSync("op_system_memory_info");
+    return core.opSync("op_system_memory_info");
   }
 
   function systemCpuInfo() {
-    const { cores, speed } = core.jsonOpSync("op_system_cpu_info");
+    const { cores, speed } = core.opSync("op_system_cpu_info");
     // Map nulls to undefined for compatibility
     return {
       cores: cores ?? undefined,
@@ -49,33 +49,33 @@
       return;
     }
 
-    core.jsonOpSync("op_exit", code);
+    core.opSync("op_exit", code);
     throw new Error("Code not reachable");
   }
 
   function setEnv(key, value) {
-    core.jsonOpSync("op_set_env", { key, value });
+    core.opSync("op_set_env", { key, value });
   }
 
   function getEnv(key) {
-    return core.jsonOpSync("op_get_env", key) ?? undefined;
+    return core.opSync("op_get_env", key) ?? undefined;
   }
 
   function deleteEnv(key) {
-    core.jsonOpSync("op_delete_env", key);
+    core.opSync("op_delete_env", key);
   }
 
   const env = {
     get: getEnv,
     toObject() {
-      return core.jsonOpSync("op_env");
+      return core.opSync("op_env");
     },
     set: setEnv,
     delete: deleteEnv,
   };
 
   function execPath() {
-    return core.jsonOpSync("op_exec_path");
+    return core.opSync("op_exec_path");
   }
 
   window.__bootstrap.os = {
diff --git a/runtime/js/40_compiler_api.js b/runtime/js/40_compiler_api.js
index cce12f2f8..b30ffc5d5 100644
--- a/runtime/js/40_compiler_api.js
+++ b/runtime/js/40_compiler_api.js
@@ -39,7 +39,7 @@
    * @returns {Promise<OpEmitResponse>}
    */
   function opEmit(request) {
-    return core.jsonOpAsync("op_emit", request);
+    return core.opAsync("op_emit", request);
   }
 
   /**
diff --git a/runtime/js/40_error_stack.js b/runtime/js/40_error_stack.js
index 9bc6567a0..e73975044 100644
--- a/runtime/js/40_error_stack.js
+++ b/runtime/js/40_error_stack.js
@@ -5,11 +5,11 @@
   const core = window.Deno.core;
 
   function opFormatDiagnostics(diagnostics) {
-    return core.jsonOpSync("op_format_diagnostic", diagnostics);
+    return core.opSync("op_format_diagnostic", diagnostics);
   }
 
   function opApplySourceMap(location) {
-    const res = core.jsonOpSync("op_apply_source_map", location);
+    const res = core.opSync("op_apply_source_map", location);
     return {
       fileName: res.fileName,
       lineNumber: res.lineNumber,
diff --git a/runtime/js/40_files.js b/runtime/js/40_files.js
index d552b4ba5..82cf19ffc 100644
--- a/runtime/js/40_files.js
+++ b/runtime/js/40_files.js
@@ -12,7 +12,7 @@
     offset,
     whence,
   ) {
-    return core.jsonOpSync("op_seek_sync", { rid, offset, whence });
+    return core.opSync("op_seek_sync", { rid, offset, whence });
   }
 
   function seek(
@@ -20,7 +20,7 @@
     offset,
     whence,
   ) {
-    return core.jsonOpAsync("op_seek_async", { rid, offset, whence });
+    return core.opAsync("op_seek_async", { rid, offset, whence });
   }
 
   function openSync(
@@ -29,7 +29,7 @@
   ) {
     checkOpenOptions(options);
     const mode = options?.mode;
-    const rid = core.jsonOpSync(
+    const rid = core.opSync(
       "op_open_sync",
       { path: pathFromURL(path), options, mode },
     );
@@ -43,7 +43,7 @@
   ) {
     checkOpenOptions(options);
     const mode = options?.mode;
-    const rid = await core.jsonOpAsync(
+    const rid = await core.opAsync(
       "op_open_async",
       { path: pathFromURL(path), options, mode },
     );
diff --git a/runtime/js/40_fs_events.js b/runtime/js/40_fs_events.js
index 06ad3a29c..a1a9877b4 100644
--- a/runtime/js/40_fs_events.js
+++ b/runtime/js/40_fs_events.js
@@ -10,7 +10,7 @@
 
     constructor(paths, options) {
       const { recursive } = options;
-      this.#rid = core.jsonOpSync("op_fs_events_open", { recursive, paths });
+      this.#rid = core.opSync("op_fs_events_open", { recursive, paths });
     }
 
     get rid() {
@@ -19,7 +19,7 @@
 
     async next() {
       try {
-        const value = await core.jsonOpAsync("op_fs_events_poll", this.rid);
+        const value = await core.opAsync("op_fs_events_poll", this.rid);
         return value
           ? { value, done: false }
           : { value: undefined, done: true };
diff --git a/runtime/js/40_http.js b/runtime/js/40_http.js
index d9dff7b52..4a2dcdf4a 100644
--- a/runtime/js/40_http.js
+++ b/runtime/js/40_http.js
@@ -10,7 +10,7 @@
   const { ReadableStream } = window.__bootstrap.streams;
 
   function serveHttp(conn) {
-    const rid = Deno.core.jsonOpSync("op_http_start", conn.rid);
+    const rid = Deno.core.opSync("op_http_start", conn.rid);
     return new HttpConn(rid);
   }
 
@@ -30,7 +30,7 @@
     async nextRequest() {
       let nextRequest;
       try {
-        nextRequest = await Deno.core.jsonOpAsync(
+        nextRequest = await Deno.core.opAsync(
           "op_http_request_next",
           this.#rid,
         );
@@ -88,7 +88,7 @@
   }
 
   function readRequest(requestRid, zeroCopyBuf) {
-    return Deno.core.jsonOpAsync(
+    return Deno.core.opAsync(
       "op_http_request_read",
       requestRid,
       zeroCopyBuf,
@@ -129,7 +129,7 @@
         zeroCopyBuf = null;
       }
 
-      const responseBodyRid = Deno.core.jsonOpSync("op_http_response", [
+      const responseBodyRid = Deno.core.opSync("op_http_response", [
         responseSenderRid,
         resp.status ?? 200,
         flattenHeaders(resp.headers),
@@ -149,7 +149,7 @@
             chunk.byteOffset,
             chunk.byteLength,
           );
-          await Deno.core.jsonOpAsync(
+          await Deno.core.opAsync(
             "op_http_response_write",
             responseBodyRid,
             data,
@@ -158,7 +158,7 @@
 
         // Once all chunks are sent, and the request body is closed, we can close
         // the response body.
-        await Deno.core.jsonOpAsync("op_http_response_close", responseBodyRid);
+        await Deno.core.opAsync("op_http_response_close", responseBodyRid);
       }
     };
   }
diff --git a/runtime/js/40_permissions.js b/runtime/js/40_permissions.js
index 7a81ca425..dd4ce5533 100644
--- a/runtime/js/40_permissions.js
+++ b/runtime/js/40_permissions.js
@@ -31,7 +31,7 @@
    * @returns {Deno.PermissionState}
    */
   function opQuery(desc) {
-    return core.jsonOpSync("op_query_permission", desc);
+    return core.opSync("op_query_permission", desc);
   }
 
   /**
@@ -39,7 +39,7 @@
    * @returns {Deno.PermissionState}
    */
   function opRevoke(desc) {
-    return core.jsonOpSync("op_revoke_permission", desc);
+    return core.opSync("op_revoke_permission", desc);
   }
 
   /**
@@ -47,7 +47,7 @@
    * @returns {Deno.PermissionState}
    */
   function opRequest(desc) {
-    return core.jsonOpSync("op_request_permission", desc);
+    return core.opSync("op_request_permission", desc);
   }
 
   class PermissionStatus extends EventTarget {
diff --git a/runtime/js/40_plugins.js b/runtime/js/40_plugins.js
index 5ebcfddad..e9a3142b4 100644
--- a/runtime/js/40_plugins.js
+++ b/runtime/js/40_plugins.js
@@ -5,7 +5,7 @@
   const core = window.Deno.core;
 
   function openPlugin(filename) {
-    return core.jsonOpSync("op_open_plugin", filename);
+    return core.opSync("op_open_plugin", filename);
   }
 
   window.__bootstrap.plugins = {
diff --git a/runtime/js/40_process.js b/runtime/js/40_process.js
index a93818b95..91e37701a 100644
--- a/runtime/js/40_process.js
+++ b/runtime/js/40_process.js
@@ -8,16 +8,16 @@
   const { assert, pathFromURL } = window.__bootstrap.util;
 
   function opKill(pid, signo) {
-    core.jsonOpSync("op_kill", { pid, signo });
+    core.opSync("op_kill", { pid, signo });
   }
 
   function opRunStatus(rid) {
-    return core.jsonOpAsync("op_run_status", rid);
+    return core.opAsync("op_run_status", rid);
   }
 
   function opRun(request) {
     assert(request.cmd.length > 0);
-    return core.jsonOpSync("op_run", request);
+    return core.opSync("op_run", request);
   }
 
   async function runStatus(rid) {
diff --git a/runtime/js/40_signals.js b/runtime/js/40_signals.js
index e222a9199..dfc604759 100644
--- a/runtime/js/40_signals.js
+++ b/runtime/js/40_signals.js
@@ -7,15 +7,15 @@
   const { errors } = window.__bootstrap.errors;
 
   function bindSignal(signo) {
-    return core.jsonOpSync("op_signal_bind", signo);
+    return core.opSync("op_signal_bind", signo);
   }
 
   function pollSignal(rid) {
-    return core.jsonOpAsync("op_signal_poll", rid);
+    return core.opAsync("op_signal_poll", rid);
   }
 
   function unbindSignal(rid) {
-    core.jsonOpSync("op_signal_unbind", rid);
+    core.opSync("op_signal_unbind", rid);
   }
 
   // From `kill -l`
diff --git a/runtime/js/40_tls.js b/runtime/js/40_tls.js
index e11754b0d..4fafe9079 100644
--- a/runtime/js/40_tls.js
+++ b/runtime/js/40_tls.js
@@ -8,19 +8,19 @@
   function opConnectTls(
     args,
   ) {
-    return core.jsonOpAsync("op_connect_tls", args);
+    return core.opAsync("op_connect_tls", args);
   }
 
   function opAcceptTLS(rid) {
-    return core.jsonOpAsync("op_accept_tls", rid);
+    return core.opAsync("op_accept_tls", rid);
   }
 
   function opListenTls(args) {
-    return core.jsonOpSync("op_listen_tls", args);
+    return core.opSync("op_listen_tls", args);
   }
 
   function opStartTls(args) {
-    return core.jsonOpAsync("op_start_tls", args);
+    return core.opAsync("op_start_tls", args);
   }
 
   async function connectTls({
diff --git a/runtime/js/40_tty.js b/runtime/js/40_tty.js
index 9b23b1ec1..e76d7d90e 100644
--- a/runtime/js/40_tty.js
+++ b/runtime/js/40_tty.js
@@ -5,11 +5,11 @@
   const core = window.Deno.core;
 
   function consoleSize(rid) {
-    return core.jsonOpSync("op_console_size", rid);
+    return core.opSync("op_console_size", rid);
   }
 
   function isatty(rid) {
-    return core.jsonOpSync("op_isatty", rid);
+    return core.opSync("op_isatty", rid);
   }
 
   const DEFAULT_SET_RAW_OPTIONS = {
@@ -18,7 +18,7 @@
 
   function setRaw(rid, mode, options = {}) {
     const rOptions = { ...DEFAULT_SET_RAW_OPTIONS, ...options };
-    core.jsonOpSync("op_set_raw", { rid, mode, options: rOptions });
+    core.opSync("op_set_raw", { rid, mode, options: rOptions });
   }
 
   window.__bootstrap.tty = {
diff --git a/runtime/js/99_main.js b/runtime/js/99_main.js
index 7f24e10cd..977755007 100644
--- a/runtime/js/99_main.js
+++ b/runtime/js/99_main.js
@@ -129,15 +129,15 @@ delete Object.prototype.__proto__;
   }
 
   function opPostMessage(data) {
-    core.jsonOpSync("op_worker_post_message", null, data);
+    core.opSync("op_worker_post_message", null, data);
   }
 
   function opCloseWorker() {
-    core.jsonOpSync("op_worker_close");
+    core.opSync("op_worker_close");
   }
 
   function opMainModule() {
-    return core.jsonOpSync("op_main_module");
+    return core.opSync("op_main_module");
   }
 
   function runtimeStart(runtimeOptions, source) {
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| {
diff --git a/runtime/web_worker.rs b/runtime/web_worker.rs
index c30b715e4..68bbe1a5d 100644
--- a/runtime/web_worker.rs
+++ b/runtime/web_worker.rs
@@ -231,8 +231,8 @@ impl WebWorker {
         Some(sender),
         options.create_web_worker_cb.clone(),
       );
-      ops::reg_json_sync(js_runtime, "op_close", deno_core::op_close);
-      ops::reg_json_sync(js_runtime, "op_resources", deno_core::op_resources);
+      ops::reg_sync(js_runtime, "op_close", deno_core::op_close);
+      ops::reg_sync(js_runtime, "op_resources", deno_core::op_resources);
       ops::url::init(js_runtime);
       ops::file::init(
         js_runtime,
diff --git a/runtime/worker.rs b/runtime/worker.rs
index 5db542b42..253725533 100644
--- a/runtime/worker.rs
+++ b/runtime/worker.rs
@@ -128,8 +128,8 @@ impl MainWorker {
         options.create_web_worker_cb.clone(),
       );
       ops::crypto::init(js_runtime, options.seed);
-      ops::reg_json_sync(js_runtime, "op_close", deno_core::op_close);
-      ops::reg_json_sync(js_runtime, "op_resources", deno_core::op_resources);
+      ops::reg_sync(js_runtime, "op_close", deno_core::op_close);
+      ops::reg_sync(js_runtime, "op_resources", deno_core::op_resources);
       ops::url::init(js_runtime);
       ops::file::init(
         js_runtime,