8 files changed, 305 insertions, 348 deletions

diff --git a/serde_v8/src/magic/buffer.rs b/serde_v8/src/magic/buffer.rs
index e6f85324e..484984ac5 100644
--- a/serde_v8/src/magic/buffer.rs
+++ b/serde_v8/src/magic/buffer.rs
@@ -1,12 +1,13 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 
-use std::convert::TryFrom;
-use std::fmt;
 use std::ops::Deref;
 use std::ops::DerefMut;
 use std::sync::Mutex;
 
+use super::transl8::FromV8;
+use super::transl8::ToV8;
 use super::zero_copy_buf::ZeroCopyBuf;
+use crate::magic::transl8::impl_magic;
 
 // An asymmetric wrapper around ZeroCopyBuf,
 // allowing us to use a single type for familiarity
@@ -14,6 +15,7 @@ pub enum MagicBuffer {
   FromV8(ZeroCopyBuf),
   ToV8(Mutex<Option<Box<[u8]>>>),
 }
+impl_magic!(MagicBuffer);
 
 impl MagicBuffer {
   pub fn empty() -> Self {
@@ -21,27 +23,6 @@ impl MagicBuffer {
   }
 }
 
-impl<'s> TryFrom<v8::Local<'s, v8::ArrayBuffer>> for MagicBuffer {
-  type Error = v8::DataError;
-  fn try_from(buffer: v8::Local<v8::ArrayBuffer>) -> Result<Self, Self::Error> {
-    Ok(Self::FromV8(ZeroCopyBuf::try_from(buffer)?))
-  }
-}
-
-// TODO(@AaronO): consider streamlining this as "ScopedValue" ?
-type ScopedView<'a, 'b, 's> = (
-  &'s mut v8::HandleScope<'a>,
-  v8::Local<'b, v8::ArrayBufferView>,
-);
-impl<'a, 'b, 's> TryFrom<ScopedView<'a, 'b, 's>> for MagicBuffer {
-  type Error = v8::DataError;
-  fn try_from(
-    scoped_view: ScopedView<'a, 'b, 's>,
-  ) -> Result<Self, Self::Error> {
-    Ok(Self::FromV8(ZeroCopyBuf::try_from(scoped_view)?))
-  }
-}
-
 impl Clone for MagicBuffer {
   fn clone(&self) -> Self {
     match self {
@@ -94,61 +75,45 @@ impl From<Vec<u8>> for MagicBuffer {
   }
 }
 
-pub const BUF_NAME: &str = "$__v8_magic_Buffer";
-pub const BUF_FIELD_1: &str = "$__v8_magic_buffer_1";
-pub const BUF_FIELD_2: &str = "$__v8_magic_buffer_2";
-
-impl serde::Serialize for MagicBuffer {
-  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-  where
-    S: serde::Serializer,
-  {
-    use serde::ser::SerializeStruct;
-
-    let mut s = serializer.serialize_struct(BUF_NAME, 1)?;
-    let boxed: Box<[u8]> = match self {
+impl ToV8 for MagicBuffer {
+  fn to_v8<'a>(
+    &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(x) => x.lock().unwrap().take().expect("MagicBuffer was empty"),
     };
-    let hack: [usize; 2] = unsafe { std::mem::transmute(boxed) };
-    let f1: u64 = hack[0] as u64;
-    let f2: u64 = hack[1] as u64;
-    s.serialize_field(BUF_FIELD_1, &f1)?;
-    s.serialize_field(BUF_FIELD_2, &f2)?;
-    s.end()
-  }
-}
-
-impl<'de, 's> serde::Deserialize<'de> for MagicBuffer {
-  fn deserialize<D>(deserializer: D) -> Result<MagicBuffer, D::Error>
-  where
-    D: serde::Deserializer<'de>,
-  {
-    struct ValueVisitor {}
-
-    impl<'de> serde::de::Visitor<'de> for ValueVisitor {
-      type Value = MagicBuffer;
-
-      fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        formatter.write_str("a serde_v8::MagicBuffer")
-      }
 
-      fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-      where
-        E: serde::de::Error,
-      {
-        let p1: &[usize] = unsafe { &*(v as *const [u8] as *const [usize]) };
-        let p2: [usize; 4] = [p1[0], p1[1], p1[2], p1[3]];
-        let zero_copy: ZeroCopyBuf = unsafe { std::mem::transmute(p2) };
-        Ok(MagicBuffer::FromV8(zero_copy))
-      }
+    if buf.is_empty() {
+      let ab = v8::ArrayBuffer::new(scope, 0);
+      return Ok(
+        v8::Uint8Array::new(scope, ab, 0, 0)
+          .expect("Failed to create Uint8Array")
+          .into(),
+      );
     }
+    let buf_len = buf.len();
+    let backing_store =
+      v8::ArrayBuffer::new_backing_store_from_boxed_slice(buf);
+    let backing_store_shared = backing_store.make_shared();
+    let ab = v8::ArrayBuffer::with_backing_store(scope, &backing_store_shared);
+    Ok(
+      v8::Uint8Array::new(scope, ab, 0, buf_len)
+        .expect("Failed to create Uint8Array")
+        .into(),
+    )
+  }
+}
 
-    static FIELDS: [&str; 0] = [];
-    let visitor = ValueVisitor {};
-    deserializer.deserialize_struct(BUF_NAME, &FIELDS, visitor)
+impl FromV8 for MagicBuffer {
+  fn from_v8(
+    scope: &mut v8::HandleScope,
+    value: v8::Local<v8::Value>,
+  ) -> Result<Self, crate::Error> {
+    Ok(Self::FromV8(ZeroCopyBuf::from_v8(scope, value)?))
   }
 }
diff --git a/serde_v8/src/magic/bytestring.rs b/serde_v8/src/magic/bytestring.rs
index 942aec64a..43ac54b97 100644
--- a/serde_v8/src/magic/bytestring.rs
+++ b/serde_v8/src/magic/bytestring.rs
@@ -2,14 +2,13 @@
 
 use std::ops::{Deref, DerefMut};
 
-use serde::{de::Visitor, Deserialize, Deserializer, Serialize, Serializer};
-
-pub const NAME: &str = "$__v8_magic_bytestring";
-pub const FIELD_PTR: &str = "$__v8_magic_bytestring_ptr";
-pub const FIELD_LEN: &str = "$__v8_magic_bytestring_len";
+use super::transl8::{FromV8, ToV8};
+use crate::magic::transl8::impl_magic;
+use crate::Error;
 
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct ByteString(pub Vec<u8>);
+impl_magic!(ByteString);
 
 impl ByteString {
   pub fn new() -> ByteString {
@@ -81,45 +80,43 @@ impl AsMut<[u8]> for ByteString {
   }
 }
 
-impl Serialize for ByteString {
-  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-  where
-    S: Serializer,
-  {
-    use serde::ser::SerializeStruct;
-
-    let mut s = serializer.serialize_struct(NAME, 1)?;
-    s.serialize_field(FIELD_PTR, &(self.0.as_ptr() as usize))?;
-    s.serialize_field(FIELD_LEN, &self.0.len())?;
-    s.end()
+impl ToV8 for ByteString {
+  fn to_v8<'a>(
+    &self,
+    scope: &mut v8::HandleScope<'a>,
+  ) -> Result<v8::Local<'a, v8::Value>, crate::Error> {
+    let v =
+      v8::String::new_from_one_byte(scope, self, v8::NewStringType::Normal)
+        .unwrap();
+    Ok(v.into())
   }
 }
 
-impl<'de> Deserialize<'de> for ByteString {
-  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-  where
-    D: Deserializer<'de>,
-  {
-    struct ValueVisitor {}
-
-    impl<'de> Visitor<'de> for ValueVisitor {
-      type Value = ByteString;
-
-      fn expecting(
-        &self,
-        formatter: &mut std::fmt::Formatter,
-      ) -> std::fmt::Result {
-        formatter.write_str("a serde_v8::ByteString")
-      }
-
-      fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-      where
-        E: serde::de::Error,
-      {
-        Ok(ByteString(v))
-      }
+impl FromV8 for ByteString {
+  fn from_v8(
+    scope: &mut v8::HandleScope,
+    value: v8::Local<v8::Value>,
+  ) -> Result<Self, crate::Error> {
+    let v8str = v8::Local::<v8::String>::try_from(value)
+      .map_err(|_| Error::ExpectedString)?;
+    if !v8str.contains_only_onebyte() {
+      return Err(Error::ExpectedLatin1);
     }
-
-    deserializer.deserialize_struct(NAME, &[], ValueVisitor {})
+    let len = v8str.length();
+    let mut buffer = Vec::with_capacity(len);
+    // SAFETY: we set length == capacity (see previous line),
+    // before immediately writing into that buffer and sanity check with an assert
+    #[allow(clippy::uninit_vec)]
+    unsafe {
+      buffer.set_len(len);
+      let written = v8str.write_one_byte(
+        scope,
+        &mut buffer,
+        0,
+        v8::WriteOptions::NO_NULL_TERMINATION,
+      );
+      assert!(written == len);
+    }
+    Ok(ByteString(buffer))
   }
 }
diff --git a/serde_v8/src/magic/field.rs b/serde_v8/src/magic/field.rs
deleted file mode 100644
index a188ed0e5..000000000
--- a/serde_v8/src/magic/field.rs
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
-use crate::error::{Error, Result};
-use serde::ser::{Impossible, Serialize, Serializer};
-
-/// All serde_v8 "magic" values are reduced to structs with 1 or 2 u64 fields
-/// assuming usize==u64, most types are simply a pointer or pointer+len (e.g: Box<T>)
-pub type TransmutedField = u64;
-pub type FieldResult = Result<TransmutedField>;
-
-macro_rules! not_reachable {
-    ($($name:ident($ty:ty);)*) => {
-        $(fn $name(self, _v: $ty) -> FieldResult {
-            unreachable!();
-        })*
-    };
-}
-
-/// FieldSerializer is a simple serde::Serializer that only returns u64s
-/// it allows the "magic" struct serializers to obtain the transmuted field values
-pub struct FieldSerializer {}
-
-impl Serializer for FieldSerializer {
-  type Ok = TransmutedField;
-  type Error = Error;
-
-  type SerializeSeq = Impossible<TransmutedField, Error>;
-  type SerializeTuple = Impossible<TransmutedField, Error>;
-  type SerializeTupleStruct = Impossible<TransmutedField, Error>;
-  type SerializeTupleVariant = Impossible<TransmutedField, Error>;
-  type SerializeMap = Impossible<TransmutedField, Error>;
-  type SerializeStruct = Impossible<TransmutedField, Error>;
-  type SerializeStructVariant = Impossible<TransmutedField, Error>;
-
-  fn serialize_u64(self, transmuted_field: u64) -> FieldResult {
-    Ok(transmuted_field)
-  }
-
-  not_reachable! {
-      serialize_i8(i8);
-      serialize_i16(i16);
-      serialize_i32(i32);
-      serialize_i64(i64);
-      serialize_u8(u8);
-      serialize_u16(u16);
-      serialize_u32(u32);
-      // serialize_u64(TransmutedField); the chosen one
-      serialize_f32(f32);
-      serialize_f64(f64);
-      serialize_bool(bool);
-      serialize_char(char);
-      serialize_str(&str);
-      serialize_bytes(&[u8]);
-  }
-
-  fn serialize_none(self) -> FieldResult {
-    unreachable!();
-  }
-
-  fn serialize_some<T: ?Sized + Serialize>(self, _value: &T) -> FieldResult {
-    unreachable!();
-  }
-
-  fn serialize_unit(self) -> FieldResult {
-    unreachable!();
-  }
-
-  fn serialize_unit_struct(self, _name: &'static str) -> FieldResult {
-    unreachable!();
-  }
-
-  fn serialize_unit_variant(
-    self,
-    _name: &'static str,
-    _variant_index: u32,
-    _variant: &'static str,
-  ) -> FieldResult {
-    unreachable!();
-  }
-
-  fn serialize_newtype_struct<T: ?Sized + Serialize>(
-    self,
-    _name: &'static str,
-    _value: &T,
-  ) -> FieldResult {
-    unreachable!();
-  }
-
-  fn serialize_newtype_variant<T: ?Sized + Serialize>(
-    self,
-    _name: &'static str,
-    _variant_index: u32,
-    _variant: &'static str,
-    _value: &T,
-  ) -> FieldResult {
-    unreachable!();
-  }
-  fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-    unreachable!();
-  }
-
-  fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-    unreachable!();
-  }
-
-  fn serialize_tuple_struct(
-    self,
-    _name: &'static str,
-    _len: usize,
-  ) -> Result<Self::SerializeTupleStruct> {
-    unreachable!();
-  }
-
-  fn serialize_tuple_variant(
-    self,
-    _name: &'static str,
-    _variant_index: u32,
-    _variant: &'static str,
-    _len: usize,
-  ) -> Result<Self::SerializeTupleVariant> {
-    unreachable!();
-  }
-
-  fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-    unreachable!();
-  }
-
-  fn serialize_struct(
-    self,
-    _name: &'static str,
-    _len: usize,
-  ) -> Result<Self::SerializeStruct> {
-    unreachable!();
-  }
-
-  fn serialize_struct_variant(
-    self,
-    _name: &'static str,
-    _variant_index: u32,
-    _variant: &'static str,
-    _len: usize,
-  ) -> Result<Self::SerializeStructVariant> {
-    unreachable!();
-  }
-}
diff --git a/serde_v8/src/magic/mod.rs b/serde_v8/src/magic/mod.rs
index e90b5ab60..bc86c6a7c 100644
--- a/serde_v8/src/magic/mod.rs
+++ b/serde_v8/src/magic/mod.rs
@@ -1,11 +1,9 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 pub mod buffer;
 pub mod bytestring;
-mod field;
 pub mod string_or_buffer;
+pub mod transl8;
 pub mod u16string;
 mod value;
 pub mod zero_copy_buf;
-
-pub use field::FieldSerializer;
-pub use value::{Value, FIELD, NAME};
+pub use value::Value;
diff --git a/serde_v8/src/magic/transl8.rs b/serde_v8/src/magic/transl8.rs
new file mode 100644
index 000000000..458b82129
--- /dev/null
+++ b/serde_v8/src/magic/transl8.rs
@@ -0,0 +1,143 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+
+//! Transerialization extends the set of serde-compatible types (for given de/serializers).
+//! By "hackishly" transmuting references across serde boundaries as u64s.
+//! Type-safety is enforced using special struct names for each "magic type".
+//! Memory-safety relies on transerialized values being "pinned" during de/serialization.
+
+pub(crate) const MAGIC_FIELD: &str = "$__v8_magic_field";
+
+pub(crate) trait MagicType {
+  const NAME: &'static str;
+  const MAGIC_NAME: &'static str;
+}
+
+pub(crate) trait ToV8 {
+  fn to_v8<'a>(
+    &self,
+    scope: &mut v8::HandleScope<'a>,
+  ) -> Result<v8::Local<'a, v8::Value>, crate::Error>;
+}
+
+pub(crate) trait FromV8: Sized {
+  fn from_v8(
+    scope: &mut v8::HandleScope,
+    value: v8::Local<v8::Value>,
+  ) -> Result<Self, crate::Error>;
+}
+
+pub(crate) fn magic_serialize<T, S>(
+  serializer: S,
+  x: &T,
+) -> Result<S::Ok, S::Error>
+where
+  S: serde::Serializer,
+  T: MagicType,
+{
+  use serde::ser::SerializeStruct;
+
+  let mut s = serializer.serialize_struct(T::MAGIC_NAME, 1)?;
+  let ptr = opaque_send(x);
+  s.serialize_field(MAGIC_FIELD, &ptr)?;
+  s.end()
+}
+
+pub(crate) fn magic_deserialize<'de, T, D>(
+  deserializer: D,
+) -> Result<T, D::Error>
+where
+  D: serde::Deserializer<'de>,
+  T: MagicType,
+{
+  struct ValueVisitor<T> {
+    p1: std::marker::PhantomData<T>,
+  }
+
+  impl<'de, T: MagicType> serde::de::Visitor<'de> for ValueVisitor<T> {
+    type Value = T;
+
+    fn expecting(
+      &self,
+      formatter: &mut std::fmt::Formatter,
+    ) -> std::fmt::Result {
+      formatter.write_str("a ")?;
+      formatter.write_str(T::NAME)
+    }
+
+    fn visit_u64<E>(self, ptr: u64) -> Result<Self::Value, E>
+    where
+      E: serde::de::Error,
+    {
+      // SAFETY: opaque ptr originates from visit_magic, which forgets ownership so we can take it
+      Ok(unsafe { opaque_take(ptr) })
+    }
+  }
+
+  deserializer.deserialize_struct(
+    T::MAGIC_NAME,
+    &[MAGIC_FIELD],
+    ValueVisitor::<T> {
+      p1: std::marker::PhantomData,
+    },
+  )
+}
+
+pub(crate) fn visit_magic<'de, T, V, E>(visitor: V, x: T) -> Result<V::Value, E>
+where
+  V: serde::de::Visitor<'de>,
+  E: serde::de::Error,
+{
+  let y = visitor.visit_u64::<E>(opaque_send(&x));
+  std::mem::forget(x);
+  y
+}
+
+/// Constructs an "opaque" ptr from a reference to transerialize
+pub(crate) fn opaque_send<T: Sized>(x: &T) -> u64 {
+  (x as *const T) as u64
+}
+
+/// Copies an "opaque" ptr from a reference to an opaque ptr (transerialized)
+/// NOTE: ptr-to-ptr, extra indirection
+pub(crate) unsafe fn opaque_recv<T: ?Sized>(ptr: &T) -> u64 {
+  *(ptr as *const T as *const u64)
+}
+
+/// Transmutes an "opaque" ptr back into a reference
+pub(crate) unsafe fn opaque_deref<'a, T>(ptr: u64) -> &'a T {
+  std::mem::transmute(ptr)
+}
+
+/// Transmutes & copies the value from the "opaque" ptr
+/// NOTE: takes ownership & requires other end to forget its ownership
+pub(crate) unsafe fn opaque_take<T>(ptr: u64) -> T {
+  std::mem::transmute_copy::<T, T>(std::mem::transmute(ptr))
+}
+
+macro_rules! impl_magic {
+  ($t:ty) => {
+    impl crate::magic::transl8::MagicType for $t {
+      const NAME: &'static str = stringify!($t);
+      const MAGIC_NAME: &'static str = concat!("$__v8_magic_", stringify!($t));
+    }
+
+    impl serde::Serialize for $t {
+      fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+      where
+        S: serde::Serializer,
+      {
+        crate::magic::transl8::magic_serialize(serializer, self)
+      }
+    }
+
+    impl<'de> serde::Deserialize<'de> for $t {
+      fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+      where
+        D: serde::Deserializer<'de>,
+      {
+        crate::magic::transl8::magic_deserialize(deserializer)
+      }
+    }
+  };
+}
+pub(crate) use impl_magic;
diff --git a/serde_v8/src/magic/u16string.rs b/serde_v8/src/magic/u16string.rs
index a75af016b..39ebf88d9 100644
--- a/serde_v8/src/magic/u16string.rs
+++ b/serde_v8/src/magic/u16string.rs
@@ -1,13 +1,12 @@
+use crate::magic::transl8::impl_magic;
+use crate::Error;
 use std::ops::{Deref, DerefMut};
 
-use serde::Serialize;
+use super::transl8::{FromV8, ToV8};
 
-pub const NAME: &str = "$__v8_magic_u16string";
-pub const FIELD_PTR: &str = "$__v8_magic_u16string_ptr";
-pub const FIELD_LEN: &str = "$__v8_magic_u16string_len";
-
-#[derive(Default, PartialEq, Eq)]
+#[derive(Default, PartialEq, Eq, Debug)]
 pub struct U16String(pub Vec<u16>);
+impl_magic!(U16String);
 
 impl U16String {
   pub fn with_zeroes(length: usize) -> U16String {
@@ -45,18 +44,40 @@ impl AsMut<[u16]> for U16String {
   }
 }
 
-impl Serialize for U16String {
-  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-  where
-    S: serde::Serializer,
-  {
-    use serde::ser::SerializeStruct;
-
-    let mut s = serializer.serialize_struct(NAME, 3)?;
-    s.serialize_field(FIELD_PTR, &(self.0.as_ptr() as usize))?;
-    s.serialize_field(FIELD_LEN, &self.0.len())?;
-    s.end()
+impl ToV8 for U16String {
+  fn to_v8<'a>(
+    &self,
+    scope: &mut v8::HandleScope<'a>,
+  ) -> Result<v8::Local<'a, v8::Value>, crate::Error> {
+    let v =
+      v8::String::new_from_two_byte(scope, self, v8::NewStringType::Normal)
+        .unwrap();
+    Ok(v.into())
   }
 }
 
-// TODO: Deserialize
+impl FromV8 for U16String {
+  fn from_v8(
+    scope: &mut v8::HandleScope,
+    value: v8::Local<v8::Value>,
+  ) -> Result<Self, crate::Error> {
+    let v8str = v8::Local::<v8::String>::try_from(value)
+      .map_err(|_| Error::ExpectedString)?;
+    let len = v8str.length();
+    let mut buffer = Vec::with_capacity(len);
+    // SAFETY: we set length == capacity (see previous line),
+    // before immediately writing into that buffer and sanity check with an assert
+    #[allow(clippy::uninit_vec)]
+    unsafe {
+      buffer.set_len(len);
+      let written = v8str.write(
+        scope,
+        &mut buffer,
+        0,
+        v8::WriteOptions::NO_NULL_TERMINATION,
+      );
+      assert!(written == len);
+    }
+    Ok(U16String(buffer))
+  }
+}
diff --git a/serde_v8/src/magic/value.rs b/serde_v8/src/magic/value.rs
index 7bd9a4059..5d844fbda 100644
--- a/serde_v8/src/magic/value.rs
+++ b/serde_v8/src/magic/value.rs
@@ -1,21 +1,19 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 
-use std::fmt;
-use std::marker::PhantomData;
-
-pub const FIELD: &str = "$__v8_magic_value";
-pub const NAME: &str = "$__v8_magic_Value";
+use crate::magic::transl8::impl_magic;
+use crate::magic::transl8::FromV8;
+use crate::magic::transl8::ToV8;
+use std::mem::transmute;
 
 /// serde_v8::Value allows passing through `v8::Value`s untouched
-/// when encoding/decoding and allows mixing rust & v8 values in
-/// structs, tuples...
-/// The implementation mainly breaks down to:
-/// 1. Transmuting between u64 <> serde_v8::Value
-/// 2. Using special struct/field names to detect these values
-/// 3. Then serde "boilerplate"
+/// when de/serializing & allows mixing rust & v8 values in structs, tuples...
+//
+// SAFETY: caveat emptor, the rust-compiler can no longer link lifetimes to their
+// original scope, you must take special care in ensuring your handles don't outlive their scope
 pub struct Value<'s> {
   pub v8_value: v8::Local<'s, v8::Value>,
 }
+impl_magic!(Value<'_>);
 
 impl<'s> From<v8::Local<'s, v8::Value>> for Value<'s> {
   fn from(v8_value: v8::Local<'s, v8::Value>) -> Self {
@@ -29,50 +27,22 @@ impl<'s> From<Value<'s>> for v8::Local<'s, v8::Value> {
   }
 }
 
-impl serde::Serialize for Value<'_> {
-  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-  where
-    S: serde::Serializer,
-  {
-    use serde::ser::SerializeStruct;
-
-    let mut s = serializer.serialize_struct(NAME, 1)?;
-    let mv = Value {
-      v8_value: self.v8_value,
-    };
-    let hack: u64 = unsafe { std::mem::transmute(mv) };
-    s.serialize_field(FIELD, &hack)?;
-    s.end()
+impl ToV8 for Value<'_> {
+  fn to_v8<'a>(
+    &self,
+    _scope: &mut v8::HandleScope<'a>,
+  ) -> Result<v8::Local<'a, v8::Value>, crate::Error> {
+    // SAFETY: not fully safe, since lifetimes are detached from original scope
+    Ok(unsafe { transmute(self.v8_value) })
   }
 }
 
