28 files changed, 160 insertions, 148 deletions

diff --git a/cli/js/globals.ts b/cli/js/globals.ts
index 9908609be..09be63315 100644
--- a/cli/js/globals.ts
+++ b/cli/js/globals.ts
@@ -80,7 +80,7 @@ declare global {
     dispatch(
       opId: number,
       control: Uint8Array,
-      zeroCopy?: ArrayBufferView | null
+      ...zeroCopy: ArrayBufferView[]
     ): Uint8Array | null;
     setAsyncHandler(opId: number, cb: (msg: Uint8Array) => void): void;
     sharedQueue: {
@@ -99,7 +99,7 @@ declare global {
     send(
       opId: number,
       control: null | ArrayBufferView,
-      data?: ArrayBufferView
+      ...data: ArrayBufferView[]
     ): null | Uint8Array;
 
     setMacrotaskCallback(cb: () => boolean): void;
diff --git a/cli/js/ops/dispatch_json.ts b/cli/js/ops/dispatch_json.ts
index 9ff0f13f5..6292c188a 100644
--- a/cli/js/ops/dispatch_json.ts
+++ b/cli/js/ops/dispatch_json.ts
@@ -59,12 +59,12 @@ export function asyncMsgFromRust(resUi8: Uint8Array): void {
 export function sendSync(
   opName: string,
   args: object = {},
-  zeroCopy?: Uint8Array
+  ...zeroCopy: Uint8Array[]
 ): Ok {
   const opId = OPS_CACHE[opName];
   util.log("sendSync", opName, opId);
   const argsUi8 = encode(args);
-  const resUi8 = core.dispatch(opId, argsUi8, zeroCopy);
+  const resUi8 = core.dispatch(opId, argsUi8, ...zeroCopy);
   util.assert(resUi8 != null);
 
   const res = decode(resUi8);
@@ -75,7 +75,7 @@ export function sendSync(
 export async function sendAsync(
   opName: string,
   args: object = {},
-  zeroCopy?: Uint8Array
+  ...zeroCopy: Uint8Array[]
 ): Promise<Ok> {
   const opId = OPS_CACHE[opName];
   util.log("sendAsync", opName, opId);
@@ -84,7 +84,7 @@ export async function sendAsync(
   const promise = util.createResolvable<Ok>();
 
   const argsUi8 = encode(args);
-  const buf = core.dispatch(opId, argsUi8, zeroCopy);
+  const buf = core.dispatch(opId, argsUi8, ...zeroCopy);
   if (buf) {
     // Sync result.
     const res = decode(buf);
diff --git a/cli/js/ops/fetch.ts b/cli/js/ops/fetch.ts
index 09b9ac1ec..290376c86 100644
--- a/cli/js/ops/fetch.ts
+++ b/cli/js/ops/fetch.ts
@@ -24,5 +24,5 @@ export function fetch(
     zeroCopy = new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
   }
 
-  return sendAsync("op_fetch", args, zeroCopy);
+  return sendAsync("op_fetch", args, ...(zeroCopy ? [zeroCopy] : []));
 }
diff --git a/cli/ops/dispatch_json.rs b/cli/ops/dispatch_json.rs
index c2c103f69..97a02991f 100644
--- a/cli/ops/dispatch_json.rs
+++ b/cli/ops/dispatch_json.rs
@@ -46,17 +46,17 @@ struct AsyncArgs {
 
 pub fn json_op<D>(
   d: D,
-) -> impl Fn(&mut CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op
+) -> impl Fn(&mut CoreIsolateState, &[u8], &mut [ZeroCopyBuf]) -> Op
 where
   D: Fn(
     &mut CoreIsolateState,
     Value,
-    Option<ZeroCopyBuf>,
+    &mut [ZeroCopyBuf],
   ) -> Result<JsonOp, OpError>,
 {
   move |isolate_state: &mut CoreIsolateState,
         control: &[u8],
-        zero_copy: Option<ZeroCopyBuf>| {
+        zero_copy: &mut [ZeroCopyBuf]| {
     let async_args: AsyncArgs = match serde_json::from_slice(control) {
       Ok(args) => args,
       Err(e) => {
diff --git a/cli/ops/dispatch_minimal.rs b/cli/ops/dispatch_minimal.rs
index 3da8305a1..eac5ad055 100644
--- a/cli/ops/dispatch_minimal.rs
+++ b/cli/ops/dispatch_minimal.rs
@@ -116,13 +116,13 @@ fn test_parse_min_record() {
 
 pub fn minimal_op<D>(
   d: D,
-) -> impl Fn(&mut CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op
+) -> impl Fn(&mut CoreIsolateState, &[u8], &mut [ZeroCopyBuf]) -> Op
 where
-  D: Fn(&mut CoreIsolateState, bool, i32, Option<ZeroCopyBuf>) -> MinimalOp,
+  D: Fn(&mut CoreIsolateState, bool, i32, &mut [ZeroCopyBuf]) -> MinimalOp,
 {
   move |isolate_state: &mut CoreIsolateState,
         control: &[u8],
-        zero_copy: Option<ZeroCopyBuf>| {
+        zero_copy: &mut [ZeroCopyBuf]| {
     let mut record = match parse_min_record(control) {
       Some(r) => r,
       None => {
diff --git a/cli/ops/errors.rs b/cli/ops/errors.rs
index 766c130e2..ade125b1a 100644
--- a/cli/ops/errors.rs
+++ b/cli/ops/errors.rs
@@ -31,7 +31,7 @@ struct ApplySourceMap {
 fn op_apply_source_map(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: ApplySourceMap = serde_json::from_value(args)?;
 
@@ -55,7 +55,7 @@ fn op_apply_source_map(
 fn op_format_diagnostic(
   _state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let diagnostic = serde_json::from_value::<Diagnostic>(args)?;
   Ok(JsonOp::Sync(json!(diagnostic.to_string())))
diff --git a/cli/ops/fetch.rs b/cli/ops/fetch.rs
index 927bc5f64..5a646325e 100644
--- a/cli/ops/fetch.rs
+++ b/cli/ops/fetch.rs
@@ -28,7 +28,7 @@ pub fn op_fetch(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  data: Option<ZeroCopyBuf>,
+  data: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: FetchArgs = serde_json::from_value(args)?;
   let url = args.url;
@@ -57,8 +57,10 @@ pub fn op_fetch(
 
   let mut request = client.request(method, url_);
 
-  if let Some(buf) = data {
-    request = request.body(Vec::from(&*buf));
+  match data.len() {
+    0 => {}
+    1 => request = request.body(Vec::from(&*data[0])),
+    _ => panic!("Invalid number of arguments"),
   }
 
   for (key, value) in args.headers {
diff --git a/cli/ops/fs.rs b/cli/ops/fs.rs
index ee52f88b8..63b3ad7f5 100644
--- a/cli/ops/fs.rs
+++ b/cli/ops/fs.rs
@@ -72,7 +72,7 @@ fn op_open(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: OpenArgs = serde_json::from_value(args)?;
   let path = Path::new(&args.path).to_path_buf();
@@ -155,7 +155,7 @@ fn op_seek(
   isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   use std::io::{Seek, SeekFrom};
   let args: SeekArgs = serde_json::from_value(args)?;
@@ -212,7 +212,7 @@ struct UmaskArgs {
 fn op_umask(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.umask");
   let args: UmaskArgs = serde_json::from_value(args)?;
@@ -250,7 +250,7 @@ struct ChdirArgs {
 fn op_chdir(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: ChdirArgs = serde_json::from_value(args)?;
   let d = PathBuf::from(&args.directory);
@@ -271,7 +271,7 @@ struct MkdirArgs {
 fn op_mkdir(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: MkdirArgs = serde_json::from_value(args)?;
   let path = Path::new(&args.path).to_path_buf();
@@ -305,7 +305,7 @@ struct ChmodArgs {
 fn op_chmod(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: ChmodArgs = serde_json::from_value(args)?;
   let path = Path::new(&args.path).to_path_buf();
@@ -345,7 +345,7 @@ struct ChownArgs {
 fn op_chown(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: ChownArgs = serde_json::from_value(args)?;
   let path = Path::new(&args.path).to_path_buf();
@@ -384,7 +384,7 @@ struct RemoveArgs {
 fn op_remove(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: RemoveArgs = serde_json::from_value(args)?;
   let path = PathBuf::from(&args.path);
@@ -438,7 +438,7 @@ struct CopyFileArgs {
 fn op_copy_file(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: CopyFileArgs = serde_json::from_value(args)?;
   let from = PathBuf::from(&args.from);
@@ -532,7 +532,7 @@ struct StatArgs {
 fn op_stat(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: StatArgs = serde_json::from_value(args)?;
   let path = PathBuf::from(&args.path);
@@ -562,7 +562,7 @@ struct RealpathArgs {
 fn op_realpath(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: RealpathArgs = serde_json::from_value(args)?;
   let path = PathBuf::from(&args.path);
@@ -597,7 +597,7 @@ struct ReadDirArgs {
 fn op_read_dir(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: ReadDirArgs = serde_json::from_value(args)?;
   let path = PathBuf::from(&args.path);
@@ -640,7 +640,7 @@ struct RenameArgs {
 fn op_rename(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: RenameArgs = serde_json::from_value(args)?;
   let oldpath = PathBuf::from(&args.oldpath);
@@ -669,7 +669,7 @@ struct LinkArgs {
 fn op_link(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.link");
   let args: LinkArgs = serde_json::from_value(args)?;
@@ -707,7 +707,7 @@ struct SymlinkOptions {
 fn op_symlink(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.symlink");
   let args: SymlinkArgs = serde_json::from_value(args)?;
@@ -767,7 +767,7 @@ struct ReadLinkArgs {
 fn op_read_link(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: ReadLinkArgs = serde_json::from_value(args)?;
   let path = PathBuf::from(&args.path);
@@ -794,7 +794,7 @@ struct TruncateArgs {
 fn op_truncate(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: TruncateArgs = serde_json::from_value(args)?;
   let path = PathBuf::from(&args.path);
@@ -868,7 +868,7 @@ struct MakeTempArgs {
 fn op_make_temp_dir(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: MakeTempArgs = serde_json::from_value(args)?;
 
@@ -899,7 +899,7 @@ fn op_make_temp_dir(
 fn op_make_temp_file(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: MakeTempArgs = serde_json::from_value(args)?;
 
@@ -939,7 +939,7 @@ struct UtimeArgs {
 fn op_utime(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.utime");
 
@@ -959,7 +959,7 @@ fn op_utime(
 fn op_cwd(
   state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let path = current_dir()?;
   state.check_read_blind(&path, "CWD")?;
diff --git a/cli/ops/fs_events.rs b/cli/ops/fs_events.rs
index 8e1831aa2..b9d54fc3e 100644
--- a/cli/ops/fs_events.rs
+++ b/cli/ops/fs_events.rs
@@ -66,7 +66,7 @@ pub fn op_fs_events_open(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   #[derive(Deserialize)]
   struct OpenArgs {
@@ -104,7 +104,7 @@ pub fn op_fs_events_poll(
   isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   #[derive(Deserialize)]
   struct PollArgs {
diff --git a/cli/ops/io.rs b/cli/ops/io.rs
index 5769d74ed..0e007ad1a 100644
--- a/cli/ops/io.rs
+++ b/cli/ops/io.rs
@@ -211,16 +211,16 @@ pub fn op_read(
   _state: &State,
   is_sync: bool,
   rid: i32,
-  zero_copy: Option<ZeroCopyBuf>,
+  zero_copy: &mut [ZeroCopyBuf],
 ) -> MinimalOp {
   debug!("read rid={}", rid);
-  if zero_copy.is_none() {
-    return MinimalOp::Sync(Err(no_buffer_specified()));
+  match zero_copy.len() {
+    0 => return MinimalOp::Sync(Err(no_buffer_specified())),
+    1 => {}
+    _ => panic!("Invalid number of arguments"),
   }
   let resource_table = isolate_state.resource_table.clone();
 
-  let mut buf = zero_copy.unwrap();
-
   if is_sync {
     MinimalOp::Sync({
       // First we look up the rid in the resource table.
@@ -229,7 +229,7 @@ pub fn op_read(
         Ok(std_file) => {
           use std::io::Read;
           std_file
-            .read(&mut buf)
+            .read(&mut zero_copy[0])
             .map(|n: usize| n as i32)
             .map_err(OpError::from)
         }
@@ -239,6 +239,7 @@ pub fn op_read(
       })
     })
   } else {
+    let mut zero_copy = zero_copy[0].clone();
     MinimalOp::Async(
       poll_fn(move |cx| {
         let mut resource_table = resource_table.borrow_mut();
@@ -249,7 +250,7 @@ pub fn op_read(
         let mut task_tracker_id: Option<usize> = None;
         let nread = match resource_holder
           .resource
-          .poll_read(cx, &mut buf.as_mut()[..])
+          .poll_read(cx, &mut zero_copy)
           .map_err(OpError::from)
         {
           Poll::Ready(t) => {
@@ -335,15 +336,15 @@ pub fn op_write(
   _state: &State,
   is_sync: bool,
   rid: i32,
-  zero_copy: Option<ZeroCopyBuf>,
+  zero_copy: &mut [ZeroCopyBuf],
 ) -> MinimalOp {
   debug!("write rid={}", rid);
-  if zero_copy.is_none() {
-    return MinimalOp::Sync(Err(no_buffer_specified()));
+  match zero_copy.len() {
+    0 => return MinimalOp::Sync(Err(no_buffer_specified())),
+    1 => {}
+    _ => panic!("Invalid number of arguments"),
   }
 
-  let buf = zero_copy.unwrap();
-
   if is_sync {
     MinimalOp::Sync({
       // First we look up the rid in the resource table.
@@ -352,7 +353,7 @@ pub fn op_write(
         Ok(std_file) => {
           use std::io::Write;
           std_file
-            .write(&buf)
+            .write(&zero_copy[0])
             .map(|nwritten: usize| nwritten as i32)
             .map_err(OpError::from)
         }
@@ -362,6 +363,7 @@ pub fn op_write(
       })
     })
   } else {
+    let zero_copy = zero_copy[0].clone();
     let resource_table = isolate_state.resource_table.clone();
     MinimalOp::Async(
       async move {
@@ -370,7 +372,7 @@ pub fn op_write(
           let resource_holder = resource_table
             .get_mut::<StreamResourceHolder>(rid as u32)
             .ok_or_else(OpError::bad_resource_id)?;
-          resource_holder.resource.poll_write(cx, &buf.as_ref()[..])
+          resource_holder.resource.poll_write(cx, &zero_copy)
         })
         .await?;
 
diff --git a/cli/ops/net.rs b/cli/ops/net.rs
index 3d524d3f1..5ccb62d6c 100644
--- a/cli/ops/net.rs
+++ b/cli/ops/net.rs
@@ -40,7 +40,7 @@ struct AcceptArgs {
 fn accept_tcp(
   isolate_state: &mut CoreIsolateState,
   args: AcceptArgs,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let rid = args.rid as u32;
   let resource_table = isolate_state.resource_table.clone();
@@ -101,7 +101,7 @@ fn op_accept(
   isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
-  zero_copy: Option<ZeroCopyBuf>,
+  zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: AcceptArgs = serde_json::from_value(args)?;
   match args.transport.as_str() {
@@ -125,9 +125,10 @@ fn receive_udp(
   isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: ReceiveArgs,
-  zero_copy: Option<ZeroCopyBuf>,
+  zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
-  let mut buf = zero_copy.unwrap();
+  assert_eq!(zero_copy.len(), 1, "Invalid number of arguments");
+  let mut zero_copy = zero_copy[0].clone();
 
   let rid = args.rid as u32;
 
@@ -142,7 +143,9 @@ fn receive_udp(
           OpError::bad_resource("Socket has been closed".to_string())
         })?;
       let socket = &mut resource.socket;
-      socket.poll_recv_from(cx, &mut buf).map_err(OpError::from)
+      socket
+        .poll_recv_from(cx, &mut zero_copy)
+        .map_err(OpError::from)
     });
     let (size, remote_addr) = receive_fut.await?;
     Ok(json!({
@@ -162,9 +165,10 @@ fn op_receive(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  zero_copy: Option<ZeroCopyBuf>,
+  zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
-  assert!(zero_copy.is_some());
+  assert_eq!(zero_copy.len(), 1, "Invalid number of arguments");
+
   let args: ReceiveArgs = serde_json::from_value(args)?;
   match args.transport.as_str() {
     "udp" => receive_udp(isolate_state, state, args, zero_copy),
@@ -191,10 +195,11 @@ fn op_send(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  zero_copy: Option<ZeroCopyBuf>,
+  zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
-  assert!(zero_copy.is_some());
-  let buf = zero_copy.unwrap();
+  assert_eq!(zero_copy.len(), 1, "Invalid number of arguments");
+  let zero_copy = zero_copy[0].clone();
+
   let resource_table = isolate_state.resource_table.clone();
   match serde_json::from_value(args)? {
     SendArgs {
@@ -213,7 +218,7 @@ fn op_send(
           })?;
         let socket = &mut resource.socket;
         let addr = resolve_addr(&args.hostname, args.port)?;
-        socket.send_to(&buf, addr).await?;
+        socket.send_to(&zero_copy, addr).await?;
         Ok(json!({}))
       };
 
@@ -237,7 +242,7 @@ fn op_send(
 
         let socket = &mut resource.socket;
         socket
-          .send_to(&buf, &resource.local_addr.as_pathname().unwrap())
+          .send_to(&zero_copy, &resource.local_addr.as_pathname().unwrap())
           .await?;
 
         Ok(json!({}))
@@ -260,7 +265,7 @@ fn op_connect(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let resource_table = isolate_state.resource_table.clone();
   match serde_json::from_value(args)? {
@@ -346,7 +351,7 @@ fn op_shutdown(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.shutdown");
 
@@ -488,7 +493,7 @@ fn op_listen(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let mut resource_table = isolate_state.resource_table.borrow_mut();
   match serde_json::from_value(args)? {
diff --git a/cli/ops/net_unix.rs b/cli/ops/net_unix.rs
index a207eaba8..0b2ceb75a 100644
--- a/cli/ops/net_unix.rs
+++ b/cli/ops/net_unix.rs
@@ -29,7 +29,7 @@ pub struct UnixListenArgs {
 pub fn accept_unix(
   isolate_state: &mut CoreIsolateState,
   rid: u32,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let resource_table = isolate_state.resource_table.clone();
   {
@@ -80,9 +80,10 @@ pub fn accept_unix(
 pub fn receive_unix_packet(
   isolate_state: &mut CoreIsolateState,
   rid: u32,
-  zero_copy: Option<ZeroCopyBuf>,
+  zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
-  let mut buf = zero_copy.unwrap();
+  assert_eq!(zero_copy.len(), 1, "Invalid number of arguments");
+  let mut zero_copy = zero_copy[0].clone();
   let resource_table = isolate_state.resource_table.clone();
 
   let op = async move {
@@ -92,7 +93,7 @@ pub fn receive_unix_packet(
       .ok_or_else(|| {
         OpError::bad_resource("Socket has been closed".to_string())
       })?;
-    let (size, remote_addr) = resource.socket.recv_from(&mut buf).await?;
+    let (size, remote_addr) = resource.socket.recv_from(&mut zero_copy).await?;
     Ok(json!({
       "size": size,
       "remoteAddr": {
diff --git a/cli/ops/os.rs b/cli/ops/os.rs
index 1dd2ddc4f..36cd99577 100644
--- a/cli/ops/os.rs
+++ b/cli/ops/os.rs
@@ -29,7 +29,7 @@ struct GetDirArgs {
 fn op_get_dir(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.dir");
   state.check_env()?;
@@ -80,7 +80,7 @@ fn op_get_dir(
 fn op_exec_path(
   state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let current_exe = env::current_exe().unwrap();
   state.check_read_blind(&current_exe, "exec_path")?;
@@ -100,7 +100,7 @@ struct SetEnv {
 fn op_set_env(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: SetEnv = serde_json::from_value(args)?;
   state.check_env()?;
@@ -111,7 +111,7 @@ fn op_set_env(
 fn op_env(
   state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_env()?;
   let v = env::vars().collect::<HashMap<String, String>>();
@@ -126,7 +126,7 @@ struct GetEnv {
 fn op_get_env(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: GetEnv = serde_json::from_value(args)?;
   state.check_env()?;
@@ -145,7 +145,7 @@ struct Exit {
 fn op_exit(
   _s: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: Exit = serde_json::from_value(args)?;
   std::process::exit(args.code)
@@ -154,7 +154,7 @@ fn op_exit(
 fn op_loadavg(
   state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.loadavg");
   state.check_env()?;
@@ -171,7 +171,7 @@ fn op_loadavg(
 fn op_hostname(
   state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.hostname");
   state.check_env()?;
@@ -182,7 +182,7 @@ fn op_hostname(
 fn op_os_release(
   state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.osRelease");
   state.check_env()?;
diff --git a/cli/ops/permissions.rs b/cli/ops/permissions.rs
index 13a8f3bb8..a4ee4120e 100644
--- a/cli/ops/permissions.rs
+++ b/cli/ops/permissions.rs
@@ -31,7 +31,7 @@ struct PermissionArgs {
 pub fn op_query_permission(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: PermissionArgs = serde_json::from_value(args)?;
   let state = state.borrow();
@@ -47,7 +47,7 @@ pub fn op_query_permission(
 pub fn op_revoke_permission(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: PermissionArgs = serde_json::from_value(args)?;
   let mut state = state.borrow_mut();
@@ -74,7 +74,7 @@ pub fn op_revoke_permission(
 pub fn op_request_permission(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: PermissionArgs = serde_json::from_value(args)?;
   let mut state = state.borrow_mut();
diff --git a/cli/ops/plugin.rs b/cli/ops/plugin.rs
index fde34ea58..775178f1e 100644
--- a/cli/ops/plugin.rs
+++ b/cli/ops/plugin.rs
@@ -37,7 +37,7 @@ pub fn op_open_plugin(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.openPlugin");
   let args: OpenPluginArgs = serde_json::from_value(args).unwrap();
diff --git a/cli/ops/process.rs b/cli/ops/process.rs
index eefabd49f..78d9313c0 100644
--- a/cli/ops/process.rs
+++ b/cli/ops/process.rs
@@ -64,7 +64,7 @@ fn op_run(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let run_args: RunArgs = serde_json::from_value(args)?;
 
@@ -178,7 +178,7 @@ fn op_run_status(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: RunStatusArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
@@ -228,7 +228,7 @@ struct KillArgs {
 fn op_kill(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.kill");
   state.check_run()?;
diff --git a/cli/ops/random.rs b/cli/ops/random.rs
index 874887cdb..b29c761b8 100644
--- a/cli/ops/random.rs
+++ b/cli/ops/random.rs
@@ -17,15 +17,15 @@ pub fn init(i: &mut CoreIsolate, s: &State) {
 fn op_get_random_values(
   state: &State,
   _args: Value,
-  zero_copy: Option<ZeroCopyBuf>,
+  zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
-  assert!(zero_copy.is_some());
+  assert_eq!(zero_copy.len(), 1);
 
   if let Some(ref mut seeded_rng) = state.borrow_mut().seeded_rng {
-    seeded_rng.fill(&mut zero_copy.unwrap()[..]);
+    seeded_rng.fill(&mut *zero_copy[0]);
   } else {
     let mut rng = thread_rng();
-    rng.fill(&mut zero_copy.unwrap()[..]);
+    rng.fill(&mut *zero_copy[0]);
   }
 
   Ok(JsonOp::Sync(json!({})))
diff --git a/cli/ops/repl.rs b/cli/ops/repl.rs
index 40bc9653e..b8fd7ab8b 100644
--- a/cli/ops/repl.rs
+++ b/cli/ops/repl.rs
@@ -27,7 +27,7 @@ fn op_repl_start(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: ReplStartArgs = serde_json::from_value(args)?;
   debug!("op_repl_start {}", args.history_file);
@@ -50,7 +50,7 @@ fn op_repl_readline(
   isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: ReplReadlineArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
diff --git a/cli/ops/resources.rs b/cli/ops/resources.rs
index be09598a9..a66a66170 100644
--- a/cli/ops/resources.rs
+++ b/cli/ops/resources.rs
@@ -15,7 +15,7 @@ fn op_resources(
   isolate_state: &mut CoreIsolateState,
   _state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let serialized_resources = isolate_state.resource_table.borrow().entries();
   Ok(JsonOp::Sync(json!(serialized_resources)))
@@ -26,7 +26,7 @@ fn op_close(
   isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   #[derive(Deserialize)]
   struct CloseArgs {
diff --git a/cli/ops/runtime.rs b/cli/ops/runtime.rs
index e96a669d0..a85ce4011 100644
--- a/cli/ops/runtime.rs
+++ b/cli/ops/runtime.rs
@@ -17,7 +17,7 @@ pub fn init(i: &mut CoreIsolate, s: &State) {
 fn op_start(
   state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let state = state.borrow();
   let gs = &state.global_state;
@@ -42,7 +42,7 @@ fn op_start(
 fn op_metrics(
   state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let state = state.borrow();
   let m = &state.metrics;
diff --git a/cli/ops/runtime_compiler.rs b/cli/ops/runtime_compiler.rs
index f3b741861..97102ef81 100644
--- a/cli/ops/runtime_compiler.rs
+++ b/cli/ops/runtime_compiler.rs
@@ -26,7 +26,7 @@ struct CompileArgs {
 fn op_compile(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.compile");
   let args: CompileArgs = serde_json::from_value(args)?;
@@ -57,7 +57,7 @@ struct TranspileArgs {
 fn op_transpile(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.transpile");
   let args: TranspileArgs = serde_json::from_value(args)?;
diff --git a/cli/ops/signal.rs b/cli/ops/signal.rs
index 7a0c29ab0..6457ac42e 100644
--- a/cli/ops/signal.rs
+++ b/cli/ops/signal.rs
@@ -43,7 +43,7 @@ fn op_signal_bind(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.signal");
   let args: BindSignalArgs = serde_json::from_value(args)?;
@@ -65,7 +65,7 @@ fn op_signal_poll(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.signal");
   let args: SignalArgs = serde_json::from_value(args)?;
@@ -92,7 +92,7 @@ pub fn op_signal_unbind(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.signal");
   let args: SignalArgs = serde_json::from_value(args)?;
@@ -117,7 +117,7 @@ pub fn op_signal_bind(
   _isolate_state: &mut CoreIsolateState,
   _state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   unimplemented!();
 }
@@ -127,7 +127,7 @@ fn op_signal_unbind(
   _isolate_state: &mut CoreIsolateState,
   _state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   unimplemented!();
 }
@@ -137,7 +137,7 @@ fn op_signal_poll(
   _isolate_state: &mut CoreIsolateState,
   _state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   unimplemented!();
 }
diff --git a/cli/ops/timers.rs b/cli/ops/timers.rs
index e5bc461d0..044c5ea4a 100644
--- a/cli/ops/timers.rs
+++ b/cli/ops/timers.rs
@@ -20,7 +20,7 @@ pub fn init(i: &mut CoreIsolate, s: &State) {
 fn op_global_timer_stop(
   state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let mut state = state.borrow_mut();
   state.global_timer.cancel();
@@ -35,7 +35,7 @@ struct GlobalTimerArgs {
 fn op_global_timer(
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: GlobalTimerArgs = serde_json::from_value(args)?;
   let val = args.timeout;
@@ -57,7 +57,7 @@ fn op_global_timer(
 fn op_now(
   state: &State,
   _args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let state = state.borrow();
   let seconds = state.start_time.elapsed().as_secs();
diff --git a/cli/ops/tls.rs b/cli/ops/tls.rs
index d4252d9ca..3e22c71ea 100644
--- a/cli/ops/tls.rs
+++ b/cli/ops/tls.rs
@@ -57,7 +57,7 @@ pub fn op_start_tls(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.startTls");
   let args: StartTLSArgs = serde_json::from_value(args)?;
@@ -136,7 +136,7 @@ pub fn op_connect_tls(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: ConnectTLSArgs = serde_json::from_value(args)?;
   let cert_file = args.cert_file.clone();
@@ -310,7 +310,7 @@ fn op_listen_tls(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: ListenTlsArgs = serde_json::from_value(args)?;
   assert_eq!(args.transport, "tcp");
@@ -360,7 +360,7 @@ fn op_accept_tls(
   isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: AcceptTlsArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
diff --git a/cli/ops/tty.rs b/cli/ops/tty.rs
index 00a5870e9..ee357ed68 100644
--- a/cli/ops/tty.rs
+++ b/cli/ops/tty.rs
@@ -50,7 +50,7 @@ pub fn op_set_raw(
   isolate_state: &mut CoreIsolateState,
   state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   state.check_unstable("Deno.setRaw");
   let args: SetRawArgs = serde_json::from_value(args)?;
@@ -219,7 +219,7 @@ pub fn op_isatty(
   isolate_state: &mut CoreIsolateState,
   _state: &State,
   args: Value,
-  _zero_copy: Option<ZeroCopyBuf>,
+  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: IsattyArgs = serde_json::from_value(args)?;
   let rid = args.rid;
diff --git a/cli/ops/web_worker.rs b/cli/ops/web_worker.rs
index d2d202e91..553278b07 100644
--- a/cli/ops/web_worker.rs
+++ b/cli/ops/web_worker.rs
@@ -17,18 +17,18 @@ pub fn web_worker_op<D>(
 ) -> impl Fn(
   &mut CoreIsolateState,
   Value,
-  Option<ZeroCopyBuf>,
+  &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError>
 where
   D: Fn(
     &mpsc::Sender<WorkerEvent>,
     Value,
-    Option<ZeroCopyBuf>,
+    &mut [ZeroCopyBuf],
   ) -> Result<JsonOp, OpError>,
 {
   move |_isolate_state: &mut CoreIsolateState,
         args: Value,
-        zero_copy: Option<ZeroCopyBuf>|
+        zero_copy: &mut [ZeroCopyBuf]|
         -> Result<JsonOp, OpError> { dispatcher(&sender, args, zero_copy) }
 }
 
@@ -39,19 +39,19 @@ pub fn web_worker_op2<D>(
 ) -> impl Fn(
   &mut CoreIsolateState,
   Value,
-  Option<ZeroCopyBuf>,
+  &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError>
 where
   D: Fn(
     WebWorkerHandle,
     &mpsc::Sender<WorkerEvent>,
     Value,
-    Option<ZeroCopyBuf>,
+    &mut [ZeroCopyBuf],
   ) -> Result<JsonOp, OpError>,
 {
   move |_isolate_state: &mut CoreIsolateState,
         args: Value,
-        zero_copy: Option<ZeroCopyBuf>|
+        zero_copy: &mut [ZeroCopyBuf]|
         -> Result<JsonOp, OpError> {
     dispatcher(handle.clone(), &sender, args, zero_copy)
   }
@@ -84,9 +84,10 @@ pub fn init(
 fn op_worker_post_message(
   sender: &mpsc::Sender<WorkerEvent>,
   _args: Value,
-  data: Option<ZeroCopyBuf>,
+  data: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
-  let d = Vec::from(data.unwrap().as_ref()).into_boxed_slice();
+  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))
@@ -99,7 +100,7 @@ fn op_worker_close(
   handle: WebWorkerHandle,
   sender: &mpsc::Sender<WorkerEvent>,
   _args: Value,
-  _data: Option<ZeroCopyBuf>,
+  _data: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let mut sender = sender.clone();
   // Notify parent that we're finished
diff --git a/cli/ops/worker_host.rs b/cli/ops/worker_host.rs
index ad3752ffa..0ed700431 100644
--- a/cli/ops/worker_host.rs
+++ b/cli/ops/worker_host.rs
@@ -174,7 +174,7 @@ struct CreateWorkerArgs {
 fn op_create_worker(
   state: &State,
   args: Value,
-  _data: Option<ZeroCopyBuf>,
+  _data: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: CreateWorkerArgs = serde_json::from_value(args)?;
 
@@ -230,7 +230,7 @@ struct WorkerArgs {
 fn op_host_terminate_worker(
   state: &State,
   args: Value,
-  _data: Option<ZeroCopyBuf>,
+  _data: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: WorkerArgs = serde_json::from_value(args)?;
   let id = args.id as u32;
@@ -296,7 +296,7 @@ fn serialize_worker_event(event: WorkerEvent) -> Value {
 fn op_host_get_message(
   state: &State,
   args: Value,
-  _data: Option<ZeroCopyBuf>,
+  _data: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
   let args: WorkerArgs = serde_json::from_value(args)?;
   let id = args.id as u32;
@@ -345,11 +345,12 @@ fn op_host_get_message(
 fn op_host_post_message(
   state: &State,
   args: Value,
-  data: Option<ZeroCopyBuf>,
+  data: &mut [ZeroCopyBuf],
 ) -> Result<JsonOp, OpError> {
+  assert_eq!(data.len(), 1, "Invalid number of arguments");
   let args: WorkerArgs = serde_json::from_value(args)?;
   let id = args.id as u32;
-  let msg = Vec::from(data.unwrap().as_ref()).into_boxed_slice();
+  let msg = Vec::from(&*data[0]).into_boxed_slice();
 
   debug!("post message to worker {}", id);
   let state = state.borrow();
diff --git a/cli/state.rs b/cli/state.rs
index 77a268fab..c94f92788 100644
--- a/cli/state.rs
+++ b/cli/state.rs
@@ -65,9 +65,9 @@ impl State {
   pub fn stateful_json_op<D>(
     &self,
     dispatcher: D,
-  ) -> impl Fn(&mut deno_core::CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op
+  ) -> impl Fn(&mut deno_core::CoreIsolateState, &[u8], &mut [ZeroCopyBuf]) -> Op
   where
-    D: Fn(&State, Value, Option<ZeroCopyBuf>) -> Result<JsonOp, OpError>,
+    D: Fn(&State, Value, &mut [ZeroCopyBuf]) -> Result<JsonOp, OpError>,
   {
     use crate::ops::json_op;
     self.core_op(json_op(self.stateful_op(dispatcher)))
@@ -76,13 +76,13 @@ impl State {
   pub fn stateful_json_op2<D>(
     &self,
     dispatcher: D,
-  ) -> impl Fn(&mut deno_core::CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op
+  ) -> impl Fn(&mut deno_core::CoreIsolateState, &[u8], &mut [ZeroCopyBuf]) -> Op
   where
     D: Fn(
       &mut deno_core::CoreIsolateState,
       &State,
       Value,
-      Option<ZeroCopyBuf>,
+      &mut [ZeroCopyBuf],
     ) -> Result<JsonOp, OpError>,
   {
     use crate::ops::json_op;
@@ -95,19 +95,19 @@ impl State {
   pub fn core_op<D>(
     &self,
     dispatcher: D,
-  ) -> impl Fn(&mut deno_core::CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op
+  ) -> impl Fn(&mut deno_core::CoreIsolateState, &[u8], &mut [ZeroCopyBuf]) -> Op
   where
-    D: Fn(&mut deno_core::CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op,
+    D: Fn(&mut deno_core::CoreIsolateState, &[u8], &mut [ZeroCopyBuf]) -> Op,
   {
     let state = self.clone();
 
     move |isolate_state: &mut deno_core::CoreIsolateState,
           control: &[u8],
-          zero_copy: Option<ZeroCopyBuf>|
+          zero_copy: &mut [ZeroCopyBuf]|
           -> Op {
       let bytes_sent_control = control.len() as u64;
       let bytes_sent_zero_copy =
-        zero_copy.as_ref().map(|b| b.len()).unwrap_or(0) as u64;
+        zero_copy.iter().map(|b| b.len()).sum::<usize>() as u64;
 
       let op = dispatcher(isolate_state, control, zero_copy);
 
@@ -155,14 +155,14 @@ impl State {
   pub fn stateful_minimal_op2<D>(
     &self,
     dispatcher: D,
-  ) -> impl Fn(&mut deno_core::CoreIsolateState, &[u8], Option<ZeroCopyBuf>) -> Op
+  ) -> impl Fn(&mut deno_core::CoreIsolateState, &[u8], &mut [ZeroCopyBuf]) -> Op
   where
     D: Fn(
       &mut deno_core::CoreIsolateState,
       &State,
       bool,
       i32,
-      Option<ZeroCopyBuf>,
+      &mut [ZeroCopyBuf],
     ) -> MinimalOp,
   {
     let state = self.clone();
@@ -170,7 +170,7 @@ impl State {
       move |isolate_state: &mut deno_core::CoreIsolateState,
             is_sync: bool,
             rid: i32,
-            zero_copy: Option<ZeroCopyBuf>|
+            zero_copy: &mut [ZeroCopyBuf]|
             -> MinimalOp {
         dispatcher(isolate_state, &state, is_sync, rid, zero_copy)
       },
@@ -188,15 +188,15 @@ impl State {
   ) -> impl Fn(
     &mut deno_core::CoreIsolateState,
     Value,
-    Option<ZeroCopyBuf>,
+    &mut [ZeroCopyBuf],
   ) -> Result<JsonOp, OpError>
   where
-    D: Fn(&State, Value, Option<ZeroCopyBuf>) -> Result<JsonOp, OpError>,
+    D: Fn(&State, Value, &mut [ZeroCopyBuf]) -> Result<JsonOp, OpError>,
   {
     let state = self.clone();
     move |_isolate_state: &mut deno_core::CoreIsolateState,
           args: Value,
-          zero_copy: Option<ZeroCopyBuf>|
+          zero_copy: &mut [ZeroCopyBuf]|
           -> Result<JsonOp, OpError> { dispatcher(&state, args, zero_copy) }
   }
 
@@ -206,20 +206,20 @@ impl State {
   ) -> impl Fn(
     &mut deno_core::CoreIsolateState,
     Value,
-    Option<ZeroCopyBuf>,
+    &mut [ZeroCopyBuf],
   ) -> Result<JsonOp, OpError>
   where
     D: Fn(
       &mut deno_core::CoreIsolateState,
       &State,
       Value,
-      Option<ZeroCopyBuf>,
+      &mut [ZeroCopyBuf],
     ) -> Result<JsonOp, OpError>,
   {
     let state = self.clone();
     move |isolate_state: &mut deno_core::CoreIsolateState,
           args: Value,
-          zero_copy: Option<ZeroCopyBuf>|
+          zero_copy: &mut [ZeroCopyBuf]|
           -> Result<JsonOp, OpError> {
       dispatcher(isolate_state, &state, args, zero_copy)
     }