Move JSON ops to deno_core (#7336)

60 files changed, 879 insertions, 1596 deletions

diff --git a/cli/Cargo.toml b/cli/Cargo.toml
index f67158310..224373053 100644
--- a/cli/Cargo.toml
+++ b/cli/Cargo.toml
@@ -45,7 +45,7 @@ futures = "0.3.5"
 filetime = "0.2.12"
 http = "0.2.1"
 idna = "0.2.0"
-indexmap = "1.5.1"
+indexmap = "1.5.2"
 jsonc-parser = "0.14.0"
 lazy_static = "1.4.0"
 libc = "0.2.74"
diff --git a/cli/bench/main.rs b/cli/bench/main.rs
index b2ae59d4f..e8d4b298d 100644
--- a/cli/bench/main.rs
+++ b/cli/bench/main.rs
@@ -11,12 +11,12 @@ use std::{
 mod http;
 mod throughput;
 
-fn read_json(filename: &str) -> Result<serde_json::Value> {
+fn read_json(filename: &str) -> Result<Value> {
   let f = fs::File::open(filename)?;
   Ok(serde_json::from_reader(f)?)
 }
 
-fn write_json(filename: &str, value: &serde_json::Value) -> Result<()> {
+fn write_json(filename: &str, value: &Value) -> Result<()> {
   let f = fs::File::create(filename)?;
   serde_json::to_writer(f, value)?;
   Ok(())
diff --git a/cli/build.rs b/cli/build.rs
index 4b26a24b0..40b803979 100644
--- a/cli/build.rs
+++ b/cli/build.rs
@@ -1,8 +1,11 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 mod op_fetch_asset;
 
 use deno_core::js_check;
+use deno_core::BasicState;
 use deno_core::CoreIsolate;
+use deno_core::OpRegistry;
 use deno_core::StartupData;
 use std::collections::HashMap;
 use std::env;
@@ -28,8 +31,9 @@ fn create_snapshot(
 }
 
 fn create_runtime_snapshot(snapshot_path: &Path, files: Vec<String>) {
-  let runtime_isolate = CoreIsolate::new(StartupData::None, true);
-  create_snapshot(runtime_isolate, snapshot_path, files);
+  let state = BasicState::new();
+  let isolate = CoreIsolate::new(state, StartupData::None, true);
+  create_snapshot(isolate, snapshot_path, files);
 }
 
 fn create_compiler_snapshot(
@@ -37,7 +41,6 @@ fn create_compiler_snapshot(
   files: Vec<String>,
   cwd: &Path,
 ) {
-  let mut runtime_isolate = CoreIsolate::new(StartupData::None, true);
   let mut custom_libs: HashMap<String, PathBuf> = HashMap::new();
   custom_libs
     .insert("lib.deno.web.d.ts".to_string(), deno_web::get_declaration());
@@ -61,11 +64,15 @@ fn create_compiler_snapshot(
     "lib.deno.unstable.d.ts".to_string(),
     cwd.join("dts/lib.deno.unstable.d.ts"),
   );
-  runtime_isolate.register_op(
+
+  let state = BasicState::new();
+  state.register_op(
     "op_fetch_asset",
     op_fetch_asset::op_fetch_asset(custom_libs),
   );
-  create_snapshot(runtime_isolate, snapshot_path, files);
+
+  let isolate = CoreIsolate::new(state, StartupData::None, true);
+  create_snapshot(isolate, snapshot_path, files);
 }
 
 fn ts_version() -> String {
diff --git a/cli/colors.rs b/cli/colors.rs
index 870f7f435..35e9bb5ca 100644
--- a/cli/colors.rs
+++ b/cli/colors.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use regex::Regex;
 use std::env;
 use std::fmt;
diff --git a/cli/deno_dir.rs b/cli/deno_dir.rs
index 49f76c7d2..5bc05f549 100644
--- a/cli/deno_dir.rs
+++ b/cli/deno_dir.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use crate::disk_cache::DiskCache;
 use std::path::PathBuf;
 
diff --git a/cli/diff.rs b/cli/diff.rs
index 121e319f4..cc516d94c 100644
--- a/cli/diff.rs
+++ b/cli/diff.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use crate::colors;
 use dissimilar::{diff as difference, Chunk};
 use std::fmt;
diff --git a/cli/errors.rs b/cli/errors.rs
index 2d7bb1cd6..327bcfb58 100644
--- a/cli/errors.rs
+++ b/cli/errors.rs
@@ -168,7 +168,7 @@ fn get_nix_error_class(error: &nix::Error) -> &'static str {
   }
 }
 
-pub fn get_error_class(e: &ErrBox) -> &'static str {
+pub(crate) fn get_error_class_name(e: &ErrBox) -> &'static str {
   use ErrBox::*;
   match e {
     Simple { class, .. } => Some(*class),
diff --git a/cli/file_fetcher.rs b/cli/file_fetcher.rs
index c5fd78897..8b3ca46a0 100644
--- a/cli/file_fetcher.rs
+++ b/cli/file_fetcher.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use crate::colors;
 use crate::http_cache::HttpCache;
 use crate::http_util;
diff --git a/cli/flags.rs b/cli/flags.rs
index c5d0532a3..835be0041 100644
--- a/cli/flags.rs
+++ b/cli/flags.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use clap::App;
 use clap::AppSettings;
 use clap::Arg;
diff --git a/cli/fs.rs b/cli/fs.rs
index f7781741d..e8d081100 100644
--- a/cli/fs.rs
+++ b/cli/fs.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 pub use deno_core::normalize_path;
 use deno_core::ErrBox;
 use std::env::current_dir;
diff --git a/cli/global_state.rs b/cli/global_state.rs
index daabcf519..cb265d9e5 100644
--- a/cli/global_state.rs
+++ b/cli/global_state.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use crate::deno_dir;
 use crate::file_fetcher::SourceFileFetcher;
 use crate::flags;
diff --git a/cli/http_util.rs b/cli/http_util.rs
index 9fb4ab914..8436b600b 100644
--- a/cli/http_util.rs
+++ b/cli/http_util.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use crate::version;
 use bytes::Bytes;
 use deno_core::ErrBox;
diff --git a/cli/inspector.rs b/cli/inspector.rs
index b4d377cef..9a8693ec7 100644
--- a/cli/inspector.rs
+++ b/cli/inspector.rs
@@ -17,6 +17,7 @@ use futures::stream::FuturesUnordered;
 use futures::task;
 use futures::task::Context;
 use futures::task::Poll;
+use serde_json::Value;
 use std::cell::BorrowMutError;
 use std::cell::RefCell;
 use std::collections::HashMap;
@@ -95,7 +96,7 @@ struct InspectorInfo {
 }
 
 impl InspectorInfo {
-  fn get_json_metadata(&self) -> serde_json::Value {
+  fn get_json_metadata(&self) -> Value {
     json!({
       "description": "deno",
       "devtoolsFrontendUrl": self.get_frontend_url(),
diff --git a/cli/installer.rs b/cli/installer.rs
index 2c2e54248..ac51d75f7 100644
--- a/cli/installer.rs
+++ b/cli/installer.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use crate::flags::Flags;
 use crate::global_state::GlobalState;
 use deno_core::ErrBox;
diff --git a/cli/js.rs b/cli/js.rs
index 763b62aed..8b19ca6ad 100644
--- a/cli/js.rs
+++ b/cli/js.rs
@@ -14,6 +14,7 @@ pub static UNSTABLE_NS_LIB: &str = include_str!("dts/lib.deno.unstable.d.ts");
 #[test]
 fn cli_snapshot() {
   let mut isolate = deno_core::CoreIsolate::new(
+    deno_core::BasicState::new(),
     deno_core::StartupData::Snapshot(deno_core::Snapshot::Static(CLI_SNAPSHOT)),
     false,
   );
@@ -31,6 +32,7 @@ fn cli_snapshot() {
 #[test]
 fn compiler_snapshot() {
   let mut isolate = deno_core::CoreIsolate::new(
+    deno_core::BasicState::new(),
     deno_core::StartupData::Snapshot(deno_core::Snapshot::Static(
       COMPILER_SNAPSHOT,
     )),
diff --git a/cli/lockfile.rs b/cli/lockfile.rs
index 0192c08df..4ac893030 100644
--- a/cli/lockfile.rs
+++ b/cli/lockfile.rs
@@ -1,5 +1,4 @@
 use serde_json::json;
-pub use serde_json::Value;
 use std::collections::BTreeMap;
 use std::io::Result;
 
diff --git a/cli/main.rs b/cli/main.rs
index e6fab71c8..49efbfed5 100644
--- a/cli/main.rs
+++ b/cli/main.rs
@@ -1,5 +1,4 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-#![deny(warnings)]
 
 extern crate dissimilar;
 #[macro_use]
diff --git a/cli/metrics.rs b/cli/metrics.rs
index ea3f90164..43f11cd36 100644
--- a/cli/metrics.rs
+++ b/cli/metrics.rs
@@ -16,22 +16,26 @@ pub struct Metrics {
 }
 
 impl Metrics {
-  fn op_dispatched(&mut self, bytes_sent_control: u64, bytes_sent_data: u64) {
+  fn op_dispatched(
+    &mut self,
+    bytes_sent_control: usize,
+    bytes_sent_data: usize,
+  ) {
     self.ops_dispatched += 1;
-    self.bytes_sent_control += bytes_sent_control;
-    self.bytes_sent_data += bytes_sent_data;
+    self.bytes_sent_control += bytes_sent_control as u64;
+    self.bytes_sent_data += bytes_sent_data as u64;
   }
 
-  fn op_completed(&mut self, bytes_received: u64) {
+  fn op_completed(&mut self, bytes_received: usize) {
     self.ops_completed += 1;
-    self.bytes_received += bytes_received;
+    self.bytes_received += bytes_received as u64;
   }
 
   pub fn op_sync(
     &mut self,
-    bytes_sent_control: u64,
-    bytes_sent_data: u64,
-    bytes_received: u64,
+    bytes_sent_control: usize,
+    bytes_sent_data: usize,
+    bytes_received: usize,
   ) {
     self.ops_dispatched_sync += 1;
     self.op_dispatched(bytes_sent_control, bytes_sent_data);
@@ -41,8 +45,8 @@ impl Metrics {
 
   pub fn op_dispatched_async(
     &mut self,
-    bytes_sent_control: u64,
-    bytes_sent_data: u64,
+    bytes_sent_control: usize,
+    bytes_sent_data: usize,
   ) {
     self.ops_dispatched_async += 1;
     self.op_dispatched(bytes_sent_control, bytes_sent_data)
@@ -50,19 +54,19 @@ impl Metrics {
 
   pub fn op_dispatched_async_unref(
     &mut self,
-    bytes_sent_control: u64,
-    bytes_sent_data: u64,
+    bytes_sent_control: usize,
+    bytes_sent_data: usize,
   ) {
     self.ops_dispatched_async_unref += 1;
     self.op_dispatched(bytes_sent_control, bytes_sent_data)
   }
 
-  pub fn op_completed_async(&mut self, bytes_received: u64) {
+  pub fn op_completed_async(&mut self, bytes_received: usize) {
     self.ops_completed_async += 1;
     self.op_completed(bytes_received);
   }
 
-  pub fn op_completed_async_unref(&mut self, bytes_received: u64) {
+  pub fn op_completed_async_unref(&mut self, bytes_received: usize) {
     self.ops_completed_async_unref += 1;
     self.op_completed(bytes_received);
   }
diff --git a/cli/module_graph.rs b/cli/module_graph.rs
index f7cfe4226..331f45241 100644
--- a/cli/module_graph.rs
+++ b/cli/module_graph.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use crate::checksum;
 use crate::file_fetcher::map_file_extension;
 use crate::file_fetcher::SourceFile;
diff --git a/cli/op_fetch_asset.rs b/cli/op_fetch_asset.rs
index cca085db7..3becc43d7 100644
--- a/cli/op_fetch_asset.rs
+++ b/cli/op_fetch_asset.rs
@@ -2,11 +2,11 @@
 // Note: this module is used both in build.rs and main.rs.
 
 pub use deno_core::v8_set_flags;
-use deno_core::CoreIsolateState;
+use deno_core::BufVec;
 use deno_core::Op;
-use deno_core::ZeroCopyBuf;
 use std::collections::HashMap;
 use std::path::PathBuf;
+use std::rc::Rc;
 
 fn get_asset(name: &str) -> Option<&'static str> {
   macro_rules! inc {
@@ -82,17 +82,15 @@ fn get_asset(name: &str) -> Option<&'static str> {
 
 /// Warning: Returns a non-JSON op dispatcher. Must be manually attached to
 /// CoreIsolate.
-pub fn op_fetch_asset<S: ::std::hash::BuildHasher>(
-  custom_assets: HashMap<String, PathBuf, S>,
-) -> impl Fn(&mut deno_core::CoreIsolateState, &mut [ZeroCopyBuf]) -> Op {
+pub fn op_fetch_asset<H: std::hash::BuildHasher, S>(
+  custom_assets: HashMap<String, PathBuf, H>,
+) -> impl Fn(Rc<S>, BufVec) -> Op {
   for (_, path) in custom_assets.iter() {
     println!("cargo:rerun-if-changed={}", path.display());
   }
-  move |_state: &mut CoreIsolateState,
-        zero_copy_bufs: &mut [ZeroCopyBuf]|
-        -> Op {
-    assert_eq!(zero_copy_bufs.len(), 1, "Invalid number of arguments");
-    let name = std::str::from_utf8(&zero_copy_bufs[0]).unwrap();
+  move |_state: Rc<S>, bufs: BufVec| -> Op {
+    assert_eq!(bufs.len(), 1, "Invalid number of arguments");
+    let name = std::str::from_utf8(&bufs[0]).unwrap();
 
     let asset_code = if let Some(source_code) = get_asset(name) {
       source_code.to_string()
diff --git a/cli/ops/compiler.rs b/cli/ops/compiler.rs
index c35043e2d..0b8379fa3 100644
--- a/cli/ops/compiler.rs
+++ b/cli/ops/compiler.rs
@@ -1,67 +1,27 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{JsonOp, Value};
-use crate::ops::json_op;
+
 use crate::state::State;
-use deno_core::CoreIsolate;
-use deno_core::CoreIsolateState;
-use deno_core::ErrBox;
-use deno_core::ZeroCopyBuf;
+use deno_core::OpRegistry;
 use std::rc::Rc;
 use std::sync::Arc;
 use std::sync::Mutex;
 
-pub fn init(
-  i: &mut CoreIsolate,
-  _s: &Rc<State>,
-  response: Arc<Mutex<Option<String>>>,
-) {
+pub fn init(s: &Rc<State>, response: Arc<Mutex<Option<String>>>) {
   let custom_assets = std::collections::HashMap::new();
   // TODO(ry) use None.
   // TODO(bartlomieju): is this op even required?
-  i.register_op(
+  s.register_op(
     "op_fetch_asset",
     crate::op_fetch_asset::op_fetch_asset(custom_assets),
   );
 
-  i.register_op(
-    "op_compiler_respond",
-    json_op(compiler_op(response, op_compiler_respond)),
-  );
-}
-
-pub fn compiler_op<D>(
-  response: Arc<Mutex<Option<String>>>,
-  dispatcher: D,
-) -> impl Fn(
-  &mut deno_core::CoreIsolateState,
-  Value,
-  &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox>
-where
-  D: Fn(
-    Arc<Mutex<Option<String>>>,
-    Value,
-    &mut [ZeroCopyBuf],
-  ) -> Result<JsonOp, ErrBox>,
-{
-  move |_isolate_state: &mut CoreIsolateState,
-        args: Value,
-        zero_copy: &mut [ZeroCopyBuf]|
-        -> Result<JsonOp, ErrBox> {
-    dispatcher(response.clone(), args, zero_copy)
-  }
-}
-
-fn op_compiler_respond(
-  response: Arc<Mutex<Option<String>>>,
-  args: Value,
-  _zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
-  let mut r = response.lock().unwrap();
-  assert!(
-    r.is_none(),
-    "op_compiler_respond found unexpected existing compiler output"
-  );
-  *r = Some(args.to_string());
-  Ok(JsonOp::Sync(json!({})))
+  s.register_op_json_sync("op_compiler_respond", move |_state, args, _bufs| {
+    let mut response_slot = response.lock().unwrap();
+    let replaced_value = response_slot.replace(args.to_string());
+    assert!(
+      replaced_value.is_none(),
+      "op_compiler_respond found unexpected existing compiler output",
+    );
+    Ok(json!({}))
+  });
 }
diff --git a/cli/ops/dispatch_json.rs b/cli/ops/dispatch_json.rs
deleted file mode 100644
index e28c32382..000000000
--- a/cli/ops/dispatch_json.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use deno_core::Buf;
-use deno_core::CoreIsolateState;
-use deno_core::ErrBox;
-use deno_core::Op;
-use deno_core::ZeroCopyBuf;
-use futures::future::FutureExt;
-pub use serde_derive::Deserialize;
-use serde_json::json;
-pub use serde_json::Value;
-use std::future::Future;
-use std::pin::Pin;
-
-pub type JsonResult = Result<Value, ErrBox>;
-
-pub type AsyncJsonOp = Pin<Box<dyn Future<Output = JsonResult>>>;
-
-pub enum JsonOp {
-  Sync(Value),
-  Async(AsyncJsonOp),
-  /// AsyncUnref is the variation of Async, which doesn't block the program
-  /// exiting.
-  AsyncUnref(AsyncJsonOp),
-}
-
-pub fn serialize_result(
-  promise_id: Option<u64>,
-  result: JsonResult,
-  get_error_class_fn: deno_core::GetErrorClassFn,
-) -> Buf {
-  let value = match result {
-    Ok(v) => json!({ "ok": v, "promiseId": promise_id }),
-    Err(err) => json!({
-      "err": {
-        "className": (get_error_class_fn)(&err),
-        "message": err.to_string()
-      },
-      "promiseId": promise_id
-    }),
-  };
-  serde_json::to_vec(&value).unwrap().into_boxed_slice()
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct AsyncArgs {
-  promise_id: Option<u64>,
-}
-
-pub fn json_op<D>(
-  d: D,
-) -> impl Fn(&mut CoreIsolateState, &mut [ZeroCopyBuf]) -> Op
-where
-  D: Fn(
-    &mut CoreIsolateState,
-    Value,
-    &mut [ZeroCopyBuf],
-  ) -> Result<JsonOp, ErrBox>,
-{
-  move |isolate_state: &mut CoreIsolateState, zero_copy: &mut [ZeroCopyBuf]| {
-    let get_error_class_fn = isolate_state.get_error_class_fn;
-
-    assert!(!zero_copy.is_empty(), "Expected JSON string at position 0");
-    let async_args: AsyncArgs = match serde_json::from_slice(&zero_copy[0]) {
-      Ok(args) => args,
-      Err(e) => {
-        let buf = serialize_result(None, Err(e.into()), get_error_class_fn);
-        return Op::Sync(buf);
-      }
-    };
-    let promise_id = async_args.promise_id;
-    let is_sync = promise_id.is_none();
-
-    let result = serde_json::from_slice(&zero_copy[0])
-      .map_err(ErrBox::from)
-      .and_then(|args| d(isolate_state, args, &mut zero_copy[1..]));
-
-    // Convert to Op
-    match result {
-      Ok(JsonOp::Sync(sync_value)) => {
-        assert!(promise_id.is_none());
-        Op::Sync(serialize_result(
-          promise_id,
-          Ok(sync_value),
-          get_error_class_fn,
-        ))
-      }
-      Ok(JsonOp::Async(fut)) => {
-        assert!(promise_id.is_some());
-        let fut2 = fut.then(move |result| {
-          futures::future::ready(serialize_result(
-            promise_id,
-            result,
-            get_error_class_fn,
-          ))
-        });
-        Op::Async(fut2.boxed_local())
-      }
-      Ok(JsonOp::AsyncUnref(fut)) => {
-        assert!(promise_id.is_some());
-        let fut2 = fut.then(move |result| {
-          futures::future::ready(serialize_result(
-            promise_id,
-            result,
-            get_error_class_fn,
-          ))
-        });
-        Op::AsyncUnref(fut2.boxed_local())
-      }
-      Err(sync_err) => {
-        let buf =
-          serialize_result(promise_id, Err(sync_err), get_error_class_fn);
-        if is_sync {
-          Op::Sync(buf)
-        } else {
-          Op::Async(futures::future::ready(buf).boxed_local())
-        }
-      }
-    }
-  }
-}
diff --git a/cli/ops/dispatch_minimal.rs b/cli/ops/dispatch_minimal.rs
index 20e8160ff..9d941682d 100644
--- a/cli/ops/dispatch_minimal.rs
+++ b/cli/ops/dispatch_minimal.rs
@@ -1,20 +1,17 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-// Do not add flatbuffer dependencies to this module.
-//! Connects to js/dispatch_minimal.ts sendAsyncMinimal This acts as a faster
-//! alternative to flatbuffers using a very simple list of int32s to lay out
-//! messages. The first i32 is used to determine if a message a flatbuffer
-//! message or a "minimal" message.
-use crate::errors::get_error_class;
-use deno_core::Buf;
-use deno_core::CoreIsolateState;
+
+use crate::state::State;
+use deno_core::BufVec;
 use deno_core::ErrBox;
 use deno_core::Op;
-use deno_core::ZeroCopyBuf;
+use deno_core::OpId;
+use deno_core::OpRegistry;
 use futures::future::FutureExt;
 use std::future::Future;
 use std::iter::repeat;
 use std::mem::size_of_val;
 use std::pin::Pin;
+use std::rc::Rc;
 use std::slice;
 
 pub enum MinimalOp {
@@ -30,8 +27,8 @@ pub struct Record {
   pub result: i32,
 }
 
-impl Into<Buf> for Record {
-  fn into(self) -> Buf {
+impl Into<Box<[u8]>> for Record {
+  fn into(self) -> Box<[u8]> {
     let vec = vec![self.promise_id, self.arg, self.result];
     let buf32 = vec.into_boxed_slice();
     let ptr = Box::into_raw(buf32) as *mut [u8; 3 * 4];
@@ -47,8 +44,8 @@ pub struct ErrorRecord {
   pub error_message: Vec<u8>,
 }
 
-impl Into<Buf> for ErrorRecord {
-  fn into(self) -> Buf {
+impl Into<Box<[u8]>> for ErrorRecord {
+  fn into(self) -> Box<[u8]> {
     let Self {
       promise_id,
       arg,
@@ -91,7 +88,7 @@ fn test_error_record() {
     error_class: b"BadResource",
     error_message: b"Error".to_vec(),
   };
-  let buf: Buf = err_record.into();
+  let buf: Box<[u8]> = err_record.into();
   assert_eq!(buf, expected.into_boxed_slice());
 }
 
@@ -124,7 +121,7 @@ fn test_parse_min_record() {
     Some(Record {
       promise_id: 1,
       arg: 3,
-      result: 4,
+      result: 4
     })
   );
 
@@ -135,73 +132,78 @@ fn test_parse_min_record() {
   assert_eq!(parse_min_record(&buf), None);
 }
 
-pub fn minimal_op<D>(
-  d: D,
-) -> impl Fn(&mut CoreIsolateState, &mut [ZeroCopyBuf]) -> Op
-where
-  D: Fn(&mut CoreIsolateState, bool, i32, &mut [ZeroCopyBuf]) -> MinimalOp,
-{
-  move |isolate_state: &mut CoreIsolateState, zero_copy: &mut [ZeroCopyBuf]| {
-    assert!(!zero_copy.is_empty(), "Expected record at position 0");
-    let mut record = match parse_min_record(&zero_copy[0]) {
-      Some(r) => r,
-      None => {
-        let error = ErrBox::type_error("Unparsable control buffer");
-        let error_class = get_error_class(&error);
-        let error_record = ErrorRecord {
-          promise_id: 0,
-          arg: -1,
-          error_len: error_class.len() as i32,
-          error_class: error_class.as_bytes(),
-          error_message: error.to_string().as_bytes().to_owned(),
-        };
-        return Op::Sync(error_record.into());
-      }
-    };
-    let is_sync = record.promise_id == 0;
-    let rid = record.arg;
-    let min_op = d(isolate_state, is_sync, rid, &mut zero_copy[1..]);
-
-    match min_op {
-      MinimalOp::Sync(sync_result) => Op::Sync(match sync_result {
-        Ok(r) => {
-          record.result = r;
-          record.into()
-        }
-        Err(err) => {
-          let error_class = get_error_class(&err);
+impl State {
+  pub fn register_op_minimal<F>(self: &Rc<Self>, name: &str, op_fn: F) -> OpId
+  where
+    F: Fn(Rc<Self>, bool, i32, BufVec) -> MinimalOp + 'static,
+  {
+    let base_op_fn = move |state: Rc<Self>, bufs: BufVec| {
+      let mut bufs_iter = bufs.into_iter();
+      let record_buf = bufs_iter.next().expect("Expected record at position 0");
+      let zero_copy = bufs_iter.collect::<BufVec>();
+
+      let mut record = match parse_min_record(&record_buf) {
+        Some(r) => r,
+        None => {
+          let error = ErrBox::type_error("Unparsable control buffer");
+          let error_class = state.get_error_class_name(&error);
           let error_record = ErrorRecord {
-            promise_id: record.promise_id,
+            promise_id: 0,
             arg: -1,
             error_len: error_class.len() as i32,
             error_class: error_class.as_bytes(),
-            error_message: err.to_string().as_bytes().to_owned(),
+            error_message: error.to_string().as_bytes().to_owned(),
           };
-          error_record.into()
+          return Op::Sync(error_record.into());
         }
-      }),
-      MinimalOp::Async(min_fut) => {
-        let fut = async move {
-          match min_fut.await {
-            Ok(r) => {
-              record.result = r;
-              record.into()
-            }
-            Err(err) => {
-              let error_class = get_error_class(&err);
-              let error_record = ErrorRecord {
-                promise_id: record.promise_id,
-                arg: -1,
-                error_len: error_class.len() as i32,
-                error_class: error_class.as_bytes(),
-                error_message: err.to_string().as_bytes().to_owned(),
-              };
-              error_record.into()
-            }
+      };
+      let is_sync = record.promise_id == 0;
+      let rid = record.arg;
+      let min_op = op_fn(state.clone(), is_sync, rid, zero_copy);
+
+      match min_op {
+        MinimalOp::Sync(sync_result) => Op::Sync(match sync_result {
+          Ok(r) => {
+            record.result = r;
+            record.into()
+          }
+          Err(err) => {
+            let error_class = state.get_error_class_name(&err);
+            let error_record = ErrorRecord {
+              promise_id: record.promise_id,
+              arg: -1,
+              error_len: error_class.len() as i32,
+              error_class: error_class.as_bytes(),
+              error_message: err.to_string().as_bytes().to_owned(),
+            };
+            error_record.into()
           }
-        };
-        Op::Async(fut.boxed_local())
+        }),
+        MinimalOp::Async(min_fut) => {
+          let fut = async move {
+            match min_fut.await {
+              Ok(r) => {
+                record.result = r;
+                record.into()
+              }
+              Err(err) => {
+                let error_class = state.get_error_class_name(&err);
+                let error_record = ErrorRecord {
+                  promise_id: record.promise_id,
+                  arg: -1,
+                  error_len: error_class.len() as i32,
+                  error_class: error_class.as_bytes(),
+                  error_message: err.to_string().as_bytes().to_owned(),
+                };
+                error_record.into()
+              }
+            }
+          };
+          Op::Async(fut.boxed_local())
+        }
       }
-    }
+    };
+
+    self.register_op(name, base_op_fn)
   }
 }
diff --git a/cli/ops/errors.rs b/cli/ops/errors.rs
index 558f9af2a..a4f4665e2 100644
--- a/cli/ops/errors.rs
+++ b/cli/ops/errors.rs
@@ -1,27 +1,20 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{Deserialize, Value};
+
 use crate::diagnostics::Diagnostic;
 use crate::source_maps::get_orig_position;
 use crate::source_maps::CachedMaps;
 use crate::state::State;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::collections::HashMap;
 use std::rc::Rc;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op(
-    "op_apply_source_map",
-    s.stateful_json_op_sync(t, op_apply_source_map),
-  );
-  i.register_op(
-    "op_format_diagnostic",
-    s.stateful_json_op_sync(t, op_format_diagnostic),
-  );
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_apply_source_map", op_apply_source_map);
+  s.register_op_json_sync("op_format_diagnostic", op_format_diagnostic);
 }
 
 #[derive(Deserialize)]
@@ -34,7 +27,6 @@ struct ApplySourceMap {
 
 fn op_apply_source_map(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -59,7 +51,6 @@ fn op_apply_source_map(
 
 fn op_format_diagnostic(
   _state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
diff --git a/cli/ops/fetch.rs b/cli/ops/fetch.rs
index aea7bc7fc..690cbc592 100644
--- a/cli/ops/fetch.rs
+++ b/cli/ops/fetch.rs
@@ -1,30 +1,25 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{Deserialize, Value};
+
 use super::io::{StreamResource, StreamResourceHolder};
 use crate::http_util::{create_http_client, HttpBody};
 use crate::state::State;
 use deno_core::BufVec;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
 use http::header::HeaderName;
 use http::header::HeaderValue;
 use http::Method;
 use reqwest::Client;
-use std::cell::RefCell;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::convert::From;
 use std::path::PathBuf;
 use std::rc::Rc;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op("op_fetch", s.stateful_json_op_async(t, op_fetch));
-  i.register_op(
-    "op_create_http_client",
-    s.stateful_json_op_sync(t, op_create_http_client),
-  );
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_async("op_fetch", op_fetch);
+  s.register_op_json_sync("op_create_http_client", op_create_http_client);
 }
 
 #[derive(Deserialize)]
@@ -38,16 +33,14 @@ struct FetchArgs {
 
 async fn op_fetch(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   data: BufVec,
 ) -> Result<Value, ErrBox> {
   let args: FetchArgs = serde_json::from_value(args)?;
   let url = args.url;
-  let resource_table2 = resource_table.clone();
 
   let client = if let Some(rid) = args.client_rid {
-    let resource_table_ = resource_table.borrow();
+    let resource_table_ = state.resource_table.borrow();
     let r = resource_table_
       .get::<HttpClientResource>(rid)
       .ok_or_else(ErrBox::bad_resource_id)?;
@@ -100,8 +93,7 @@ async fn op_fetch(
   }
 
   let body = HttpBody::from(res);
-  let mut resource_table = resource_table2.borrow_mut();
-  let rid = resource_table.add(
+  let rid = state.resource_table.borrow_mut().add(
     "httpBody",
     Box::new(StreamResourceHolder::new(StreamResource::HttpBody(
       Box::new(body),
@@ -137,7 +129,6 @@ struct CreateHttpClientOptions {
 
 fn op_create_http_client(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -149,7 +140,9 @@ fn op_create_http_client(
 
   let client = create_http_client(args.ca_file.as_deref()).unwrap();
 
-  let rid =
-    resource_table.add("httpClient", Box::new(HttpClientResource::new(client)));
+  let rid = state
+    .resource_table
+    .borrow_mut()
+    .add("httpClient", Box::new(HttpClientResource::new(client)));
   Ok(json!(rid))
 }
diff --git a/cli/ops/fs.rs b/cli/ops/fs.rs
index 490ecd52f..e281f947e 100644
--- a/cli/ops/fs.rs
+++ b/cli/ops/fs.rs
@@ -1,16 +1,16 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
 // Some deserializer fields are only used on Unix and Windows build fails without it
-use super::dispatch_json::{Deserialize, Value};
 use super::io::std_file_resource;
 use super::io::{FileMetadata, StreamResource, StreamResourceHolder};
-use crate::ops::dispatch_json::JsonResult;
 use crate::state::State;
 use deno_core::BufVec;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
-use std::cell::RefCell;
+use rand::thread_rng;
+use rand::Rng;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::convert::From;
 use std::env::{current_dir, set_current_dir, temp_dir};
 use std::io;
@@ -20,171 +20,80 @@ use std::rc::Rc;
 use std::time::SystemTime;
 use std::time::UNIX_EPOCH;
 
-use rand::{thread_rng, Rng};
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_open_sync", op_open_sync);
+  s.register_op_json_async("op_open_async", op_open_async);
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
+  s.register_op_json_sync("op_seek_sync", op_seek_sync);
+  s.register_op_json_async("op_seek_async", op_seek_async);
 
-  i.register_op("op_open_sync", s.stateful_json_op_sync(t, op_open_sync));
-  i.register_op("op_open_async", s.stateful_json_op_async(t, op_open_async));
+  s.register_op_json_sync("op_fdatasync_sync", op_fdatasync_sync);
+  s.register_op_json_async("op_fdatasync_async", op_fdatasync_async);
 
-  i.register_op("op_seek_sync", s.stateful_json_op_sync(t, op_seek_sync));
-  i.register_op("op_seek_async", s.stateful_json_op_async(t, op_seek_async));
+  s.register_op_json_sync("op_fsync_sync", op_fsync_sync);
+  s.register_op_json_async("op_fsync_async", op_fsync_async);
 
-  i.register_op(
-    "op_fdatasync_sync",
-    s.stateful_json_op_sync(t, op_fdatasync_sync),
-  );
-  i.register_op(
-    "op_fdatasync_async",
-    s.stateful_json_op_async(t, op_fdatasync_async),
-  );
+  s.register_op_json_sync("op_fstat_sync", op_fstat_sync);
+  s.register_op_json_async("op_fstat_async", op_fstat_async);
 
-  i.register_op("op_fsync_sync", s.stateful_json_op_sync(t, op_fsync_sync));
-  i.register_op(
-    "op_fsync_async",
-    s.stateful_json_op_async(t, op_fsync_async),
-  );
+  s.register_op_json_sync("op_umask", op_umask);
+  s.register_op_json_sync("op_chdir", op_chdir);
 
-  i.register_op("op_fstat_sync", s.stateful_json_op_sync(t, op_fstat_sync));
-  i.register_op(
-    "op_fstat_async",
-    s.stateful_json_op_async(t, op_fstat_async),
-  );
+  s.register_op_json_sync("op_mkdir_sync", op_mkdir_sync);
+  s.register_op_json_async("op_mkdir_async", op_mkdir_async);
 
-  i.register_op("op_umask", s.stateful_json_op_sync(t, op_umask));
-  i.register_op("op_chdir", s.stateful_json_op_sync(t, op_chdir));
+  s.register_op_json_sync("op_chmod_sync", op_chmod_sync);
+  s.register_op_json_async("op_chmod_async", op_chmod_async);
 
-  i.register_op("op_mkdir_sync", s.stateful_json_op_sync(t, op_mkdir_sync));
-  i.register_op(
-    "op_mkdir_async",
-    s.stateful_json_op_async(t, op_mkdir_async),
-  );
+  s.register_op_json_sync("op_chown_sync", op_chown_sync);
+  s.register_op_json_async("op_chown_async", op_chown_async);
 
-  i.register_op("op_chmod_sync", s.stateful_json_op_sync(t, op_chmod_sync));
-  i.register_op(
-    "op_chmod_async",
-    s.stateful_json_op_async(t, op_chmod_async),
-  );
+  s.register_op_json_sync("op_remove_sync", op_remove_sync);
+  s.register_op_json_async("op_remove_async", op_remove_async);
 
-  i.register_op("op_chown_sync", s.stateful_json_op_sync(t, op_chown_sync));
-  i.register_op(
-    "op_chown_async",
-    s.stateful_json_op_async(t, op_chown_async),
-  );
+  s.register_op_json_sync("op_copy_file_sync", op_copy_file_sync);
+  s.register_op_json_async("op_copy_file_async", op_copy_file_async);
 
-  i.register_op("op_remove_sync", s.stateful_json_op_sync(t, op_remove_sync));
-  i.register_op(
-    "op_remove_async",
-    s.stateful_json_op_async(t, op_remove_async),
-  );
+  s.register_op_json_sync("op_stat_sync", op_stat_sync);
+  s.register_op_json_async("op_stat_async", op_stat_async);
 
-  i.register_op(
-    "op_copy_file_sync",
-    s.stateful_json_op_sync(t, op_copy_file_sync),
-  );
-  i.register_op(
-    "op_copy_file_async",
-    s.stateful_json_op_async(t, op_copy_file_async),
-  );
+  s.register_op_json_sync("op_realpath_sync", op_realpath_sync);
+  s.register_op_json_async("op_realpath_async", op_realpath_async);
 
-  i.register_op("op_stat_sync", s.stateful_json_op_sync(t, op_stat_sync));
-  i.register_op("op_stat_async", s.stateful_json_op_async(t, op_stat_async));
+  s.register_op_json_sync("op_read_dir_sync", op_read_dir_sync);
+  s.register_op_json_async("op_read_dir_async", op_read_dir_async);
 
-  i.register_op(
-    "op_realpath_sync",
-    s.stateful_json_op_sync(t, op_realpath_sync),
-  );
-  i.register_op(
-    "op_realpath_async",
-    s.stateful_json_op_async(t, op_realpath_async),
-  );
+  s.register_op_json_sync("op_rename_sync", op_rename_sync);
+  s.register_op_json_async("op_rename_async", op_rename_async);
 
-  i.register_op(
-    "op_read_dir_sync",
-    s.stateful_json_op_sync(t, op_read_dir_sync),
-  );
-  i.register_op(
-    "op_read_dir_async",
-    s.stateful_json_op_async(t, op_read_dir_async),
-  );
+  s.register_op_json_sync("op_link_sync", op_link_sync);
+  s.register_op_json_async("op_link_async", op_link_async);
 
-  i.register_op("op_rename_sync", s.stateful_json_op_sync(t, op_rename_sync));
-  i.register_op(
-    "op_rename_async",
-    s.stateful_json_op_async(t, op_rename_async),
-  );
+  s.register_op_json_sync("op_symlink_sync", op_symlink_sync);
+  s.register_op_json_async("op_symlink_async", op_symlink_async);
 
-  i.register_op("op_link_sync", s.stateful_json_op_sync(t, op_link_sync));
-  i.register_op("op_link_async", s.stateful_json_op_async(t, op_link_async));
+  s.register_op_json_sync("op_read_link_sync", op_read_link_sync);
+  s.register_op_json_async("op_read_link_async", op_read_link_async);
 
-  i.register_op(
-    "op_symlink_sync",
-    s.stateful_json_op_sync(t, op_symlink_sync),
-  );
-  i.register_op(
-    "op_symlink_async",
-    s.stateful_json_op_async(t, op_symlink_async),
-  );
+  s.register_op_json_sync("op_ftruncate_sync", op_ftruncate_sync);
+  s.register_op_json_async("op_ftruncate_async", op_ftruncate_async);
 
-  i.register_op(
-    "op_read_link_sync",
-    s.stateful_json_op_sync(t, op_read_link_sync),
-  );
-  i.register_op(
-    "op_read_link_async",
-    s.stateful_json_op_async(t, op_read_link_async),
-  );
-
-  i.register_op(
-    "op_ftruncate_sync",
-    s.stateful_json_op_sync(t, op_ftruncate_sync),
-  );
-  i.register_op(
-    "op_ftruncate_async",
-    s.stateful_json_op_async(t, op_ftruncate_async),
-  );
-
-  i.register_op(
-    "op_truncate_sync",
-    s.stateful_json_op_sync(t, op_truncate_sync),
-  );
-  i.register_op(
-    "op_truncate_async",
-    s.stateful_json_op_async(t, op_truncate_async),
-  );
+  s.register_op_json_sync("op_truncate_sync", op_truncate_sync);
+  s.register_op_json_async("op_truncate_async", op_truncate_async);
 
-  i.register_op(
-    "op_make_temp_dir_sync",
-    s.stateful_json_op_sync(t, op_make_temp_dir_sync),
-  );
-  i.register_op(
-    "op_make_temp_dir_async",
-    s.stateful_json_op_async(t, op_make_temp_dir_async),
-  );
+  s.register_op_json_sync("op_make_temp_dir_sync", op_make_temp_dir_sync);
+  s.register_op_json_async("op_make_temp_dir_async", op_make_temp_dir_async);
 
-  i.register_op(
-    "op_make_temp_file_sync",
-    s.stateful_json_op_sync(t, op_make_temp_file_sync),
-  );
-  i.register_op(
-    "op_make_temp_file_async",
-    s.stateful_json_op_async(t, op_make_temp_file_async),
-  );
+  s.register_op_json_sync("op_make_temp_file_sync", op_make_temp_file_sync);
+  s.register_op_json_async("op_make_temp_file_async", op_make_temp_file_async);
 
-  i.register_op("op_cwd", s.stateful_json_op_sync(t, op_cwd));
+  s.register_op_json_sync("op_cwd", op_cwd);
 
-  i.register_op("op_futime_sync", s.stateful_json_op_sync(t, op_futime_sync));
-  i.register_op(
-    "op_futime_async",
-    s.stateful_json_op_async(t, op_futime_async),
-  );
+  s.register_op_json_sync("op_futime_sync", op_futime_sync);
+  s.register_op_json_async("op_futime_async", op_futime_async);
 
-  i.register_op("op_utime_sync", s.stateful_json_op_sync(t, op_utime_sync));
-  i.register_op(
-    "op_utime_async",
-    s.stateful_json_op_async(t, op_utime_async),
-  );
+  s.register_op_json_sync("op_utime_sync", op_utime_sync);
+  s.register_op_json_async("op_utime_async", op_utime_async);
 }
 
 fn into_string(s: std::ffi::OsString) -> Result<String, ErrBox> {
@@ -257,14 +166,13 @@ fn open_helper(
 
 fn op_open_sync(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
   let (path, open_options) = open_helper(state, args)?;
   let std_file = open_options.open(path)?;
   let tokio_file = tokio::fs::File::from_std(std_file);
-  let rid = resource_table.add(
+  let rid = state.resource_table.borrow_mut().add(
     "fsFile",
     Box::new(StreamResourceHolder::new(StreamResource::FsFile(Some((
       tokio_file,
@@ -276,7 +184,6 @@ fn op_open_sync(
 
 async fn op_open_async(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -284,7 +191,7 @@ async fn op_open_async(
   let tokio_file = tokio::fs::OpenOptions::from(open_options)
     .open(path)
     .await?;
-  let rid = resource_table.borrow_mut().add(
+  let rid = state.resource_table.borrow_mut().add(
     "fsFile",
     Box::new(StreamResourceHolder::new(StreamResource::FsFile(Some((
       tokio_file,
@@ -321,13 +228,12 @@ fn seek_helper(args: Value) -> Result<(u32, SeekFrom), ErrBox> {
 }
 
 fn op_seek_sync(
-  _state: &State,
-  resource_table: &mut ResourceTable,
+  state: &State,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
   let (rid, seek_from) = seek_helper(args)?;
-  let pos = std_file_resource(resource_table, rid, |r| match r {
+  let pos = std_file_resource(state, rid, |r| match r {
     Ok(std_file) => std_file.seek(seek_from).map_err(ErrBox::from),
     Err(_) => Err(ErrBox::type_error(
       "cannot seek on this type of resource".to_string(),
@@ -337,16 +243,14 @@ fn op_seek_sync(
 }
 
 async fn op_seek_async(
-  _state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
+  state: Rc<State>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
   let (rid, seek_from) = seek_helper(args)?;
   // TODO(ry) This is a fake async op. We need to use poll_fn,
   // tokio::fs::File::start_seek and tokio::fs::File::poll_complete
-  let mut resource_table = resource_table.borrow_mut();
-  let pos = std_file_resource(&mut resource_table, rid, |r| match r {
+  let pos = std_file_resource(&state, rid, |r| match r {
     Ok(std_file) => std_file.seek(seek_from).map_err(ErrBox::from),
     Err(_) => Err(ErrBox::type_error(
       "cannot seek on this type of resource".to_string(),
@@ -363,14 +267,13 @@ struct FdatasyncArgs {
 
 fn op_fdatasync_sync(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
   state.check_unstable("Deno.fdatasync");
   let args: FdatasyncArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
-  std_file_resource(resource_table, rid, |r| match r {
+  std_file_resource(state, rid, |r| match r {
     Ok(std_file) => std_file.sync_data().map_err(ErrBox::from),
     Err(_) => Err(ErrBox::type_error(
       "cannot sync this type of resource".to_string(),
@@ -381,15 +284,13 @@ fn op_fdatasync_sync(
 
 async fn op_fdatasync_async(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
   state.check_unstable("Deno.fdatasync");
   let args: FdatasyncArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
-  let mut resource_table = resource_table.borrow_mut();
-  std_file_resource(&mut resource_table, rid, |r| match r {
+  std_file_resource(&state, rid, |r| match r {
     Ok(std_file) => std_file.sync_data().map_err(ErrBox::from),
     Err(_) => Err(ErrBox::type_error(
       "cannot sync this type of resource".to_string(),
@@ -406,14 +307,13 @@ struct FsyncArgs {
 
 fn op_fsync_sync(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
   state.check_unstable("Deno.fsync");
   let args: FsyncArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
-  std_file_resource(resource_table, rid, |r| match r {
+  std_file_resource(state, rid, |r| match r {
     Ok(std_file) => std_file.sync_all().map_err(ErrBox::from),
     Err(_) => Err(ErrBox::type_error(
       "cannot sync this type of resource".to_string(),
@@ -424,15 +324,13 @@ fn op_fsync_sync(
 
 async fn op_fsync_async(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
   state.check_unstable("Deno.fsync");
   let args: FsyncArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
-  let mut resource_table = resource_table.borrow_mut();
-  std_file_resource(&mut resource_table, rid, |r| match r {
+  std_file_resource(&state, rid, |r| match r {
     Ok(std_file) => std_file.sync_all().map_err(ErrBox::from),
     Err(_) => Err(ErrBox::type_error(
       "cannot sync this type of resource".to_string(),
@@ -449,14 +347,13 @@ struct FstatArgs {
 
 fn op_fstat_sync(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
   state.check_unstable("Deno.fstat");
   let args: FstatArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
-  let metadata = std_file_resource(resource_table, rid, |r| match r {
+  let metadata = std_file_resource(state, rid, |r| match r {
     Ok(std_file) => std_file.metadata().map_err(ErrBox::from),
     Err(_) => Err(ErrBox::type_error(
       "cannot stat this type of resource".to_string(),
@@ -467,15 +364,13 @@ fn op_fstat_sync(
 
 async fn op_fstat_async(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
   state.check_unstable("Deno.fstat");
   let args: FstatArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
-  let mut resource_table = resource_table.borrow_mut();
-  let metadata = std_file_resource(&mut resource_table, rid, |r| match r {
+  let metadata = std_file_resource(&state, rid, |r| match r {
     Ok(std_file) => std_file.metadata().map_err(ErrBox::from),
     Err(_) => Err(ErrBox::type_error(
       "cannot stat this type of resource".to_string(),
@@ -491,7 +386,6 @@ struct UmaskArgs {
 
 fn op_umask(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -530,7 +424,6 @@ struct ChdirArgs {
 
 fn op_chdir(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -551,7 +444,6 @@ struct MkdirArgs {
 
 fn op_mkdir_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -573,7 +465,6 @@ fn op_mkdir_sync(
 
 async fn op_mkdir_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -606,7 +497,6 @@ struct ChmodArgs {
 
 fn op_chmod_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -634,7 +524,6 @@ fn op_chmod_sync(
 
 async fn op_chmod_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -673,7 +562,6 @@ struct ChownArgs {
 
 fn op_chown_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -703,7 +591,6 @@ fn op_chown_sync(
 
 async fn op_chown_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -742,7 +629,6 @@ struct RemoveArgs {
 
 fn op_remove_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -786,7 +672,6 @@ fn op_remove_sync(
 
 async fn op_remove_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -841,7 +726,6 @@ struct CopyFileArgs {
 
 fn op_copy_file_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -867,7 +751,6 @@ fn op_copy_file_sync(
 
 async fn op_copy_file_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -895,7 +778,7 @@ async fn op_copy_file_async(
   .unwrap()
 }
 
-fn to_msec(maybe_time: Result<SystemTime, io::Error>) -> serde_json::Value {
+fn to_msec(maybe_time: Result<SystemTime, io::Error>) -> Value {
   match maybe_time {
     Ok(time) => {
       let msec = time
@@ -903,18 +786,18 @@ fn to_msec(maybe_time: Result<SystemTime, io::Error>) -> serde_json::Value {
         .map(|t| t.as_secs_f64() * 1000f64)
         .unwrap_or_else(|err| err.duration().as_secs_f64() * -1000f64);
       serde_json::Number::from_f64(msec)
-        .map(serde_json::Value::Number)
-        .unwrap_or(serde_json::Value::Null)
+        .map(Value::Number)
+        .unwrap_or(Value::Null)
     }
-    Err(_) => serde_json::Value::Null,
+    Err(_) => Value::Null,
   }
 }
 
 #[inline(always)]
-fn get_stat_json(metadata: std::fs::Metadata) -> JsonResult {
+fn get_stat_json(metadata: std::fs::Metadata) -> Result<Value, ErrBox> {
   // Unix stat member (number types only). 0 if not on unix.
   macro_rules! usm {
-    ($member: ident) => {{
+    ($member:ident) => {{
       #[cfg(unix)]
       {
         metadata.$member()
@@ -962,7 +845,6 @@ struct StatArgs {
 
 fn op_stat_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -981,7 +863,6 @@ fn op_stat_sync(
 
 async fn op_stat_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -1012,7 +893,6 @@ struct RealpathArgs {
 
 fn op_realpath_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -1038,7 +918,6 @@ fn op_realpath_sync(
 
 async fn op_realpath_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -1074,7 +953,6 @@ struct ReadDirArgs {
 
 fn op_read_dir_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -1107,7 +985,6 @@ fn op_read_dir_sync(
 
 async fn op_read_dir_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -1151,7 +1028,6 @@ struct RenameArgs {
 
 fn op_rename_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -1169,7 +1045,6 @@ fn op_rename_sync(
 
 async fn op_rename_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -1203,7 +1078,6 @@ struct LinkArgs {
 
 fn op_link_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -1222,7 +1096,6 @@ fn op_link_sync(
 
 async fn op_link_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -1261,7 +1134,6 @@ struct SymlinkOptions {
 
 fn op_symlink_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -1303,10 +1175,7 @@ fn op_symlink_sync(
               symlink_dir(&oldpath, &newpath)?
             }
           }
-          Err(_) => return Err(ErrBox::type_error(
-            "you must pass a `options` argument for non-existent target path in windows"
-              .to_string(),
-          )),
+          Err(_) => return Err(ErrBox::type_error("you must pass a `options` argument for non-existent target path in windows".to_string())),
         }
       }
     };
@@ -1316,7 +1185,6 @@ fn op_symlink_sync(
 
 async fn op_symlink_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -1355,10 +1223,7 @@ async fn op_symlink_async(
                 symlink_dir(&oldpath, &newpath)?
               }
             }
-            Err(_) => return Err(ErrBox::type_error(
-              "you must pass a `options` argument for non-existent target path in windows"
-                .to_string(),
-            )),
+            Err(_) => return Err(ErrBox::type_error("you must pass a `options` argument for non-existent target path in windows".to_string())),
           }
         }
       };
@@ -1377,7 +1242,6 @@ struct ReadLinkArgs {
 
 fn op_read_link_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -1394,7 +1258,6 @@ fn op_read_link_sync(
 
 async fn op_read_link_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -1422,7 +1285,6 @@ struct FtruncateArgs {
 
 fn op_ftruncate_sync(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -1430,7 +1292,7 @@ fn op_ftruncate_sync(
   let args: FtruncateArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
   let len = args.len as u64;
-  std_file_resource(resource_table, rid, |r| match r {
+  std_file_resource(state, rid, |r| match r {
     Ok(std_file) => std_file.set_len(len).map_err(ErrBox::from),
     Err(_) => Err(ErrBox::type_error("cannot truncate this type of resource")),
   })?;
@@ -1439,7 +1301,6 @@ fn op_ftruncate_sync(
 
 async fn op_ftruncate_async(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -1447,8 +1308,7 @@ async fn op_ftruncate_async(
   let args: FtruncateArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
   let len = args.len as u64;
-  let mut resource_table = resource_table.borrow_mut();
-  std_file_resource(&mut resource_table, rid, |r| match r {
+  std_file_resource(&state, rid, |r| match r {
     Ok(std_file) => std_file.set_len(len).map_err(ErrBox::from),
     Err(_) => Err(ErrBox::type_error("cannot truncate this type of resource")),
   })?;
@@ -1464,7 +1324,6 @@ struct TruncateArgs {
 
 fn op_truncate_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -1482,7 +1341,6 @@ fn op_truncate_sync(
 
 async fn op_truncate_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -1557,7 +1415,6 @@ struct MakeTempArgs {
 
 fn op_make_temp_dir_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -1586,7 +1443,6 @@ fn op_make_temp_dir_sync(
 
 async fn op_make_temp_dir_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -1619,7 +1475,6 @@ async fn op_make_temp_dir_async(
 
 fn op_make_temp_file_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -1648,7 +1503,6 @@ fn op_make_temp_file_sync(
 
 async fn op_make_temp_file_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -1689,7 +1543,6 @@ struct FutimeArgs {
 
 fn op_futime_sync(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -1699,7 +1552,7 @@ fn op_futime_sync(
   let atime = filetime::FileTime::from_unix_time(args.atime.0, args.atime.1);
   let mtime = filetime::FileTime::from_unix_time(args.mtime.0, args.mtime.1);
 
-  std_file_resource(resource_table, rid, |r| match r {
+  std_file_resource(state, rid, |r| match r {
     Ok(std_file) => {
       filetime::set_file_handle_times(std_file, Some(atime), Some(mtime))
         .map_err(ErrBox::from)
@@ -1714,7 +1567,6 @@ fn op_futime_sync(
 
 async fn op_futime_async(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -1724,8 +1576,7 @@ async fn op_futime_async(
   let atime = filetime::FileTime::from_unix_time(args.atime.0, args.atime.1);
   let mtime = filetime::FileTime::from_unix_time(args.mtime.0, args.mtime.1);
 
-  let mut resource_table = resource_table.borrow_mut();
-  std_file_resource(&mut resource_table, rid, |r| match r {
+  std_file_resource(&state, rid, |r| match r {
     Ok(std_file) => {
       filetime::set_file_handle_times(std_file, Some(atime), Some(mtime))
         .map_err(ErrBox::from)
@@ -1748,7 +1599,6 @@ struct UtimeArgs {
 
 fn op_utime_sync(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -1766,7 +1616,6 @@ fn op_utime_sync(
 
 async fn op_utime_async(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -1789,7 +1638,6 @@ async fn op_utime_async(
 
 fn op_cwd(
   state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
diff --git a/cli/ops/fs_events.rs b/cli/ops/fs_events.rs
index e1c98b8de..142aa3ccf 100644
--- a/cli/ops/fs_events.rs
+++ b/cli/ops/fs_events.rs
@@ -1,10 +1,9 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{Deserialize, Value};
+
 use crate::state::State;
 use deno_core::BufVec;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
 use futures::future::poll_fn;
 use notify::event::Event as NotifyEvent;
@@ -14,23 +13,16 @@ use notify::RecommendedWatcher;
 use notify::RecursiveMode;
 use notify::Watcher;
 use serde::Serialize;
-use std::cell::RefCell;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::convert::From;
 use std::path::PathBuf;
 use std::rc::Rc;
 use tokio::sync::mpsc;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op(
-    "op_fs_events_open",
-    s.stateful_json_op_sync(t, op_fs_events_open),
-  );
-  i.register_op(
-    "op_fs_events_poll",
-    s.stateful_json_op_async(t, op_fs_events_poll),
-  );
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_fs_events_open", op_fs_events_open);
+  s.register_op_json_async("op_fs_events_poll", op_fs_events_poll);
 }
 
 struct FsEventsResource {
@@ -73,7 +65,6 @@ impl From<NotifyEvent> for FsEvent {
 
 fn op_fs_events_open(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -103,13 +94,15 @@ fn op_fs_events_open(
     watcher.watch(path, recursive_mode)?;
   }
   let resource = FsEventsResource { watcher, receiver };
-  let rid = resource_table.add("fsEvents", Box::new(resource));
+  let rid = state
+    .resource_table
+    .borrow_mut()
+    .add("fsEvents", Box::new(resource));
   Ok(json!(rid))
 }
 
 async fn op_fs_events_poll(
-  _state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
+  state: Rc<State>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -119,7 +112,7 @@ async fn op_fs_events_poll(
   }
   let PollArgs { rid } = serde_json::from_value(args)?;
   poll_fn(move |cx| {
-    let mut resource_table = resource_table.borrow_mut();
+    let mut resource_table = state.resource_table.borrow_mut();
     let watcher = resource_table
       .get_mut::<FsEventsResource>(rid)
       .ok_or_else(ErrBox::bad_resource_id)?;
diff --git a/cli/ops/idna.rs b/cli/ops/idna.rs
index 392eceb24..8e83a03ba 100644
--- a/cli/ops/idna.rs
+++ b/cli/ops/idna.rs
@@ -2,21 +2,18 @@
 
 //! https://url.spec.whatwg.org/#idna
 
-use super::dispatch_json::{Deserialize, Value};
 use crate::state::State;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
-use idna::{domain_to_ascii, domain_to_ascii_strict};
+use idna::domain_to_ascii;
+use idna::domain_to_ascii_strict;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::rc::Rc;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-  i.register_op(
-    "op_domain_to_ascii",
-    s.stateful_json_op_sync(t, op_domain_to_ascii),
-  );
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_domain_to_ascii", op_domain_to_ascii);
 }
 
 #[derive(Deserialize)]
@@ -28,7 +25,6 @@ struct DomainToAscii {
 
 fn op_domain_to_ascii(
   _state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
diff --git a/cli/ops/io.rs b/cli/ops/io.rs
index 14d32a39b..4a8f6d96d 100644
--- a/cli/ops/io.rs
+++ b/cli/ops/io.rs
@@ -1,11 +1,8 @@
 use super::dispatch_minimal::MinimalOp;
 use crate::http_util::HttpBody;
 use crate::state::State;
-use deno_core::CoreIsolate;
-use deno_core::CoreIsolateState;
+use deno_core::BufVec;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
-use deno_core::ZeroCopyBuf;
 use futures::future::poll_fn;
 use futures::future::FutureExt;
 use futures::ready;
@@ -85,9 +82,9 @@ lazy_static! {
   };
 }
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  i.register_op("op_read", s.stateful_minimal_op2(op_read));
-  i.register_op("op_write", s.stateful_minimal_op2(op_write));
+pub fn init(s: &Rc<State>) {
+  s.register_op_minimal("op_read", op_read);
+  s.register_op_minimal("op_write", op_write);
 }
 
 pub fn get_stdio() -> (
@@ -236,11 +233,10 @@ impl DenoAsyncRead for StreamResource {
 }
 
 pub fn op_read(
-  isolate_state: &mut CoreIsolateState,
-  _state: &Rc<State>,
+  state: Rc<State>,
   is_sync: bool,
   rid: i32,
-  zero_copy: &mut [ZeroCopyBuf],
+  mut zero_copy: BufVec,
 ) -> MinimalOp {
   debug!("read rid={}", rid);
   match zero_copy.len() {
@@ -248,13 +244,11 @@ pub fn op_read(
     1 => {}
     _ => panic!("Invalid number of arguments"),
   }
-  let resource_table = isolate_state.resource_table.clone();
 
   if is_sync {
     MinimalOp::Sync({
       // First we look up the rid in the resource table.
-      let mut resource_table = resource_table.borrow_mut();
-      std_file_resource(&mut resource_table, rid as u32, move |r| match r {
+      std_file_resource(&state, rid as u32, move |r| match r {
         Ok(std_file) => {
           use std::io::Read;
           std_file
@@ -271,7 +265,7 @@ pub fn op_read(
     let mut zero_copy = zero_copy[0].clone();
     MinimalOp::Async(
       poll_fn(move |cx| {
-        let mut resource_table = resource_table.borrow_mut();
+        let mut resource_table = state.resource_table.borrow_mut();
         let resource_holder = resource_table
           .get_mut::<StreamResourceHolder>(rid as u32)
           .ok_or_else(ErrBox::bad_resource_id)?;
@@ -358,11 +352,10 @@ impl DenoAsyncWrite for StreamResource {
 }
 
 pub fn op_write(
-  isolate_state: &mut CoreIsolateState,
-  _state: &Rc<State>,
+  state: Rc<State>,
   is_sync: bool,
   rid: i32,
-  zero_copy: &mut [ZeroCopyBuf],
+  zero_copy: BufVec,
 ) -> MinimalOp {
   debug!("write rid={}", rid);
   match zero_copy.len() {
@@ -374,8 +367,7 @@ pub fn op_write(
   if is_sync {
     MinimalOp::Sync({
       // First we look up the rid in the resource table.
-      let mut resource_table = isolate_state.resource_table.borrow_mut();
-      std_file_resource(&mut resource_table, rid as u32, move |r| match r {
+      std_file_resource(&state, rid as u32, move |r| match r {
         Ok(std_file) => {
           use std::io::Write;
           std_file
@@ -390,11 +382,10 @@ pub fn op_write(
     })
   } else {
     let zero_copy = zero_copy[0].clone();
-    let resource_table = isolate_state.resource_table.clone();
     MinimalOp::Async(
       async move {
         let nwritten = poll_fn(|cx| {
-          let mut resource_table = resource_table.borrow_mut();
+          let mut resource_table = state.resource_table.borrow_mut();
           let resource_holder = resource_table
             .get_mut::<StreamResourceHolder>(rid as u32)
             .ok_or_else(ErrBox::bad_resource_id)?;
@@ -407,7 +398,7 @@ pub fn op_write(
         // Figure out why it's needed and preferably remove it.
         // https://github.com/denoland/deno/issues/3565
         poll_fn(|cx| {
-          let mut resource_table = resource_table.borrow_mut();
+          let mut resource_table = state.resource_table.borrow_mut();
           let resource_holder = resource_table
             .get_mut::<StreamResourceHolder>(rid as u32)
             .ok_or_else(ErrBox::bad_resource_id)?;
@@ -430,7 +421,7 @@ pub fn op_write(
 ///
 /// Returns ErrorKind::Busy if the resource is being used by another op.
 pub fn std_file_resource<F, T>(
-  resource_table: &mut ResourceTable,
+  state: &State,
   rid: u32,
   mut f: F,
 ) -> Result<T, ErrBox>
@@ -439,6 +430,7 @@ where
     FnMut(Result<&mut std::fs::File, &mut StreamResource>) -> Result<T, ErrBox>,
 {
   // First we look up the rid in the resource table.
+  let mut resource_table = state.resource_table.borrow_mut();
   let mut r = resource_table.get_mut::<StreamResourceHolder>(rid);
   if let Some(ref mut resource_holder) = r {
     // Sync write only works for FsFile. It doesn't make sense to do this
diff --git a/cli/ops/mod.rs b/cli/ops/mod.rs
index bc6b4f377..06a55bade 100644
--- a/cli/ops/mod.rs
+++ b/cli/ops/mod.rs
@@ -1,12 +1,6 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-mod dispatch_json;
-mod dispatch_minimal;
 
-pub use dispatch_json::json_op;
-pub use dispatch_json::serialize_result;
-pub use dispatch_json::JsonOp;
-pub use dispatch_json::JsonResult;
-pub use dispatch_minimal::minimal_op;
+mod dispatch_minimal;
 pub use dispatch_minimal::MinimalOp;
 
 pub mod compiler;
diff --git a/cli/ops/net.rs b/cli/ops/net.rs
index 9cb6eb79d..91a9079d4 100644
--- a/cli/ops/net.rs
+++ b/cli/ops/net.rs
@@ -1,15 +1,15 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{Deserialize, Value};
-use super::io::{StreamResource, StreamResourceHolder};
+
+use crate::ops::io::{StreamResource, StreamResourceHolder};
 use crate::resolve_addr::resolve_addr;
 use crate::state::State;
 use deno_core::BufVec;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
 use futures::future::poll_fn;
-use std::cell::RefCell;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::net::Shutdown;
 use std::net::SocketAddr;
 use std::rc::Rc;
@@ -22,38 +22,30 @@ use tokio::net::UdpSocket;
 #[cfg(unix)]
 use super::net_unix;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op("op_accept", s.stateful_json_op_async(t, op_accept));
-  i.register_op("op_connect", s.stateful_json_op_async(t, op_connect));
-  i.register_op("op_shutdown", s.stateful_json_op_sync(t, op_shutdown));
-  i.register_op("op_listen", s.stateful_json_op_sync(t, op_listen));
-  i.register_op(
-    "op_datagram_receive",
-    s.stateful_json_op_async(t, op_datagram_receive),
-  );
-  i.register_op(
-    "op_datagram_send",
-    s.stateful_json_op_async(t, op_datagram_send),
-  );
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_async("op_accept", op_accept);
+  s.register_op_json_async("op_connect", op_connect);
+  s.register_op_json_sync("op_shutdown", op_shutdown);
+  s.register_op_json_sync("op_listen", op_listen);
+  s.register_op_json_async("op_datagram_receive", op_datagram_receive);
+  s.register_op_json_async("op_datagram_send", op_datagram_send);
 }
 
 #[derive(Deserialize)]
-struct AcceptArgs {
-  rid: i32,
-  transport: String,
+pub(crate) struct AcceptArgs {
+  pub rid: i32,
+  pub transport: String,
 }
 
 async fn accept_tcp(
-  resource_table: Rc<RefCell<ResourceTable>>,
+  state: Rc<State>,
   args: AcceptArgs,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
   let rid = args.rid as u32;
 
   let accept_fut = poll_fn(|cx| {
-    let mut resource_table = resource_table.borrow_mut();
+    let mut resource_table = state.resource_table.borrow_mut();
     let listener_resource = resource_table
       .get_mut::<TcpListenerResource>(rid)
       .ok_or_else(|| ErrBox::bad_resource("Listener has been closed"))?;
@@ -76,8 +68,7 @@ async fn accept_tcp(
   let (tcp_stream, _socket_addr) = accept_fut.await?;
   let local_addr = tcp_stream.local_addr()?;
   let remote_addr = tcp_stream.peer_addr()?;
-  let mut resource_table = resource_table.borrow_mut();
-  let rid = resource_table.add(
+  let rid = state.resource_table.borrow_mut().add(
     "tcpStream",
     Box::new(StreamResourceHolder::new(StreamResource::TcpStream(Some(
       tcp_stream,
@@ -99,18 +90,15 @@ async fn accept_tcp(
 }
 
 async fn op_accept(
-  _state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
+  state: Rc<State>,
   args: Value,
-  zero_copy: BufVec,
+  bufs: BufVec,
 ) -> Result<Value, ErrBox> {
   let args: AcceptArgs = serde_json::from_value(args)?;
   match args.transport.as_str() {
-    "tcp" => accept_tcp(resource_table, args, zero_copy).await,
+    "tcp" => accept_tcp(state, args, bufs).await,
     #[cfg(unix)]
-    "unix" => {
-      net_unix::accept_unix(resource_table, args.rid as u32, zero_copy).await
-    }
+    "unix" => net_unix::accept_unix(state, args, bufs).await,
     _ => Err(ErrBox::error(format!(
       "Unsupported transport protocol {}",
       args.transport
@@ -119,14 +107,13 @@ async fn op_accept(
 }
 
 #[derive(Deserialize)]
-struct ReceiveArgs {
-  rid: i32,
-  transport: String,
+pub(crate) struct ReceiveArgs {
+  pub rid: i32,
+  pub transport: String,
 }
 
 async fn receive_udp(
-  resource_table: Rc<RefCell<ResourceTable>>,
-  _state: &Rc<State>,
+  state: Rc<State>,
   args: ReceiveArgs,
   zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -136,7 +123,7 @@ async fn receive_udp(
   let rid = args.rid as u32;
 
   let receive_fut = poll_fn(|cx| {
-    let mut resource_table = resource_table.borrow_mut();
+    let mut resource_table = state.resource_table.borrow_mut();
     let resource = resource_table
       .get_mut::<UdpSocketResource>(rid)
       .ok_or_else(|| ErrBox::bad_resource("Socket has been closed"))?;
@@ -158,7 +145,6 @@ async fn receive_udp(
 
 async fn op_datagram_receive(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -166,12 +152,9 @@ async fn op_datagram_receive(
 
   let args: ReceiveArgs = serde_json::from_value(args)?;
   match args.transport.as_str() {
-    "udp" => receive_udp(resource_table, &state, args, zero_copy).await,
+    "udp" => receive_udp(state, args, zero_copy).await,
     #[cfg(unix)]
-    "unixpacket" => {
-      net_unix::receive_unix_packet(resource_table, args.rid as u32, zero_copy)
-        .await
-    }
+    "unixpacket" => net_unix::receive_unix_packet(state, args, zero_copy).await,
     _ => Err(ErrBox::error(format!(
       "Unsupported transport protocol {}",
       args.transport
@@ -189,7 +172,6 @@ struct SendArgs {
 
 async fn op_datagram_send(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -205,7 +187,7 @@ async fn op_datagram_send(
       state.check_net(&args.hostname, args.port)?;
       let addr = resolve_addr(&args.hostname, args.port)?;
       poll_fn(move |cx| {
-        let mut resource_table = resource_table.borrow_mut();
+        let mut resource_table = state.resource_table.borrow_mut();
         let resource = resource_table
           .get_mut::<UdpSocketResource>(rid as u32)
           .ok_or_else(|| ErrBox::bad_resource("Socket has been closed"))?;
@@ -225,7 +207,7 @@ async fn op_datagram_send(
     } if transport == "unixpacket" => {
       let address_path = net_unix::Path::new(&args.path);
       state.check_read(&address_path)?;
-      let mut resource_table = resource_table.borrow_mut();
+      let mut resource_table = state.resource_table.borrow_mut();
       let resource = resource_table
         .get_mut::<net_unix::UnixDatagramResource>(rid as u32)
         .ok_or_else(|| ErrBox::new("NotConnected", "Socket has been closed"))?;
@@ -249,7 +231,6 @@ struct ConnectArgs {
 
 async fn op_connect(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -263,8 +244,7 @@ async fn op_connect(
       let tcp_stream = TcpStream::connect(&addr).await?;
       let local_addr = tcp_stream.local_addr()?;
       let remote_addr = tcp_stream.peer_addr()?;
-      let mut resource_table = resource_table.borrow_mut();
-      let rid = resource_table.add(
+      let rid = state.resource_table.borrow_mut().add(
         "tcpStream",
         Box::new(StreamResourceHolder::new(StreamResource::TcpStream(Some(
           tcp_stream,
@@ -297,8 +277,7 @@ async fn op_connect(
         net_unix::UnixStream::connect(net_unix::Path::new(&path)).await?;
       let local_addr = unix_stream.local_addr()?;
       let remote_addr = unix_stream.peer_addr()?;
-      let mut resource_table = resource_table.borrow_mut();
-      let rid = resource_table.add(
+      let rid = state.resource_table.borrow_mut().add(
         "unixStream",
         Box::new(StreamResourceHolder::new(StreamResource::UnixStream(
           unix_stream,
@@ -328,7 +307,6 @@ struct ShutdownArgs {
 
 fn op_shutdown(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -345,6 +323,7 @@ fn op_shutdown(
     _ => unimplemented!(),
   };
 
+  let mut resource_table = state.resource_table.borrow_mut();
   let resource_holder = resource_table
     .get_mut::<StreamResourceHolder>(rid)
     .ok_or_else(ErrBox::bad_resource_id)?;
@@ -437,7 +416,7 @@ struct ListenArgs {
 }
 
 fn listen_tcp(
-  resource_table: &mut ResourceTable,
+  state: &State,
   addr: SocketAddr,
 ) -> Result<(u32, SocketAddr), ErrBox> {
   let std_listener = std::net::TcpListener::bind(&addr)?;
@@ -448,27 +427,32 @@ fn listen_tcp(
     waker: None,
     local_addr,
   };
-  let rid = resource_table.add("tcpListener", Box::new(listener_resource));
+  let rid = state
+    .resource_table
+    .borrow_mut()
+    .add("tcpListener", Box::new(listener_resource));
 
   Ok((rid, local_addr))
 }
 
 fn listen_udp(
-  resource_table: &mut ResourceTable,
+  state: &State,
   addr: SocketAddr,
 ) -> Result<(u32, SocketAddr), ErrBox> {
   let std_socket = std::net::UdpSocket::bind(&addr)?;
   let socket = UdpSocket::from_std(std_socket)?;
   let local_addr = socket.local_addr()?;
   let socket_resource = UdpSocketResource { socket };
-  let rid = resource_table.add("udpSocket", Box::new(socket_resource));
+  let rid = state
+    .resource_table
+    .borrow_mut()
+    .add("udpSocket", Box::new(socket_resource));
 
   Ok((rid, local_addr))
 }
 
 fn op_listen(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -483,9 +467,9 @@ fn op_listen(
       state.check_net(&args.hostname, args.port)?;
       let addr = resolve_addr(&args.hostname, args.port)?;
       let (rid, local_addr) = if transport == "tcp" {
-        listen_tcp(resource_table, addr)?
+        listen_tcp(state, addr)?
       } else {
-        listen_udp(resource_table, addr)?
+        listen_udp(state, addr)?
       };
       debug!(
         "New listener {} {}:{}",
@@ -517,9 +501,9 @@ fn op_listen(
       state.check_read(&address_path)?;
       state.check_write(&address_path)?;
       let (rid, local_addr) = if transport == "unix" {
-        net_unix::listen_unix(resource_table, &address_path)?
+        net_unix::listen_unix(state, &address_path)?
       } else {
-        net_unix::listen_unix_packet(resource_table, &address_path)?
+        net_unix::listen_unix_packet(state, &address_path)?
       };
       debug!(
         "New listener {} {}",
diff --git a/cli/ops/net_unix.rs b/cli/ops/net_unix.rs
index 29851b093..a73db89b2 100644
--- a/cli/ops/net_unix.rs
+++ b/cli/ops/net_unix.rs
@@ -1,9 +1,12 @@
-use super::dispatch_json::{Deserialize, Value};
-use super::io::{StreamResource, StreamResourceHolder};
+use crate::ops::io::StreamResource;
+use crate::ops::io::StreamResourceHolder;
+use crate::ops::net::AcceptArgs;
+use crate::ops::net::ReceiveArgs;
+use crate::state::State;
 use deno_core::BufVec;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
-use std::cell::RefCell;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::fs::remove_file;
 use std::os::unix;
 pub use std::path::Path;
@@ -26,24 +29,25 @@ pub struct UnixListenArgs {
   pub path: String,
 }
 
-pub async fn accept_unix(
-  resource_table: Rc<RefCell<ResourceTable>>,
-  rid: u32,
-  _zero_copy: BufVec,
+pub(crate) async fn accept_unix(
+  state: Rc<State>,
+  args: AcceptArgs,
+  _bufs: BufVec,
 ) -> Result<Value, ErrBox> {
-  let mut resource_table_ = resource_table.borrow_mut();
+  let rid = args.rid as u32;
+
+  let mut resource_table_ = state.resource_table.borrow_mut();
   let listener_resource = {
     resource_table_
       .get_mut::<UnixListenerResource>(rid)
       .ok_or_else(|| ErrBox::bad_resource("Listener has been closed"))?
   };
-
   let (unix_stream, _socket_addr) = listener_resource.listener.accept().await?;
   drop(resource_table_);
 
   let local_addr = unix_stream.local_addr()?;
   let remote_addr = unix_stream.peer_addr()?;
-  let mut resource_table_ = resource_table.borrow_mut();
+  let mut resource_table_ = state.resource_table.borrow_mut();
   let rid = resource_table_.add(
     "unixStream",
     Box::new(StreamResourceHolder::new(StreamResource::UnixStream(
@@ -63,19 +67,21 @@ pub async fn accept_unix(
   }))
 }
 
-pub async fn receive_unix_packet(
-  resource_table: Rc<RefCell<ResourceTable>>,
-  rid: u32,
-  zero_copy: BufVec,
+pub(crate) async fn receive_unix_packet(
+  state: Rc<State>,
+  args: ReceiveArgs,
+  bufs: BufVec,
 ) -> Result<Value, ErrBox> {
-  assert_eq!(zero_copy.len(), 1, "Invalid number of arguments");
-  let mut zero_copy = zero_copy[0].clone();
+  assert_eq!(bufs.len(), 1, "Invalid number of arguments");
+
+  let rid = args.rid as u32;
+  let mut buf = bufs.into_iter().next().unwrap();
 
-  let mut resource_table_ = resource_table.borrow_mut();
+  let mut resource_table_ = state.resource_table.borrow_mut();
   let resource = resource_table_
     .get_mut::<UnixDatagramResource>(rid)
     .ok_or_else(|| ErrBox::bad_resource("Socket has been closed"))?;
-  let (size, remote_addr) = resource.socket.recv_from(&mut zero_copy).await?;
+  let (size, remote_addr) = resource.socket.recv_from(&mut buf).await?;
   Ok(json!({
     "size": size,
     "remoteAddr": {
@@ -86,7 +92,7 @@ pub async fn receive_unix_packet(
 }
 
 pub fn listen_unix(
-  resource_table: &mut ResourceTable,
+  state: &State,
   addr: &Path,
 ) -> Result<(u32, unix::net::SocketAddr), ErrBox> {
   if addr.exists() {
@@ -95,13 +101,16 @@ pub fn listen_unix(
   let listener = UnixListener::bind(&addr)?;
   let local_addr = listener.local_addr()?;
   let listener_resource = UnixListenerResource { listener };
-  let rid = resource_table.add("unixListener", Box::new(listener_resource));
+  let rid = state
+    .resource_table
+    .borrow_mut()
+    .add("unixListener", Box::new(listener_resource));
 
   Ok((rid, local_addr))
 }
 
 pub fn listen_unix_packet(
-  resource_table: &mut ResourceTable,
+  state: &State,
   addr: &Path,
 ) -> Result<(u32, unix::net::SocketAddr), ErrBox> {
   if addr.exists() {
@@ -113,7 +122,10 @@ pub fn listen_unix_packet(
     socket,
     local_addr: local_addr.clone(),
   };
-  let rid = resource_table.add("unixDatagram", Box::new(datagram_resource));
+  let rid = state
+    .resource_table
+    .borrow_mut()
+    .add("unixDatagram", Box::new(datagram_resource));
 
   Ok((rid, local_addr))
 }
diff --git a/cli/ops/os.rs b/cli/ops/os.rs
index 7a2a7155e..4778d49a4 100644
--- a/cli/ops/os.rs
+++ b/cli/ops/os.rs
@@ -1,32 +1,30 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{Deserialize, Value};
+
 use crate::state::State;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::collections::HashMap;
 use std::env;
 use std::rc::Rc;
 use url::Url;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op("op_exit", s.stateful_json_op_sync(t, op_exit));
-  i.register_op("op_env", s.stateful_json_op_sync(t, op_env));
-  i.register_op("op_exec_path", s.stateful_json_op_sync(t, op_exec_path));
-  i.register_op("op_set_env", s.stateful_json_op_sync(t, op_set_env));
-  i.register_op("op_get_env", s.stateful_json_op_sync(t, op_get_env));
-  i.register_op("op_delete_env", s.stateful_json_op_sync(t, op_delete_env));
-  i.register_op("op_hostname", s.stateful_json_op_sync(t, op_hostname));
-  i.register_op("op_loadavg", s.stateful_json_op_sync(t, op_loadavg));
-  i.register_op("op_os_release", s.stateful_json_op_sync(t, op_os_release));
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_exit", op_exit);
+  s.register_op_json_sync("op_env", op_env);
+  s.register_op_json_sync("op_exec_path", op_exec_path);
+  s.register_op_json_sync("op_set_env", op_set_env);
+  s.register_op_json_sync("op_get_env", op_get_env);
+  s.register_op_json_sync("op_delete_env", op_delete_env);
+  s.register_op_json_sync("op_hostname", op_hostname);
+  s.register_op_json_sync("op_loadavg", op_loadavg);
+  s.register_op_json_sync("op_os_release", op_os_release);
 }
 
 fn op_exec_path(
   state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -47,7 +45,6 @@ struct SetEnv {
 
 fn op_set_env(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -59,7 +56,6 @@ fn op_set_env(
 
 fn op_env(
   state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -75,7 +71,6 @@ struct GetEnv {
 
 fn op_get_env(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -95,7 +90,6 @@ struct DeleteEnv {
 
 fn op_delete_env(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -112,7 +106,6 @@ struct Exit {
 
 fn op_exit(
   _state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -122,7 +115,6 @@ fn op_exit(
 
 fn op_loadavg(
   state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -136,7 +128,6 @@ fn op_loadavg(
 
 fn op_hostname(
   state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -148,7 +139,6 @@ fn op_hostname(
 
 fn op_os_release(
   state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
diff --git a/cli/ops/permissions.rs b/cli/ops/permissions.rs
index 1d19f91d4..90d21a726 100644
--- a/cli/ops/permissions.rs
+++ b/cli/ops/permissions.rs
@@ -1,28 +1,18 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{Deserialize, Value};
+
 use crate::state::State;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::path::Path;
 use std::rc::Rc;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op(
-    "op_query_permission",
-    s.stateful_json_op_sync(t, op_query_permission),
-  );
-  i.register_op(
-    "op_revoke_permission",
-    s.stateful_json_op_sync(t, op_revoke_permission),
-  );
-  i.register_op(
-    "op_request_permission",
-    s.stateful_json_op_sync(t, op_request_permission),
-  );
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_query_permission", op_query_permission);
+  s.register_op_json_sync("op_revoke_permission", op_revoke_permission);
+  s.register_op_json_sync("op_request_permission", op_request_permission);
 }
 
 #[derive(Deserialize)]
@@ -34,7 +24,6 @@ struct PermissionArgs {
 
 pub fn op_query_permission(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -61,7 +50,6 @@ pub fn op_query_permission(
 
 pub fn op_revoke_permission(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -88,7 +76,6 @@ pub fn op_revoke_permission(
 
 pub fn op_request_permission(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
diff --git a/cli/ops/plugin.rs b/cli/ops/plugin.rs
index bd1a0a002..9cab05011 100644
--- a/cli/ops/plugin.rs
+++ b/cli/ops/plugin.rs
@@ -1,26 +1,26 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use crate::ops::dispatch_json::Deserialize;
-use crate::ops::dispatch_json::JsonOp;
-use crate::ops::dispatch_json::Value;
+
 use crate::state::State;
 use deno_core::plugin_api;
-use deno_core::CoreIsolate;
-use deno_core::CoreIsolateState;
+use deno_core::BufVec;
 use deno_core::ErrBox;
 use deno_core::Op;
 use deno_core::OpAsyncFuture;
 use deno_core::OpId;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
 use dlopen::symbor::Library;
 use futures::prelude::*;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::path::PathBuf;
 use std::pin::Pin;
 use std::rc::Rc;
 use std::task::Context;
 use std::task::Poll;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  i.register_op("op_open_plugin", s.stateful_json_op2(op_open_plugin));
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_open_plugin", op_open_plugin);
 }
 
 #[derive(Deserialize)]
@@ -30,12 +30,12 @@ struct OpenPluginArgs {
 }
 
 pub fn op_open_plugin(
-  isolate_state: &mut CoreIsolateState,
-  state: &Rc<State>,
+  state: &State,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
+) -> Result<Value, ErrBox> {
   state.check_unstable("Deno.openPlugin");
+
   let args: OpenPluginArgs = serde_json::from_value(args).unwrap();
   let filename = PathBuf::from(&args.filename);
 
@@ -45,22 +45,25 @@ pub fn op_open_plugin(
   let plugin_lib = Library::open(filename).map(Rc::new)?;
   let plugin_resource = PluginResource::new(&plugin_lib);
 
-  let mut resource_table = isolate_state.resource_table.borrow_mut();
-  let rid = resource_table.add("plugin", Box::new(plugin_resource));
-  let plugin_resource = resource_table.get::<PluginResource>(rid).unwrap();
-
-  let deno_plugin_init = *unsafe {
-    plugin_resource
-      .lib
-      .symbol::<plugin_api::InitFn>("deno_plugin_init")
+  let rid;
+  let deno_plugin_init;
+  {
+    let mut resource_table = state.resource_table.borrow_mut();
+    rid = resource_table.add("plugin", Box::new(plugin_resource));
+    deno_plugin_init = *unsafe {
+      resource_table
+        .get::<PluginResource>(rid)
+        .unwrap()
+        .lib
+        .symbol::<plugin_api::InitFn>("deno_plugin_init")
+        .unwrap()
+    };
   }
-  .unwrap();
-  drop(resource_table);
 
-  let mut interface = PluginInterface::new(isolate_state, &plugin_lib);
+  let mut interface = PluginInterface::new(state, &plugin_lib);
   deno_plugin_init(&mut interface);
 
-  Ok(JsonOp::Sync(json!(rid)))
+  Ok(json!(rid))
 }
 
 struct PluginResource {
@@ -74,19 +77,13 @@ impl PluginResource {
 }
 
 struct PluginInterface<'a> {
-  isolate_state: &'a mut CoreIsolateState,
+  state: &'a State,
   plugin_lib: &'a Rc<Library>,
 }
 
 impl<'a> PluginInterface<'a> {
-  fn new(
-    isolate_state: &'a mut CoreIsolateState,
-    plugin_lib: &'a Rc<Library>,
-  ) -> Self {
-    Self {
-      isolate_state,
-      plugin_lib,
-    }
+  fn new(state: &'a State, plugin_lib: &'a Rc<Library>) -> Self {
+    Self { state, plugin_lib }
   }
 }
 
@@ -102,11 +99,11 @@ impl<'a> plugin_api::Interface for PluginInterface<'a> {
     dispatch_op_fn: plugin_api::DispatchOpFn,
   ) -> OpId {
     let plugin_lib = self.plugin_lib.clone();
-    self.isolate_state.op_registry.register(
+    self.state.register_op(
       name,
-      move |isolate_state, zero_copy| {
-        let mut interface = PluginInterface::new(isolate_state, &plugin_lib);
-        let op = dispatch_op_fn(&mut interface, zero_copy);
+      move |state: Rc<State>, mut zero_copy: BufVec| {
+        let mut interface = PluginInterface::new(&state, &plugin_lib);
+        let op = dispatch_op_fn(&mut interface, &mut zero_copy);
         match op {
           sync_op @ Op::Sync(..) => sync_op,
           Op::Async(fut) => {
@@ -115,6 +112,7 @@ impl<'a> plugin_api::Interface for PluginInterface<'a> {
           Op::AsyncUnref(fut) => {
             Op::AsyncUnref(PluginOpAsyncFuture::new(&plugin_lib, fut))
           }
+          _ => unreachable!(),
         }
       },
     )
diff --git a/cli/ops/process.rs b/cli/ops/process.rs
index 836db08cd..fb8675db9 100644
--- a/cli/ops/process.rs
+++ b/cli/ops/process.rs
@@ -1,35 +1,30 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{Deserialize, Value};
+
 use super::io::{std_file_resource, StreamResource, StreamResourceHolder};
 use crate::signal::kill;
 use crate::state::State;
 use deno_core::BufVec;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
 use futures::future::poll_fn;
 use futures::future::FutureExt;
-use std::cell::RefCell;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::rc::Rc;
 use tokio::process::Command;
 
 #[cfg(unix)]
 use std::os::unix::process::ExitStatusExt;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op("op_run", s.stateful_json_op_sync(t, op_run));
-  i.register_op("op_run_status", s.stateful_json_op_async(t, op_run_status));
-  i.register_op("op_kill", s.stateful_json_op_sync(t, op_kill));
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_run", op_run);
+  s.register_op_json_async("op_run_status", op_run_status);
+  s.register_op_json_sync("op_kill", op_kill);
 }
 
-fn clone_file(
-  rid: u32,
-  resource_table: &mut ResourceTable,
-) -> Result<std::fs::File, ErrBox> {
-  std_file_resource(resource_table, rid, move |r| match r {
+fn clone_file(state: &State, rid: u32) -> Result<std::fs::File, ErrBox> {
+  std_file_resource(state, rid, move |r| match r {
     Ok(std_file) => std_file.try_clone().map_err(ErrBox::from),
     Err(_) => Err(ErrBox::bad_resource_id()),
   })
@@ -64,7 +59,6 @@ struct ChildResource {
 
 fn op_run(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -90,21 +84,21 @@ fn op_run(
   if run_args.stdin != "" {
     c.stdin(subprocess_stdio_map(run_args.stdin.as_ref())?);
   } else {
-    let file = clone_file(run_args.stdin_rid, resource_table)?;
+    let file = clone_file(state, run_args.stdin_rid)?;
     c.stdin(file);
   }
 
   if run_args.stdout != "" {
     c.stdout(subprocess_stdio_map(run_args.stdout.as_ref())?);
   } else {
-    let file = clone_file(run_args.stdout_rid, resource_table)?;
+    let file = clone_file(state, run_args.stdout_rid)?;
     c.stdout(file);
   }
 
   if run_args.stderr != "" {
     c.stderr(subprocess_stdio_map(run_args.stderr.as_ref())?);
   } else {
-    let file = clone_file(run_args.stderr_rid, resource_table)?;
+    let file = clone_file(state, run_args.stderr_rid)?;
     c.stderr(file);
   }
 
@@ -117,7 +111,7 @@ fn op_run(
 
   let stdin_rid = match child.stdin.take() {
     Some(child_stdin) => {
-      let rid = resource_table.add(
+      let rid = state.resource_table.borrow_mut().add(
         "childStdin",
         Box::new(StreamResourceHolder::new(StreamResource::ChildStdin(
           child_stdin,
@@ -130,7 +124,7 @@ fn op_run(
 
   let stdout_rid = match child.stdout.take() {
     Some(child_stdout) => {
-      let rid = resource_table.add(
+      let rid = state.resource_table.borrow_mut().add(
         "childStdout",
         Box::new(StreamResourceHolder::new(StreamResource::ChildStdout(
           child_stdout,
@@ -143,7 +137,7 @@ fn op_run(
 
   let stderr_rid = match child.stderr.take() {
     Some(child_stderr) => {
-      let rid = resource_table.add(
+      let rid = state.resource_table.borrow_mut().add(
         "childStderr",
         Box::new(StreamResourceHolder::new(StreamResource::ChildStderr(
           child_stderr,
@@ -155,7 +149,10 @@ fn op_run(
   };
 
   let child_resource = ChildResource { child };
-  let child_rid = resource_table.add("child", Box::new(child_resource));
+  let child_rid = state
+    .resource_table
+    .borrow_mut()
+    .add("child", Box::new(child_resource));
 
   Ok(json!({
     "rid": child_rid,
@@ -174,7 +171,6 @@ struct RunStatusArgs {
 
 async fn op_run_status(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -184,7 +180,7 @@ async fn op_run_status(
   state.check_run()?;
 
   let run_status = poll_fn(|cx| {
-    let mut resource_table = resource_table.borrow_mut();
+    let mut resource_table = state.resource_table.borrow_mut();
     let child_resource = resource_table
       .get_mut::<ChildResource>(rid)
       .ok_or_else(ErrBox::bad_resource_id)?;
@@ -220,7 +216,6 @@ struct KillArgs {
 
 fn op_kill(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
diff --git a/cli/ops/random.rs b/cli/ops/random.rs
index fb2286116..4ce1411b8 100644
--- a/cli/ops/random.rs
+++ b/cli/ops/random.rs
@@ -1,26 +1,20 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::Value;
+
 use crate::state::State;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
 use rand::thread_rng;
 use rand::Rng;
+use serde_json::Value;
 use std::rc::Rc;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op(
-    "op_get_random_values",
-    s.stateful_json_op_sync(t, op_get_random_values),
-  );
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_get_random_values", op_get_random_values);
 }
 
 fn op_get_random_values(
   state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
diff --git a/cli/ops/repl.rs b/cli/ops/repl.rs
index 82fa3e23e..300432832 100644
--- a/cli/ops/repl.rs
+++ b/cli/ops/repl.rs
@@ -1,26 +1,21 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{Deserialize, Value};
+
 use crate::repl;
 use crate::repl::Repl;
 use crate::state::State;
 use deno_core::BufVec;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
-use std::cell::RefCell;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::rc::Rc;
 use std::sync::Arc;
 use std::sync::Mutex;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op("op_repl_start", s.stateful_json_op_sync(t, op_repl_start));
-  i.register_op(
-    "op_repl_readline",
-    s.stateful_json_op_async(t, op_repl_readline),
-  );
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_repl_start", op_repl_start);
+  s.register_op_json_async("op_repl_readline", op_repl_readline);
 }
 
 struct ReplResource(Arc<Mutex<Repl>>);
@@ -33,7 +28,6 @@ struct ReplStartArgs {
 
 fn op_repl_start(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -43,7 +37,10 @@ fn op_repl_start(
     repl::history_path(&state.global_state.dir, &args.history_file);
   let repl = repl::Repl::new(history_path);
   let resource = ReplResource(Arc::new(Mutex::new(repl)));
-  let rid = resource_table.add("repl", Box::new(resource));
+  let rid = state
+    .resource_table
+    .borrow_mut()
+    .add("repl", Box::new(resource));
   Ok(json!(rid))
 }
 
@@ -54,8 +51,7 @@ struct ReplReadlineArgs {
 }
 
 async fn op_repl_readline(
-  _state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
+  state: Rc<State>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -63,7 +59,7 @@ async fn op_repl_readline(
   let rid = args.rid as u32;
   let prompt = args.prompt;
   debug!("op_repl_readline {} {}", rid, prompt);
-  let resource_table = resource_table.borrow();
+  let resource_table = state.resource_table.borrow();
   let resource = resource_table
     .get::<ReplResource>(rid)
     .ok_or_else(ErrBox::bad_resource_id)?;
diff --git a/cli/ops/resources.rs b/cli/ops/resources.rs
index 0493aeed3..d7c2fd142 100644
--- a/cli/ops/resources.rs
+++ b/cli/ops/resources.rs
@@ -1,33 +1,31 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{Deserialize, Value};
+
 use crate::state::State;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::rc::Rc;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op("op_resources", s.stateful_json_op_sync(t, op_resources));
-  i.register_op("op_close", s.stateful_json_op_sync(t, op_close));
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_resources", op_resources);
+  s.register_op_json_sync("op_close", op_close);
 }
 
 fn op_resources(
-  _state: &State,
-  resource_table: &mut ResourceTable,
+  state: &State,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
+  let resource_table = state.resource_table.borrow();
   let serialized_resources = resource_table.entries();
   Ok(json!(serialized_resources))
 }
 
 /// op_close removes a resource from the resource table.
 fn op_close(
-  _state: &State,
-  resource_table: &mut ResourceTable,
+  state: &State,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -36,7 +34,9 @@ fn op_close(
     rid: i32,
   }
   let args: CloseArgs = serde_json::from_value(args)?;
-  resource_table
+  state
+    .resource_table
+    .borrow_mut()
     .close(args.rid as u32)
     .ok_or_else(ErrBox::bad_resource_id)?;
   Ok(json!({}))
diff --git a/cli/ops/runtime.rs b/cli/ops/runtime.rs
index 119e152c8..10aac11fa 100644
--- a/cli/ops/runtime.rs
+++ b/cli/ops/runtime.rs
@@ -1,28 +1,25 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::Value;
+
 use crate::colors;
 use crate::state::State;
 use crate::version;
 use crate::DenoSubcommand;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
 use deno_core::ModuleSpecifier;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
+use serde_json::Value;
 use std::env;
 use std::rc::Rc;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op("op_start", s.stateful_json_op_sync(t, op_start));
-  i.register_op("op_main_module", s.stateful_json_op_sync(t, op_main_module));
-  i.register_op("op_metrics", s.stateful_json_op_sync(t, op_metrics));
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_start", op_start);
+  s.register_op_json_sync("op_main_module", op_main_module);
+  s.register_op_json_sync("op_metrics", op_metrics);
 }
 
 fn op_start(
   state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -48,7 +45,6 @@ fn op_start(
 
 fn op_main_module(
   state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -63,7 +59,6 @@ fn op_main_module(
 
 fn op_metrics(
   state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
diff --git a/cli/ops/runtime_compiler.rs b/cli/ops/runtime_compiler.rs
index a5991dabf..71974e6da 100644
--- a/cli/ops/runtime_compiler.rs
+++ b/cli/ops/runtime_compiler.rs
@@ -1,23 +1,21 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{Deserialize, Value};
+
 use crate::futures::FutureExt;
 use crate::state::State;
 use crate::tsc::runtime_bundle;
 use crate::tsc::runtime_compile;
 use crate::tsc::runtime_transpile;
 use deno_core::BufVec;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
-use std::cell::RefCell;
+use deno_core::OpRegistry;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::collections::HashMap;
 use std::rc::Rc;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op("op_compile", s.stateful_json_op_async(t, op_compile));
-  i.register_op("op_transpile", s.stateful_json_op_async(t, op_transpile));
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_async("op_compile", op_compile);
+  s.register_op_json_async("op_transpile", op_transpile);
 }
 
 #[derive(Deserialize, Debug)]
@@ -31,7 +29,6 @@ struct CompileArgs {
 
 async fn op_compile(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _data: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -70,7 +67,6 @@ struct TranspileArgs {
 
 async fn op_transpile(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _data: BufVec,
 ) -> Result<Value, ErrBox> {
diff --git a/cli/ops/signal.rs b/cli/ops/signal.rs
index 8c0b338b3..c0b1220e0 100644
--- a/cli/ops/signal.rs
+++ b/cli/ops/signal.rs
@@ -1,35 +1,26 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::Value;
+
 use crate::state::State;
 use deno_core::BufVec;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
-use std::cell::RefCell;
+use serde_json::Value;
 use std::rc::Rc;
 
 #[cfg(unix)]
-use super::dispatch_json::Deserialize;
-#[cfg(unix)]
 use futures::future::poll_fn;
 #[cfg(unix)]
+use serde_derive::Deserialize;
+#[cfg(unix)]
 use std::task::Waker;
 #[cfg(unix)]
 use tokio::signal::unix::{signal, Signal, SignalKind};
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op("op_signal_bind", s.stateful_json_op_sync(t, op_signal_bind));
-  i.register_op(
-    "op_signal_unbind",
-    s.stateful_json_op_sync(t, op_signal_unbind),
-  );
-  i.register_op(
-    "op_signal_poll",
-    s.stateful_json_op_async(t, op_signal_poll),
-  );
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_signal_bind", op_signal_bind);
+  s.register_op_json_sync("op_signal_unbind", op_signal_unbind);
+  s.register_op_json_async("op_signal_poll", op_signal_poll);
 }
 
 #[cfg(unix)]
@@ -52,13 +43,12 @@ struct SignalArgs {
 #[cfg(unix)]
 fn op_signal_bind(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
   state.check_unstable("Deno.signal");
   let args: BindSignalArgs = serde_json::from_value(args)?;
-  let rid = resource_table.add(
+  let rid = state.resource_table.borrow_mut().add(
     "signal",
     Box::new(SignalStreamResource(
       signal(SignalKind::from_raw(args.signo)).expect(""),
@@ -73,7 +63,6 @@ fn op_signal_bind(
 #[cfg(unix)]
 async fn op_signal_poll(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -82,7 +71,7 @@ async fn op_signal_poll(
   let rid = args.rid as u32;
 
   let future = poll_fn(move |cx| {
-    let mut resource_table = resource_table.borrow_mut();
+    let mut resource_table = state.resource_table.borrow_mut();
     if let Some(mut signal) =
       resource_table.get_mut::<SignalStreamResource>(rid)
     {
@@ -98,14 +87,14 @@ async fn op_signal_poll(
 #[cfg(unix)]
 pub fn op_signal_unbind(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
   state.check_unstable("Deno.signal");
+  let mut resource_table = state.resource_table.borrow_mut();
   let args: SignalArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
-  let resource = resource_table.get::<SignalStreamResource>(rid);
+  let resource = resource_table.get_mut::<SignalStreamResource>(rid);
   if let Some(signal) = resource {
     if let Some(waker) = &signal.1 {
       // Wakes up the pending poll if exists.
@@ -122,7 +111,6 @@ pub fn op_signal_unbind(
 #[cfg(not(unix))]
 pub fn op_signal_bind(
   _state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -132,7 +120,6 @@ pub fn op_signal_bind(
 #[cfg(not(unix))]
 fn op_signal_unbind(
   _state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -142,7 +129,6 @@ fn op_signal_unbind(
 #[cfg(not(unix))]
 async fn op_signal_poll(
   _state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   _args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
diff --git a/cli/ops/timers.rs b/cli/ops/timers.rs
index 66a9b007b..36d617a85 100644
--- a/cli/ops/timers.rs
+++ b/cli/ops/timers.rs
@@ -1,34 +1,25 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{Deserialize, Value};
+
 use crate::state::State;
 use deno_core::BufVec;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
 use futures::future::FutureExt;
-use std::cell::RefCell;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::rc::Rc;
 use std::time::Duration;
 use std::time::Instant;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op(
-    "op_global_timer_stop",
-    s.stateful_json_op_sync(t, op_global_timer_stop),
-  );
-  i.register_op(
-    "op_global_timer",
-    s.stateful_json_op_async(t, op_global_timer),
-  );
-  i.register_op("op_now", s.stateful_json_op_sync(t, op_now));
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_global_timer_stop", op_global_timer_stop);
+  s.register_op_json_async("op_global_timer", op_global_timer);
+  s.register_op_json_sync("op_now", op_now);
 }
 
 fn op_global_timer_stop(
   state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -43,7 +34,6 @@ struct GlobalTimerArgs {
 
 async fn op_global_timer(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -66,7 +56,6 @@ async fn op_global_timer(
 // nanoseconds are rounded on 2ms.
 fn op_now(
   state: &State,
-  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
diff --git a/cli/ops/tls.rs b/cli/ops/tls.rs
index 4a7b9613e..3a478c3ad 100644
--- a/cli/ops/tls.rs
+++ b/cli/ops/tls.rs
@@ -1,15 +1,15 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{Deserialize, Value};
+
 use super::io::{StreamResource, StreamResourceHolder};
 use crate::resolve_addr::resolve_addr;
 use crate::state::State;
 use deno_core::BufVec;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
 use futures::future::poll_fn;
-use std::cell::RefCell;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::convert::From;
 use std::fs::File;
 use std::io::BufReader;
@@ -31,16 +31,11 @@ use tokio_rustls::{
 };
 use webpki::DNSNameRef;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op("op_start_tls", s.stateful_json_op_async(t, op_start_tls));
-  i.register_op(
-    "op_connect_tls",
-    s.stateful_json_op_async(t, op_connect_tls),
-  );
-  i.register_op("op_listen_tls", s.stateful_json_op_sync(t, op_listen_tls));
-  i.register_op("op_accept_tls", s.stateful_json_op_async(t, op_accept_tls));
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_async("op_start_tls", op_start_tls);
+  s.register_op_json_async("op_connect_tls", op_connect_tls);
+  s.register_op_json_sync("op_listen_tls", op_listen_tls);
+  s.register_op_json_async("op_accept_tls", op_accept_tls);
 }
 
 #[derive(Deserialize)]
@@ -62,7 +57,6 @@ struct StartTLSArgs {
 
 async fn op_start_tls(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -82,8 +76,8 @@ async fn op_start_tls(
   }
 
   let mut resource_holder = {
-    let mut resource_table_ = resource_table.borrow_mut();
-    match resource_table_.remove::<StreamResourceHolder>(rid) {
+    let mut resource_table = state.resource_table.borrow_mut();
+    match resource_table.remove::<StreamResourceHolder>(rid) {
       Some(resource) => *resource,
       None => return Err(ErrBox::bad_resource_id()),
     }
@@ -110,8 +104,8 @@ async fn op_start_tls(
       DNSNameRef::try_from_ascii_str(&domain).expect("Invalid DNS lookup");
     let tls_stream = tls_connector.connect(dnsname, tcp_stream).await?;
 
-    let mut resource_table_ = resource_table.borrow_mut();
-    let rid = resource_table_.add(
+    let mut resource_table = state.resource_table.borrow_mut();
+    let rid = resource_table.add(
       "clientTlsStream",
       Box::new(StreamResourceHolder::new(StreamResource::ClientTlsStream(
         Box::new(tls_stream),
@@ -137,7 +131,6 @@ async fn op_start_tls(
 
 async fn op_connect_tls(
   state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -170,8 +163,8 @@ async fn op_connect_tls(
   let dnsname =
     DNSNameRef::try_from_ascii_str(&domain).expect("Invalid DNS lookup");
   let tls_stream = tls_connector.connect(dnsname, tcp_stream).await?;
-  let mut resource_table_ = resource_table.borrow_mut();
-  let rid = resource_table_.add(
+  let mut resource_table = state.resource_table.borrow_mut();
+  let rid = resource_table.add(
     "clientTlsStream",
     Box::new(StreamResourceHolder::new(StreamResource::ClientTlsStream(
       Box::new(tls_stream),
@@ -306,7 +299,6 @@ struct ListenTlsArgs {
 
 fn op_listen_tls(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -336,7 +328,10 @@ fn op_listen_tls(
     local_addr,
   };
 
-  let rid = resource_table.add("tlsListener", Box::new(tls_listener_resource));
+  let rid = state
+    .resource_table
+    .borrow_mut()
+    .add("tlsListener", Box::new(tls_listener_resource));
 
   Ok(json!({
     "rid": rid,
@@ -354,15 +349,14 @@ struct AcceptTlsArgs {
 }
 
 async fn op_accept_tls(
-  _state: Rc<State>,
-  resource_table: Rc<RefCell<ResourceTable>>,
+  state: Rc<State>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
   let args: AcceptTlsArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
   let accept_fut = poll_fn(|cx| {
-    let mut resource_table = resource_table.borrow_mut();
+    let mut resource_table = state.resource_table.borrow_mut();
     let listener_resource = resource_table
       .get_mut::<TlsListenerResource>(rid)
       .ok_or_else(|| ErrBox::bad_resource("Listener has been closed"))?;
@@ -386,7 +380,7 @@ async fn op_accept_tls(
   let local_addr = tcp_stream.local_addr()?;
   let remote_addr = tcp_stream.peer_addr()?;
   let tls_acceptor = {
-    let resource_table = resource_table.borrow();
+    let resource_table = state.resource_table.borrow();
     let resource = resource_table
       .get::<TlsListenerResource>(rid)
       .ok_or_else(ErrBox::bad_resource_id)
@@ -395,7 +389,7 @@ async fn op_accept_tls(
   };
   let tls_stream = tls_acceptor.accept(tcp_stream).await?;
   let rid = {
-    let mut resource_table = resource_table.borrow_mut();
+    let mut resource_table = state.resource_table.borrow_mut();
     resource_table.add(
       "serverTlsStream",
       Box::new(StreamResourceHolder::new(StreamResource::ServerTlsStream(
diff --git a/cli/ops/tty.rs b/cli/ops/tty.rs
index bb8ad8714..9079ca57e 100644
--- a/cli/ops/tty.rs
+++ b/cli/ops/tty.rs
@@ -1,10 +1,10 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use super::io::std_file_resource;
 use super::io::{StreamResource, StreamResourceHolder};
 use crate::state::State;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
 #[cfg(unix)]
 use nix::sys::termios;
@@ -36,15 +36,10 @@ fn get_windows_handle(
   Ok(handle)
 }
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op("op_set_raw", s.stateful_json_op_sync(t, op_set_raw));
-  i.register_op("op_isatty", s.stateful_json_op_sync(t, op_isatty));
-  i.register_op(
-    "op_console_size",
-    s.stateful_json_op_sync(t, op_console_size),
-  );
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_set_raw", op_set_raw);
+  s.register_op_json_sync("op_isatty", op_isatty);
+  s.register_op_json_sync("op_console_size", op_console_size);
 }
 
 #[derive(Deserialize)]
@@ -55,7 +50,6 @@ struct SetRawArgs {
 
 fn op_set_raw(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -75,6 +69,7 @@ fn op_set_raw(
     use winapi::shared::minwindef::FALSE;
     use winapi::um::{consoleapi, handleapi};
 
+    let mut resource_table = state.resource_table.borrow_mut();
     let resource_holder = resource_table.get_mut::<StreamResourceHolder>(rid);
     if resource_holder.is_none() {
       return Err(ErrBox::bad_resource_id());
@@ -140,6 +135,7 @@ fn op_set_raw(
   {
     use std::os::unix::io::AsRawFd;
 
+    let mut resource_table = state.resource_table.borrow_mut();
     let resource_holder = resource_table.get_mut::<StreamResourceHolder>(rid);
     if resource_holder.is_none() {
       return Err(ErrBox::bad_resource_id());
@@ -221,37 +217,35 @@ struct IsattyArgs {
 }
 
 fn op_isatty(
-  _state: &State,
-  resource_table: &mut ResourceTable,
+  state: &State,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
   let args: IsattyArgs = serde_json::from_value(args)?;
   let rid = args.rid;
 
-  let isatty: bool =
-    std_file_resource(resource_table, rid as u32, move |r| match r {
-      Ok(std_file) => {
-        #[cfg(windows)]
-        {
-          use winapi::um::consoleapi;
-
-          let handle = get_windows_handle(&std_file)?;
-          let mut test_mode: DWORD = 0;
-          // If I cannot get mode out of console, it is not a console.
-          Ok(unsafe { consoleapi::GetConsoleMode(handle, &mut test_mode) != 0 })
-        }
-        #[cfg(unix)]
-        {
-          use std::os::unix::io::AsRawFd;
-          let raw_fd = std_file.as_raw_fd();
-          Ok(unsafe { libc::isatty(raw_fd as libc::c_int) == 1 })
-        }
+  let isatty: bool = std_file_resource(state, rid as u32, move |r| match r {
+    Ok(std_file) => {
+      #[cfg(windows)]
+      {
+        use winapi::um::consoleapi;
+
+        let handle = get_windows_handle(&std_file)?;
+        let mut test_mode: DWORD = 0;
+        // If I cannot get mode out of console, it is not a console.
+        Ok(unsafe { consoleapi::GetConsoleMode(handle, &mut test_mode) != 0 })
       }
-      Err(StreamResource::FsFile(_)) => unreachable!(),
-      Err(StreamResource::Stdin(..)) => Ok(atty::is(atty::Stream::Stdin)),
-      _ => Ok(false),
-    })?;
+      #[cfg(unix)]
+      {
+        use std::os::unix::io::AsRawFd;
+        let raw_fd = std_file.as_raw_fd();
+        Ok(unsafe { libc::isatty(raw_fd as libc::c_int) == 1 })
+      }
+    }
+    Err(StreamResource::FsFile(_)) => unreachable!(),
+    Err(StreamResource::Stdin(..)) => Ok(atty::is(atty::Stream::Stdin)),
+    _ => Ok(false),
+  })?;
   Ok(json!(isatty))
 }
 
@@ -268,7 +262,6 @@ struct ConsoleSize {
 
 fn op_console_size(
   state: &State,
-  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -276,7 +269,7 @@ fn op_console_size(
   let args: ConsoleSizeArgs = serde_json::from_value(args)?;
   let rid = args.rid;
 
-  let size = std_file_resource(resource_table, rid as u32, move |r| match r {
+  let size = std_file_resource(state, rid as u32, move |r| match r {
     Ok(std_file) => {
       #[cfg(windows)]
       {
diff --git a/cli/ops/web_worker.rs b/cli/ops/web_worker.rs
index 023a4708c..9d8140d7b 100644
--- a/cli/ops/web_worker.rs
+++ b/cli/ops/web_worker.rs
@@ -1,112 +1,39 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{JsonOp, Value};
-use crate::ops::json_op;
+
 use crate::state::State;
 use crate::web_worker::WebWorkerHandle;
 use crate::worker::WorkerEvent;
-use deno_core::CoreIsolate;
-use deno_core::CoreIsolateState;
-use deno_core::ErrBox;
-use deno_core::ZeroCopyBuf;
+use deno_core::OpRegistry;
 use futures::channel::mpsc;
-use std::convert::From;
 use std::rc::Rc;
 
-pub fn web_worker_op<D>(
-  sender: mpsc::Sender<WorkerEvent>,
-  dispatcher: D,
-) -> impl Fn(
-  &mut CoreIsolateState,
-  Value,
-  &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox>
-where
-  D: Fn(
-    &mpsc::Sender<WorkerEvent>,
-    Value,
-    &mut [ZeroCopyBuf],
-  ) -> Result<JsonOp, ErrBox>,
-{
-  move |_isolate_state: &mut CoreIsolateState,
-        args: Value,
-        zero_copy: &mut [ZeroCopyBuf]|
-        -> Result<JsonOp, ErrBox> { dispatcher(&sender, args, zero_copy) }
-}
-
-pub fn web_worker_op2<D>(
-  handle: WebWorkerHandle,
-  sender: mpsc::Sender<WorkerEvent>,
-  dispatcher: D,
-) -> impl Fn(
-  &mut CoreIsolateState,
-  Value,
-  &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox>
-where
-  D: Fn(
-    WebWorkerHandle,
-    &mpsc::Sender<WorkerEvent>,
-    Value,
-    &mut [ZeroCopyBuf],
-  ) -> Result<JsonOp, ErrBox>,
-{
-  move |_isolate_state: &mut CoreIsolateState,
-        args: Value,
-        zero_copy: &mut [ZeroCopyBuf]|
-        -> Result<JsonOp, ErrBox> {
-    dispatcher(handle.clone(), &sender, args, zero_copy)
-  }
-}
-
 pub fn init(
-  i: &mut CoreIsolate,
   s: &Rc<State>,
   sender: &mpsc::Sender<WorkerEvent>,
   handle: WebWorkerHandle,
 ) {
-  i.register_op(
+  // Post message to host as guest worker.
+  let sender_ = sender.clone();
+  s.register_op_json_sync(
     "op_worker_post_message",
-    s.core_op(json_op(web_worker_op(
-      sender.clone(),
-      op_worker_post_message,
-    ))),
-  );
-  i.register_op(
-    "op_worker_close",
-    s.core_op(json_op(web_worker_op2(
-      handle,
-      sender.clone(),
-      op_worker_close,
-    ))),
+    move |_state, _args, bufs| {
+      assert_eq!(bufs.len(), 1, "Invalid number of arguments");
+      let msg_buf: Box<[u8]> = (*bufs[0]).into();
+      sender_
+        .clone()
+        .try_send(WorkerEvent::Message(msg_buf))
+        .expect("Failed to post message to host");
+      Ok(json!({}))
+    },
   );
-}
-
-/// Post message to host as guest worker
-fn op_worker_post_message(
-  sender: &mpsc::Sender<WorkerEvent>,
-  _args: Value,
-  data: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
-  assert_eq!(data.len(), 1, "Invalid number of arguments");
-  let d = Vec::from(&*data[0]).into_boxed_slice();
-  let mut sender = sender.clone();
-  sender
-    .try_send(WorkerEvent::Message(d))
-    .expect("Failed to post message to host");
-  Ok(JsonOp::Sync(json!({})))
-}
 
-/// Notify host that guest worker closes
-fn op_worker_close(
-  handle: WebWorkerHandle,
-  sender: &mpsc::Sender<WorkerEvent>,
-  _args: Value,
-  _data: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
-  let mut sender = sender.clone();
-  // Notify parent that we're finished
-  sender.close_channel();
-  // Terminate execution of current worker
-  handle.terminate();
-  Ok(JsonOp::Sync(json!({})))
+  // Notify host that guest worker closes.
+  let sender_ = sender.clone();
+  s.register_op_json_sync("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(json!({}))
+  });
 }
diff --git a/cli/ops/websocket.rs b/cli/ops/websocket.rs
index 126d67861..131c52179 100644
--- a/cli/ops/websocket.rs
+++ b/cli/ops/websocket.rs
@@ -1,15 +1,16 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
 
-use super::dispatch_json::{Deserialize, JsonOp, Value};
 use crate::state::State;
 use core::task::Poll;
+use deno_core::BufVec;
 use deno_core::ErrBox;
-use deno_core::ZeroCopyBuf;
-use deno_core::{CoreIsolate, CoreIsolateState};
-use futures::future::{poll_fn, FutureExt};
+use deno_core::OpRegistry;
+use futures::future::poll_fn;
 use futures::StreamExt;
 use futures::{ready, SinkExt};
 use http::{Method, Request, Uri};
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::borrow::Cow;
 use std::fs::File;
 use std::io::BufReader;
@@ -25,11 +26,11 @@ use tokio_tungstenite::tungstenite::{
 use tokio_tungstenite::{client_async, WebSocketStream};
 use webpki::DNSNameRef;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  i.register_op("op_ws_create", s.stateful_json_op2(op_ws_create));
-  i.register_op("op_ws_send", s.stateful_json_op2(op_ws_send));
-  i.register_op("op_ws_close", s.stateful_json_op2(op_ws_close));
-  i.register_op("op_ws_next_event", s.stateful_json_op2(op_ws_next_event));
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_async("op_ws_create", op_ws_create);
+  s.register_op_json_async("op_ws_send", op_ws_send);
+  s.register_op_json_async("op_ws_close", op_ws_close);
+  s.register_op_json_async("op_ws_next_event", op_ws_next_event);
 }
 
 type MaybeTlsStream =
@@ -44,86 +45,81 @@ struct CreateArgs {
   protocols: String,
 }
 
-pub fn op_ws_create(
-  isolate_state: &mut CoreIsolateState,
-  state: &Rc<State>,
+pub async fn op_ws_create(
+  state: Rc<State>,
   args: Value,
-  _zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
+  _bufs: BufVec,
+) -> Result<Value, ErrBox> {
   let args: CreateArgs = serde_json::from_value(args)?;
   state.check_net_url(&url::Url::parse(&args.url)?)?;
-  let resource_table = isolate_state.resource_table.clone();
   let ca_file = state.global_state.flags.ca_file.clone();
-  let future = async move {
-    let uri: Uri = args.url.parse().unwrap();
-    let request = Request::builder()
-      .method(Method::GET)
-      .uri(&uri)
-      .header("Sec-WebSocket-Protocol", args.protocols)
-      .body(())
-      .unwrap();
-    let domain = &uri.host().unwrap().to_string();
-    let port = &uri.port_u16().unwrap_or(match uri.scheme_str() {
-      Some("wss") => 443,
-      Some("ws") => 80,
-      _ => unreachable!(),
-    });
-    let addr = format!("{}:{}", domain, port);
-    let try_socket = TcpStream::connect(addr).await;
-    let tcp_socket = match try_socket.map_err(Error::Io) {
-      Ok(socket) => socket,
-      Err(_) => return Ok(json!({"success": false})),
-    };
+  let uri: Uri = args.url.parse().unwrap();
+  let request = Request::builder()
+    .method(Method::GET)
+    .uri(&uri)
+    .header("Sec-WebSocket-Protocol", args.protocols)
+    .body(())
+    .unwrap();
+  let domain = &uri.host().unwrap().to_string();
+  let port = &uri.port_u16().unwrap_or(match uri.scheme_str() {
+    Some("wss") => 443,
+    Some("ws") => 80,
+    _ => unreachable!(),
+  });
+  let addr = format!("{}:{}", domain, port);
+  let try_socket = TcpStream::connect(addr).await;
+  let tcp_socket = match try_socket.map_err(Error::Io) {
+    Ok(socket) => socket,
+    Err(_) => return Ok(json!({"success": false})),
+  };
 
-    let socket: MaybeTlsStream = match uri.scheme_str() {
-      Some("ws") => StreamSwitcher::Plain(tcp_socket),
-      Some("wss") => {
-        let mut config = ClientConfig::new();
-        config
-          .root_store
-          .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS);
+  let socket: MaybeTlsStream = match uri.scheme_str() {
+    Some("ws") => StreamSwitcher::Plain(tcp_socket),
+    Some("wss") => {
+      let mut config = ClientConfig::new();
+      config
+        .root_store
+        .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS);
 
-        if let Some(path) = ca_file {
-          let key_file = File::open(path)?;
-          let reader = &mut BufReader::new(key_file);
-          config.root_store.add_pem_file(reader).unwrap();
-        }
-
-        let tls_connector = TlsConnector::from(Arc::new(config));
-        let dnsname =
-          DNSNameRef::try_from_ascii_str(&domain).expect("Invalid DNS lookup");
-        let tls_socket = tls_connector.connect(dnsname, tcp_socket).await?;
-        StreamSwitcher::Tls(tls_socket)
+      if let Some(path) = ca_file {
+        let key_file = File::open(path)?;
+        let reader = &mut BufReader::new(key_file);
+        config.root_store.add_pem_file(reader).unwrap();
       }
-      _ => unreachable!(),
-    };
 
-    let (stream, response): (WsStream, Response) =
-      client_async(request, socket).await.unwrap();
+      let tls_connector = TlsConnector::from(Arc::new(config));
+      let dnsname =
+        DNSNameRef::try_from_ascii_str(&domain).expect("Invalid DNS lookup");
+      let tls_socket = tls_connector.connect(dnsname, tcp_socket).await?;
+      StreamSwitcher::Tls(tls_socket)
+    }
+    _ => unreachable!(),
+  };
+
+  let (stream, response): (WsStream, Response) =
+    client_async(request, socket).await.unwrap();
 
-    let rid = {
-      let mut resource_table = resource_table.borrow_mut();
-      resource_table.add("webSocketStream", Box::new(stream))
-    };
+  let rid = state
+    .resource_table
+    .borrow_mut()
+    .add("webSocketStream", Box::new(stream));
 
-    let protocol = match response.headers().get("Sec-WebSocket-Protocol") {
-      Some(header) => header.to_str().unwrap(),
-      None => "",
-    };
-    let extensions = response
-      .headers()
-      .get_all("Sec-WebSocket-Extensions")
-      .iter()
-      .map(|header| header.to_str().unwrap())
-      .collect::<String>();
-    Ok(json!({
+  let protocol = match response.headers().get("Sec-WebSocket-Protocol") {
+    Some(header) => header.to_str().unwrap(),
+    None => "",
+  };
+  let extensions = response
+    .headers()
+    .get_all("Sec-WebSocket-Extensions")
+    .iter()
+    .map(|header| header.to_str().unwrap())
+    .collect::<String>();
+  Ok(json!({
     "success": true,
     "rid": rid,
     "protocol": protocol,
     "extensions": extensions
-    }))
-  };
-  Ok(JsonOp::Async(future.boxed_local()))
+  }))
 }
 
 #[derive(Deserialize)]
@@ -133,23 +129,21 @@ struct SendArgs {
   text: Option<String>,
 }
 
-pub fn op_ws_send(
-  isolate_state: &mut CoreIsolateState,
-  _state: &Rc<State>,
+pub async fn op_ws_send(
+  state: Rc<State>,
   args: Value,
-  zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
+  bufs: BufVec,
+) -> Result<Value, ErrBox> {
   let args: SendArgs = serde_json::from_value(args)?;
 
   let mut maybe_msg = Some(match args.text {
     Some(text) => Message::Text(text),
-    None => Message::Binary(zero_copy[0].to_owned().to_vec()),
+    None => Message::Binary(bufs[0].to_vec()),
   });
-  let resource_table = isolate_state.resource_table.clone();
   let rid = args.rid;
 
-  let future = poll_fn(move |cx| {
-    let mut resource_table = resource_table.borrow_mut();
+  poll_fn(move |cx| {
+    let mut resource_table = state.resource_table.borrow_mut();
     let stream = resource_table
       .get_mut::<WsStream>(rid)
       .ok_or_else(ErrBox::bad_resource_id)?;
@@ -164,8 +158,8 @@ pub fn op_ws_send(
     ready!(stream.poll_flush_unpin(cx)).unwrap();
 
     Poll::Ready(Ok(json!({})))
-  });
-  Ok(JsonOp::Async(future.boxed_local()))
+  })
+  .await
 }
 
 #[derive(Deserialize)]
@@ -176,14 +170,12 @@ struct CloseArgs {
   reason: Option<String>,
 }
 
-pub fn op_ws_close(
-  isolate_state: &mut CoreIsolateState,
-  _state: &Rc<State>,
+pub async fn op_ws_close(
+  state: Rc<State>,
   args: Value,
-  _zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
+  _bufs: BufVec,
+) -> Result<Value, ErrBox> {
   let args: CloseArgs = serde_json::from_value(args)?;
-  let resource_table = isolate_state.resource_table.clone();
   let rid = args.rid;
   let mut maybe_msg = Some(Message::Close(args.code.map(|c| CloseFrame {
     code: CloseCode::from(c),
@@ -193,8 +185,8 @@ pub fn op_ws_close(
     },
   })));
 
-  let future = poll_fn(move |cx| {
-    let mut resource_table = resource_table.borrow_mut();
+  poll_fn(move |cx| {
+    let mut resource_table = state.resource_table.borrow_mut();
     let stream = resource_table
       .get_mut::<WsStream>(rid)
       .ok_or_else(ErrBox::bad_resource_id)?;
@@ -210,9 +202,8 @@ pub fn op_ws_close(
     ready!(stream.poll_close_unpin(cx)).unwrap();
 
     Poll::Ready(Ok(json!({})))
-  });
-
-  Ok(JsonOp::Async(future.boxed_local()))
+  })
+  .await
 }
 
 #[derive(Deserialize)]
@@ -221,68 +212,48 @@ struct NextEventArgs {
   rid: u32,
 }
 
-pub fn op_ws_next_event(
-  isolate_state: &mut CoreIsolateState,
-  _state: &Rc<State>,
+pub async fn op_ws_next_event(
+  state: Rc<State>,
   args: Value,
-  _zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
+  _bufs: BufVec,
+) -> Result<Value, ErrBox> {
   let args: NextEventArgs = serde_json::from_value(args)?;
-  let resource_table = isolate_state.resource_table.clone();
-  let future = poll_fn(move |cx| {
-    let mut resource_table = resource_table.borrow_mut();
+  poll_fn(move |cx| {
+    let mut resource_table = state.resource_table.borrow_mut();
     let stream = resource_table
       .get_mut::<WsStream>(args.rid)
       .ok_or_else(ErrBox::bad_resource_id)?;
-
-    stream.poll_next_unpin(cx).map(|val| {
-      match val {
-        Some(val) => {
-          match val {
-            Ok(message) => {
-              match message {
-                Message::Text(text) => Ok(json!({
-                  "type": "string",
-                  "data": text
-                })),
-                Message::Binary(data) => {
-                  Ok(json!({ //TODO: don't use json to send binary data
-                    "type": "binary",
-                    "data": data
-                  }))
-                }
-                Message::Close(frame) => {
-                  if let Some(frame) = frame {
-                    let code: u16 = frame.code.into();
-                    Ok(json!({
-                      "type": "close",
-                      "code": code,
-                      "reason": frame.reason.as_ref()
-                    }))
-                  } else {
-                    Ok(json!({ "type": "close" }))
-                  }
-                }
-                Message::Ping(_) => Ok(json!({"type": "ping"})),
-                Message::Pong(_) => Ok(json!({"type": "pong"})),
-              }
-            }
-            Err(_) => Ok(json!({
-              "type": "error",
-            })),
+    stream
+      .poll_next_unpin(cx)
+      .map(|val| {
+        match val {
+          Some(Ok(Message::Text(text))) => json!({
+            "type": "string",
+            "data": text
+          }),
+          Some(Ok(Message::Binary(data))) => {
+            // TODO(ry): don't use json to send binary data.
+            json!({
+              "type": "binary",
+              "data": data
+            })
+          }
+          Some(Ok(Message::Close(Some(frame)))) => json!({
+            "type": "close",
+            "code": u16::from(frame.code),
+            "reason": frame.reason.as_ref()
+          }),
+          Some(Ok(Message::Close(None))) => json!({ "type": "close" }),
+          Some(Ok(Message::Ping(_))) => json!({"type": "ping"}),
+          Some(Ok(Message::Pong(_))) => json!({"type": "pong"}),
+          Some(Err(_)) => json!({"type": "error"}),
+          None => {
+            resource_table.close(args.rid).unwrap();
+            json!({"type": "closed"})
           }
         }
-        None => {
-          resource_table
-            .close(args.rid)
-            .ok_or_else(ErrBox::bad_resource_id)?;
-          Ok(json!({
-            "type": "closed",
-          }))
-        }
-      }
-    })
-  });
-
-  Ok(JsonOp::Async(future.boxed_local()))
+      })
+      .map(Ok)
+  })
+  .await
 }
diff --git a/cli/ops/worker_host.rs b/cli/ops/worker_host.rs
index 35ec11223..d2c33f005 100644
--- a/cli/ops/worker_host.rs
+++ b/cli/ops/worker_host.rs
@@ -1,5 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{Deserialize, Value};
+
 use crate::fmt_errors::JSError;
 use crate::global_state::GlobalState;
 use crate::ops::io::get_stdio;
@@ -11,37 +11,23 @@ use crate::web_worker::WebWorker;
 use crate::web_worker::WebWorkerHandle;
 use crate::worker::WorkerEvent;
 use deno_core::BufVec;
-use deno_core::CoreIsolate;
 use deno_core::ErrBox;
 use deno_core::ModuleSpecifier;
-use deno_core::ResourceTable;
+use deno_core::OpRegistry;
 use deno_core::ZeroCopyBuf;
 use futures::future::FutureExt;
-use std::cell::RefCell;
+use serde_derive::Deserialize;
+use serde_json::Value;
 use std::convert::From;
 use std::rc::Rc;
 use std::sync::Arc;
 use std::thread::JoinHandle;
 
-pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
-
-  i.register_op(
-    "op_create_worker",
-    s.stateful_json_op_sync(t, op_create_worker),
-  );
-  i.register_op(
-    "op_host_terminate_worker",
-    s.stateful_json_op_sync(t, op_host_terminate_worker),
-  );
-  i.register_op(
-    "op_host_post_message",
-    s.stateful_json_op_sync(t, op_host_post_message),
-  );
-  i.register_op(
-    "op_host_get_message",
-    s.stateful_json_op_async(t, op_host_get_message),
-  );
+pub fn init(s: &Rc<State>) {
+  s.register_op_json_sync("op_create_worker", op_create_worker);
+  s.register_op_json_sync("op_host_terminate_worker", op_host_terminate_worker);
+  s.register_op_json_sync("op_host_post_message", op_host_post_message);
+  s.register_op_json_async("op_host_get_message", op_host_get_message);
 }
 
 fn create_web_worker(
@@ -63,8 +49,6 @@ fn create_web_worker(
   );
 
   if has_deno_namespace {
-    let state_rc = CoreIsolate::state(&worker.isolate);
-    let state = state_rc.borrow();
     let mut resource_table = state.resource_table.borrow_mut();
     let (stdin, stdout, stderr) = get_stdio();
     if let Some(stream) = stdin {
@@ -189,7 +173,6 @@ struct CreateWorkerArgs {
 /// Create worker as the host
 fn op_create_worker(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _data: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -240,7 +223,6 @@ struct WorkerArgs {
 
 fn op_host_terminate_worker(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   _data: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
@@ -309,7 +291,6 @@ fn serialize_worker_event(event: WorkerEvent) -> Value {
 /// Get message from guest worker as host
 async fn op_host_get_message(
   state: Rc<State>,
-  _resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
   _zero_copy: BufVec,
 ) -> Result<Value, ErrBox> {
@@ -358,7 +339,6 @@ async fn op_host_get_message(
 /// Post message to guest worker as host
 fn op_host_post_message(
   state: &State,
-  _resource_table: &mut ResourceTable,
   args: Value,
   data: &mut [ZeroCopyBuf],
 ) -> Result<Value, ErrBox> {
diff --git a/cli/permissions.rs b/cli/permissions.rs
index 577ebd40e..327b17267 100644
--- a/cli/permissions.rs
+++ b/cli/permissions.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use crate::colors;
 use crate::flags::Flags;
 use crate::fs::resolve_from_cwd;
diff --git a/cli/repl.rs b/cli/repl.rs
index 28b99cf07..8387de05f 100644
--- a/cli/repl.rs
+++ b/cli/repl.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use crate::deno_dir::DenoDir;
 use deno_core::ErrBox;
 use rustyline::Editor;
diff --git a/cli/resolve_addr.rs b/cli/resolve_addr.rs
index a25bf7454..66ee470c9 100644
--- a/cli/resolve_addr.rs
+++ b/cli/resolve_addr.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use deno_core::ErrBox;
 use std::net::SocketAddr;
 use std::net::ToSocketAddrs;
diff --git a/cli/signal.rs b/cli/signal.rs
index 5c9a7d717..200f8f3bc 100644
--- a/cli/signal.rs
+++ b/cli/signal.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use deno_core::ErrBox;
 
 #[cfg(not(unix))]
diff --git a/cli/startup_data.rs b/cli/startup_data.rs
index 2f209a378..1cdfb4188 100644
--- a/cli/startup_data.rs
+++ b/cli/startup_data.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use crate::js::CLI_SNAPSHOT;
 use crate::js::COMPILER_SNAPSHOT;
 use deno_core::Snapshot;
diff --git a/cli/state.rs b/cli/state.rs
index 9f225e522..c85701bac 100644
--- a/cli/state.rs
+++ b/cli/state.rs
@@ -1,31 +1,30 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
+use crate::errors::get_error_class_name;
 use crate::file_fetcher::SourceFileFetcher;
 use crate::global_state::GlobalState;
 use crate::global_timer::GlobalTimer;
 use crate::http_util::create_http_client;
 use crate::import_map::ImportMap;
 use crate::metrics::Metrics;
-use crate::ops::serialize_result;
-use crate::ops::JsonOp;
-use crate::ops::MinimalOp;
 use crate::permissions::Permissions;
 use crate::tsc::TargetLib;
 use crate::web_worker::WebWorkerHandle;
-use deno_core::Buf;
 use deno_core::BufVec;
-use deno_core::CoreIsolateState;
 use deno_core::ErrBox;
 use deno_core::ModuleLoadId;
 use deno_core::ModuleLoader;
 use deno_core::ModuleSpecifier;
 use deno_core::Op;
+use deno_core::OpId;
+use deno_core::OpRegistry;
+use deno_core::OpRouter;
+use deno_core::OpTable;
 use deno_core::ResourceTable;
-use deno_core::ZeroCopyBuf;
 use futures::future::FutureExt;
 use futures::Future;
 use rand::rngs::StdRng;
 use rand::SeedableRng;
-use serde_json::Value;
 use std::cell::Cell;
 use std::cell::RefCell;
 use std::collections::HashMap;
@@ -55,266 +54,11 @@ pub struct State {
   pub is_main: bool,
   pub is_internal: bool,
   pub http_client: RefCell<reqwest::Client>,
+  pub resource_table: RefCell<ResourceTable>,
+  pub op_table: RefCell<OpTable<Self>>,
 }
 
 impl State {
-  pub fn stateful_json_op_sync<D>(
-    self: &Rc<Self>,
-    resource_table: &Rc<RefCell<ResourceTable>>,
-    dispatcher: D,
-  ) -> impl Fn(&mut deno_core::CoreIsolateState, &mut [ZeroCopyBuf]) -> Op
-  where
-    D: Fn(
-      &State,
-      &mut ResourceTable,
-      Value,
-      &mut [ZeroCopyBuf],
-    ) -> Result<Value, ErrBox>,
-  {
-    let state = self.clone();
-    let resource_table = resource_table.clone();
-
-    let f = move |isolate_state: &mut CoreIsolateState,
-                  bufs: &mut [ZeroCopyBuf]| {
-      let get_error_class_fn = isolate_state.get_error_class_fn;
-
-      // The first buffer should contain JSON encoded op arguments; parse them.
-      let args: Value = match serde_json::from_slice(&bufs[0]) {
-        Ok(v) => v,
-        Err(e) => {
-          return Op::Sync(serialize_result(
-            None,
-            Err(e.into()),
-            get_error_class_fn,
-          ));
-        }
-      };
-
-      // Make a slice containing all buffers except for the first one.
-      let zero_copy = &mut bufs[1..];
-
-      let result =
-        dispatcher(&state, &mut *resource_table.borrow_mut(), args, zero_copy);
-
-      // Convert to Op.
-      Op::Sync(serialize_result(None, result, get_error_class_fn))
-    };
-    self.core_op(f)
-  }
-
-  pub fn stateful_json_op_async<D, F>(
-    self: &Rc<Self>,
-    resource_table: &Rc<RefCell<ResourceTable>>,
-    dispatcher: D,
-  ) -> impl Fn(&mut CoreIsolateState, &mut [ZeroCopyBuf]) -> Op
-  where
-    D:
-      FnOnce(Rc<State>, Rc<RefCell<ResourceTable>>, Value, BufVec) -> F + Clone,
-    F: Future<Output = Result<Value, ErrBox>> + 'static,
-  {
-    let state = self.clone();
-    let resource_table = resource_table.clone();
-
-    let f = move |isolate_state: &mut CoreIsolateState,
-                  bufs: &mut [ZeroCopyBuf]| {
-      let get_error_class_fn = isolate_state.get_error_class_fn;
-
-      // The first buffer should contain JSON encoded op arguments; parse them.
-      let args: Value = match serde_json::from_slice(&bufs[0]) {
-        Ok(v) => v,
-        Err(e) => {
-          let e = e.into();
-          return Op::Sync(serialize_result(None, Err(e), get_error_class_fn));
-        }
-      };
-
-      // `args` should have a `promiseId` property with positive integer value.
-      let promise_id = match args.get("promiseId").and_then(|v| v.as_u64()) {
-        Some(i) => i,
-        None => {
-          let e = ErrBox::new("TypeError", "`promiseId` invalid/missing");
-          return Op::Sync(serialize_result(None, Err(e), get_error_class_fn));
-        }
-      };
-
-      // Take ownership of all buffers after the first one.
-      let zero_copy: BufVec = bufs[1..].into();
-
-      // Call dispatcher to obtain op future.
-      let fut = (dispatcher.clone())(
-        state.clone(),
-        resource_table.clone(),
-        args,
-        zero_copy,
-      );
-
-      // Convert to Op.
-      Op::Async(
-        async move {
-          serialize_result(Some(promise_id), fut.await, get_error_class_fn)
-        }
-        .boxed_local(),
-      )
-    };
-    self.core_op(f)
-  }
-
-  // TODO(bartlomieju): remove me - still used by `op_open_plugin` which
-  // needs access to isolate_state
-  pub fn stateful_json_op2<D>(
-    self: &Rc<Self>,
-    dispatcher: D,
-  ) -> impl Fn(&mut deno_core::CoreIsolateState, &mut [ZeroCopyBuf]) -> Op
-  where
-    D: Fn(
-      &mut deno_core::CoreIsolateState,
-      &Rc<State>,
-      Value,
-      &mut [ZeroCopyBuf],
-    ) -> Result<JsonOp, ErrBox>,
-  {
-    use crate::ops::json_op;
-    self.core_op(json_op(self.stateful_op2(dispatcher)))
-  }
-
-  /// Wrap core `OpDispatcher` to collect metrics.
-  // TODO(ry) this should be private. Is called by stateful_json_op or
-  // stateful_minimal_op
-  pub(crate) fn core_op<D>(
-    self: &Rc<Self>,
-    dispatcher: D,
-  ) -> impl Fn(&mut deno_core::CoreIsolateState, &mut [ZeroCopyBuf]) -> Op
-  where
-    D: Fn(&mut deno_core::CoreIsolateState, &mut [ZeroCopyBuf]) -> Op,
-  {
-    let state = self.clone();
-
-    move |isolate_state: &mut deno_core::CoreIsolateState,
-          zero_copy: &mut [ZeroCopyBuf]|
-          -> Op {
-      let bytes_sent_control =
-        zero_copy.get(0).map(|s| s.len()).unwrap_or(0) as u64;
-      let bytes_sent_zero_copy =
-        zero_copy[1..].iter().map(|b| b.len()).sum::<usize>() as u64;
-
-      let op = dispatcher(isolate_state, zero_copy);
-
-      match op {
-        Op::Sync(buf) => {
-          state.metrics.borrow_mut().op_sync(
-            bytes_sent_control,
-            bytes_sent_zero_copy,
-            buf.len() as u64,
-          );
-          Op::Sync(buf)
-        }
-        Op::Async(fut) => {
-          state
-            .metrics
-            .borrow_mut()
-            .op_dispatched_async(bytes_sent_control, bytes_sent_zero_copy);
-          let state = state.clone();
-          let result_fut = fut.map(move |buf: Buf| {
-            state
-              .metrics
-              .borrow_mut()
-              .op_completed_async(buf.len() as u64);
-            buf
-          });
-          Op::Async(result_fut.boxed_local())
-        }
-        Op::AsyncUnref(fut) => {
-          state.metrics.borrow_mut().op_dispatched_async_unref(
-            bytes_sent_control,
-            bytes_sent_zero_copy,
-          );
-          let state = state.clone();
-          let result_fut = fut.map(move |buf: Buf| {
-            state
-              .metrics
-              .borrow_mut()
-              .op_completed_async_unref(buf.len() as u64);
-            buf
-          });
-          Op::AsyncUnref(result_fut.boxed_local())
-        }
-      }
-    }
-  }
-
-  pub fn stateful_minimal_op2<D>(
-    self: &Rc<Self>,
-    dispatcher: D,
-  ) -> impl Fn(&mut deno_core::CoreIsolateState, &mut [ZeroCopyBuf]) -> Op
-  where
-    D: Fn(
-      &mut deno_core::CoreIsolateState,
-      &Rc<State>,
-      bool,
-      i32,
-      &mut [ZeroCopyBuf],
-    ) -> MinimalOp,
-  {
-    let state = self.clone();
-    self.core_op(crate::ops::minimal_op(
-      move |isolate_state: &mut deno_core::CoreIsolateState,
-            is_sync: bool,
-            rid: i32,
-            zero_copy: &mut [ZeroCopyBuf]|
-            -> MinimalOp {
-        dispatcher(isolate_state, &state, is_sync, rid, zero_copy)
-      },
-    ))
-  }
-
-  /// This is a special function that provides `state` argument to dispatcher.
-  ///
-  /// NOTE: This only works with JSON dispatcher.
-  /// This is a band-aid for transition to `CoreIsolate.register_op` API as most of our
-  /// ops require `state` argument.
-  pub fn stateful_op<D>(
-    self: &Rc<Self>,
-    dispatcher: D,
-  ) -> impl Fn(
-    &mut deno_core::CoreIsolateState,
-    Value,
-    &mut [ZeroCopyBuf],
-  ) -> Result<JsonOp, ErrBox>
-  where
-    D: Fn(&Rc<State>, Value, &mut [ZeroCopyBuf]) -> Result<JsonOp, ErrBox>,
-  {
-    let state = self.clone();
-    move |_isolate_state: &mut deno_core::CoreIsolateState,
-          args: Value,
-          zero_copy: &mut [ZeroCopyBuf]|
-          -> Result<JsonOp, ErrBox> { dispatcher(&state, args, zero_copy) }
-  }
-
-  pub fn stateful_op2<D>(
-    self: &Rc<Self>,
-    dispatcher: D,
-  ) -> impl Fn(
-    &mut deno_core::CoreIsolateState,
-    Value,
-    &mut [ZeroCopyBuf],
-  ) -> Result<JsonOp, ErrBox>
-  where
-    D: Fn(
-      &mut deno_core::CoreIsolateState,
-      &Rc<State>,
-      Value,
-      &mut [ZeroCopyBuf],
-    ) -> Result<JsonOp, ErrBox>,
-  {
-    let state = self.clone();
-    move |isolate_state: &mut deno_core::CoreIsolateState,
-          args: Value,
-          zero_copy: &mut [ZeroCopyBuf]|
-          -> Result<JsonOp, ErrBox> {
-      dispatcher(isolate_state, &state, args, zero_copy)
-    }
-  }
-
   /// Quits the process if the --unstable flag was not provided.
   ///
   /// This is intentionally a non-recoverable check so that people cannot probe
@@ -458,6 +202,8 @@ impl State {
       is_main: true,
       is_internal,
       http_client: create_http_client(fl.ca_file.as_deref())?.into(),
+      resource_table: Default::default(),
+      op_table: Default::default(),
     };
     Ok(Rc::new(state))
   }
@@ -486,6 +232,8 @@ impl State {
       is_main: false,
       is_internal: false,
       http_client: create_http_client(fl.ca_file.as_deref())?.into(),
+      resource_table: Default::default(),
+      op_table: Default::default(),
     };
     Ok(Rc::new(state))
   }
@@ -570,7 +318,7 @@ impl State {
   }
 
   #[cfg(test)]
-  pub fn mock(main_module: &str) -> Rc<State> {
+  pub fn mock(main_module: &str) -> Rc<Self> {
     let module_specifier = ModuleSpecifier::resolve_url_or_path(main_module)
       .expect("Invalid entry module");
     State::new(
@@ -583,3 +331,78 @@ impl State {
     .unwrap()
   }
 }
+
+impl OpRouter for State {
+  fn route_op(self: Rc<Self>, op_id: OpId, bufs: BufVec) -> Op {
+    // TODOs:
+    // * The 'bytes' metrics seem pretty useless, especially now that the
+    //   distinction between 'control' and 'data' buffers has become blurry.
+    // * Tracking completion of async ops currently makes us put the boxed
+    //   future into _another_ box. Keeping some counters may not be expensive
+    //   in itself, but adding a heap allocation for every metric seems bad.
+    let mut buf_len_iter = bufs.iter().map(|buf| buf.len());
+    let bytes_sent_control = buf_len_iter.next().unwrap_or(0);
+    let bytes_sent_data = buf_len_iter.sum();
+
+    let op_fn = self
+      .op_table
+      .borrow()
+      .get_index(op_id)
+      .map(|(_, op_fn)| op_fn.clone())
+      .unwrap();
+
+    let self_ = self.clone();
+    let op = (op_fn)(self_, bufs);
+
+    let self_ = self.clone();
+    let mut metrics = self_.metrics.borrow_mut();
+    match op {
+      Op::Sync(buf) => {
+        metrics.op_sync(bytes_sent_control, bytes_sent_data, buf.len());
+        Op::Sync(buf)
+      }
+      Op::Async(fut) => {
+        metrics.op_dispatched_async(bytes_sent_control, bytes_sent_data);
+        let fut = fut
+          .inspect(move |buf| {
+            self.metrics.borrow_mut().op_completed_async(buf.len());
+          })
+          .boxed_local();
+        Op::Async(fut)
+      }
+      Op::AsyncUnref(fut) => {
+        metrics.op_dispatched_async_unref(bytes_sent_control, bytes_sent_data);
+        let fut = fut
+          .inspect(move |buf| {
+            self
+              .metrics
+              .borrow_mut()
+              .op_completed_async_unref(buf.len());
+          })
+          .boxed_local();
+        Op::AsyncUnref(fut)
+      }
+      other => other,
+    }
+  }
+}
+
+impl OpRegistry for State {
+  fn get_op_catalog(self: Rc<Self>) -> HashMap<String, OpId> {
+    self.op_table.borrow().get_op_catalog()
+  }
+
+  fn register_op<F>(&self, name: &str, op_fn: F) -> OpId
+  where
+    F: Fn(Rc<Self>, BufVec) -> Op + 'static,
+  {
+    let mut op_table = self.op_table.borrow_mut();
+    let (op_id, prev) = op_table.insert_full(name.to_owned(), Rc::new(op_fn));
+    assert!(prev.is_none());
+    op_id
+  }
+
+  fn get_error_class_name(&self, err: &ErrBox) -> &'static str {
+    get_error_class_name(err)
+  }
+}
diff --git a/cli/swc_util.rs b/cli/swc_util.rs
index f354a0fe3..f54f187e3 100644
--- a/cli/swc_util.rs
+++ b/cli/swc_util.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use crate::msg::MediaType;
 use deno_core::ErrBox;
 use serde::Serialize;
@@ -304,7 +305,7 @@ pub fn transpile(
     Optional::new(jsx_pass, options.transform_jsx),
     decorators::decorators(decorators::Config {
       legacy: true,
-      emit_metadata: options.emit_metadata,
+      emit_metadata: options.emit_metadata
     }),
     typescript::strip(),
     fixer(Some(&ast_parser.comments)),
diff --git a/cli/text_encoding.rs b/cli/text_encoding.rs
index 9d8e5bcc9..bf40f3a3c 100644
--- a/cli/text_encoding.rs
+++ b/cli/text_encoding.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use encoding_rs::*;
 use std::{
   borrow::Cow,
diff --git a/cli/tsc.rs b/cli/tsc.rs
index bf4e4fe5c..118dc86ae 100644
--- a/cli/tsc.rs
+++ b/cli/tsc.rs
@@ -139,14 +139,13 @@ impl CompilerWorker {
     startup_data: StartupData,
     state: &Rc<State>,
   ) -> Self {
-    let mut worker = Worker::new(name, startup_data, state);
+    let worker = Worker::new(name, startup_data, state);
     let response = Arc::new(Mutex::new(None));
     {
-      let isolate = &mut worker.isolate;
-      ops::runtime::init(isolate, &state);
-      ops::errors::init(isolate, &state);
-      ops::timers::init(isolate, &state);
-      ops::compiler::init(isolate, &state, response.clone());
+      ops::runtime::init(&state);
+      ops::errors::init(&state);
+      ops::timers::init(&state);
+      ops::compiler::init(&state, response.clone());
     }
 
     Self { worker, response }
@@ -1437,7 +1436,7 @@ pub async fn runtime_transpile(
   let json_str = execute_in_same_thread(global_state, permissions, req_msg)
     .await
     .map_err(js_error_to_errbox)?;
-  let v = serde_json::from_str::<serde_json::Value>(&json_str)
+  let v = serde_json::from_str::<Value>(&json_str)
     .expect("Error decoding JSON string.");
   Ok(v)
 }
diff --git a/cli/version.rs b/cli/version.rs
index b1ac42d39..6967d7435 100644
--- a/cli/version.rs
+++ b/cli/version.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 pub const DENO: &str = env!("CARGO_PKG_VERSION");
 pub const TYPESCRIPT: &str = crate::js::TS_VERSION;
 
diff --git a/cli/web_worker.rs b/cli/web_worker.rs
index 9b42ebe32..095d5b376 100644
--- a/cli/web_worker.rs
+++ b/cli/web_worker.rs
@@ -1,4 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
 use crate::ops;
 use crate::state::State;
 use crate::worker::Worker;
@@ -101,7 +102,7 @@ impl WebWorker {
       terminate_tx,
     };
 
-    let mut web_worker = Self {
+    let web_worker = Self {
       worker,
       event_loop_idle: false,
       terminate_rx,
@@ -112,36 +113,34 @@ impl WebWorker {
     let handle = web_worker.thread_safe_handle();
 
     {
-      let isolate = &mut web_worker.worker.isolate;
-      ops::runtime::init(isolate, &state);
+      ops::runtime::init(&state);
       ops::web_worker::init(
-        isolate,
         &state,
         &web_worker.worker.internal_channels.sender,
         handle,
       );
-      ops::worker_host::init(isolate, &state);
-      ops::idna::init(isolate, &state);
-      ops::io::init(isolate, &state);
-      ops::resources::init(isolate, &state);
-      ops::errors::init(isolate, &state);
-      ops::timers::init(isolate, &state);
-      ops::fetch::init(isolate, &state);
-      ops::websocket::init(isolate, &state);
+      ops::worker_host::init(&state);
+      ops::idna::init(&state);
+      ops::io::init(&state);
+      ops::resources::init(&state);
+      ops::errors::init(&state);
+      ops::timers::init(&state);
+      ops::fetch::init(&state);
+      ops::websocket::init(&state);
 
       if has_deno_namespace {
-        ops::runtime_compiler::init(isolate, &state);
-        ops::fs::init(isolate, &state);
-        ops::fs_events::init(isolate, &state);
-        ops::plugin::init(isolate, &state);
-        ops::net::init(isolate, &state);
-        ops::tls::init(isolate, &state);
-        ops::os::init(isolate, &state);
-        ops::permissions::init(isolate, &state);
-        ops::process::init(isolate, &state);
-        ops::random::init(isolate, &state);
-        ops::signal::init(isolate, &state);
-        ops::tty::init(isolate, &state);
+        ops::runtime_compiler::init(&state);
+        ops::fs::init(&state);
+        ops::fs_events::init(&state);
+        ops::plugin::init(&state);
+        ops::net::init(&state);
+        ops::tls::init(&state);
+        ops::os::init(&state);
+        ops::permissions::init(&state);
+        ops::process::init(&state);
+        ops::random::init(&state);
+        ops::signal::init(&state);
+        ops::tty::init(&state);
       }
     }
 
diff --git a/cli/worker.rs b/cli/worker.rs
index 3773871dc..3aaf92f48 100644
--- a/cli/worker.rs
+++ b/cli/worker.rs
@@ -1,5 +1,5 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use crate::errors::get_error_class;
+
 use crate::fmt_errors::JSError;
 use crate::global_state::GlobalState;
 use crate::inspector::DenoInspector;
@@ -7,7 +7,6 @@ use crate::ops;
 use crate::ops::io::get_stdio;
 use crate::startup_data;
 use crate::state::State;
-use deno_core::Buf;
 use deno_core::CoreIsolate;
 use deno_core::ErrBox;
 use deno_core::ModuleId;
@@ -32,25 +31,25 @@ use url::Url;
 /// Events that are sent to host from child
 /// worker.
 pub enum WorkerEvent {
-  Message(Buf),
+  Message(Box<[u8]>),
   Error(ErrBox),
   TerminalError(ErrBox),
 }
 
 pub struct WorkerChannelsInternal {
   pub sender: mpsc::Sender<WorkerEvent>,
-  pub receiver: mpsc::Receiver<Buf>,
+  pub receiver: mpsc::Receiver<Box<[u8]>>,
 }
 
 #[derive(Clone)]
 pub struct WorkerHandle {
-  pub sender: mpsc::Sender<Buf>,
+  pub sender: mpsc::Sender<Box<[u8]>>,
   pub receiver: Arc<AsyncMutex<mpsc::Receiver<WorkerEvent>>>,
 }
 
 impl WorkerHandle {
   /// Post message to worker as a host.
-  pub fn post_message(&self, buf: Buf) -> Result<(), ErrBox> {
+  pub fn post_message(&self, buf: Box<[u8]>) -> Result<(), ErrBox> {
     let mut sender = self.sender.clone();
     sender.try_send(buf)?;
     Ok(())
@@ -65,7 +64,7 @@ impl WorkerHandle {
 }
 
 fn create_channels() -> (WorkerChannelsInternal, WorkerHandle) {
-  let (in_tx, in_rx) = mpsc::channel::<Buf>(1);
+  let (in_tx, in_rx) = mpsc::channel::<Box<[u8]>>(1);
   let (out_tx, out_rx) = mpsc::channel::<WorkerEvent>(1);
   let internal_channels = WorkerChannelsInternal {
     sender: out_tx,
@@ -106,8 +105,12 @@ impl Worker {
     startup_data: StartupData,
     state: &Rc<State>,
   ) -> Self {
-    let mut isolate =
-      deno_core::EsIsolate::new(state.clone(), startup_data, false);
+    let mut isolate = deno_core::EsIsolate::new(
+      state.clone(),
+      state.clone(),
+      startup_data,
+      false,
+    );
 
     {
       let global_state = state.global_state.clone();
@@ -116,7 +119,6 @@ impl Worker {
       core_state.set_js_error_create_fn(move |core_js_error| {
         JSError::create(core_js_error, &global_state.ts_compiler)
       });
-      core_state.set_get_error_class_fn(&get_error_class);
     }
 
     let inspector = {
@@ -256,31 +258,30 @@ pub struct MainWorker(Worker);
 impl MainWorker {
   // TODO(ry) combine MainWorker::new and MainWorker::create.
   fn new(name: String, startup_data: StartupData, state: &Rc<State>) -> Self {
-    let mut worker = Worker::new(name, startup_data, state);
+    let worker = Worker::new(name, startup_data, state);
     {
-      let isolate = &mut worker.isolate;
-      ops::runtime::init(isolate, &state);
-      ops::runtime_compiler::init(isolate, &state);
-      ops::errors::init(isolate, &state);
-      ops::fetch::init(isolate, &state);
-      ops::websocket::init(isolate, &state);
-      ops::fs::init(isolate, &state);
-      ops::fs_events::init(isolate, &state);
-      ops::idna::init(isolate, &state);
-      ops::io::init(isolate, &state);
-      ops::plugin::init(isolate, &state);
-      ops::net::init(isolate, &state);
-      ops::tls::init(isolate, &state);
-      ops::os::init(isolate, &state);
-      ops::permissions::init(isolate, &state);
-      ops::process::init(isolate, &state);
-      ops::random::init(isolate, &state);
-      ops::repl::init(isolate, &state);
-      ops::resources::init(isolate, &state);
-      ops::signal::init(isolate, &state);
-      ops::timers::init(isolate, &state);
-      ops::tty::init(isolate, &state);
-      ops::worker_host::init(isolate, &state);
+      ops::runtime::init(&state);
+      ops::runtime_compiler::init(&state);
+      ops::errors::init(&state);
+      ops::fetch::init(&state);
+      ops::websocket::init(&state);
+      ops::fs::init(&state);
+      ops::fs_events::init(&state);
+      ops::idna::init(&state);
+      ops::io::init(&state);
+      ops::plugin::init(&state);
+      ops::net::init(&state);
+      ops::tls::init(&state);
+      ops::os::init(&state);
+      ops::permissions::init(&state);
+      ops::process::init(&state);
+      ops::random::init(&state);
+      ops::repl::init(&state);
+      ops::resources::init(&state);
+      ops::signal::init(&state);
+      ops::timers::init(&state);
+      ops::tty::init(&state);
+      ops::worker_host::init(&state);
     }
     Self(worker)
   }
@@ -302,10 +303,8 @@ impl MainWorker {
       &state,
     );
     {
-      let (stdin, stdout, stderr) = get_stdio();
-      let state_rc = CoreIsolate::state(&worker.isolate);
-      let state = state_rc.borrow();
       let mut t = state.resource_table.borrow_mut();
+      let (stdin, stdout, stderr) = get_stdio();
       if let Some(stream) = stdin {
         t.add("stdin", Box::new(stream));
       }