-impl<'de, 's> serde::Deserialize<'de> for Value<'s> {
-  fn deserialize<D>(deserializer: D) -> Result<Value<'s>, D::Error>
-  where
-    D: serde::Deserializer<'de>,
-  {
-    struct ValueVisitor<'s> {
-      p1: PhantomData<&'s ()>,
-    }
-
-    impl<'de, 's> serde::de::Visitor<'de> for ValueVisitor<'s> {
-      type Value = Value<'s>;
-
-      fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        formatter.write_str("a v8::Value")
-      }
-
-      fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
-      where
-        E: serde::de::Error,
-      {
-        let mv: Value<'s> = unsafe { std::mem::transmute(v) };
-        Ok(mv)
-      }
-    }
-
-    static FIELDS: [&str; 1] = [FIELD];
-    let visitor = ValueVisitor { p1: PhantomData };
-    deserializer.deserialize_struct(NAME, &FIELDS, visitor)
+impl FromV8 for Value<'_> {
+  fn from_v8(
+    _scope: &mut v8::HandleScope,
+    value: v8::Local<v8::Value>,
+  ) -> Result<Self, crate::Error> {
+    // SAFETY: not fully safe, since lifetimes are detached from original scope
+    Ok(unsafe { transmute::<Value, Value>(value.into()) })
   }
 }
