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.

9 files changed, 93 insertions, 149 deletions

diff --git a/serde_v8/de.rs b/serde_v8/de.rs
index edb1263eb..d36cf6452 100644
--- a/serde_v8/de.rs
+++ b/serde_v8/de.rs
@@ -18,9 +18,9 @@ use crate::AnyValue;
 use crate::BigInt;
 use crate::ByteString;
 use crate::DetachedBuffer;
+use crate::JsBuffer;
 use crate::StringOrBuffer;
 use crate::U16String;
-use crate::ZeroCopyBuf;
 
 pub struct Deserializer<'a, 'b, 's> {
   input: v8::Local<'a, v8::Value>,
@@ -337,8 +337,8 @@ impl<'de, 'a, 'b, 's, 'x> de::Deserializer<'de>
     V: Visitor<'de>,
   {
     match name {
-      ZeroCopyBuf::MAGIC_NAME => {
-        visit_magic(visitor, ZeroCopyBuf::from_v8(self.scope, self.input)?)
+      JsBuffer::MAGIC_NAME => {
+        visit_magic(visitor, JsBuffer::from_v8(self.scope, self.input)?)
       }
       DetachedBuffer::MAGIC_NAME => {
         visit_magic(visitor, DetachedBuffer::from_v8(self.scope, self.input)?)
@@ -452,7 +452,7 @@ impl<'de, 'a, 'b, 's, 'x> de::Deserializer<'de>
   where
     V: Visitor<'de>,
   {
-    magic::buffer::ZeroCopyBuf::from_v8(self.scope, self.input)
+    magic::buffer::JsBuffer::from_v8(self.scope, self.input)
       .and_then(|zb| visitor.visit_bytes(&zb))
   }
 
@@ -460,7 +460,7 @@ impl<'de, 'a, 'b, 's, 'x> de::Deserializer<'de>
   where
     V: Visitor<'de>,
   {
-    magic::buffer::ZeroCopyBuf::from_v8(self.scope, self.input)
+    magic::buffer::JsBuffer::from_v8(self.scope, self.input)
       .and_then(|zb| visitor.visit_byte_buf(Vec::from(&*zb)))
   }
 }
diff --git a/serde_v8/lib.rs b/serde_v8/lib.rs
index 26d95c67a..59c8fd41f 100644
--- a/serde_v8/lib.rs
+++ b/serde_v8/lib.rs
@@ -17,7 +17,8 @@ pub use error::Result;
 pub use keys::KeyCache;
 pub use magic::any_value::AnyValue;
 pub use magic::bigint::BigInt;
-pub use magic::buffer::ZeroCopyBuf;
+pub use magic::buffer::JsBuffer;
+pub use magic::buffer::ToJsBuffer;
 pub use magic::bytestring::ByteString;
 pub use magic::detached_buffer::DetachedBuffer;
 pub use magic::string_or_buffer::StringOrBuffer;
diff --git a/serde_v8/magic/any_value.rs b/serde_v8/magic/any_value.rs
index 31a74cfde..9ae39bb2e 100644
--- a/serde_v8/magic/any_value.rs
+++ b/serde_v8/magic/any_value.rs
@@ -1,17 +1,19 @@
 use num_bigint::BigInt;
 
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-use super::buffer::ZeroCopyBuf;
+use super::buffer::JsBuffer;
 use super::transl8::FromV8;
 use super::transl8::ToV8;
 use crate::magic::transl8::impl_magic;
 use crate::Error;
+use crate::ToJsBuffer;
 
 /// An untagged enum type that can be any of number, string, bool, bigint, or
 /// buffer.
 #[derive(Debug)]
 pub enum AnyValue {
-  Buffer(ZeroCopyBuf),
+  RustBuffer(ToJsBuffer),
+  V8Buffer(JsBuffer),
   String(String),
   Number(f64),
   BigInt(BigInt),
@@ -26,7 +28,8 @@ impl ToV8 for AnyValue {
     scope: &mut v8::HandleScope<'a>,
   ) -> Result<v8::Local<'a, v8::Value>, crate::Error> {
     match self {
-      Self::Buffer(buf) => buf.to_v8(scope),
+      Self::RustBuffer(buf) => crate::to_v8(scope, buf),
+      Self::V8Buffer(_) => unreachable!(),
       Self::String(s) => crate::to_v8(scope, s),
       Self::Number(num) => crate::to_v8(scope, num),
       Self::BigInt(bigint) => {
@@ -52,8 +55,8 @@ impl FromV8 for AnyValue {
       let bigint = crate::BigInt::from_v8(scope, value)?;
       Ok(AnyValue::BigInt(bigint.into()))
     } else if value.is_array_buffer_view() {
-      let buf = ZeroCopyBuf::from_v8(scope, value)?;
-      Ok(AnyValue::Buffer(buf))
+      let buf = JsBuffer::from_v8(scope, value)?;
+      Ok(AnyValue::V8Buffer(buf))
     } else if value.is_boolean() {
       let string = crate::from_v8(scope, value)?;
       Ok(AnyValue::Bool(string))
diff --git a/serde_v8/magic/buffer.rs b/serde_v8/magic/buffer.rs
index d0f0909bc..032a3be33 100644
--- a/serde_v8/magic/buffer.rs
+++ b/serde_v8/magic/buffer.rs
@@ -9,91 +9,93 @@ use super::transl8::ToV8;
 use super::v8slice::V8Slice;
 use crate::magic::transl8::impl_magic;
 
-// An asymmetric wrapper around V8Slice,
-// allowing us to use a single type for familiarity
-pub enum ZeroCopyBuf {
-  FromV8(V8Slice),
-  ToV8(Option<Box<[u8]>>),
-}
+pub struct JsBuffer(V8Slice);
 
-impl_magic!(ZeroCopyBuf);
+impl_magic!(JsBuffer);
 
-impl Debug for ZeroCopyBuf {
+impl Debug for JsBuffer {
   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    f.debug_list().entries(self.as_ref().iter()).finish()
-  }
-}
-
-impl ZeroCopyBuf {
-  pub fn empty() -> Self {
-    ZeroCopyBuf::ToV8(Some(vec![0_u8; 0].into_boxed_slice()))
+    f.debug_list().entries(self.0.as_ref().iter()).finish()
   }
 }
 
-impl Clone for ZeroCopyBuf {
+impl Clone for JsBuffer {
   fn clone(&self) -> Self {
-    match self {
-      Self::FromV8(zbuf) => Self::FromV8(zbuf.clone()),
-      Self::ToV8(_) => panic!("Don't Clone a ZeroCopyBuf sent to v8"),
-    }
+    Self(self.0.clone())
   }
 }
 
-impl AsRef<[u8]> for ZeroCopyBuf {
+impl AsRef<[u8]> for JsBuffer {
   fn as_ref(&self) -> &[u8] {
-    self
+    &self.0
   }
 }
 
-impl AsMut<[u8]> for ZeroCopyBuf {
+impl AsMut<[u8]> for JsBuffer {
   fn as_mut(&mut self) -> &mut [u8] {
-    &mut *self
+    &mut self.0
   }
 }
 
-impl Deref for ZeroCopyBuf {
+impl Deref for JsBuffer {
   type Target = [u8];
   fn deref(&self) -> &[u8] {
-    match self {
-      Self::FromV8(buf) => buf,
-      Self::ToV8(_) => panic!("Don't Deref a ZeroCopyBuf sent to v8"),
-    }
+    &self.0
   }
 }
 
-impl DerefMut for ZeroCopyBuf {
+impl DerefMut for JsBuffer {
   fn deref_mut(&mut self) -> &mut [u8] {
-    match self {
-      Self::FromV8(buf) => &mut *buf,
-      Self::ToV8(_) => panic!("Don't Deref a ZeroCopyBuf sent to v8"),
-    }
+    &mut self.0
+  }
+}
+
+impl FromV8 for JsBuffer {
+  fn from_v8(
+    scope: &mut v8::HandleScope,
+    value: v8::Local<v8::Value>,
+  ) -> Result<Self, crate::Error> {
+    Ok(Self(V8Slice::from_v8(scope, value)?))
+  }
+}
+
+impl From<JsBuffer> for bytes::Bytes {
+  fn from(zbuf: JsBuffer) -> bytes::Bytes {
+    zbuf.0.into()
   }
 }
 
-impl From<Box<[u8]>> for ZeroCopyBuf {
+// NOTE(bartlomieju): we use Option here, because `to_v8()` uses `&mut self`
+// instead of `self` which is dictated by the `serde` API.
+#[derive(Debug)]
+pub struct ToJsBuffer(Option<Box<[u8]>>);
+
+impl_magic!(ToJsBuffer);
+
+impl ToJsBuffer {
+  pub fn empty() -> Self {
+    ToJsBuffer(Some(vec![0_u8; 0].into_boxed_slice()))
+  }
+}
+
+impl From<Box<[u8]>> for ToJsBuffer {
   fn from(buf: Box<[u8]>) -> Self {
-    ZeroCopyBuf::ToV8(Some(buf))
+    ToJsBuffer(Some(buf))
   }
 }
 
-impl From<Vec<u8>> for ZeroCopyBuf {
+impl From<Vec<u8>> for ToJsBuffer {
   fn from(vec: Vec<u8>) -> Self {
     vec.into_boxed_slice().into()
   }
 }
 
-impl ToV8 for ZeroCopyBuf {
+impl ToV8 for ToJsBuffer {
   fn to_v8<'a>(
     &mut self,
     scope: &mut v8::HandleScope<'a>,
   ) -> Result<v8::Local<'a, v8::Value>, crate::Error> {
-    let buf: Box<[u8]> = match self {
-      Self::FromV8(buf) => {
-        let value: &[u8] = buf;
-        value.into()
-      }
-      Self::ToV8(ref mut x) => x.take().expect("ZeroCopyBuf was empty"),
-    };
+    let buf: Box<[u8]> = self.0.take().expect("RustToV8Buf was empty");
 
     if buf.is_empty() {
       let ab = v8::ArrayBuffer::new(scope, 0);
@@ -103,7 +105,7 @@ impl ToV8 for ZeroCopyBuf {
           .into(),
       );
     }
-    let buf_len = buf.len();
+    let buf_len: usize = buf.len();
     let backing_store =
       v8::ArrayBuffer::new_backing_store_from_boxed_slice(buf);
     let backing_store_shared = backing_store.make_shared();
@@ -115,23 +117,3 @@ impl ToV8 for ZeroCopyBuf {
     )
   }
 }
-
-impl FromV8 for ZeroCopyBuf {
-  fn from_v8(
-    scope: &mut v8::HandleScope,
-    value: v8::Local<v8::Value>,
-  ) -> Result<Self, crate::Error> {
-    Ok(Self::FromV8(V8Slice::from_v8(scope, value)?))
-  }
-}
-
-impl From<ZeroCopyBuf> for bytes::Bytes {
-  fn from(zbuf: ZeroCopyBuf) -> bytes::Bytes {
-    match zbuf {
-      ZeroCopyBuf::FromV8(v) => v.into(),
-      ZeroCopyBuf::ToV8(mut v) => {
-        v.take().expect("ZeroCopyBuf was empty").into()
-      }
-    }
-  }
-}
diff --git a/serde_v8/magic/string_or_buffer.rs b/serde_v8/magic/string_or_buffer.rs
index 02571f669..986f7d32a 100644
--- a/serde_v8/magic/string_or_buffer.rs
+++ b/serde_v8/magic/string_or_buffer.rs
@@ -1,7 +1,6 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-use super::buffer::ZeroCopyBuf;
+use super::buffer::JsBuffer;
 use super::transl8::FromV8;
-use super::transl8::ToV8;
 use crate::error::value_to_type_str;
 use crate::magic::transl8::impl_magic;
 use crate::Error;
@@ -9,7 +8,7 @@ use std::ops::Deref;
 
 #[derive(Debug)]
 pub enum StringOrBuffer {
-  Buffer(ZeroCopyBuf),
+  Buffer(JsBuffer),
   String(String),
 }
 
@@ -35,40 +34,12 @@ impl<'a> TryFrom<&'a StringOrBuffer> for &'a str {
   }
 }
 
-impl ToV8 for StringOrBuffer {
-  fn to_v8<'a>(
-    &mut self,
-    scope: &mut v8::HandleScope<'a>,
-  ) -> Result<v8::Local<'a, v8::Value>, crate::Error> {
-    match self {
-      Self::Buffer(buf) => {
-        let buf: Box<[u8]> = match buf {
-          ZeroCopyBuf::FromV8(buf) => {
-            let value: &[u8] = buf;
-            value.into()
-          }
-          ZeroCopyBuf::ToV8(ref mut x) => {
-            x.take().expect("ZeroCopyBuf was empty")
-          }
-        };
-        let backing_store =
-          v8::ArrayBuffer::new_backing_store_from_boxed_slice(buf);
-        Ok(
-          v8::ArrayBuffer::with_backing_store(scope, &backing_store.into())
-            .into(),
-        )
-      }
-      Self::String(s) => crate::to_v8(scope, s),
-    }
-  }
-}
-
 impl FromV8 for StringOrBuffer {
   fn from_v8(
     scope: &mut v8::HandleScope,
     value: v8::Local<v8::Value>,
   ) -> Result<Self, crate::Error> {
-    if let Ok(buf) = ZeroCopyBuf::from_v8(scope, value) {
+    if let Ok(buf) = JsBuffer::from_v8(scope, value) {
       return Ok(Self::Buffer(buf));
     } else if let Ok(s) = crate::from_v8(scope, value) {
       return Ok(Self::String(s));
diff --git a/serde_v8/ser.rs b/serde_v8/ser.rs
index 74ad9ec10..51625f230 100644
--- a/serde_v8/ser.rs
+++ b/serde_v8/ser.rs
@@ -19,9 +19,8 @@ use crate::BigInt;
 use crate::ByteString;
 use crate::DetachedBuffer;
 use crate::ExternalPointer;
-use crate::StringOrBuffer;
+use crate::ToJsBuffer;
 use crate::U16String;
-use crate::ZeroCopyBuf;
 
 type JsValue<'s> = v8::Local<'s, v8::Value>;
 type JsResult<'s> = Result<JsValue<'s>>;
@@ -274,12 +273,11 @@ impl<'a, 'b, 'c, T: MagicType + ToV8> ser::SerializeStruct
 pub enum StructSerializers<'a, 'b, 'c> {
   ExternalPointer(MagicalSerializer<'a, 'b, 'c, magic::ExternalPointer>),
   Magic(MagicalSerializer<'a, 'b, 'c, magic::Value<'a>>),
-  ZeroCopyBuf(MagicalSerializer<'a, 'b, 'c, ZeroCopyBuf>),
+  RustToV8Buf(MagicalSerializer<'a, 'b, 'c, ToJsBuffer>),
   MagicAnyValue(MagicalSerializer<'a, 'b, 'c, AnyValue>),
   MagicDetached(MagicalSerializer<'a, 'b, 'c, DetachedBuffer>),
   MagicByteString(MagicalSerializer<'a, 'b, 'c, ByteString>),
   MagicU16String(MagicalSerializer<'a, 'b, 'c, U16String>),
-  MagicStringOrBuffer(MagicalSerializer<'a, 'b, 'c, StringOrBuffer>),
   MagicBigInt(MagicalSerializer<'a, 'b, 'c, BigInt>),
   Regular(ObjectSerializer<'a, 'b, 'c>),
 }
@@ -296,14 +294,11 @@ impl<'a, 'b, 'c> ser::SerializeStruct for StructSerializers<'a, 'b, 'c> {
     match self {
       StructSerializers::ExternalPointer(s) => s.serialize_field(key, value),
       StructSerializers::Magic(s) => s.serialize_field(key, value),
-      StructSerializers::ZeroCopyBuf(s) => s.serialize_field(key, value),
+      StructSerializers::RustToV8Buf(s) => s.serialize_field(key, value),
       StructSerializers::MagicAnyValue(s) => s.serialize_field(key, value),
       StructSerializers::MagicDetached(s) => s.serialize_field(key, value),
       StructSerializers::MagicByteString(s) => s.serialize_field(key, value),
       StructSerializers::MagicU16String(s) => s.serialize_field(key, value),
-      StructSerializers::MagicStringOrBuffer(s) => {
-        s.serialize_field(key, value)
-      }
       StructSerializers::MagicBigInt(s) => s.serialize_field(key, value),
       StructSerializers::Regular(s) => s.serialize_field(key, value),
     }
@@ -313,12 +308,11 @@ impl<'a, 'b, 'c> ser::SerializeStruct for StructSerializers<'a, 'b, 'c> {
     match self {
       StructSerializers::ExternalPointer(s) => s.end(),
       StructSerializers::Magic(s) => s.end(),
-      StructSerializers::ZeroCopyBuf(s) => s.end(),
+      StructSerializers::RustToV8Buf(s) => s.end(),
       StructSerializers::MagicAnyValue(s) => s.end(),
       StructSerializers::MagicDetached(s) => s.end(),
       StructSerializers::MagicByteString(s) => s.end(),
       StructSerializers::MagicU16String(s) => s.end(),
-      StructSerializers::MagicStringOrBuffer(s) => s.end(),
       StructSerializers::MagicBigInt(s) => s.end(),
       StructSerializers::Regular(s) => s.end(),
     }
@@ -588,9 +582,9 @@ impl<'a, 'b, 'c> ser::Serializer for Serializer<'a, 'b, 'c> {
         let m = MagicalSerializer::<U16String>::new(self.scope);
         Ok(StructSerializers::MagicU16String(m))
       }
-      ZeroCopyBuf::MAGIC_NAME => {
-        let m = MagicalSerializer::<ZeroCopyBuf>::new(self.scope);
-        Ok(StructSerializers::ZeroCopyBuf(m))
+      ToJsBuffer::MAGIC_NAME => {
+        let m = MagicalSerializer::<ToJsBuffer>::new(self.scope);
+        Ok(StructSerializers::RustToV8Buf(m))
       }
       AnyValue::MAGIC_NAME => {
         let m = MagicalSerializer::<AnyValue>::new(self.scope);
@@ -600,10 +594,6 @@ impl<'a, 'b, 'c> ser::Serializer for Serializer<'a, 'b, 'c> {
         let m = MagicalSerializer::<DetachedBuffer>::new(self.scope);
         Ok(StructSerializers::MagicDetached(m))
       }
-      StringOrBuffer::MAGIC_NAME => {
-        let m = MagicalSerializer::<StringOrBuffer>::new(self.scope);
-        Ok(StructSerializers::MagicStringOrBuffer(m))
-      }
       BigInt::MAGIC_NAME => {
         let m = MagicalSerializer::<BigInt>::new(self.scope);
         Ok(StructSerializers::MagicBigInt(m))
diff --git a/serde_v8/serializable.rs b/serde_v8/serializable.rs
index b02aa0629..36a8bc27b 100644
--- a/serde_v8/serializable.rs
+++ b/serde_v8/serializable.rs
@@ -4,8 +4,8 @@ use std::mem::transmute_copy;
 
 use crate::BigInt;
 use crate::ByteString;
+use crate::ToJsBuffer;
 use crate::U16String;
-use crate::ZeroCopyBuf;
 
 /// Serializable exists to allow boxing values as "objects" to be serialized later,
 /// this is particularly useful for async op-responses. This trait is a more efficient
@@ -63,7 +63,7 @@ pub enum Primitive {
   Float32(f32),
   Float64(f64),
   String(String),
-  ZeroCopyBuf(ZeroCopyBuf),
+  RustToV8Buf(ToJsBuffer),
   ByteString(ByteString),
   U16String(U16String),
   BigInt(BigInt),
@@ -88,7 +88,7 @@ impl serde::Serialize for Primitive {
       Self::Float32(x) => x.serialize(s),
       Self::Float64(x) => x.serialize(s),
       Self::String(x) => x.serialize(s),
-      Self::ZeroCopyBuf(x) => x.serialize(s),
+      Self::RustToV8Buf(x) => x.serialize(s),
       Self::ByteString(x) => x.serialize(s),
       Self::U16String(x) => x.serialize(s),
       Self::BigInt(x) => x.serialize(s),
@@ -134,8 +134,8 @@ impl<T: serde::Serialize + 'static> From<T> for SerializablePkg {
       Self::Primitive(Primitive::Float64(tc(x)))
     } else if tid == TypeId::of::<String>() {
       Self::Primitive(Primitive::String(tc(x)))
-    } else if tid == TypeId::of::<ZeroCopyBuf>() {
-      Self::Primitive(Primitive::ZeroCopyBuf(tc(x)))
+    } else if tid == TypeId::of::<ToJsBuffer>() {
+      Self::Primitive(Primitive::RustToV8Buf(tc(x)))
     } else if tid == TypeId::of::<ByteString>() {
       Self::Primitive(Primitive::ByteString(tc(x)))
     } else if tid == TypeId::of::<U16String>() {
diff --git a/serde_v8/tests/de.rs b/serde_v8/tests/de.rs
index 4c5cf7283..3abaa0979 100644
--- a/serde_v8/tests/de.rs
+++ b/serde_v8/tests/de.rs
@@ -7,8 +7,8 @@ use serde_v8::utils::v8_do;
 use serde_v8::BigInt;
 use serde_v8::ByteString;
 use serde_v8::Error;
+use serde_v8::JsBuffer;
 use serde_v8::U16String;
-use serde_v8::ZeroCopyBuf;
 
 #[derive(Debug, Deserialize, PartialEq)]
 struct MathOp {
@@ -248,31 +248,31 @@ fn de_string_or_buffer() {
 fn de_buffers() {
   // ArrayBufferView
   dedo("new Uint8Array([97])", |scope, v| {
-    let buf: ZeroCopyBuf = serde_v8::from_v8(scope, v).unwrap();
+    let buf: JsBuffer = serde_v8::from_v8(scope, v).unwrap();
     assert_eq!(&*buf, &[97]);
   });
 
   // ArrayBuffer
   dedo("(new Uint8Array([97])).buffer", |scope, v| {
-    let buf: ZeroCopyBuf = serde_v8::from_v8(scope, v).unwrap();
+    let buf: JsBuffer = serde_v8::from_v8(scope, v).unwrap();
     assert_eq!(&*buf, &[97]);
   });
 
   dedo(
     "(Uint8Array.from([0x68, 0x65, 0x6C, 0x6C, 0x6F]))",
     |scope, v| {
-      let buf: ZeroCopyBuf = serde_v8::from_v8(scope, v).unwrap();
+      let buf: JsBuffer = serde_v8::from_v8(scope, v).unwrap();
       assert_eq!(&*buf, &[0x68, 0x65, 0x6C, 0x6C, 0x6F]);
     },
   );
 
   dedo("(new ArrayBuffer(4))", |scope, v| {
-    let buf: ZeroCopyBuf = serde_v8::from_v8(scope, v).unwrap();
+    let buf: JsBuffer = serde_v8::from_v8(scope, v).unwrap();
     assert_eq!(&*buf, &[0x0, 0x0, 0x0, 0x0]);
   });
 
   dedo("(new ArrayBuffer(8, { maxByteLength: 16}))", |scope, v| {
-    let result: Result<ZeroCopyBuf, Error> = serde_v8::from_v8(scope, v);
+    let result: Result<JsBuffer, Error> = serde_v8::from_v8(scope, v);
     matches!(result, Err(Error::ResizableBackingStoreNotSupported));
   });
 }
diff --git a/serde_v8/tests/magic.rs b/serde_v8/tests/magic.rs
index 8ae163784..09e520561 100644
--- a/serde_v8/tests/magic.rs
+++ b/serde_v8/tests/magic.rs
@@ -68,27 +68,26 @@ fn magic_buffer() {
 
     // Simple buffer
     let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])");
-    let zbuf: serde_v8::ZeroCopyBuf =
-      serde_v8::from_v8(scope, v8_array).unwrap();
+    let zbuf: serde_v8::JsBuffer = serde_v8::from_v8(scope, v8_array).unwrap();
     assert_eq!(&*zbuf, &[1, 2, 3, 4, 5]);
 
     // Multi buffers
     let v8_arrays =
       js_exec(scope, "[new Uint8Array([1,2]), new Uint8Array([3,4,5])]");
-    let (z1, z2): (serde_v8::ZeroCopyBuf, serde_v8::ZeroCopyBuf) =
+    let (z1, z2): (serde_v8::JsBuffer, serde_v8::JsBuffer) =
       serde_v8::from_v8(scope, v8_arrays).unwrap();
     assert_eq!(&*z1, &[1, 2]);
     assert_eq!(&*z2, &[3, 4, 5]);
 
     // Wrapped in option, like our current op-ABI
     let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])");
-    let zbuf: Option<serde_v8::ZeroCopyBuf> =
+    let zbuf: Option<serde_v8::JsBuffer> =
       serde_v8::from_v8(scope, v8_array).unwrap();
     assert_eq!(&*zbuf.unwrap(), &[1, 2, 3, 4, 5]);
 
     // Observe mutation in JS
     let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])");
-    let mut zbuf: serde_v8::ZeroCopyBuf =
+    let mut zbuf: serde_v8::JsBuffer =
       serde_v8::from_v8(scope, v8_array).unwrap();
     let key = serde_v8::to_v8(scope, "t1").unwrap();
     global.set(scope, key, v8_array);
@@ -99,13 +98,12 @@ fn magic_buffer() {
     // Shared buffers
     let v8_array =
       js_exec(scope, "new Uint8Array(new SharedArrayBuffer([1,2,3,4,5]))");
-    let zbuf: Result<serde_v8::ZeroCopyBuf> =
-      serde_v8::from_v8(scope, v8_array);
+    let zbuf: Result<serde_v8::JsBuffer> = serde_v8::from_v8(scope, v8_array);
     assert!(zbuf.is_err());
 
     // Serialization
     let buf: Vec<u8> = vec![1, 2, 3, 99, 5];
-    let zbuf: serde_v8::ZeroCopyBuf = buf.into();
+    let zbuf: serde_v8::ToJsBuffer = buf.into();
     let v8_value = serde_v8::to_v8(scope, zbuf).unwrap();
     let key = serde_v8::to_v8(scope, "t2").unwrap();
     global.set(scope, key, v8_value);
@@ -115,8 +113,8 @@ fn magic_buffer() {
     // Composite Serialization
     #[derive(serde::Serialize)]
     struct Wrapper {
-      a: serde_v8::ZeroCopyBuf,
-      b: serde_v8::ZeroCopyBuf,
+      a: serde_v8::ToJsBuffer,
+      b: serde_v8::ToJsBuffer,
     }
     let buf1: Vec<u8> = vec![1, 2, 33, 4, 5];
     let buf2: Vec<u8> = vec![5, 4, 3, 2, 11];
@@ -134,8 +132,7 @@ fn magic_buffer() {
 
     // ZeroCopyBuf as bytes::Bytes
     let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])");
-    let zbuf: serde_v8::ZeroCopyBuf =
-      serde_v8::from_v8(scope, v8_array).unwrap();
+    let zbuf: serde_v8::JsBuffer = serde_v8::from_v8(scope, v8_array).unwrap();
     let buf: bytes::Bytes = zbuf.into();
     assert_eq!(buf, bytes::Bytes::from_static(&[1, 2, 3, 4, 5]));
     assert_eq!(buf, bytes::Bytes::from_static(&[1, 2, 3, 4, 5]));