refactor(serde_v8): split ZeroCopyBuf into JsBuffer and ToJsBuffer (#19566)

`ZeroCopyBuf` was convenient to use, but sometimes it did hide details
that some copies were necessary in certain cases. Also it made it way to easy
for the caller to pass around and convert into different values. This commit
splits `ZeroCopyBuf` into `JsBuffer` (an array buffer coming from V8) and
`ToJsBuffer` (a Rust buffer that will be converted into a V8 array buffer).

As a result some magical conversions were removed (they were never used)
limiting the API surface and preparing for changes in #19534.

22 files changed, 224 insertions, 200 deletions

diff --git a/ext/broadcast_channel/lib.rs b/ext/broadcast_channel/lib.rs
index 5b38e70f8..56ce4b3bd 100644
--- a/ext/broadcast_channel/lib.rs
+++ b/ext/broadcast_channel/lib.rs
@@ -12,10 +12,10 @@ use std::rc::Rc;
 use async_trait::async_trait;
 use deno_core::error::AnyError;
 use deno_core::op;
+use deno_core::JsBuffer;
 use deno_core::OpState;
 use deno_core::Resource;
 use deno_core::ResourceId;
-use deno_core::ZeroCopyBuf;
 
 #[async_trait]
 pub trait BroadcastChannel: Clone {
@@ -81,7 +81,7 @@ pub async fn op_broadcast_send<BC>(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
   name: String,
-  buf: ZeroCopyBuf,
+  buf: JsBuffer,
 ) -> Result<(), AnyError>
 where
   BC: BroadcastChannel + 'static,
diff --git a/ext/crypto/decrypt.rs b/ext/crypto/decrypt.rs
index fc54fe818..59679614f 100644
--- a/ext/crypto/decrypt.rs
+++ b/ext/crypto/decrypt.rs
@@ -21,7 +21,8 @@ use deno_core::error::type_error;
 use deno_core::error::AnyError;
 use deno_core::op;
 use deno_core::task::spawn_blocking;
-use deno_core::ZeroCopyBuf;
+use deno_core::JsBuffer;
+use deno_core::ToJsBuffer;
 use rsa::pkcs1::DecodeRsaPrivateKey;
 use rsa::PaddingScheme;
 use serde::Deserialize;
@@ -36,7 +37,7 @@ use crate::shared::*;
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct DecryptOptions {
-  key: RawKeyData,
+  key: V8RawKeyData,
   #[serde(flatten)]
   algorithm: DecryptAlgorithm,
 }
@@ -77,8 +78,8 @@ pub enum DecryptAlgorithm {
 #[op]
 pub async fn op_crypto_decrypt(
   opts: DecryptOptions,
-  data: ZeroCopyBuf,
-) -> Result<ZeroCopyBuf, AnyError> {
+  data: JsBuffer,
+) -> Result<ToJsBuffer, AnyError> {
   let key = opts.key;
   let fun = move || match opts.algorithm {
     DecryptAlgorithm::RsaOaep { hash, label } => {
@@ -104,7 +105,7 @@ pub async fn op_crypto_decrypt(
 }
 
 fn decrypt_rsa_oaep(
-  key: RawKeyData,
+  key: V8RawKeyData,
   hash: ShaHash,
   label: Vec<u8>,
   data: &[u8],
@@ -143,7 +144,7 @@ fn decrypt_rsa_oaep(
 }
 
 fn decrypt_aes_cbc(
-  key: RawKeyData,
+  key: V8RawKeyData,
   length: usize,
   iv: Vec<u8>,
   data: &[u8],
@@ -281,7 +282,7 @@ fn decrypt_aes_gcm_gen<N: ArrayLength<u8>>(
 }
 
 fn decrypt_aes_ctr(
-  key: RawKeyData,
+  key: V8RawKeyData,
   key_length: usize,
   counter: &[u8],
   ctr_length: usize,
@@ -315,7 +316,7 @@ fn decrypt_aes_ctr(
 }
 
 fn decrypt_aes_gcm(
-  key: RawKeyData,
+  key: V8RawKeyData,
   length: usize,
   tag_length: usize,
   iv: Vec<u8>,
diff --git a/ext/crypto/ed25519.rs b/ext/crypto/ed25519.rs
index 784583c6b..98eabbd59 100644
--- a/ext/crypto/ed25519.rs
+++ b/ext/crypto/ed25519.rs
@@ -2,7 +2,7 @@
 
 use deno_core::error::AnyError;
 use deno_core::op;
-use deno_core::ZeroCopyBuf;
+use deno_core::ToJsBuffer;
 use elliptic_curve::pkcs8::PrivateKeyInfo;
 use rand::rngs::OsRng;
 use rand::RngCore;
@@ -105,7 +105,7 @@ pub fn op_crypto_import_pkcs8_ed25519(key_data: &[u8], out: &mut [u8]) -> bool {
 #[op]
 pub fn op_crypto_export_spki_ed25519(
   pubkey: &[u8],
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let key_info = spki::SubjectPublicKeyInfo {
     algorithm: spki::AlgorithmIdentifier {
       // id-Ed25519
@@ -120,7 +120,7 @@ pub fn op_crypto_export_spki_ed25519(
 #[op]
 pub fn op_crypto_export_pkcs8_ed25519(
   pkey: &[u8],
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   // This should probably use OneAsymmetricKey instead
   let pk_info = rsa::pkcs8::PrivateKeyInfo {
     public_key: None,
diff --git a/ext/crypto/encrypt.rs b/ext/crypto/encrypt.rs
index 2831ca0f4..0dc300538 100644
--- a/ext/crypto/encrypt.rs
+++ b/ext/crypto/encrypt.rs
@@ -20,7 +20,8 @@ use deno_core::error::type_error;
 use deno_core::error::AnyError;
 use deno_core::op;
 use deno_core::task::spawn_blocking;
-use deno_core::ZeroCopyBuf;
+use deno_core::JsBuffer;
+use deno_core::ToJsBuffer;
 use rand::rngs::OsRng;
 use rsa::pkcs1::DecodeRsaPublicKey;
 use rsa::PaddingScheme;
@@ -37,7 +38,7 @@ use crate::shared::*;
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct EncryptOptions {
-  key: RawKeyData,
+  key: V8RawKeyData,
   #[serde(flatten)]
   algorithm: EncryptAlgorithm,
 }
@@ -78,8 +79,8 @@ pub enum EncryptAlgorithm {
 #[op]
 pub async fn op_crypto_encrypt(
   opts: EncryptOptions,
-  data: ZeroCopyBuf,
-) -> Result<ZeroCopyBuf, AnyError> {
+  data: JsBuffer,
+) -> Result<ToJsBuffer, AnyError> {
   let key = opts.key;
   let fun = move || match opts.algorithm {
     EncryptAlgorithm::RsaOaep { hash, label } => {
@@ -105,7 +106,7 @@ pub async fn op_crypto_encrypt(
 }
 
 fn encrypt_rsa_oaep(
-  key: RawKeyData,
+  key: V8RawKeyData,
   hash: ShaHash,
   label: Vec<u8>,
   data: &[u8],
@@ -145,7 +146,7 @@ fn encrypt_rsa_oaep(
 }
 
 fn encrypt_aes_cbc(
-  key: RawKeyData,
+  key: V8RawKeyData,
   length: usize,
   iv: Vec<u8>,
   data: &[u8],
@@ -218,7 +219,7 @@ fn encrypt_aes_gcm_general<N: ArrayLength<u8>>(
 }
 
 fn encrypt_aes_gcm(
-  key: RawKeyData,
+  key: V8RawKeyData,
   length: usize,
   tag_length: usize,
   iv: Vec<u8>,
@@ -277,7 +278,7 @@ where
 }
 
 fn encrypt_aes_ctr(
-  key: RawKeyData,
+  key: V8RawKeyData,
   key_length: usize,
   counter: &[u8],
   ctr_length: usize,
diff --git a/ext/crypto/export_key.rs b/ext/crypto/export_key.rs
index ec76bac92..13f7357fa 100644
--- a/ext/crypto/export_key.rs
+++ b/ext/crypto/export_key.rs
@@ -5,7 +5,7 @@ use const_oid::ObjectIdentifier;
 use deno_core::error::custom_error;
 use deno_core::error::AnyError;
 use deno_core::op;
-use deno_core::ZeroCopyBuf;
+use deno_core::ToJsBuffer;
 use elliptic_curve::sec1::ToEncodedPoint;
 use p256::pkcs8::DecodePrivateKey;
 use rsa::pkcs1::UIntRef;
@@ -59,9 +59,9 @@ pub enum ExportKeyAlgorithm {
 #[derive(Serialize)]
 #[serde(untagged)]
 pub enum ExportKeyResult {
-  Raw(ZeroCopyBuf),
-  Pkcs8(ZeroCopyBuf),
-  Spki(ZeroCopyBuf),
+  Raw(ToJsBuffer),
+  Pkcs8(ToJsBuffer),
+  Spki(ToJsBuffer),
   JwkSecret {
     k: String,
   },
@@ -93,7 +93,7 @@ pub enum ExportKeyResult {
 #[op]
 pub fn op_crypto_export_key(
   opts: ExportKeyOptions,
-  key_data: RawKeyData,
+  key_data: V8RawKeyData,
 ) -> Result<ExportKeyResult, AnyError> {
   match opts.algorithm {
     ExportKeyAlgorithm::RsassaPkcs1v15 {}
@@ -119,7 +119,7 @@ fn bytes_to_b64(bytes: &[u8]) -> String {
 
 fn export_key_rsa(
   format: ExportKeyFormat,
-  key_data: RawKeyData,
+  key_data: V8RawKeyData,
 ) -> Result<ExportKeyResult, deno_core::anyhow::Error> {
   match format {
     ExportKeyFormat::Spki => {
@@ -212,7 +212,7 @@ fn export_key_rsa(
 
 fn export_key_symmetric(
   format: ExportKeyFormat,
-  key_data: RawKeyData,
+  key_data: V8RawKeyData,
 ) -> Result<ExportKeyResult, deno_core::anyhow::Error> {
   match format {
     ExportKeyFormat::JwkSecret => {
@@ -228,7 +228,7 @@ fn export_key_symmetric(
 
 fn export_key_ec(
   format: ExportKeyFormat,
-  key_data: RawKeyData,
+  key_data: V8RawKeyData,
   algorithm: ExportKeyAlgorithm,
   named_curve: EcNamedCurve,
 ) -> Result<ExportKeyResult, deno_core::anyhow::Error> {
diff --git a/ext/crypto/generate_key.rs b/ext/crypto/generate_key.rs
index 426c61376..9e2d14ea7 100644
--- a/ext/crypto/generate_key.rs
+++ b/ext/crypto/generate_key.rs
@@ -3,7 +3,7 @@
 use deno_core::error::AnyError;
 use deno_core::op;
 use deno_core::task::spawn_blocking;
-use deno_core::ZeroCopyBuf;
+use deno_core::ToJsBuffer;
 use elliptic_curve::rand_core::OsRng;
 use num_traits::FromPrimitive;
 use once_cell::sync::Lazy;
@@ -45,7 +45,7 @@ pub enum GenerateKeyOptions {
 #[op]
 pub async fn op_crypto_generate_key(
   opts: GenerateKeyOptions,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let fun = || match opts {
     GenerateKeyOptions::Rsa {
       modulus_length,
diff --git a/ext/crypto/import_key.rs b/ext/crypto/import_key.rs
index 42eab0e6c..c3d60101c 100644
--- a/ext/crypto/import_key.rs
+++ b/ext/crypto/import_key.rs
@@ -2,7 +2,8 @@
 
 use deno_core::error::AnyError;
 use deno_core::op;
-use deno_core::ZeroCopyBuf;
+use deno_core::JsBuffer;
+use deno_core::ToJsBuffer;
 use elliptic_curve::pkcs8::PrivateKeyInfo;
 use p256::pkcs8::EncodePrivateKey;
 use ring::signature::EcdsaKeyPair;
@@ -18,9 +19,9 @@ use crate::shared::*;
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum KeyData {
-  Spki(ZeroCopyBuf),
-  Pkcs8(ZeroCopyBuf),
-  Raw(ZeroCopyBuf),
+  Spki(JsBuffer),
+  Pkcs8(JsBuffer),
+  Raw(JsBuffer),
   JwkSecret {
     k: String,
   },
@@ -73,17 +74,17 @@ pub enum ImportKeyOptions {
 pub enum ImportKeyResult {
   #[serde(rename_all = "camelCase")]
   Rsa {
-    raw_data: RawKeyData,
+    raw_data: RustRawKeyData,
     modulus_length: usize,
-    public_exponent: ZeroCopyBuf,
+    public_exponent: ToJsBuffer,
   },
   #[serde(rename_all = "camelCase")]
-  Ec { raw_data: RawKeyData },
+  Ec { raw_data: RustRawKeyData },
   #[serde(rename_all = "camelCase")]
   #[allow(dead_code)]
-  Aes { raw_data: RawKeyData },
+  Aes { raw_data: RustRawKeyData },
   #[serde(rename_all = "camelCase")]
-  Hmac { raw_data: RawKeyData },
+  Hmac { raw_data: RustRawKeyData },
 }
 
 #[op]
@@ -136,7 +137,7 @@ fn import_key_rsa_jwk(
       let modulus_length = public_key.modulus.as_bytes().len() * 8;
 
       Ok(ImportKeyResult::Rsa {
-        raw_data: RawKeyData::Public(data.into()),
+        raw_data: RustRawKeyData::Public(data.into()),
         modulus_length,
         public_exponent,
       })
@@ -181,7 +182,7 @@ fn import_key_rsa_jwk(
       let modulus_length = private_key.modulus.as_bytes().len() * 8;
 
       Ok(ImportKeyResult::Rsa {
-        raw_data: RawKeyData::Private(data.into()),
+        raw_data: RustRawKeyData::Private(data.into()),
         modulus_length,
         public_exponent,
       })
@@ -228,7 +229,7 @@ fn import_key_rsassa(
       let modulus_length = public_key.modulus.as_bytes().len() * 8;
 
       Ok(ImportKeyResult::Rsa {
-        raw_data: RawKeyData::Public(data),
+        raw_data: RustRawKeyData::Public(data),
         modulus_length,
         public_exponent,
       })
@@ -267,7 +268,7 @@ fn import_key_rsassa(
       let modulus_length = private_key.modulus.as_bytes().len() * 8;
 
       Ok(ImportKeyResult::Rsa {
-        raw_data: RawKeyData::Private(data),
+        raw_data: RustRawKeyData::Private(data),
         modulus_length,
         public_exponent,
       })
@@ -317,7 +318,7 @@ fn import_key_rsapss(
       let modulus_length = public_key.modulus.as_bytes().len() * 8;
 
       Ok(ImportKeyResult::Rsa {
-        raw_data: RawKeyData::Public(data),
+        raw_data: RustRawKeyData::Public(data),
         modulus_length,
         public_exponent,
       })
@@ -356,7 +357,7 @@ fn import_key_rsapss(
       let modulus_length = private_key.modulus.as_bytes().len() * 8;
 
       Ok(ImportKeyResult::Rsa {
-        raw_data: RawKeyData::Private(data),
+        raw_data: RustRawKeyData::Private(data),
         modulus_length,
         public_exponent,
       })
@@ -406,7 +407,7 @@ fn import_key_rsaoaep(
       let modulus_length = public_key.modulus.as_bytes().len() * 8;
 
       Ok(ImportKeyResult::Rsa {
-        raw_data: RawKeyData::Public(data),
+        raw_data: RustRawKeyData::Public(data),
         modulus_length,
         public_exponent,
       })
@@ -445,7 +446,7 @@ fn import_key_rsaoaep(
       let modulus_length = private_key.modulus.as_bytes().len() * 8;
 
       Ok(ImportKeyResult::Rsa {
-        raw_data: RawKeyData::Private(data),
+        raw_data: RustRawKeyData::Private(data),
         modulus_length,
         public_exponent,
       })
@@ -513,7 +514,7 @@ fn import_key_ec_jwk(
       let point_bytes = import_key_ec_jwk_to_point(x, y, named_curve)?;
 
       Ok(ImportKeyResult::Ec {
-        raw_data: RawKeyData::Public(point_bytes.into()),
+        raw_data: RustRawKeyData::Public(point_bytes.into()),
       })
     }
     KeyData::JwkPrivateEc { d, x, y } => {
@@ -553,7 +554,7 @@ fn import_key_ec_jwk(
       );
 
       Ok(ImportKeyResult::Ec {
-        raw_data: RawKeyData::Private(pkcs8_der.as_bytes().to_vec().into()),
+        raw_data: RustRawKeyData::Private(pkcs8_der.as_bytes().to_vec().into()),
       })
     }
     _ => unreachable!(),
@@ -606,7 +607,7 @@ fn import_key_ec(
         _ => return Err(not_supported_error("Unsupported named curve")),
       };
       Ok(ImportKeyResult::Ec {
-        raw_data: RawKeyData::Public(data),
+        raw_data: RustRawKeyData::Public(data.to_vec().into()),
       })
     }
     KeyData::Pkcs8(data) => {
@@ -660,7 +661,7 @@ fn import_key_ec(
       }
 
       Ok(ImportKeyResult::Ec {
-        raw_data: RawKeyData::Private(data),
+        raw_data: RustRawKeyData::Private(data.to_vec().into()),
       })
     }
     KeyData::Spki(data) => {
@@ -744,7 +745,7 @@ fn import_key_ec(
       }
 
       Ok(ImportKeyResult::Ec {
-        raw_data: RawKeyData::Public(encoded_key.into()),
+        raw_data: RustRawKeyData::Public(encoded_key.into()),
       })
     }
     KeyData::JwkPublicEc { .. } | KeyData::JwkPrivateEc { .. } => {
@@ -760,7 +761,7 @@ fn import_key_aes(key_data: KeyData) -> Result<ImportKeyResult, AnyError> {
       let data = base64::decode_config(k, URL_SAFE_FORGIVING)
         .map_err(|_| data_error("invalid key data"))?;
       ImportKeyResult::Hmac {
-        raw_data: RawKeyData::Secret(data.into()),
+        raw_data: RustRawKeyData::Secret(data.into()),
       }
     }
     _ => return Err(unsupported_format()),
@@ -773,7 +774,7 @@ fn import_key_hmac(key_data: KeyData) -> Result<ImportKeyResult, AnyError> {
       let data = base64::decode_config(k, URL_SAFE_FORGIVING)
         .map_err(|_| data_error("invalid key data"))?;
       ImportKeyResult::Hmac {
-        raw_data: RawKeyData::Secret(data.into()),
+        raw_data: RustRawKeyData::Secret(data.into()),
       }
     }
     _ => return Err(unsupported_format()),
diff --git a/ext/crypto/lib.rs b/ext/crypto/lib.rs
index dc5faf5e7..1765697c6 100644
--- a/ext/crypto/lib.rs
+++ b/ext/crypto/lib.rs
@@ -9,10 +9,11 @@ use deno_core::error::not_supported;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
 use deno_core::op;
+use deno_core::ToJsBuffer;
 
 use deno_core::task::spawn_blocking;
+use deno_core::JsBuffer;
 use deno_core::OpState;
-use deno_core::ZeroCopyBuf;
 use serde::Deserialize;
 use shared::operation_error;
 
@@ -69,7 +70,7 @@ use crate::key::Algorithm;
 use crate::key::CryptoHash;
 use crate::key::CryptoNamedCurve;
 use crate::key::HkdfOutput;
-use crate::shared::RawKeyData;
+use crate::shared::V8RawKeyData;
 
 deno_core::extension!(deno_crypto,
   deps = [ deno_webidl, deno_web ],
@@ -118,13 +119,13 @@ deno_core::extension!(deno_crypto,
 #[op]
 pub fn op_crypto_base64url_decode(
   data: String,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let data: Vec<u8> = base64::decode_config(data, base64::URL_SAFE_NO_PAD)?;
   Ok(data.into())
 }
 
 #[op]
-pub fn op_crypto_base64url_encode(data: ZeroCopyBuf) -> String {
+pub fn op_crypto_base64url_encode(data: JsBuffer) -> String {
   let data: String = base64::encode_config(data, base64::URL_SAFE_NO_PAD);
   data
 }
@@ -172,7 +173,7 @@ pub enum KeyType {
 #[serde(rename_all = "lowercase")]
 pub struct KeyData {
   r#type: KeyType,
-  data: ZeroCopyBuf,
+  data: JsBuffer,
 }
 
 #[derive(Deserialize)]
@@ -188,8 +189,8 @@ pub struct SignArg {
 #[op]
 pub async fn op_crypto_sign_key(
   args: SignArg,
-  zero_copy: ZeroCopyBuf,
-) -> Result<ZeroCopyBuf, AnyError> {
+  zero_copy: JsBuffer,
+) -> Result<ToJsBuffer, AnyError> {
   let data = &*zero_copy;
   let algorithm = args.algorithm;
 
@@ -297,14 +298,14 @@ pub struct VerifyArg {
   key: KeyData,
   algorithm: Algorithm,
   hash: Option<CryptoHash>,
-  signature: ZeroCopyBuf,
+  signature: JsBuffer,
   named_curve: Option<CryptoNamedCurve>,
 }
 
 #[op]
 pub async fn op_crypto_verify_key(
   args: VerifyArg,
-  zero_copy: ZeroCopyBuf,
+  zero_copy: JsBuffer,
 ) -> Result<bool, AnyError> {
   let data = &*zero_copy;
   let algorithm = args.algorithm;
@@ -414,14 +415,14 @@ pub struct DeriveKeyArg {
   public_key: Option<KeyData>,
   named_curve: Option<CryptoNamedCurve>,
   // HKDF
-  info: Option<ZeroCopyBuf>,
+  info: Option<JsBuffer>,
 }
 
 #[op]
 pub async fn op_crypto_derive_bits(
   args: DeriveKeyArg,
-  zero_copy: Option<ZeroCopyBuf>,
-) -> Result<ZeroCopyBuf, AnyError> {
+  zero_copy: Option<JsBuffer>,
+) -> Result<ToJsBuffer, AnyError> {
   let algorithm = args.algorithm;
   match algorithm {
     Algorithm::Pbkdf2 => {
@@ -601,8 +602,8 @@ pub fn op_crypto_random_uuid(state: &mut OpState) -> Result<String, AnyError> {
 #[op]
 pub async fn op_crypto_subtle_digest(
   algorithm: CryptoHash,
-  data: ZeroCopyBuf,
-) -> Result<ZeroCopyBuf, AnyError> {
+  data: JsBuffer,
+) -> Result<ToJsBuffer, AnyError> {
   let output = spawn_blocking(move || {
     digest::digest(algorithm.into(), &data)
       .as_ref()
@@ -617,15 +618,15 @@ pub async fn op_crypto_subtle_digest(
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct WrapUnwrapKeyArg {
-  key: RawKeyData,
+  key: V8RawKeyData,
   algorithm: Algorithm,
 }
 
 #[op]
 pub fn op_crypto_wrap_key(
   args: WrapUnwrapKeyArg,
-  data: ZeroCopyBuf,
-) -> Result<ZeroCopyBuf, AnyError> {
+  data: JsBuffer,
+) -> Result<ToJsBuffer, AnyError> {
   let algorithm = args.algorithm;
 
   match algorithm {
@@ -653,8 +654,8 @@ pub fn op_crypto_wrap_key(
 #[op]
 pub fn op_crypto_unwrap_key(
   args: WrapUnwrapKeyArg,
-  data: ZeroCopyBuf,
-) -> Result<ZeroCopyBuf, AnyError> {
+  data: JsBuffer,
+) -> Result<ToJsBuffer, AnyError> {
   let algorithm = args.algorithm;
   match algorithm {
     Algorithm::AesKw => {
diff --git a/ext/crypto/shared.rs b/ext/crypto/shared.rs
index 4ecb35dc2..109f51fa1 100644
--- a/ext/crypto/shared.rs
+++ b/ext/crypto/shared.rs
@@ -5,7 +5,8 @@ use std::borrow::Cow;
 use deno_core::error::custom_error;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
-use deno_core::ZeroCopyBuf;
+use deno_core::JsBuffer;
+use deno_core::ToJsBuffer;
 use elliptic_curve::sec1::ToEncodedPoint;
 use rsa::pkcs1::DecodeRsaPrivateKey;
 use rsa::pkcs1::EncodeRsaPublicKey;
@@ -46,19 +47,27 @@ pub enum EcNamedCurve {
   P521,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Deserialize)]
 #[serde(rename_all = "lowercase", tag = "type", content = "data")]
-pub enum RawKeyData {
-  Secret(ZeroCopyBuf),
-  Private(ZeroCopyBuf),
-  Public(ZeroCopyBuf),
+pub enum V8RawKeyData {
+  Secret(JsBuffer),
+  Private(JsBuffer),
+  Public(JsBuffer),
 }
 
-impl RawKeyData {
+#[derive(Serialize)]
+#[serde(rename_all = "lowercase", tag = "type", content = "data")]
+pub enum RustRawKeyData {
+  Secret(ToJsBuffer),
+  Private(ToJsBuffer),
+  Public(ToJsBuffer),
+}
+
+impl V8RawKeyData {
   pub fn as_rsa_public_key(&self) -> Result<Cow<'_, [u8]>, AnyError> {
     match self {
-      RawKeyData::Public(data) => Ok(Cow::Borrowed(data)),
-      RawKeyData::Private(data) => {
+      V8RawKeyData::Public(data) => Ok(Cow::Borrowed(data)),
+      V8RawKeyData::Private(data) => {
         let private_key = RsaPrivateKey::from_pkcs1_der(data)
           .map_err(|_| type_error("expected valid private key"))?;
 
@@ -75,55 +84,55 @@ impl RawKeyData {
 
   pub fn as_rsa_private_key(&self) -> Result<&[u8], AnyError> {
     match self {
-      RawKeyData::Private(data) => Ok(data),
+      V8RawKeyData::Private(data) => Ok(data),
       _ => Err(type_error("expected private key")),
     }
   }
 
   pub fn as_secret_key(&self) -> Result<&[u8], AnyError> {
     match self {
-      RawKeyData::Secret(data) => Ok(data),
+      V8RawKeyData::Secret(data) => Ok(data),
       _ => Err(type_error("expected secret key")),
     }
   }
 
   pub fn as_ec_public_key_p256(&self) -> Result<p256::EncodedPoint, AnyError> {
     match self {
-      RawKeyData::Public(data) => {
+      V8RawKeyData::Public(data) => {
         // public_key is a serialized EncodedPoint
         p256::EncodedPoint::from_bytes(data)
           .map_err(|_| type_error("expected valid public EC key"))
       }
-      RawKeyData::Private(data) => {
+      V8RawKeyData::Private(data) => {
         let signing_key = p256::SecretKey::from_pkcs8_der(data)
           .map_err(|_| type_error("expected valid private EC key"))?;
         Ok(signing_key.public_key().to_encoded_point(false))
       }
       // Should never reach here.
-      RawKeyData::Secret(_) => unreachable!(),
+      V8RawKeyData::Secret(_) => unreachable!(),
     }
   }
 
   pub fn as_ec_public_key_p384(&self) -> Result<p384::EncodedPoint, AnyError> {
     match self {
-      RawKeyData::Public(data) => {
+      V8RawKeyData::Public(data) => {
         // public_key is a serialized EncodedPoint
         p384::EncodedPoint::from_bytes(data)
           .map_err(|_| type_error("expected valid public EC key"))
       }
-      RawKeyData::Private(data) => {
+      V8RawKeyData::Private(data) => {
         let signing_key = p384::SecretKey::from_pkcs8_der(data)
           .map_err(|_| type_error("expected valid private EC key"))?;
         Ok(signing_key.public_key().to_encoded_point(false))
       }
       // Should never reach here.
-      RawKeyData::Secret(_) => unreachable!(),
+      V8RawKeyData::Secret(_) => unreachable!(),
     }
   }
 
   pub fn as_ec_private_key(&self) -> Result<&[u8], AnyError> {
     match self {
-      RawKeyData::Private(data) => Ok(data),
+      V8RawKeyData::Private(data) => Ok(data),
       _ => Err(type_error("expected private key")),
     }
   }
diff --git a/ext/crypto/x25519.rs b/ext/crypto/x25519.rs
index 99914e14e..77554129e 100644
--- a/ext/crypto/x25519.rs
+++ b/ext/crypto/x25519.rs
@@ -3,7 +3,7 @@
 use curve25519_dalek::montgomery::MontgomeryPoint;
 use deno_core::error::AnyError;
 use deno_core::op;
-use deno_core::ZeroCopyBuf;
+use deno_core::ToJsBuffer;
 use elliptic_curve::pkcs8::PrivateKeyInfo;
 use elliptic_curve::subtle::ConstantTimeEq;
 use rand::rngs::OsRng;
@@ -101,7 +101,7 @@ pub fn op_crypto_import_pkcs8_x25519(key_data: &[u8], out: &mut [u8]) -> bool {
 #[op]
 pub fn op_crypto_export_spki_x25519(
   pubkey: &[u8],
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let key_info = spki::SubjectPublicKeyInfo {
     algorithm: spki::AlgorithmIdentifier {
       // id-X25519
@@ -116,7 +116,7 @@ pub fn op_crypto_export_spki_x25519(
 #[op]
 pub fn op_crypto_export_pkcs8_x25519(
   pkey: &[u8],
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   // This should probably use OneAsymmetricKey instead
   let pk_info = rsa::pkcs8::PrivateKeyInfo {
     public_key: None,
diff --git a/ext/fetch/lib.rs b/ext/fetch/lib.rs
index 538b741a6..a3daff040 100644
--- a/ext/fetch/lib.rs
+++ b/ext/fetch/lib.rs
@@ -32,11 +32,11 @@ use deno_core::CancelFuture;
 use deno_core::CancelHandle;
 use deno_core::CancelTryFuture;
 use deno_core::Canceled;
+use deno_core::JsBuffer;
 use deno_core::OpState;
 use deno_core::RcRef;
 use deno_core::Resource;
 use deno_core::ResourceId;
-use deno_core::ZeroCopyBuf;
 use deno_tls::rustls::RootCertStore;
 use deno_tls::Proxy;
 use deno_tls::RootCertStoreProvider;
@@ -232,7 +232,7 @@ pub fn op_fetch<FP>(
   client_rid: Option<u32>,
   has_body: bool,
   body_length: Option<u64>,
-  data: Option<ZeroCopyBuf>,
+  data: Option<JsBuffer>,
 ) -> Result<FetchReturn, AnyError>
 where
   FP: FetchPermissions + 'static,
diff --git a/ext/fs/ops.rs b/ext/fs/ops.rs
index 5bf3b1c6f..083d1b15f 100644
--- a/ext/fs/ops.rs
+++ b/ext/fs/ops.rs
@@ -14,9 +14,10 @@ use deno_core::error::AnyError;
 use deno_core::op;
 use deno_core::CancelFuture;
 use deno_core::CancelHandle;
+use deno_core::JsBuffer;
 use deno_core::OpState;
 use deno_core::ResourceId;
-use deno_core::ZeroCopyBuf;
+use deno_core::ToJsBuffer;
 use deno_io::fs::FileResource;
 use deno_io::fs::FsError;
 use deno_io::fs::FsStat;
@@ -1077,7 +1078,7 @@ fn op_fs_write_file_sync<P>(
   append: bool,
   create: bool,
   create_new: bool,
-  data: ZeroCopyBuf,
+  data: JsBuffer,
 ) -> Result<(), AnyError>
 where
   P: FsPermissions + 'static,
@@ -1104,7 +1105,7 @@ async fn op_fs_write_file_async<P>(
   append: bool,
   create: bool,
   create_new: bool,
-  data: ZeroCopyBuf,
+  data: JsBuffer,
   cancel_rid: Option<ResourceId>,
 ) -> Result<(), AnyError>
 where
@@ -1144,7 +1145,7 @@ where
 fn op_fs_read_file_sync<P>(
   state: &mut OpState,
   path: String,
-) -> Result<ZeroCopyBuf, AnyError>
+) -> Result<ToJsBuffer, AnyError>
 where
   P: FsPermissions + 'static,
 {
@@ -1164,7 +1165,7 @@ async fn op_fs_read_file_async<P>(
   state: Rc<RefCell<OpState>>,
   path: String,
   cancel_rid: Option<ResourceId>,
-) -> Result<ZeroCopyBuf, AnyError>
+) -> Result<ToJsBuffer, AnyError>
 where
   P: FsPermissions + 'static,
 {
diff --git a/ext/http/lib.rs b/ext/http/lib.rs
index da007ba39..1ae156b86 100644
--- a/ext/http/lib.rs
+++ b/ext/http/lib.rs
@@ -28,12 +28,12 @@ use deno_core::ByteString;
 use deno_core::CancelFuture;
 use deno_core::CancelHandle;
 use deno_core::CancelTryFuture;
+use deno_core::JsBuffer;
 use deno_core::OpState;
 use deno_core::RcRef;
 use deno_core::Resource;
 use deno_core::ResourceId;
 use deno_core::StringOrBuffer;
-use deno_core::ZeroCopyBuf;
 use deno_net::raw::NetworkStream;
 use deno_websocket::ws_create_server_stream;
 use flate2::write::GzEncoder;
@@ -880,7 +880,7 @@ async fn op_http_write_resource(
 async fn op_http_write(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
-  buf: ZeroCopyBuf,
+  buf: JsBuffer,
 ) -> Result<(), AnyError> {
   let stream = state
     .borrow()
diff --git a/ext/kv/lib.rs b/ext/kv/lib.rs
index 2763fcf50..db7c5c22e 100644
--- a/ext/kv/lib.rs
+++ b/ext/kv/lib.rs
@@ -19,10 +19,11 @@ use deno_core::op;
 use deno_core::serde_v8::AnyValue;
 use deno_core::serde_v8::BigInt;
 use deno_core::ByteString;
+use deno_core::JsBuffer;
 use deno_core::OpState;
 use deno_core::Resource;
 use deno_core::ResourceId;
-use deno_core::ZeroCopyBuf;
+use deno_core::ToJsBuffer;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -122,7 +123,8 @@ impl From<AnyValue> for KeyPart {
       AnyValue::Number(n) => KeyPart::Float(n),
       AnyValue::BigInt(n) => KeyPart::Int(n),
       AnyValue::String(s) => KeyPart::String(s),
-      AnyValue::Buffer(buf) => KeyPart::Bytes(buf.to_vec()),
+      AnyValue::V8Buffer(buf) => KeyPart::Bytes(buf.to_vec()),
+      AnyValue::RustBuffer(_) => unreachable!(),
     }
   }
 }
@@ -135,51 +137,61 @@ impl From<KeyPart> for AnyValue {
       KeyPart::Float(n) => AnyValue::Number(n),
       KeyPart::Int(n) => AnyValue::BigInt(n),
       KeyPart::String(s) => AnyValue::String(s),
-      KeyPart::Bytes(buf) => AnyValue::Buffer(buf.into()),
+      KeyPart::Bytes(buf) => AnyValue::RustBuffer(buf.into()),
     }
   }
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize)]
 #[serde(tag = "kind", content = "value", rename_all = "snake_case")]
-enum V8Value {
-  V8(ZeroCopyBuf),
-  Bytes(ZeroCopyBuf),
+enum FromV8Value {
+  V8(JsBuffer),
+  Bytes(JsBuffer),
   U64(BigInt),
 }
 
-impl TryFrom<V8Value> for Value {
+#[derive(Debug, Serialize)]
+#[serde(tag = "kind", content = "value", rename_all = "snake_case")]
+enum ToV8Value {
+  V8(ToJsBuffer),
+  Bytes(ToJsBuffer),
+  U64(BigInt),
+}
+
+impl TryFrom<FromV8Value> for Value {
   type Error = AnyError;
-  fn try_from(value: V8Value) -> Result<Self, AnyError> {
+  fn try_from(value: FromV8Value) -> Result<Self, AnyError> {
     Ok(match value {
-      V8Value::V8(buf) => Value::V8(buf.to_vec()),
-      V8Value::Bytes(buf) => Value::Bytes(buf.to_vec()),
-      V8Value::U64(n) => Value::U64(num_bigint::BigInt::from(n).try_into()?),
+      FromV8Value::V8(buf) => Value::V8(buf.to_vec()),
+      FromV8Value::Bytes(buf) => Value::Bytes(buf.to_vec()),
+      FromV8Value::U64(n) => {
+        Value::U64(num_bigint::BigInt::from(n).try_into()?)
+      }
     })
   }
 }
 
-impl From<Value> for V8Value {
+impl From<Value> for ToV8Value {
   fn from(value: Value) -> Self {
     match value {
-      Value::V8(buf) => V8Value::V8(buf.into()),
-      Value::Bytes(buf) => V8Value::Bytes(buf.into()),
-      Value::U64(n) => V8Value::U64(num_bigint::BigInt::from(n).into()),
+      Value::V8(buf) => ToV8Value::V8(buf.into()),
+      Value::Bytes(buf) => ToV8Value::Bytes(buf.into()),
+      Value::U64(n) => ToV8Value::U64(num_bigint::BigInt::from(n).into()),
     }
   }
 }
 
-#[derive(Deserialize, Serialize)]
-struct V8KvEntry {
+#[derive(Serialize)]
+struct ToV8KvEntry {
   key: KvKey,
-  value: V8Value,
+  value: ToV8Value,
   versionstamp: ByteString,
 }
 
-impl TryFrom<KvEntry> for V8KvEntry {
+impl TryFrom<KvEntry> for ToV8KvEntry {
   type Error = AnyError;
   fn try_from(entry: KvEntry) -> Result<Self, AnyError> {
-    Ok(V8KvEntry {
+    Ok(ToV8KvEntry {
       key: decode_key(&entry.key)?
         .0
         .into_iter()
@@ -223,7 +235,7 @@ async fn op_kv_snapshot_read<DBH>(
   rid: ResourceId,
   ranges: Vec<SnapshotReadRange>,
   consistency: V8Consistency,
-) -> Result<Vec<Vec<V8KvEntry>>, AnyError>
+) -> Result<Vec<Vec<ToV8KvEntry>>, AnyError>
 where
   DBH: DatabaseHandler + 'static,
 {
@@ -301,7 +313,7 @@ impl<QMH: QueueMessageHandle + 'static> Resource for QueueMessageResource<QMH> {
 async fn op_kv_dequeue_next_message<DBH>(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
-) -> Result<(ZeroCopyBuf, ResourceId), AnyError>
+) -> Result<(ToJsBuffer, ResourceId), AnyError>
 where
   DBH: DatabaseHandler + 'static,
 {
@@ -364,7 +376,7 @@ impl TryFrom<V8KvCheck> for KvCheck {
   }
 }
 
-type V8KvMutation = (KvKey, String, Option<V8Value>);
+type V8KvMutation = (KvKey, String, Option<FromV8Value>);
 
 impl TryFrom<V8KvMutation> for KvMutation {
   type Error = AnyError;
@@ -389,7 +401,7 @@ impl TryFrom<V8KvMutation> for KvMutation {
   }
 }
 
-type V8Enqueue = (ZeroCopyBuf, u64, Vec<KvKey>, Option<Vec<u32>>);
+type V8Enqueue = (JsBuffer, u64, Vec<KvKey>, Option<Vec<u32>>);
 
 impl TryFrom<V8Enqueue> for Enqueue {
   type Error = AnyError;
diff --git a/ext/net/ops.rs b/ext/net/ops.rs
index 05aa416b4..921b9ea5b 100644
--- a/ext/net/ops.rs
+++ b/ext/net/ops.rs
@@ -15,11 +15,11 @@ use deno_core::AsyncRefCell;
 use deno_core::ByteString;
 use deno_core::CancelHandle;
 use deno_core::CancelTryFuture;
+use deno_core::JsBuffer;
 use deno_core::OpState;
 use deno_core::RcRef;
 use deno_core::Resource;
 use deno_core::ResourceId;
-use deno_core::ZeroCopyBuf;
 use serde::Deserialize;
 use serde::Serialize;
 use socket2::Domain;
@@ -109,7 +109,7 @@ async fn op_net_accept_tcp(
 async fn op_net_recv_udp(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
-  mut buf: ZeroCopyBuf,
+  mut buf: JsBuffer,
 ) -> Result<(usize, IpAddr), AnyError> {
   let resource = state
     .borrow_mut()
@@ -130,7 +130,7 @@ async fn op_net_send_udp<NP>(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
   addr: IpAddr,
-  zero_copy: ZeroCopyBuf,
+  zero_copy: JsBuffer,
 ) -> Result<usize, AnyError>
 where
   NP: NetPermissions + 'static,
diff --git a/ext/net/ops_unix.rs b/ext/net/ops_unix.rs
index bed923f8b..f3ff9617a 100644
--- a/ext/net/ops_unix.rs
+++ b/ext/net/ops_unix.rs
@@ -9,11 +9,11 @@ use deno_core::op;
 use deno_core::AsyncRefCell;
 use deno_core::CancelHandle;
 use deno_core::CancelTryFuture;
+use deno_core::JsBuffer;
 use deno_core::OpState;
 use deno_core::RcRef;
 use deno_core::Resource;
 use deno_core::ResourceId;
-use deno_core::ZeroCopyBuf;
 use serde::Deserialize;
 use serde::Serialize;
 use std::borrow::Cow;
@@ -138,7 +138,7 @@ where
 pub async fn op_net_recv_unixpacket(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
-  mut buf: ZeroCopyBuf,
+  mut buf: JsBuffer,
 ) -> Result<(usize, Option<String>), AnyError> {
   let resource = state
     .borrow()
@@ -160,7 +160,7 @@ async fn op_net_send_unixpacket<NP>(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
   path: String,
-  zero_copy: ZeroCopyBuf,
+  zero_copy: JsBuffer,
 ) -> Result<usize, AnyError>
 where
   NP: NetPermissions + 'static,
diff --git a/ext/node/ops/crypto/mod.rs b/ext/node/ops/crypto/mod.rs
index 05f2d34f7..a83263fff 100644
--- a/ext/node/ops/crypto/mod.rs
+++ b/ext/node/ops/crypto/mod.rs
@@ -5,10 +5,11 @@ use deno_core::error::AnyError;
 use deno_core::op;
 use deno_core::serde_v8;
 use deno_core::task::spawn_blocking;
+use deno_core::JsBuffer;
 use deno_core::OpState;
 use deno_core::ResourceId;
 use deno_core::StringOrBuffer;
-use deno_core::ZeroCopyBuf;
+use deno_core::ToJsBuffer;
 use hkdf::Hkdf;
 use num_bigint::BigInt;
 use num_bigint_dig::BigUint;
@@ -115,7 +116,7 @@ pub fn op_node_hash_update_str(
 pub fn op_node_hash_digest(
   state: &mut OpState,
   rid: ResourceId,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let context = state.resource_table.take::<digest::Context>(rid)?;
   let context = Rc::try_unwrap(context)
     .map_err(|_| type_error("Hash context is already in use"))?;
@@ -148,7 +149,7 @@ pub fn op_node_private_encrypt(
   key: StringOrBuffer,
   msg: StringOrBuffer,
   padding: u32,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let key = RsaPrivateKey::from_pkcs8_pem((&key).try_into()?)?;
 
   let mut rng = rand::thread_rng();
@@ -172,7 +173,7 @@ pub fn op_node_private_decrypt(
   key: StringOrBuffer,
   msg: StringOrBuffer,
   padding: u32,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let key = RsaPrivateKey::from_pkcs8_pem((&key).try_into()?)?;
 
   match padding {
@@ -195,7 +196,7 @@ pub fn op_node_public_encrypt(
   key: StringOrBuffer,
   msg: StringOrBuffer,
   padding: u32,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let key = RsaPublicKey::from_public_key_pem((&key).try_into()?)?;
 
   let mut rng = rand::thread_rng();
@@ -307,7 +308,7 @@ pub fn op_node_sign(
   key: StringOrBuffer,
   key_type: &str,
   key_format: &str,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   match key_type {
     "rsa" => {
       use rsa::pkcs1v15::SigningKey;
@@ -456,7 +457,7 @@ pub async fn op_node_pbkdf2_async(
   iterations: u32,
   digest: String,
   keylen: usize,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   spawn_blocking(move || {
     let mut derived_key = vec![0; keylen];
     pbkdf2_sync(&password, &salt, iterations, &digest, &mut derived_key)
@@ -471,7 +472,7 @@ pub fn op_node_generate_secret(buf: &mut [u8]) {
 }
 
 #[op]
-pub async fn op_node_generate_secret_async(len: i32) -> ZeroCopyBuf {
+pub async fn op_node_generate_secret_async(len: i32) -> ToJsBuffer {
   spawn_blocking(move || {
     let mut buf = vec![0u8; len as usize];
     rand::thread_rng().fill(&mut buf[..]);
@@ -525,11 +526,11 @@ pub fn op_node_hkdf(
 #[op]
 pub async fn op_node_hkdf_async(
   hash: String,
-  ikm: ZeroCopyBuf,
-  salt: ZeroCopyBuf,
-  info: ZeroCopyBuf,
+  ikm: JsBuffer,
+  salt: JsBuffer,
+  info: JsBuffer,
   okm_len: usize,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   spawn_blocking(move || {
     let mut okm = vec![0u8; okm_len];
     hkdf_sync(&hash, &ikm, &salt, &info, &mut okm)?;
@@ -546,7 +547,7 @@ use self::primes::Prime;
 fn generate_rsa(
   modulus_length: usize,
   public_exponent: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   let mut rng = rand::thread_rng();
   let private_key = RsaPrivateKey::new_with_exp(
     &mut rng,
@@ -564,7 +565,7 @@ fn generate_rsa(
 pub fn op_node_generate_rsa(
   modulus_length: usize,
   public_exponent: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   generate_rsa(modulus_length, public_exponent)
 }
 
@@ -572,14 +573,14 @@ pub fn op_node_generate_rsa(
 pub async fn op_node_generate_rsa_async(
   modulus_length: usize,
   public_exponent: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(move || generate_rsa(modulus_length, public_exponent)).await?
 }
 
 fn dsa_generate(
   modulus_length: usize,
   divisor_length: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   let mut rng = rand::thread_rng();
   use dsa::pkcs8::EncodePrivateKey;
   use dsa::pkcs8::EncodePublicKey;
@@ -618,7 +619,7 @@ fn dsa_generate(
 pub fn op_node_dsa_generate(
   modulus_length: usize,
   divisor_length: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   dsa_generate(modulus_length, divisor_length)
 }
 
@@ -626,13 +627,13 @@ pub fn op_node_dsa_generate(
 pub async fn op_node_dsa_generate_async(
   modulus_length: usize,
   divisor_length: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(move || dsa_generate(modulus_length, divisor_length)).await?
 }
 
 fn ec_generate(
   named_curve: &str,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   use ring::signature::EcdsaKeyPair;
   use ring::signature::KeyPair;
 
@@ -658,18 +659,18 @@ fn ec_generate(
 #[op]
 pub fn op_node_ec_generate(
   named_curve: &str,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   ec_generate(named_curve)
 }
 
 #[op]
 pub async fn op_node_ec_generate_async(
   named_curve: String,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(move || ec_generate(&named_curve)).await?
 }
 
-fn ed25519_generate() -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+fn ed25519_generate() -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   use ring::signature::Ed25519KeyPair;
   use ring::signature::KeyPair;
 
@@ -685,18 +686,18 @@ fn ed25519_generate() -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
 }
 
 #[op]
-pub fn op_node_ed25519_generate() -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError>
+pub fn op_node_ed25519_generate() -> Result<(ToJsBuffer, ToJsBuffer), AnyError>
 {
   ed25519_generate()
 }
 
 #[op]
 pub async fn op_node_ed25519_generate_async(
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(ed25519_generate).await?
 }
 
-fn x25519_generate() -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+fn x25519_generate() -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   // u-coordinate of the base point.
   const X25519_BASEPOINT_BYTES: [u8; 32] = [
     9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -720,20 +721,19 @@ fn x25519_generate() -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
 }
 
 #[op]
-pub fn op_node_x25519_generate() -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError>
-{
+pub fn op_node_x25519_generate() -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   x25519_generate()
 }
 
 #[op]
 pub async fn op_node_x25519_generate_async(
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(x25519_generate).await?
 }
 
 fn dh_generate_group(
   group_name: &str,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   let dh = match group_name {
     "modp5" => dh::DiffieHellman::group::<dh::Modp1536>(),
     "modp14" => dh::DiffieHellman::group::<dh::Modp2048>(),
@@ -753,14 +753,14 @@ fn dh_generate_group(
 #[op]
 pub fn op_node_dh_generate_group(
   group_name: &str,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   dh_generate_group(group_name)
 }
 
 #[op]
 pub async fn op_node_dh_generate_group_async(
   group_name: String,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(move || dh_generate_group(&group_name)).await?
 }
 
@@ -768,7 +768,7 @@ fn dh_generate(
   prime: Option<&[u8]>,
   prime_len: usize,
   generator: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   let prime = prime
     .map(|p| p.into())
     .unwrap_or_else(|| Prime::generate(prime_len));
@@ -785,26 +785,26 @@ pub fn op_node_dh_generate(
   prime: Option<&[u8]>,
   prime_len: usize,
   generator: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   dh_generate(prime, prime_len, generator)
 }
 
 // TODO(lev): This duplication should be avoided.
 #[op]
 pub fn op_node_dh_generate2(
-  prime: ZeroCopyBuf,
+  prime: JsBuffer,
   prime_len: usize,
   generator: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   dh_generate(Some(prime).as_deref(), prime_len, generator)
 }
 
 #[op]
 pub fn op_node_dh_compute_secret(
-  prime: ZeroCopyBuf,
-  private_key: ZeroCopyBuf,
-  their_public_key: ZeroCopyBuf,
-) -> Result<ZeroCopyBuf, AnyError> {
+  prime: JsBuffer,
+  private_key: JsBuffer,
+  their_public_key: JsBuffer,
+) -> Result<ToJsBuffer, AnyError> {
   let pubkey: BigUint = BigUint::from_bytes_be(their_public_key.as_ref());
   let privkey: BigUint = BigUint::from_bytes_be(private_key.as_ref());
   let primei: BigUint = BigUint::from_bytes_be(prime.as_ref());
@@ -815,10 +815,10 @@ pub fn op_node_dh_compute_secret(
 
 #[op]
 pub async fn op_node_dh_generate_async(
-  prime: Option<ZeroCopyBuf>,
+  prime: Option<JsBuffer>,
   prime_len: usize,
   generator: usize,
-) -> Result<(ZeroCopyBuf, ZeroCopyBuf), AnyError> {
+) -> Result<(ToJsBuffer, ToJsBuffer), AnyError> {
   spawn_blocking(move || dh_generate(prime.as_deref(), prime_len, generator))
     .await?
 }
@@ -895,7 +895,7 @@ pub async fn op_node_scrypt_async(
   block_size: u32,
   parallelization: u32,
   maxmem: u32,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   spawn_blocking(move || {
     let mut output_buffer = vec![0u8; keylen as usize];
     let res = scrypt(
@@ -963,7 +963,7 @@ pub fn op_node_ecdh_generate_keys(
 #[op]
 pub fn op_node_ecdh_compute_secret(
   curve: &str,
-  this_priv: Option<ZeroCopyBuf>,
+  this_priv: Option<JsBuffer>,
   their_pub: &mut [u8],
   secret: &mut [u8],
 ) -> Result<(), AnyError> {
@@ -1079,18 +1079,18 @@ pub fn op_node_ecdh_compute_public_key(
 }
 
 #[inline]
-fn gen_prime(size: usize) -> ZeroCopyBuf {
+fn gen_prime(size: usize) -> ToJsBuffer {
   primes::Prime::generate(size).0.to_bytes_be().into()
 }
 
 #[op]
-pub fn op_node_gen_prime(size: usize) -> ZeroCopyBuf {
+pub fn op_node_gen_prime(size: usize) -> ToJsBuffer {
   gen_prime(size)
 }
 
 #[op]
 pub async fn op_node_gen_prime_async(
   size: usize,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   Ok(spawn_blocking(move || gen_prime(size)).await?)
 }
diff --git a/ext/url/lib.rs b/ext/url/lib.rs
index cfb6497c3..b884f7948 100644
--- a/ext/url/lib.rs
+++ b/ext/url/lib.rs
@@ -8,8 +8,8 @@ use deno_core::op;
 use deno_core::url::form_urlencoded;
 use deno_core::url::quirks;
 use deno_core::url::Url;
+use deno_core::JsBuffer;
 use deno_core::OpState;
-use deno_core::ZeroCopyBuf;
 use std::path::PathBuf;
 
 use crate::urlpattern::op_urlpattern_parse;
@@ -220,7 +220,7 @@ pub fn op_url_reparse(
 #[op]
 pub fn op_url_parse_search_params(
   args: Option<String>,
-  zero_copy: Option<ZeroCopyBuf>,
+  zero_copy: Option<JsBuffer>,
 ) -> Result<Vec<(String, String)>, AnyError> {
   let params = match (args, zero_copy) {
     (None, Some(zero_copy)) => form_urlencoded::parse(&zero_copy)
diff --git a/ext/web/blob.rs b/ext/web/blob.rs
index 7796c18af..9c5f5a09c 100644
--- a/ext/web/blob.rs
+++ b/ext/web/blob.rs
@@ -12,8 +12,9 @@ use deno_core::error::AnyError;
 use deno_core::op;
 use deno_core::parking_lot::Mutex;
 use deno_core::url::Url;
+use deno_core::JsBuffer;
 use deno_core::OpState;
-use deno_core::ZeroCopyBuf;
+use deno_core::ToJsBuffer;
 use serde::Deserialize;
 use serde::Serialize;
 use uuid::Uuid;
@@ -160,7 +161,7 @@ impl BlobPart for SlicedBlobPart {
 }
 
 #[op]
-pub fn op_blob_create_part(state: &mut OpState, data: ZeroCopyBuf) -> Uuid {
+pub fn op_blob_create_part(state: &mut OpState, data: JsBuffer) -> Uuid {
   let blob_store = state.borrow::<BlobStore>();
   let part = InMemoryBlobPart(data.to_vec());
   blob_store.insert_part(Arc::new(part))
@@ -203,7 +204,7 @@ pub fn op_blob_slice_part(
 pub async fn op_blob_read_part(
   state: Rc<RefCell<OpState>>,
   id: Uuid,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let part = {
     let state = state.borrow();
     let blob_store = state.borrow::<BlobStore>();
@@ -211,7 +212,7 @@ pub async fn op_blob_read_part(
   }
   .ok_or_else(|| type_error("Blob part not found"))?;
   let buf = part.read().await?;
-  Ok(ZeroCopyBuf::from(buf.to_vec()))
+  Ok(ToJsBuffer::from(buf.to_vec()))
 }
 
 #[op]
diff --git a/ext/web/compression.rs b/ext/web/compression.rs
index 11ea9196a..557bff6ba 100644
--- a/ext/web/compression.rs
+++ b/ext/web/compression.rs
@@ -5,7 +5,7 @@ use deno_core::op;
 use deno_core::OpState;
 use deno_core::Resource;
 use deno_core::ResourceId;
-use deno_core::ZeroCopyBuf;
+use deno_core::ToJsBuffer;
 use flate2::write::DeflateDecoder;
 use flate2::write::DeflateEncoder;
 use flate2::write::GzDecoder;
@@ -69,7 +69,7 @@ pub fn op_compression_write(
   state: &mut OpState,
   rid: ResourceId,
   input: &[u8],
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let resource = state.resource_table.get::<CompressionResource>(rid)?;
   let mut inner = resource.0.borrow_mut();
   let out: Vec<u8> = match &mut *inner {
@@ -112,7 +112,7 @@ pub fn op_compression_write(
 pub fn op_compression_finish(
   state: &mut OpState,
   rid: ResourceId,
-) -> Result<ZeroCopyBuf, AnyError> {
+) -> Result<ToJsBuffer, AnyError> {
   let resource = state.resource_table.take::<CompressionResource>(rid)?;
   let resource = Rc::try_unwrap(resource).unwrap();
   let inner = resource.0.into_inner();
diff --git a/ext/web/lib.rs b/ext/web/lib.rs
index b1e0dd5d8..af213b5be 100644
--- a/ext/web/lib.rs
+++ b/ext/web/lib.rs
@@ -18,8 +18,8 @@ use deno_core::CancelHandle;
 use deno_core::OpState;
 use deno_core::Resource;
 use deno_core::ResourceId;
+use deno_core::ToJsBuffer;
 use deno_core::U16String;
-use deno_core::ZeroCopyBuf;
 
 use encoding_rs::CoderResult;
 use encoding_rs::Decoder;
@@ -123,7 +123,7 @@ deno_core::extension!(deno_web,
 );
 
 #[op]
-fn op_base64_decode(input: String) -> Result<ZeroCopyBuf, AnyError> {
+fn op_base64_decode(input: String) -> Result<ToJsBuffer, AnyError> {
   let mut s = input.into_bytes();
   let decoded_len = forgiving_base64_decode_inplace(&mut s)?;
   s.truncate(decoded_len);
diff --git a/ext/websocket/lib.rs b/ext/websocket/lib.rs
index cbf9f8ff1..dd975589c 100644
--- a/ext/websocket/lib.rs
+++ b/ext/websocket/lib.rs
@@ -11,11 +11,12 @@ use deno_core::AsyncRefCell;
 use deno_core::ByteString;
 use deno_core::CancelFuture;
 use deno_core::CancelHandle;
+use deno_core::JsBuffer;
 use deno_core::OpState;
 use deno_core::RcRef;
 use deno_core::Resource;
 use deno_core::ResourceId;
-use deno_core::ZeroCopyBuf;
+use deno_core::ToJsBuffer;
 use deno_net::raw::NetworkStream;
 use deno_tls::create_client_config;
 use deno_tls::RootCertStoreProvider;
@@ -406,11 +407,7 @@ pub fn ws_create_server_stream(
 }
 
 #[op(fast)]
-pub fn op_ws_send_binary(
-  state: &mut OpState,
-  rid: ResourceId,
-  data: ZeroCopyBuf,
-) {
+pub fn op_ws_send_binary(state: &mut OpState, rid: ResourceId, data: JsBuffer) {
   let resource = state.resource_table.get::<ServerWebSocket>(rid).unwrap();
   let data = data.to_vec();
   let len = data.len();
@@ -454,7 +451,7 @@ pub fn op_ws_send_text(state: &mut OpState, rid: ResourceId, data: String) {
 pub async fn op_ws_send_binary_async(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
-  data: ZeroCopyBuf,
+  data: JsBuffer,
 ) -> Result<(), AnyError> {
   let resource = state
     .borrow_mut()
@@ -547,7 +544,7 @@ pub async fn op_ws_close(
 }
 
 #[op]
-pub fn op_ws_get_buffer(state: &mut OpState, rid: ResourceId) -> ZeroCopyBuf {
+pub fn op_ws_get_buffer(state: &mut OpState, rid: ResourceId) -> ToJsBuffer {
   let resource = state.resource_table.get::<ServerWebSocket>(rid).unwrap();
   resource.buffer.take().unwrap().into()
 }