diff --git a/serde_v8/src/magic/zero_copy_buf.rs b/serde_v8/src/magic/zero_copy_buf.rs
index 30acd8137..c63d4ba66 100644
--- a/serde_v8/src/magic/zero_copy_buf.rs
+++ b/serde_v8/src/magic/zero_copy_buf.rs
@@ -4,6 +4,8 @@ use std::cell::Cell;
 use std::ops::Deref;
 use std::ops::DerefMut;
 
+use super::transl8::FromV8;
+
 /// A ZeroCopyBuf encapsulates a slice that's been borrowed from a JavaScript
 /// ArrayBuffer object. JavaScript objects can normally be garbage collected,
 /// but the existence of a ZeroCopyBuf inhibits this until it is dropped. It
@@ -43,28 +45,33 @@ impl ZeroCopyBuf {
       }),
     }
   }
-}
 
-impl<'s> TryFrom<v8::Local<'s, v8::ArrayBuffer>> for ZeroCopyBuf {
-  type Error = v8::DataError;
-  fn try_from(buffer: v8::Local<v8::ArrayBuffer>) -> Result<Self, Self::Error> {
-    Self::from_buffer(buffer, 0, buffer.byte_length())
+  pub fn from_view(
+    scope: &mut v8::HandleScope,
+    view: v8::Local<v8::ArrayBufferView>,
+  ) -> Result<Self, v8::DataError> {
+    let buffer = view.buffer(scope).ok_or(v8::DataError::NoData {
+      expected: "view to have a buffer",
+    })?;
+    Self::from_buffer(buffer, view.byte_offset(), view.byte_length())
   }
 }
 
-// TODO(@AaronO): consider streamlining this as "ScopedValue" ?
-type ScopedView<'a, 'b, 's> = (
-  &'s mut v8::HandleScope<'a>,
-  v8::Local<'b, v8::ArrayBufferView>,
-);
-impl<'a, 'b, 's> TryFrom<ScopedView<'a, 'b, 's>> for ZeroCopyBuf {
-  type Error = v8::DataError;
-  fn try_from(
-    scoped_view: ScopedView<'a, 'b, 's>,
-  ) -> Result<Self, Self::Error> {
-    let (scope, view) = scoped_view;
-    let buffer = view.buffer(scope).unwrap();
-    Self::from_buffer(buffer, view.byte_offset(), view.byte_length())
+impl FromV8 for ZeroCopyBuf {
+  fn from_v8(
+    scope: &mut v8::HandleScope,
+    value: v8::Local<v8::Value>,
+  ) -> Result<Self, crate::Error> {
+    if value.is_array_buffer() {
+      value
+        .try_into()
+        .and_then(|b| Self::from_buffer(b, 0, b.byte_length()))
+    } else {
+      value
+        .try_into()
+        .and_then(|view| Self::from_view(scope, view))
+    }
+    .map_err(|_| crate::Error::ExpectedBuffer)
   }
 }