From 900898db2e281055e61c1410b215af7215655c8a Mon Sep 17 00:00:00 2001
From: Connor Tsui <connor.tsui20@gmail.com>
Date: Wed, 11 Feb 2026 17:49:10 -0500
Subject: [PATCH 1/2] extension scalars

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>
---
 Cargo.lock                                    |   1 +
 vortex-array/src/stats/flatbuffers.rs         |  11 +-
 vortex-dtype/src/datetime/timestamp.rs        |   7 +
 vortex-dtype/src/extension/mod.rs             |  38 +-
 vortex-scalar/Cargo.toml                      |   1 +
 vortex-scalar/src/arrow.rs                    |  44 +-
 vortex-scalar/src/cast.rs                     |  13 +
 vortex-scalar/src/constructor.rs              |  64 ++-
 vortex-scalar/src/display.rs                  | 128 ++---
 vortex-scalar/src/downcast.rs                 | 214 ++++++++
 vortex-scalar/src/extension/datetime/date.rs  |  67 +++
 vortex-scalar/src/extension/datetime/mod.rs   |  70 +++
 vortex-scalar/src/extension/datetime/time.rs  | 117 +++++
 .../src/extension/datetime/timestamp.rs       |  97 ++++
 vortex-scalar/src/extension/matcher.rs        |  55 +++
 vortex-scalar/src/extension/mod.rs            |  29 ++
 vortex-scalar/src/extension/scalar_value.rs   | 377 +++++++++++++++
 vortex-scalar/src/extension/tests/apples.rs   |  96 ++++
 vortex-scalar/src/extension/tests/cast.rs     |  91 ++++
 .../src/extension/tests/grapheme_utf8.rs      | 258 ++++++++++
 vortex-scalar/src/extension/tests/mod.rs      |   7 +
 .../src/extension/tests/trivial_ext.rs        | 159 ++++++
 vortex-scalar/src/extension/vtable.rs         |  91 ++++
 vortex-scalar/src/lib.rs                      |   2 +
 vortex-scalar/src/proto.rs                    | 455 ++----------------
 vortex-scalar/src/scalar.rs                   | 122 +++--
 vortex-scalar/src/scalar_value.rs             | 124 +++--
 vortex-scalar/src/session.rs                  |  66 +++
 vortex-scalar/src/tests/casting.rs            | 171 +++++--
 vortex-scalar/src/tests/mod.rs                |  10 +-
 vortex-scalar/src/tests/proto.rs              | 407 ++++++++++++++++
 vortex-scalar/src/typed_view/ext.rs           | 144 ++++++
 vortex-scalar/src/typed_view/extension/mod.rs | 152 ------
 .../src/typed_view/extension/tests.rs         | 293 -----------
 vortex-scalar/src/typed_view/mod.rs           |   4 +-
 .../src/typed_view/primitive/scalar.rs        |   1 +
 36 files changed, 2860 insertions(+), 1126 deletions(-)
 create mode 100644 vortex-scalar/src/extension/datetime/date.rs
 create mode 100644 vortex-scalar/src/extension/datetime/mod.rs
 create mode 100644 vortex-scalar/src/extension/datetime/time.rs
 create mode 100644 vortex-scalar/src/extension/datetime/timestamp.rs
 create mode 100644 vortex-scalar/src/extension/matcher.rs
 create mode 100644 vortex-scalar/src/extension/mod.rs
 create mode 100644 vortex-scalar/src/extension/scalar_value.rs
 create mode 100644 vortex-scalar/src/extension/tests/apples.rs
 create mode 100644 vortex-scalar/src/extension/tests/cast.rs
 create mode 100644 vortex-scalar/src/extension/tests/grapheme_utf8.rs
 create mode 100644 vortex-scalar/src/extension/tests/mod.rs
 create mode 100644 vortex-scalar/src/extension/tests/trivial_ext.rs
 create mode 100644 vortex-scalar/src/extension/vtable.rs
 create mode 100644 vortex-scalar/src/session.rs
 create mode 100644 vortex-scalar/src/tests/proto.rs
 create mode 100644 vortex-scalar/src/typed_view/ext.rs
 delete mode 100644 vortex-scalar/src/typed_view/extension/mod.rs
 delete mode 100644 vortex-scalar/src/typed_view/extension/tests.rs

diff --git a/Cargo.lock b/Cargo.lock
index 50ed7e89ee7..f8da56a51df 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10666,6 +10666,7 @@ dependencies = [
  "arrow-array",
  "bytes",
  "itertools 0.14.0",
+ "jiff",
  "num-traits",
  "paste",
  "prost 0.14.3",
diff --git a/vortex-array/src/stats/flatbuffers.rs b/vortex-array/src/stats/flatbuffers.rs
index 67f82fcb7c3..0d0594e9390 100644
--- a/vortex-array/src/stats/flatbuffers.rs
+++ b/vortex-array/src/stats/flatbuffers.rs
@@ -11,6 +11,7 @@ use vortex_error::vortex_bail;
 use vortex_flatbuffers::WriteFlatBuffer;
 use vortex_flatbuffers::array as fba;
 use vortex_scalar::ScalarValue;
+use vortex_session::VortexSession;
 
 use crate::expr::stats::Precision;
 use crate::expr::stats::Stat;
@@ -113,6 +114,7 @@ impl StatsSet {
     pub fn from_flatbuffer<'a>(
         fb: &fba::ArrayStats<'a>,
         array_dtype: &DType,
+        session: &VortexSession,
     ) -> VortexResult<Self> {
         let mut stats_set = StatsSet::default();
 
@@ -142,7 +144,8 @@ impl StatsSet {
                     if let Some(max) = fb.max()
                         && let Some(stat_dtype) = stat_dtype
                     {
-                        let value = ScalarValue::from_proto_bytes(max.bytes(), &stat_dtype)?;
+                        let value =
+                            ScalarValue::from_proto_bytes(max.bytes(), &stat_dtype, session)?;
                         let Some(value) = value else {
                             continue;
                         };
@@ -161,7 +164,8 @@ impl StatsSet {
                     if let Some(min) = fb.min()
                         && let Some(stat_dtype) = stat_dtype
                     {
-                        let value = ScalarValue::from_proto_bytes(min.bytes(), &stat_dtype)?;
+                        let value =
+                            ScalarValue::from_proto_bytes(min.bytes(), &stat_dtype, session)?;
                         let Some(value) = value else {
                             continue;
                         };
@@ -193,7 +197,8 @@ impl StatsSet {
                     if let Some(sum) = fb.sum()
                         && let Some(stat_dtype) = stat_dtype
                     {
-                        let value = ScalarValue::from_proto_bytes(sum.bytes(), &stat_dtype)?;
+                        let value =
+                            ScalarValue::from_proto_bytes(sum.bytes(), &stat_dtype, session)?;
                         let Some(value) = value else {
                             continue;
                         };
diff --git a/vortex-dtype/src/datetime/timestamp.rs b/vortex-dtype/src/datetime/timestamp.rs
index e454b80adbe..f104f8d7b57 100644
--- a/vortex-dtype/src/datetime/timestamp.rs
+++ b/vortex-dtype/src/datetime/timestamp.rs
@@ -31,6 +31,7 @@ impl Timestamp {
         Self::new_with_tz(time_unit, None, nullability)
     }
 
+    // TODO(connor): This should probably be deprecated in favor of `new_with_options`.
     /// Creates a new Timestamp extension dtype with the given time unit, timezone, and nullability.
     pub fn new_with_tz(
         time_unit: TimeUnit,
@@ -46,6 +47,12 @@ impl Timestamp {
         )
         .vortex_expect("failed to create timestamp dtype")
     }
+
+    /// Creates a new Timestamp extension dtype with the given options and nullability.
+    pub fn new_with_options(options: TimestampOptions, nullability: Nullability) -> ExtDType<Self> {
+        ExtDType::try_new(options, DType::Primitive(PType::I64, nullability))
+            .vortex_expect("failed to create timestamp dtype")
+    }
 }
 
 /// Options for the Timestamp DType.
diff --git a/vortex-dtype/src/extension/mod.rs b/vortex-dtype/src/extension/mod.rs
index d6d955346c5..95c8fa4e644 100644
--- a/vortex-dtype/src/extension/mod.rs
+++ b/vortex-dtype/src/extension/mod.rs
@@ -29,7 +29,7 @@ use crate::Nullability;
 pub type ExtID = ArcRef<str>;
 
 /// An extension data type.
-#[derive(Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ExtDType<V: ExtDTypeVTable>(Arc<ExtDTypeAdapter<V>>);
 
 // Convenience impls for zero-sized VTables
@@ -60,6 +60,11 @@ impl<V: ExtDTypeVTable> ExtDType<V> {
         self.0.id()
     }
 
+    /// Returns the vtable of the extension type.
+    pub fn vtable(&self) -> &V {
+        &self.0.vtable
+    }
+
     /// Returns the metadata of the extension type.
     pub fn metadata(&self) -> &V::Metadata {
         &self.0.metadata
@@ -70,6 +75,18 @@ impl<V: ExtDTypeVTable> ExtDType<V> {
         &self.0.storage_dtype
     }
 
+    /// Returns the nullability of the storage dtype.
+    #[inline]
+    pub fn nullability(&self) -> Nullability {
+        self.storage_dtype().nullability()
+    }
+
+    /// Returns true if the storage dtype is nullable.
+    #[inline]
+    pub fn is_nullable(&self) -> bool {
+        self.nullability().is_nullable()
+    }
+
     /// Erase the concrete type information, returning a type-erased extension dtype.
     pub fn erased(self) -> ExtDTypeRef {
         ExtDTypeRef(self.0)
@@ -135,9 +152,14 @@ impl ExtDTypeRef {
         self.0.storage_dtype()
     }
 
+    /// Returns the nullability of the storage dtype.
+    pub fn nullability(&self) -> Nullability {
+        self.storage_dtype().nullability()
+    }
+
     /// Returns a new ExtDTypeRef with the given nullability.
     pub fn with_nullability(&self, nullability: Nullability) -> Self {
-        if self.storage_dtype().nullability() == nullability {
+        if self.nullability() == nullability {
             self.clone()
         } else {
             self.0.with_nullability(nullability)
@@ -211,7 +233,7 @@ impl ExtDTypeRef {
 
 /// Wrapper for type-erased extension dtype metadata.
 pub struct ExtDTypeMetadata<'a> {
-    pub(super) ext_dtype: &'a ExtDTypeRef,
+    ext_dtype: &'a ExtDTypeRef,
 }
 
 impl ExtDTypeMetadata<'_> {
@@ -249,7 +271,7 @@ impl Hash for ExtDTypeMetadata<'_> {
 }
 
 /// An object-safe trait encapsulating the behavior for extension DTypes.
-trait ExtDTypeImpl: 'static + Send + Sync + private::Sealed {
+trait ExtDTypeImpl: 'static + Send + Sync {
     fn as_any(&self) -> &dyn Any;
     fn id(&self) -> ExtID;
     fn storage_dtype(&self) -> &DType;
@@ -262,6 +284,7 @@ trait ExtDTypeImpl: 'static + Send + Sync + private::Sealed {
     fn with_nullability(&self, nullability: Nullability) -> ExtDTypeRef;
 }
 
+#[derive(Debug, Hash, PartialEq, Eq)]
 struct ExtDTypeAdapter<V: ExtDTypeVTable> {
     vtable: V,
     metadata: V::Metadata,
@@ -314,10 +337,3 @@ impl<V: ExtDTypeVTable> ExtDTypeImpl for ExtDTypeAdapter<V> {
             .vortex_expect("Extension DType {} incorrect fails validation with the same storage type but different nullability").erased()
     }
 }
-
-mod private {
-    use super::ExtDTypeAdapter;
-
-    pub trait Sealed {}
-    impl<V: super::ExtDTypeVTable> Sealed for ExtDTypeAdapter<V> {}
-}
diff --git a/vortex-scalar/Cargo.toml b/vortex-scalar/Cargo.toml
index d69c03f8679..dd52ccbc0ec 100644
--- a/vortex-scalar/Cargo.toml
+++ b/vortex-scalar/Cargo.toml
@@ -21,6 +21,7 @@ arbitrary = { workspace = true, optional = true }
 arrow-array = { workspace = true }
 bytes = { workspace = true }
 itertools = { workspace = true }
+jiff = { workspace = true }
 num-traits = { workspace = true }
 paste = { workspace = true }
 prost = { workspace = true }
diff --git a/vortex-scalar/src/arrow.rs b/vortex-scalar/src/arrow.rs
index a47958796b5..cdd8f06f9a9 100644
--- a/vortex-scalar/src/arrow.rs
+++ b/vortex-scalar/src/arrow.rs
@@ -202,9 +202,6 @@ mod tests {
     use vortex_dtype::datetime::TimeUnit;
     use vortex_dtype::datetime::Timestamp;
     use vortex_dtype::datetime::TimestampOptions;
-    use vortex_dtype::extension::ExtDTypeVTable;
-    use vortex_error::VortexResult;
-    use vortex_error::vortex_bail;
 
     use crate::DecimalValue;
     use crate::Scalar;
@@ -443,45 +440,6 @@ mod tests {
         Arc::<dyn Datum>::try_from(&list_scalar).unwrap();
     }
 
-    #[test]
-    #[should_panic(expected = "Cannot convert extension scalar")]
-    fn test_non_temporal_extension_to_arrow_todo() {
-        use vortex_dtype::ExtID;
-
-        #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-        struct SomeExt;
-        impl ExtDTypeVTable for SomeExt {
-            type Metadata = String;
-
-            fn id(&self) -> ExtID {
-                ExtID::new_ref("some_ext")
-            }
-
-            fn serialize(&self, _options: &Self::Metadata) -> VortexResult<Vec<u8>> {
-                vortex_bail!("not implemented")
-            }
-
-            fn deserialize(&self, _data: &[u8]) -> VortexResult<Self::Metadata> {
-                vortex_bail!("not implemented")
-            }
-
-            fn validate_dtype(
-                &self,
-                _options: &Self::Metadata,
-                _storage_dtype: &DType,
-            ) -> VortexResult<()> {
-                Ok(())
-            }
-        }
-
-        let scalar = Scalar::extension::<SomeExt>(
-            "".into(),
-            Scalar::primitive(42i32, Nullability::NonNullable),
-        );
-
-        Arc::<dyn Datum>::try_from(&scalar).unwrap();
-    }
-
     #[rstest]
     #[case(TimeUnit::Nanoseconds, PType::I64, 123456789i64)]
     #[case(TimeUnit::Microseconds, PType::I64, 123456789i64)]
@@ -553,7 +511,7 @@ mod tests {
     #[rstest]
     #[case(TimeUnit::Nanoseconds, "UTC", 1234567890000000000i64)]
     #[case(TimeUnit::Microseconds, "EST", 1234567890000000i64)]
-    #[case(TimeUnit::Milliseconds, "ABC", 1234567890000i64)]
+    #[case(TimeUnit::Milliseconds, "CET", 1234567890000i64)]
     #[case(TimeUnit::Seconds, "UTC", 1234567890i64)]
     fn test_temporal_timestamp_tz_to_arrow(
         #[case] time_unit: TimeUnit,
diff --git a/vortex-scalar/src/cast.rs b/vortex-scalar/src/cast.rs
index 97902819852..6318860593f 100644
--- a/vortex-scalar/src/cast.rs
+++ b/vortex-scalar/src/cast.rs
@@ -45,6 +45,19 @@ impl Scalar {
         // If the target is an extension type, then we want to cast to its storage type.
         if let Some(ext_dtype) = target_dtype.as_extension_opt() {
             let cast_storage_scalar_value = self.cast(ext_dtype.storage_dtype())?.into_value();
+
+            // NEED A SESSION!
+            // let ext_scalar_registry = session.scalars();
+            // let dyn_scalar_vtable = ext_scalar_registry
+            //     .registry()
+            //     .find(&ext_dtype.id())
+            //     .ok_or_else(|| {
+            //         vortex_err!(
+            //             "extension type scalar {} did not exist in the registry",
+            //             ext_dtype.id()
+            //         )
+            //     })?;
+
             return Scalar::try_new(target_dtype.clone(), cast_storage_scalar_value);
         }
 
diff --git a/vortex-scalar/src/constructor.rs b/vortex-scalar/src/constructor.rs
index e8dcd68777e..48a983a5f24 100644
--- a/vortex-scalar/src/constructor.rs
+++ b/vortex-scalar/src/constructor.rs
@@ -14,14 +14,20 @@ use vortex_dtype::ExtDTypeRef;
 use vortex_dtype::NativePType;
 use vortex_dtype::Nullability;
 use vortex_dtype::PType;
-use vortex_dtype::extension::ExtDTypeVTable;
 use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure_eq;
+use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
+use vortex_session::VortexSession;
 
 use crate::DecimalValue;
 use crate::PValue;
 use crate::Scalar;
 use crate::ScalarValue;
+use crate::extension::ExtScalarVTable;
+use crate::extension::ExtScalarValue;
+use crate::session::ScalarSessionExt;
 
 // TODO(connor): Really, we want `try_` constructors that return errors instead of just panic.
 impl Scalar {
@@ -170,27 +176,57 @@ impl Scalar {
             .vortex_expect("unable to construct a list `Scalar`")
     }
 
-    /// Creates a new extension scalar wrapping the given storage value.
-    pub fn extension<V: ExtDTypeVTable + Default>(options: V::Metadata, value: Scalar) -> Self {
-        let ext_dtype = ExtDType::<V>::try_new(options, value.dtype().clone())
-            .vortex_expect("Failed to create extension dtype");
-        Self::try_new(DType::Extension(ext_dtype.erased()), value.into_value())
-            .vortex_expect("unable to construct an extension `Scalar`")
-    }
-
+    // TODO(connor): This needs to return a `VortexResult` instead.
     /// Creates a new extension scalar wrapping the given storage value.
     ///
     /// # Panics
     ///
-    /// Panics if the storage dtype of `ext_dtype` does not match `value`'s dtype.
-    pub fn extension_ref(ext_dtype: ExtDTypeRef, value: Scalar) -> Self {
-        assert_eq!(ext_dtype.storage_dtype(), value.dtype());
-        Self::try_new(DType::Extension(ext_dtype), value.into_value())
+    /// Panics if the storage dtype is incompatible with the extension type, or if the storage
+    /// value fails validation.
+    pub fn extension<V: ExtScalarVTable + Default>(metadata: V::Metadata, value: Scalar) -> Self {
+        let ext_dtype = ExtDType::<V>::try_new(metadata, value.dtype().clone())
+            .vortex_expect("Failed to create extension dtype");
+        let storage_value = value.into_value();
+
+        let ext_value = storage_value.map(|sv| {
+            let owned = ExtScalarValue::<V>::try_new(ext_dtype.clone(), sv)
+                .vortex_expect("unable to construct an extension `Scalar`");
+            ScalarValue::Extension(owned.erased())
+        });
+
+        Self::try_new(DType::Extension(ext_dtype.erased()), ext_value)
             .vortex_expect("unable to construct an extension `Scalar`")
     }
+
+    /// TODO docs.
+    pub fn extension_ref(
+        ext_dtype: ExtDTypeRef,
+        value: Scalar,
+        session: &VortexSession,
+    ) -> VortexResult<Self> {
+        let (storage_dtype, storage_value) = value.into_parts();
+        Self::extension_ref_from_value(ext_dtype, &storage_dtype, storage_value, session)
+    }
+
+    /// TODO docs.
+    pub fn extension_ref_from_value(
+        ext_dtype: ExtDTypeRef,
+        storage_dtype: &DType,
+        storage_value: Option<ScalarValue>,
+        session: &VortexSession,
+    ) -> VortexResult<Self> {
+        vortex_ensure_eq!(ext_dtype.storage_dtype(), storage_dtype);
+
+        let ext_value = Self::extension_value(&ext_dtype, storage_value, session)?;
+
+        Ok(
+            // SAFETY: `create_ext_scalar_value_ref` validates that the scalar value is compatible.
+            unsafe { Scalar::new_unchecked(DType::Extension(ext_dtype), ext_value) },
+        )
+    }
 }
 
-/// A helper enum for creating a [`ListScalar`].
+/// A helper enum for creating a list scalar.
 enum ListKind {
     /// Variable-length list.
     Variable,
diff --git a/vortex-scalar/src/display.rs b/vortex-scalar/src/display.rs
index df6e5b1ea1c..f106e77695e 100644
--- a/vortex-scalar/src/display.rs
+++ b/vortex-scalar/src/display.rs
@@ -42,6 +42,7 @@ mod tests {
     use vortex_dtype::datetime::Time;
     use vortex_dtype::datetime::TimeUnit;
     use vortex_dtype::datetime::Timestamp;
+    use vortex_dtype::datetime::TimestampOptions;
 
     use crate::PValue;
     use crate::Scalar;
@@ -197,18 +198,17 @@ mod tests {
             DType::Extension(Time::new(TimeUnit::Seconds, Nullable).erased())
         }
 
+        let storage_dtype = dtype().as_extension().storage_dtype().clone();
         assert_eq!(format!("{}", Scalar::null(dtype())), "null");
 
-        assert_eq!(
-            format!(
-                "{}",
-                Scalar::new(
-                    dtype(),
-                    Some(ScalarValue::Primitive(PValue::I32(3 * MINUTES + 25)))
-                )
-            ),
-            "00:03:25"
+        let storage_scalar = Scalar::new(
+            storage_dtype,
+            Some(ScalarValue::Primitive(PValue::I32(3 * MINUTES + 25))),
         );
+        let ext_scalar = Scalar::extension::<Time>(TimeUnit::Seconds, storage_scalar);
+        assert_eq!(ext_scalar.dtype(), &dtype());
+
+        assert_eq!(format!("{ext_scalar}"), "00:03:25");
     }
 
     #[test]
@@ -217,85 +217,101 @@ mod tests {
             DType::Extension(Date::new(TimeUnit::Days, Nullable).erased())
         }
 
+        let storage_dtype = dtype().as_extension().storage_dtype().clone();
         assert_eq!(format!("{}", Scalar::null(dtype())), "null");
 
-        assert_eq!(
-            format!(
-                "{}",
-                Scalar::new(dtype(), Some(ScalarValue::Primitive(PValue::I32(25))))
-            ),
-            "1970-01-26"
+        let storage_scalar = Scalar::new(
+            storage_dtype.clone(),
+            Some(ScalarValue::Primitive(PValue::I32(25))),
         );
+        let ext_scalar = Scalar::extension::<Date>(TimeUnit::Days, storage_scalar);
+        assert_eq!(ext_scalar.dtype(), &dtype());
+        assert_eq!(format!("{ext_scalar}"), "1970-01-26");
 
-        assert_eq!(
-            format!(
-                "{}",
-                Scalar::new(dtype(), Some(ScalarValue::Primitive(PValue::I32(365))))
-            ),
-            "1971-01-01"
+        let storage_scalar = Scalar::new(
+            storage_dtype.clone(),
+            Some(ScalarValue::Primitive(PValue::I32(365))),
         );
+        let ext_scalar = Scalar::extension::<Date>(TimeUnit::Days, storage_scalar);
+        assert_eq!(ext_scalar.dtype(), &dtype());
+        assert_eq!(format!("{ext_scalar}"), "1971-01-01");
 
-        assert_eq!(
-            format!(
-                "{}",
-                Scalar::new(dtype(), Some(ScalarValue::Primitive(PValue::I32(365 * 4))))
-            ),
-            "1973-12-31"
+        let storage_scalar = Scalar::new(
+            storage_dtype,
+            Some(ScalarValue::Primitive(PValue::I32(365 * 4))),
         );
+        let ext_scalar = Scalar::extension::<Date>(TimeUnit::Days, storage_scalar);
+        assert_eq!(ext_scalar.dtype(), &dtype());
+        assert_eq!(format!("{ext_scalar}"), "1973-12-31");
     }
 
     #[test]
     fn display_local_timestamp() {
+        fn timestamp_options() -> TimestampOptions {
+            TimestampOptions {
+                unit: TimeUnit::Seconds,
+                tz: None,
+            }
+        }
+
         fn dtype() -> DType {
             DType::Extension(Timestamp::new(TimeUnit::Seconds, Nullable).erased())
         }
 
+        let storage_dtype = dtype().as_extension().storage_dtype().clone();
         assert_eq!(format!("{}", Scalar::null(dtype())), "null");
 
-        assert_eq!(
-            format!(
-                "{}",
-                Scalar::new(
-                    dtype(),
-                    Some(ScalarValue::Primitive(PValue::I64(
-                        (3 * DAYS + 2 * HOURS + 5 * MINUTES + 10) as i64
-                    )))
-                )
-            ),
-            "1970-01-04T02:05:10"
+        let storage_scalar = Scalar::new(
+            storage_dtype,
+            Some(ScalarValue::Primitive(PValue::I64(
+                (3 * DAYS + 2 * HOURS + 5 * MINUTES + 10) as i64,
+            ))),
         );
+        let ext_scalar = Scalar::extension::<Timestamp>(timestamp_options(), storage_scalar);
+        assert_eq!(ext_scalar.dtype(), &dtype());
+
+        assert_eq!(format!("{ext_scalar}"), "1970-01-04T02:05:10Z");
     }
 
-    #[cfg_attr(miri, ignore)]
     #[test]
     fn display_zoned_timestamp() {
+        fn timestamp_options() -> TimestampOptions {
+            TimestampOptions {
+                unit: TimeUnit::Seconds,
+                tz: Some("Pacific/Guam".into()),
+            }
+        }
+
         fn dtype() -> DType {
-            DType::Extension(
-                Timestamp::new_with_tz(TimeUnit::Seconds, Some("Pacific/Guam".into()), Nullable)
-                    .erased(),
-            )
+            DType::Extension(Timestamp::new_with_options(timestamp_options(), Nullable).erased())
         }
 
+        let storage_dtype = dtype().as_extension().storage_dtype().clone();
         assert_eq!(format!("{}", Scalar::null(dtype())), "null");
 
+        let storage_scalar = Scalar::new(
+            storage_dtype.clone(),
+            Some(ScalarValue::Primitive(PValue::I64(0i64))),
+        );
+        let ext_scalar = Scalar::extension::<Timestamp>(timestamp_options(), storage_scalar);
+        assert_eq!(ext_scalar.dtype(), &dtype());
+
         assert_eq!(
-            format!(
-                "{}",
-                Scalar::new(dtype(), Some(ScalarValue::Primitive(PValue::I64(0i64))))
-            ),
+            format!("{ext_scalar}"),
             "1970-01-01T10:00:00+10:00[Pacific/Guam]"
         );
 
+        let storage_scalar = Scalar::new(
+            storage_dtype,
+            Some(ScalarValue::Primitive(PValue::I64(
+                (3 * DAYS + 2 * HOURS + 5 * MINUTES + 10) as i64,
+            ))),
+        );
+        let ext_scalar = Scalar::extension::<Timestamp>(timestamp_options(), storage_scalar);
+        assert_eq!(ext_scalar.dtype(), &dtype());
+
         assert_eq!(
-            format!(
-                "{}",
-                Scalar::new(
-                    dtype(),
-                    Some(ScalarValue::Primitive(PValue::I64(
-                        (3 * DAYS + 2 * HOURS + 5 * MINUTES + 10) as i64
-                    )))
-                )
-            ),
+            format!("{ext_scalar}"),
             "1970-01-04T12:05:10+10:00[Pacific/Guam]"
         );
     }
diff --git a/vortex-scalar/src/downcast.rs b/vortex-scalar/src/downcast.rs
index 3074f590ca6..09f888083c2 100644
--- a/vortex-scalar/src/downcast.rs
+++ b/vortex-scalar/src/downcast.rs
@@ -3,17 +3,24 @@
 
 //! Scalar downcasting methods to typed views.
 
+use vortex_buffer::BufferString;
+use vortex_buffer::ByteBuffer;
 use vortex_error::VortexExpect;
+use vortex_error::vortex_panic;
 
 use crate::BinaryScalar;
 use crate::BoolScalar;
 use crate::DecimalScalar;
+use crate::DecimalValue;
 use crate::ExtScalar;
 use crate::ListScalar;
+use crate::PValue;
 use crate::PrimitiveScalar;
 use crate::Scalar;
+use crate::ScalarValue;
 use crate::StructScalar;
 use crate::Utf8Scalar;
+use crate::extension::ExtScalarValueRef;
 
 impl Scalar {
     /// Returns a view of the scalar as a boolean scalar.
@@ -142,3 +149,210 @@ impl Scalar {
         ExtScalar::try_new(self.dtype(), self.value()).ok()
     }
 }
+
+impl ScalarValue {
+    /// Returns the boolean value, panicking if the value is not a [`Bool`][ScalarValue::Bool].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the value is not a [`Bool`][ScalarValue::Bool].
+    pub fn as_bool(&self) -> bool {
+        match self {
+            ScalarValue::Bool(b) => *b,
+            _ => vortex_panic!("ScalarValue is not a Bool"),
+        }
+    }
+
+    /// Returns the boolean value, or `None` if the value is not a [`Bool`][ScalarValue::Bool].
+    pub fn as_bool_opt(&self) -> Option<bool> {
+        match self {
+            ScalarValue::Bool(b) => Some(*b),
+            _ => None,
+        }
+    }
+
+    /// Returns the primitive value, panicking if the value is not a
+    /// [`Primitive`][ScalarValue::Primitive].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the value is not a [`Primitive`][ScalarValue::Primitive].
+    pub fn as_primitive(&self) -> &PValue {
+        match self {
+            ScalarValue::Primitive(p) => p,
+            _ => vortex_panic!("ScalarValue is not a Primitive"),
+        }
+    }
+
+    /// Returns the primitive value, or `None` if the value is not a
+    /// [`Primitive`][ScalarValue::Primitive].
+    pub fn as_primitive_opt(&self) -> Option<&PValue> {
+        match self {
+            ScalarValue::Primitive(p) => Some(p),
+            _ => None,
+        }
+    }
+
+    /// Returns the decimal value, panicking if the value is not a
+    /// [`Decimal`][ScalarValue::Decimal].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the value is not a [`Decimal`][ScalarValue::Decimal].
+    pub fn as_decimal(&self) -> &DecimalValue {
+        match self {
+            ScalarValue::Decimal(d) => d,
+            _ => vortex_panic!("ScalarValue is not a Decimal"),
+        }
+    }
+
+    /// Returns the decimal value, or `None` if the value is not a
+    /// [`Decimal`][ScalarValue::Decimal].
+    pub fn as_decimal_opt(&self) -> Option<&DecimalValue> {
+        match self {
+            ScalarValue::Decimal(d) => Some(d),
+            _ => None,
+        }
+    }
+
+    /// Returns the UTF-8 string value, panicking if the value is not a [`Utf8`][ScalarValue::Utf8].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the value is not a [`Utf8`][ScalarValue::Utf8].
+    pub fn as_utf8(&self) -> &BufferString {
+        match self {
+            ScalarValue::Utf8(s) => s,
+            _ => vortex_panic!("ScalarValue is not a Utf8"),
+        }
+    }
+
+    /// Returns the UTF-8 string value, or `None` if the value is not a [`Utf8`][ScalarValue::Utf8].
+    pub fn as_utf8_opt(&self) -> Option<&BufferString> {
+        match self {
+            ScalarValue::Utf8(s) => Some(s),
+            _ => None,
+        }
+    }
+
+    /// Returns the binary value, panicking if the value is not a [`Binary`][ScalarValue::Binary].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the value is not a [`Binary`][ScalarValue::Binary].
+    pub fn as_binary(&self) -> &ByteBuffer {
+        match self {
+            ScalarValue::Binary(b) => b,
+            _ => vortex_panic!("ScalarValue is not a Binary"),
+        }
+    }
+
+    /// Returns the binary value, or `None` if the value is not a [`Binary`][ScalarValue::Binary].
+    pub fn as_binary_opt(&self) -> Option<&ByteBuffer> {
+        match self {
+            ScalarValue::Binary(b) => Some(b),
+            _ => None,
+        }
+    }
+
+    /// Returns the list elements, panicking if the value is not a [`List`][ScalarValue::List].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the value is not a [`List`][ScalarValue::List].
+    pub fn as_list(&self) -> &[Option<ScalarValue>] {
+        match self {
+            ScalarValue::List(elements) => elements,
+            _ => vortex_panic!("ScalarValue is not a List"),
+        }
+    }
+
+    /// Returns the list elements, or `None` if the value is not a [`List`][ScalarValue::List].
+    pub fn as_list_opt(&self) -> Option<&[Option<ScalarValue>]> {
+        match self {
+            ScalarValue::List(elements) => Some(elements),
+            _ => None,
+        }
+    }
+
+    /// Returns the extension value reference, panicking if the value is not an
+    /// [`Extension`][ScalarValue::Extension].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the value is not an [`Extension`][ScalarValue::Extension].
+    pub fn as_extension(&self) -> &ExtScalarValueRef {
+        match self {
+            ScalarValue::Extension(e) => e,
+            _ => vortex_panic!("ScalarValue is not an Extension"),
+        }
+    }
+
+    /// Returns the extension value reference, or `None` if the value is not an
+    /// [`Extension`][ScalarValue::Extension].
+    pub fn as_extension_opt(&self) -> Option<&ExtScalarValueRef> {
+        match self {
+            ScalarValue::Extension(e) => Some(e),
+            _ => None,
+        }
+    }
+
+    /// Returns the boolean value, panicking if the value is not a [`Bool`][ScalarValue::Bool].
+    pub fn into_bool(self) -> bool {
+        match self {
+            ScalarValue::Bool(b) => b,
+            _ => vortex_panic!("ScalarValue is not a Bool"),
+        }
+    }
+
+    /// Returns the primitive value, panicking if the value is not a
+    /// [`Primitive`][ScalarValue::Primitive].
+    pub fn into_primitive(self) -> PValue {
+        match self {
+            ScalarValue::Primitive(p) => p,
+            _ => vortex_panic!("ScalarValue is not a Primitive"),
+        }
+    }
+
+    /// Returns the decimal value, panicking if the value is not a
+    /// [`Decimal`][ScalarValue::Decimal].
+    pub fn into_decimal(self) -> DecimalValue {
+        match self {
+            ScalarValue::Decimal(d) => d,
+            _ => vortex_panic!("ScalarValue is not a Decimal"),
+        }
+    }
+
+    /// Returns the UTF-8 string value, panicking if the value is not a [`Utf8`][ScalarValue::Utf8].
+    pub fn into_utf8(self) -> BufferString {
+        match self {
+            ScalarValue::Utf8(s) => s,
+            _ => vortex_panic!("ScalarValue is not a Utf8"),
+        }
+    }
+
+    /// Returns the binary value, panicking if the value is not a [`Binary`][ScalarValue::Binary].
+    pub fn into_binary(self) -> ByteBuffer {
+        match self {
+            ScalarValue::Binary(b) => b,
+            _ => vortex_panic!("ScalarValue is not a Binary"),
+        }
+    }
+
+    /// Returns the list elements, panicking if the value is not a [`List`][ScalarValue::List].
+    pub fn into_list(self) -> Vec<Option<ScalarValue>> {
+        match self {
+            ScalarValue::List(elements) => elements,
+            _ => vortex_panic!("ScalarValue is not a List"),
+        }
+    }
+
+    /// Returns the extension value reference, panicking if the value is not an
+    /// [`Extension`][ScalarValue::Extension].
+    pub fn into_extension(self) -> ExtScalarValueRef {
+        match self {
+            ScalarValue::Extension(e) => e,
+            _ => vortex_panic!("ScalarValue is not an Extension"),
+        }
+    }
+}
diff --git a/vortex-scalar/src/extension/datetime/date.rs b/vortex-scalar/src/extension/datetime/date.rs
new file mode 100644
index 00000000000..28b1cda67fe
--- /dev/null
+++ b/vortex-scalar/src/extension/datetime/date.rs
@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! [`ExtScalarVTable`] implementation for [`Date`] extension scalars.
+
+use std::fmt;
+
+use jiff::Span;
+use vortex_dtype::DType;
+use vortex_dtype::datetime::Date;
+use vortex_dtype::datetime::TimeUnit;
+use vortex_error::VortexResult;
+
+use crate::ScalarValue;
+use crate::extension::ExtScalarVTable;
+
+/// The Unix epoch date (1970-01-01).
+const EPOCH: jiff::civil::Date = jiff::civil::Date::constant(1970, 1, 1);
+
+/// Unpacked value of a [`Date`] extension scalar.
+pub enum DateValue {
+    /// Days since the Unix epoch.
+    Days(i32),
+    /// Milliseconds since the Unix epoch.
+    Milliseconds(i64),
+}
+
+impl fmt::Display for DateValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let date = match self {
+            DateValue::Days(days) => EPOCH + Span::new().days(*days),
+            DateValue::Milliseconds(ms) => EPOCH + Span::new().milliseconds(*ms),
+        };
+        write!(f, "{}", date)
+    }
+}
+
+impl ExtScalarVTable for Date {
+    type Value<'a> = DateValue;
+
+    fn unpack(
+        &self,
+        metadata: &Self::Metadata,
+        _storage_dtype: &DType,
+        storage_value: &ScalarValue,
+    ) -> Self::Value<'_> {
+        match metadata {
+            TimeUnit::Milliseconds => {
+                DateValue::Milliseconds(storage_value.as_primitive().cast::<i64>())
+            }
+            TimeUnit::Days => DateValue::Days(storage_value.as_primitive().cast::<i32>()),
+            _ => unreachable!(),
+        }
+    }
+
+    fn validate_scalar_value(
+        &self,
+        _metadata: &<Self as vortex_dtype::extension::ExtDTypeVTable>::Metadata,
+        _storage_dtype: &DType,
+        _storage_value: &ScalarValue,
+    ) -> VortexResult<()> {
+        // We know that the dtype is correct for this extension type (primitive) by the
+        // precondition, and we know that the `Scalar` we came from has verified that the storage
+        // value is a primitive. We also say that any i32 or i64 is a valid date value.
+        Ok(())
+    }
+}
diff --git a/vortex-scalar/src/extension/datetime/mod.rs b/vortex-scalar/src/extension/datetime/mod.rs
new file mode 100644
index 00000000000..ef3ecaeba91
--- /dev/null
+++ b/vortex-scalar/src/extension/datetime/mod.rs
@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Extension scalar definitions for concrete datetime types.
+
+use vortex_dtype::datetime::AnyTemporal;
+use vortex_dtype::datetime::Date;
+use vortex_dtype::datetime::Time;
+use vortex_dtype::datetime::TimeUnit;
+use vortex_dtype::datetime::Timestamp;
+
+mod date;
+mod time;
+mod timestamp;
+
+pub use date::*;
+pub use time::*;
+pub use timestamp::*;
+
+use crate::ExtScalar;
+use crate::extension::Matcher;
+
+/// A matched temporal storage value, produced by [`AnyTemporal`]'s [`Matcher`] impl.
+pub enum TemporalValue<'a> {
+    /// A [`Timestamp`] value.
+    Timestamp(TimestampValue<'a>),
+    /// A [`Date`] value.
+    Date(DateValue),
+    /// A [`Time`] value.
+    Time(TimeValue),
+}
+
+impl Matcher for AnyTemporal {
+    /// Extract the matched temporal storage value as an i64.
+    type Match<'a> = Option<TemporalValue<'a>>;
+
+    fn try_match<'a>(item: &'a ExtScalar) -> Option<Self::Match<'a>> {
+        if let Some(value) = item.as_value_opt::<Timestamp>() {
+            return Some(value.map(TemporalValue::Timestamp));
+        }
+
+        if let Some(value) = item.as_value_opt::<Date>() {
+            return Some(value.map(TemporalValue::Date));
+        }
+
+        if let Some(value) = item.as_value_opt::<Time>() {
+            return Some(value.map(TemporalValue::Time));
+        }
+
+        None
+    }
+}
+
+/// Convenience constructor for building a [`jiff::Span`] from a [`TimeUnit`] and length.
+trait SpanExt {
+    /// Create a span of the given `length` in the specified [`TimeUnit`].
+    fn from_unit_length(length: i64, time_unit: TimeUnit) -> Self;
+}
+
+impl SpanExt for jiff::Span {
+    fn from_unit_length(length: i64, time_unit: TimeUnit) -> Self {
+        match time_unit {
+            TimeUnit::Nanoseconds => jiff::Span::new().nanoseconds(length),
+            TimeUnit::Microseconds => jiff::Span::new().microseconds(length),
+            TimeUnit::Milliseconds => jiff::Span::new().milliseconds(length),
+            TimeUnit::Seconds => jiff::Span::new().seconds(length),
+            TimeUnit::Days => jiff::Span::new().days(length),
+        }
+    }
+}
diff --git a/vortex-scalar/src/extension/datetime/time.rs b/vortex-scalar/src/extension/datetime/time.rs
new file mode 100644
index 00000000000..8256f81a7f3
--- /dev/null
+++ b/vortex-scalar/src/extension/datetime/time.rs
@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! [`ExtScalarVTable`] implementation for [`Time`] extension scalars.
+
+use std::fmt::Formatter;
+
+use jiff::Span;
+use vortex_dtype::DType;
+use vortex_dtype::datetime::Time;
+use vortex_dtype::datetime::TimeUnit;
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
+
+use crate::ScalarValue;
+use crate::extension::ExtScalarVTable;
+use crate::extension::datetime::SpanExt;
+
+/// Unpacked value of a [`Time`] extension scalar.
+pub enum TimeValue {
+    /// Seconds since midnight.
+    Seconds(i32),
+    /// Milliseconds since midnight.
+    Milliseconds(i32),
+    /// Microseconds since midnight.
+    Microseconds(i64),
+    /// Nanoseconds since midnight.
+    Nanoseconds(i64),
+}
+
+impl std::fmt::Display for TimeValue {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let min = jiff::civil::Time::MIN;
+
+        let time = match self {
+            TimeValue::Seconds(s) => min + Span::new().seconds(*s),
+            TimeValue::Milliseconds(ms) => min + Span::new().milliseconds(*ms),
+            TimeValue::Microseconds(us) => min + Span::new().microseconds(*us),
+            TimeValue::Nanoseconds(ns) => min + Span::new().nanoseconds(*ns),
+        };
+
+        write!(f, "{}", time)
+    }
+}
+
+impl ExtScalarVTable for Time {
+    type Value<'a> = TimeValue;
+
+    fn unpack(
+        &self,
+        metadata: &Self::Metadata,
+        _storage_dtype: &DType,
+        storage_value: &ScalarValue,
+    ) -> Self::Value<'_> {
+        match metadata {
+            TimeUnit::Seconds => TimeValue::Seconds(storage_value.as_primitive().cast::<i32>()),
+            TimeUnit::Milliseconds => {
+                TimeValue::Milliseconds(storage_value.as_primitive().cast::<i32>())
+            }
+            TimeUnit::Microseconds => {
+                TimeValue::Microseconds(storage_value.as_primitive().cast::<i64>())
+            }
+            TimeUnit::Nanoseconds => {
+                TimeValue::Nanoseconds(storage_value.as_primitive().cast::<i64>())
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    fn validate_scalar_value(
+        &self,
+        metadata: &Self::Metadata,
+        _storage_dtype: &DType,
+        storage_value: &ScalarValue,
+    ) -> VortexResult<()> {
+        // Validate the storage value is within the valid range for Time
+        let span = Span::from_unit_length(storage_value.as_primitive().cast::<i64>(), *metadata);
+
+        jiff::civil::Time::MIN
+            .checked_add(span)
+            .map_err(|e| vortex_err!("Invalid time scalar: {}", e))?;
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use vortex_dtype::Nullability;
+    use vortex_dtype::PType;
+    use vortex_dtype::datetime::TimeUnit;
+
+    use super::*;
+
+    #[test]
+    fn test_validate() {
+        // 86_399 seconds = 23:59:59, valid civil time
+        assert!(
+            Time.validate_scalar_value(
+                &TimeUnit::Seconds,
+                &DType::Primitive(PType::I32, Nullability::NonNullable),
+                &ScalarValue::from(86_399i32),
+            )
+            .is_ok()
+        );
+
+        // 86_400 seconds = 24:00:00, invalid civil time (wraps to next day)
+        assert!(
+            Time.validate_scalar_value(
+                &TimeUnit::Seconds,
+                &DType::Primitive(PType::I32, Nullability::NonNullable),
+                &ScalarValue::from(86_400i32),
+            )
+            .is_err()
+        );
+    }
+}
diff --git a/vortex-scalar/src/extension/datetime/timestamp.rs b/vortex-scalar/src/extension/datetime/timestamp.rs
new file mode 100644
index 00000000000..f15ea530415
--- /dev/null
+++ b/vortex-scalar/src/extension/datetime/timestamp.rs
@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! [`ExtScalarVTable`] implementation for [`Timestamp`] extension scalars.
+
+use std::fmt::Formatter;
+use std::sync::Arc;
+
+use jiff::Span;
+use vortex_dtype::DType;
+use vortex_dtype::datetime::TimeUnit;
+use vortex_dtype::datetime::Timestamp;
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
+
+use crate::ScalarValue;
+use crate::extension::ExtScalarVTable;
+use crate::extension::datetime::SpanExt;
+
+/// Unpacked value of a [`Timestamp`] extension scalar.
+///
+/// Each variant carries the raw storage value and an optional timezone.
+pub enum TimestampValue<'a> {
+    /// Seconds since the Unix epoch.
+    Seconds(i64, Option<&'a Arc<str>>),
+    /// Milliseconds since the Unix epoch.
+    Milliseconds(i64, Option<&'a Arc<str>>),
+    /// Microseconds since the Unix epoch.
+    Microseconds(i64, Option<&'a Arc<str>>),
+    /// Nanoseconds since the Unix epoch.
+    Nanoseconds(i64, Option<&'a Arc<str>>),
+}
+
+impl std::fmt::Display for TimestampValue<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let (span, tz) = match self {
+            TimestampValue::Seconds(v, tz) => (Span::new().seconds(*v), *tz),
+            TimestampValue::Milliseconds(v, tz) => (Span::new().milliseconds(*v), *tz),
+            TimestampValue::Microseconds(v, tz) => (Span::new().microseconds(*v), *tz),
+            TimestampValue::Nanoseconds(v, tz) => (Span::new().nanoseconds(*v), *tz),
+        };
+        let ts = jiff::Timestamp::UNIX_EPOCH + span;
+
+        match tz {
+            None => {
+                write!(f, "{}", ts)
+            }
+            Some(tz) => {
+                write!(f, "{}", ts.in_tz(tz.as_ref()).map_err(|_| std::fmt::Error)?)
+            }
+        }
+    }
+}
+
+impl ExtScalarVTable for Timestamp {
+    type Value<'a> = TimestampValue<'a>;
+
+    fn unpack<'a>(
+        &self,
+        metadata: &'a Self::Metadata,
+        _storage_dtype: &'a DType,
+        storage_value: &'a ScalarValue,
+    ) -> Self::Value<'a> {
+        let ts_value = storage_value.as_primitive().cast::<i64>();
+        let tz = metadata.tz.as_ref();
+
+        match metadata.unit {
+            TimeUnit::Nanoseconds => TimestampValue::Nanoseconds(ts_value, tz),
+            TimeUnit::Microseconds => TimestampValue::Microseconds(ts_value, tz),
+            TimeUnit::Milliseconds => TimestampValue::Milliseconds(ts_value, tz),
+            TimeUnit::Seconds => TimestampValue::Seconds(ts_value, tz),
+            TimeUnit::Days => unreachable!(),
+        }
+    }
+
+    fn validate_scalar_value(
+        &self,
+        metadata: &Self::Metadata,
+        _storage_dtype: &DType,
+        storage_value: &ScalarValue,
+    ) -> VortexResult<()> {
+        // Validate the storage value is within the valid range for Timestamp
+        let span =
+            Span::from_unit_length(storage_value.as_primitive().cast::<i64>(), metadata.unit);
+
+        let ts = jiff::Timestamp::UNIX_EPOCH
+            .checked_add(span)
+            .map_err(|e| vortex_err!("Invalid timestamp scalar: {}", e))?;
+
+        if let Some(tz) = &metadata.tz {
+            ts.in_tz(tz.as_ref())
+                .map_err(|e| vortex_err!("Invalid timezone for timestamp scalar: {}", e))?;
+        }
+
+        Ok(())
+    }
+}
diff --git a/vortex-scalar/src/extension/matcher.rs b/vortex-scalar/src/extension/matcher.rs
new file mode 100644
index 00000000000..26474cba174
--- /dev/null
+++ b/vortex-scalar/src/extension/matcher.rs
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Definition of [`Matcher`] and a blanket implementation for [`ExtScalarVTable`].
+
+use vortex_error::VortexExpect;
+
+use crate::ExtScalar;
+use crate::extension::ExtScalarVTable;
+
+/// A trait for matching extension scalars.
+pub trait Matcher {
+    /// The matched view type.
+    type Match<'a>;
+
+    /// Check if the given extension scalar matches this matcher.
+    fn matches(item: &ExtScalar) -> bool {
+        Self::try_match(item).is_some()
+    }
+
+    /// Try to match the scalar into the correct view type.
+    ///
+    /// Returns `None` if unable to match to the type, or if the scalar is null.
+    fn try_match<'a>(item: &'a ExtScalar) -> Option<Self::Match<'a>>;
+}
+
+impl<V: ExtScalarVTable> Matcher for V {
+    type Match<'a> = Option<V::Value<'a>>;
+
+    fn matches(item: &ExtScalar) -> bool {
+        item.ext_dtype().is::<V>()
+    }
+
+    /// Returns `None` if unable to match with the vtable, `Some(None)` if scalar is null, and
+    /// `Some(Some(_))` there is a matched value.
+    fn try_match<'a>(item: &'a ExtScalar) -> Option<Option<V::Value<'a>>> {
+        let metadata = item.ext_dtype().metadata_opt::<V>()?;
+
+        let Some(ext_value_ref) = item.ext_value() else {
+            // If there the value is null, we cannot match on it.
+            return Some(None);
+        };
+
+        let vtable = ext_value_ref
+            .try_get_vtable::<V>()
+            .vortex_expect("we were able to match the dtype vtable but not the scalar value vtable")
+            .clone();
+
+        Some(Some(vtable.unpack(
+            metadata,
+            item.ext_dtype().storage_dtype(),
+            ext_value_ref.storage_value(),
+        )))
+    }
+}
diff --git a/vortex-scalar/src/extension/mod.rs b/vortex-scalar/src/extension/mod.rs
new file mode 100644
index 00000000000..003a92c5eff
--- /dev/null
+++ b/vortex-scalar/src/extension/mod.rs
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Extension scalar types and traits for working with custom (extension) scalar values.
+//!
+//! This module provides the infrastructure for defining and working with extension scalar types in
+//! Vortex, including:
+//!
+//! - [`Matcher`] - For matching extension scalar types
+//! - [`ExtScalarValueRef`] and [`OwnedExtScalarValue`] - References and owned values for extension
+//!   scalars
+//! - [`ExtScalarVTable`] and [`DynExtScalarVTable`] - Virtual table traits for extension scalar
+//!   operations
+
+mod datetime;
+
+mod matcher;
+pub use matcher::Matcher;
+
+mod scalar_value;
+pub use scalar_value::ExtScalarValue;
+pub use scalar_value::ExtScalarValueRef;
+
+mod vtable;
+pub use vtable::DynExtScalarVTable;
+pub use vtable::ExtScalarVTable;
+
+#[cfg(test)]
+mod tests;
diff --git a/vortex-scalar/src/extension/scalar_value.rs b/vortex-scalar/src/extension/scalar_value.rs
new file mode 100644
index 00000000000..43f6871f8ef
--- /dev/null
+++ b/vortex-scalar/src/extension/scalar_value.rs
@@ -0,0 +1,377 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Type-erased and typed extension scalar values.
+//!
+//! Extension scalars wrap an underlying storage [`ScalarValue`] together with an
+//! [`ExtScalarVTable`] that gives the value semantic meaning beyond its raw storage
+//! representation.
+//!
+//! There are two main (public) types:
+//!
+//! - [`ExtScalarValueRef`]: A type-erased extension scalar that can be stored heterogeneously.
+//! - [`OwnedExtScalarValue`]: A typed extension scalar parameterized by a concrete
+//!   [`ExtScalarVTable`] implementation.
+//!
+//! These mirror the [`ExtDTypeRef`] / [`ExtDType`] pattern in `vortex-dtype`.
+//!
+//! [`ExtDType`]: vortex_dtype::ExtDType
+
+use std::any::Any;
+use std::any::type_name;
+use std::cmp::Ordering;
+use std::fmt;
+use std::fmt::Debug;
+use std::fmt::Display;
+use std::hash::Hash;
+use std::hash::Hasher;
+use std::sync::Arc;
+
+use vortex_dtype::ExtDType;
+use vortex_dtype::ExtDTypeRef;
+use vortex_dtype::ExtID;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_err;
+
+use crate::ScalarValue;
+use crate::extension::ExtScalarVTable;
+
+/// A type-erased extension scalar value.
+///
+/// This is the extension scalar analog of [`ExtDTypeRef`]: it stores an [`ExtScalarVTable`]
+/// and a storage [`ScalarValue`] behind a trait object, allowing heterogeneous storage inside
+/// [`ScalarValue::Extension`] (so that we do not need a generic parameter).
+///
+/// You can use [`try_downcast`] or [`downcast`] to recover the concrete vtable type as an
+/// [`OwnedExtScalarValue<V>`].
+///
+/// [`try_downcast`]: ExtScalarValueRef::try_downcast
+/// [`downcast`]: ExtScalarValueRef::downcast
+#[derive(Clone)]
+pub struct ExtScalarValueRef(Arc<dyn ExtScalarValueAdapterImpl>);
+
+/// A typed extension scalar value, parameterized by a concrete [`ExtScalarVTable`].
+///
+/// This is the extension scalar analog of [`ExtDType<V>`]: it retains full type information
+/// about the vtable, providing direct access to the vtable and storage value without
+/// downcasting.
+///
+/// You can construct one of these via [`try_new`] from an [`ExtDType<V>`] and a storage
+/// [`ScalarValue`], and erase the type with [`erased`] to obtain an [`ExtScalarValueRef`].
+///
+/// [`ExtDType<V>`]: vortex_dtype::ExtDType
+/// [`try_new`]: OwnedExtScalarValue::try_new
+/// [`erased`]: OwnedExtScalarValue::erased
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExtScalarValue<V: ExtScalarVTable>(Arc<ExtScalarValueAdapter<V>>);
+
+/// The concrete inner representation of an extension scalar, pairing a vtable with its storage
+/// value.
+///
+/// This is the sole implementor of [`ExtScalarValueAdapterImpl`], enabling [`ExtScalarValueRef`] to
+/// downcast back to the concrete vtable type via [`Any`].
+#[derive(Debug, PartialEq, Eq, Hash)]
+struct ExtScalarValueAdapter<V: ExtScalarVTable> {
+    /// The extension scalar vtable.
+    vtable: V,
+    /// The underlying storage value.
+    storage: ScalarValue,
+}
+
+impl<V: ExtScalarVTable> ExtScalarValueAdapterImpl for ExtScalarValueAdapter<V> {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn id(&self) -> ExtID {
+        self.vtable.id()
+    }
+
+    fn vtable_any(&self) -> &dyn Any {
+        &self.vtable
+    }
+
+    fn storage_value(&self) -> &ScalarValue {
+        &self.storage
+    }
+
+    fn validate(&self, ext_dtype: &ExtDTypeRef) -> VortexResult<()> {
+        // Downcasting the metadata implicitly verifies the vtable types match, but we still want to
+        // validate the actual scalar value.
+        let Some(metadata) = ext_dtype.metadata_opt::<V>() else {
+            vortex_bail!("extension scalar is not compatible with type {ext_dtype}");
+        };
+
+        self.vtable
+            .validate_scalar_value(metadata, ext_dtype.storage_dtype(), &self.storage)
+    }
+
+    fn fmt_ext_scalar(&self, ext_dtype: &ExtDTypeRef, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let value = V::unpack(
+            &self.vtable,
+            ext_dtype.metadata::<V>(),
+            ext_dtype.storage_dtype(),
+            &self.storage,
+        );
+
+        write!(f, "{value}")
+    }
+}
+
+// NB: If you need access to the vtable, you probably want to add a method and implementation to
+// `ExtScalarValueAdapterImpl` and `ExtScalarValueAdapter`.
+/// Methods for downcasting type-erased extension scalars.
+impl ExtScalarValueRef {
+    /// Returns the [`ExtID`] identifying this extension scalar's type.
+    pub fn id(&self) -> ExtID {
+        self.0.id()
+    }
+
+    /// Returns a reference to the underlying storage [`ScalarValue`].
+    pub fn storage_value(&self) -> &ScalarValue {
+        self.0.storage_value()
+    }
+
+    /// Formats the extension scalar using the provided [`ExtDTypeRef`] for metadata context.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the underlying [`fmt::Write`] operation fails.
+    pub fn fmt_ext_scalar(
+        &self,
+        ext_dtype: &ExtDTypeRef,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        self.0.fmt_ext_scalar(ext_dtype, f)
+    }
+
+    /// Attempts to downcast to a concrete [`OwnedExtScalarValue<V>`].
+    ///
+    /// # Errors
+    ///
+    /// Returns `Err(self)` if the underlying vtable type does not match `V`.
+    pub fn try_downcast<V: ExtScalarVTable>(self) -> Result<ExtScalarValue<V>, ExtScalarValueRef> {
+        // `ExtScalarValueAdapter<V>` is the only implementor of `ExtScalarValueAdapterImpl` (due to
+        // the sealed implementation below), so if the vtable is correct, we know the type can be
+        // downcasted and reinterpreted safely.
+        if !self.0.as_any().is::<ExtScalarValueAdapter<V>>() {
+            return Err(self);
+        }
+
+        let ptr = Arc::into_raw(self.0) as *const ExtScalarValueAdapter<V>;
+        // SAFETY: We verified the type matches above, so the size and alignment are correct.
+        let inner = unsafe { Arc::from_raw(ptr) };
+
+        Ok(ExtScalarValue(inner))
+    }
+
+    /// Downcasts to a concrete [`OwnedExtScalarValue<V>`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the underlying vtable type does not match `V`.
+    pub fn downcast<V: ExtScalarVTable>(self) -> ExtScalarValue<V> {
+        self.try_downcast::<V>()
+            .map_err(|this| {
+                vortex_err!(
+                    "Failed to downcast ExtScalar {} to {}",
+                    this.0.id(),
+                    type_name::<V>(),
+                )
+            })
+            .vortex_expect("Failed to downcast ExtScalar")
+    }
+
+    /// Attempts to downcast the vtable to a concrete [`ExtScalarVTable`] type by reference.
+    ///
+    /// Unlike [`try_downcast`], this borrows rather than consuming `self`.
+    ///
+    /// [`try_downcast`]: ExtScalarValueRef::try_downcast
+    pub fn try_get_vtable<V: ExtScalarVTable>(&self) -> Option<&V> {
+        self.0.vtable_any().downcast_ref::<V>()
+    }
+
+    /// Downcasts the vtable to a concrete [`ExtScalarVTable`] type by reference.
+    ///
+    /// Unlike [`downcast`], this borrows rather than consuming `self`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the underlying vtable type does not match `V`.
+    ///
+    /// [`downcast`]: ExtScalarValueRef::downcast
+    pub fn get_vtable<V: ExtScalarVTable>(&self) -> &V {
+        self.try_get_vtable::<V>()
+            .vortex_expect("ExtScalarVTable downcast failed")
+    }
+
+    /// Checks whether this extension scalar value is compatible with the given [`ExtDTypeRef`].
+    ///
+    /// This validates that the vtable types match and that the storage value passes the
+    /// vtable's [`ExtScalarVTable::validate_scalar_value`] check.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if it is not compatible with the extension type.
+    pub fn validate(&self, ext_dtype: &ExtDTypeRef) -> VortexResult<()> {
+        self.0.validate(ext_dtype)
+    }
+}
+
+impl<V: ExtScalarVTable> ExtScalarValue<V> {
+    /// Creates a new extension scalar from a storage [`ScalarValue`], validating it against the
+    /// given [`ExtDType`].
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if [`ExtScalarVTable::validate_scalar_value`] fails for the given
+    /// storage value and extension dtype.
+    pub fn try_new(ext_dtype: ExtDType<V>, storage: ScalarValue) -> VortexResult<Self> {
+        ExtScalarVTable::validate_scalar_value(
+            ext_dtype.vtable(),
+            ext_dtype.metadata(),
+            ext_dtype.storage_dtype(),
+            &storage,
+        )?;
+
+        Ok(Self(Arc::new(ExtScalarValueAdapter::<V> {
+            vtable: ext_dtype.vtable().clone(),
+            storage,
+        })))
+    }
+
+    /// Erases the concrete type information, returning a type-erased [`ExtScalarValueRef`].
+    pub fn erased(self) -> ExtScalarValueRef {
+        ExtScalarValueRef(self.0)
+    }
+
+    /// Returns the [`ExtID`] identifying this extension scalar's type.
+    pub fn id(&self) -> ExtID {
+        self.0.vtable.id()
+    }
+
+    /// Returns a reference to the [`ExtScalarVTable`] for this extension scalar.
+    pub fn vtable(&self) -> &V {
+        &self.0.vtable
+    }
+
+    /// Returns a reference to the underlying storage [`ScalarValue`].
+    pub fn storage_value(&self) -> &ScalarValue {
+        self.0.storage_value()
+    }
+
+    /// Formats the extension scalar using the provided [`ExtDTypeRef`] for metadata context.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the underlying [`fmt::Write`] operation fails.
+    pub fn fmt_ext_scalar(
+        &self,
+        ext_dtype: &ExtDTypeRef,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        self.0.fmt_ext_scalar(ext_dtype, f)
+    }
+
+    // pub(crate) fn cast(&self, dtype: &DType) -> VortexResult<Scalar> {
+    //     if self.value.is_none() && !dtype.is_nullable() {
+    //         vortex_bail!(
+    //             "cannot cast extension dtype with id {} and storage type {} to {}",
+    //             self.ext_dtype.id(),
+    //             self.ext_dtype.storage_dtype(),
+    //             dtype
+    //         );
+    //     }
+    //
+    //     if self.ext_dtype.storage_dtype().eq_ignore_nullability(dtype) {
+    //         // Casting from an extension type to the underlying storage type is OK.
+    //         return Ok(Scalar::new(dtype.clone(), self.value.clone()));
+    //     }
+    //
+    //     if let DType::Extension(ext_dtype) = dtype
+    //         && self.ext_dtype.eq_ignore_nullability(ext_dtype)
+    //     {
+    //         return Ok(Scalar::new(dtype.clone(), self.value.clone()));
+    //     }
+    //
+    //     vortex_bail!(
+    //         "cannot cast extension dtype with id {} and storage type {} to {}",
+    //         self.ext_dtype.id(),
+    //         self.ext_dtype.storage_dtype(),
+    //         dtype
+    //     );
+    // }
+}
+
+impl Display for ExtScalarValueRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}({})", self.0.id(), self.0.storage_value())
+    }
+}
+
+impl Debug for ExtScalarValueRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ExtScalar")
+            .field("id", &self.0.id())
+            .field("storage_value", self.0.storage_value())
+            .finish()
+    }
+}
+
+impl PartialEq for ExtScalarValueRef {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.id() == other.0.id() && self.0.storage_value() == other.0.storage_value()
+    }
+}
+impl Eq for ExtScalarValueRef {}
+
+impl PartialOrd for ExtScalarValueRef {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.0.storage_value().partial_cmp(other.0.storage_value())
+    }
+}
+
+impl Hash for ExtScalarValueRef {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.id().hash(state);
+        self.0.storage_value().hash(state);
+    }
+}
+
+/// Private module to seal [`ExtScalarValueAdapterImpl`].
+///
+/// Note that this is not strictly necessary since [`ExtScalarValueAdapter`] and
+/// [`ExtScalarValueAdapterImpl`] are both private to this module, this is just for hygiene.
+mod sealed {
+    use super::*;
+
+    /// Marker trait to prevent external implementations of [`ExtScalarValueAdapterImpl`].
+    pub(super) trait Sealed {}
+
+    /// This can be the **only** implementor for [`ExtScalarValueAdapterImpl`].
+    impl<V: ExtScalarVTable> Sealed for ExtScalarValueAdapter<V> {}
+}
+
+/// An object-safe, sealed trait encapsulating the behavior for extension scalar values.
+///
+/// This mirrors [`ExtDTypeImpl`] in `vortex-dtype`: it provides type-erased access to the
+/// extension scalar's identity, storage value, and display formatting. The only implementor is
+/// [`ExtScalarValueAdapter`].
+///
+/// [`ExtDTypeImpl`]: vortex_dtype::extension
+trait ExtScalarValueAdapterImpl: sealed::Sealed + 'static + Send + Sync {
+    /// Returns `self` as a trait object for downcasting.
+    fn as_any(&self) -> &dyn Any;
+    /// Returns the [`ExtID`] identifying this extension type.
+    fn id(&self) -> ExtID;
+    /// Returns the vtable as a trait object for downcasting.
+    fn vtable_any(&self) -> &dyn Any;
+    /// Returns a reference to the underlying storage [`ScalarValue`].
+    fn storage_value(&self) -> &ScalarValue;
+    /// Checks whether this extension scalar value is compatible with the given [`ExtDTypeRef`].
+    fn validate(&self, ext_dtype: &ExtDTypeRef) -> VortexResult<()>;
+    /// Formats the extension scalar using the provided [`ExtDTypeRef`] for metadata context.
+    fn fmt_ext_scalar(&self, ext_dtype: &ExtDTypeRef, f: &mut fmt::Formatter<'_>) -> fmt::Result;
+}
diff --git a/vortex-scalar/src/extension/tests/apples.rs b/vortex-scalar/src/extension/tests/apples.rs
new file mode 100644
index 00000000000..d50c25b6f6b
--- /dev/null
+++ b/vortex-scalar/src/extension/tests/apples.rs
@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt::Display;
+
+use vortex_dtype::DType;
+use vortex_dtype::ExtDType;
+use vortex_dtype::ExtID;
+use vortex_dtype::Nullability;
+use vortex_dtype::PType;
+use vortex_dtype::extension::ExtDTypeVTable;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
+use crate::ScalarValue;
+use crate::extension::ExtScalarVTable;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+struct ApplesVTable;
+
+impl ExtDTypeVTable for ApplesVTable {
+    // Let's just say this is the number of times we repeat the scalar (which can be any type).
+    type Metadata = usize;
+
+    fn id(&self) -> ExtID {
+        ExtID::new_ref("apples")
+    }
+
+    fn validate_dtype(&self, _options: &Self::Metadata, storage_dtype: &DType) -> VortexResult<()> {
+        match storage_dtype {
+            DType::List(..) => Ok(()),
+            _ => Err(vortex_error::vortex_err!(
+                "Expected list dtype for apples extension"
+            )),
+        }
+    }
+}
+
+struct BasketOfApples(Vec<Option<ScalarValue>>);
+impl Display for BasketOfApples {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "[")?;
+        for (i, item) in self.0.iter().enumerate() {
+            if i > 0 {
+                write!(f, ", ")?;
+            }
+            match item {
+                Some(value) => write!(f, "{}", value)?,
+                None => write!(f, "null")?,
+            }
+        }
+        write!(f, "]")
+    }
+}
+
+impl ExtScalarVTable for ApplesVTable {
+    type Value<'a> = BasketOfApples;
+
+    fn unpack<'a>(
+        &self,
+        _metadata: &'a <Self as ExtDTypeVTable>::Metadata,
+        storage_dtype: &'a DType,
+        storage_value: &'a ScalarValue,
+    ) -> Self::Value<'a> {
+        assert!(
+            matches!(storage_dtype, DType::List(..)),
+            "Expected list dtype"
+        );
+
+        let elements = storage_value.clone().into_list();
+        BasketOfApples(elements)
+    }
+
+    fn validate_scalar_value(
+        &self,
+        _metadata: &<Self as ExtDTypeVTable>::Metadata,
+        _storage_dtype: &DType,
+        storage_value: &ScalarValue,
+    ) -> VortexResult<()> {
+        debug_assert!(
+            matches!(storage_value, ScalarValue::List(_)),
+            "Expected list variant"
+        );
+
+        // Since the dtype has been verified for this extension scalar, and list dtype must
+        // always be paired with a `ScalarValue::List`, we don't have to do any checking here.
+        Ok(())
+    }
+}
+
+impl ApplesVTable {
+    fn new() -> ExtDType<ApplesVTable> {
+        ExtDType::try_new(0, DType::Primitive(PType::U16, Nullability::NonNullable))
+            .vortex_expect("valid apples dtype")
+    }
+}
diff --git a/vortex-scalar/src/extension/tests/cast.rs b/vortex-scalar/src/extension/tests/cast.rs
new file mode 100644
index 00000000000..65f52a9c037
--- /dev/null
+++ b/vortex-scalar/src/extension/tests/cast.rs
@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_dtype::{extension::EmptyMetadata, DType, Nullability, PType};
+
+use crate::Scalar;
+
+use super::*;
+
+#[test]
+fn test_ext_scalar_cast_to_storage() {
+    let scalar = Scalar::extension::<TrivialExtType>(
+        EmptyMetadata,
+        Scalar::primitive(42i32, Nullability::NonNullable),
+    );
+
+    let ext = scalar.as_extension();
+
+    // Cast to storage type
+    let casted = ext
+        .cast(&DType::Primitive(PType::I32, Nullability::NonNullable))
+        .unwrap();
+    assert_eq!(
+        casted.dtype(),
+        &DType::Primitive(PType::I32, Nullability::NonNullable)
+    );
+    assert_eq!(casted.as_primitive().typed_value::<i32>(), Some(42));
+
+    // Cast to nullable storage type
+    let casted_nullable = ext
+        .cast(&DType::Primitive(PType::I32, Nullability::Nullable))
+        .unwrap();
+    assert_eq!(
+        casted_nullable.dtype(),
+        &DType::Primitive(PType::I32, Nullability::Nullable)
+    );
+    assert_eq!(
+        casted_nullable.as_primitive().typed_value::<i32>(),
+        Some(42)
+    );
+}
+
+#[test]
+fn test_ext_scalar_cast_to_self() {
+    let ext_dtype = TrivialExtType::new_non_nullable();
+
+    let scalar = Scalar::extension::<TrivialExtType>(
+        EmptyMetadata,
+        Scalar::primitive(42i32, Nullability::NonNullable),
+    );
+
+    let ext = scalar.as_extension();
+    let ext_dtype = ext_dtype.erased();
+
+    // Cast to same extension type
+    let casted = ext.cast(&DType::Extension(ext_dtype.clone())).unwrap();
+    assert_eq!(casted.dtype(), &DType::Extension(ext_dtype.clone()));
+
+    // Cast to nullable version of same extension type
+    let nullable_ext = DType::Extension(ext_dtype).as_nullable();
+    let casted_nullable = ext.cast(&nullable_ext).unwrap();
+    assert_eq!(casted_nullable.dtype(), &nullable_ext);
+}
+
+#[test]
+fn test_ext_scalar_cast_incompatible() {
+    let scalar = Scalar::extension::<TrivialExtType>(
+        EmptyMetadata,
+        Scalar::primitive(42i32, Nullability::NonNullable),
+    );
+
+    let ext = scalar.as_extension();
+
+    // Cast to incompatible type should fail
+    let result = ext.cast(&DType::Utf8(Nullability::NonNullable));
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_ext_scalar_cast_null_to_non_nullable() {
+    let scalar = Scalar::extension::<TrivialExtType>(
+        EmptyMetadata,
+        Scalar::null(DType::Primitive(PType::I32, Nullability::Nullable)),
+    );
+
+    let ext = scalar.as_extension();
+
+    // Cast null to non-nullable should fail
+    let result = ext.cast(&DType::Primitive(PType::I32, Nullability::NonNullable));
+    assert!(result.is_err());
+}
diff --git a/vortex-scalar/src/extension/tests/grapheme_utf8.rs b/vortex-scalar/src/extension/tests/grapheme_utf8.rs
new file mode 100644
index 00000000000..5c84bd8c8c0
--- /dev/null
+++ b/vortex-scalar/src/extension/tests/grapheme_utf8.rs
@@ -0,0 +1,258 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::cmp::Ordering;
+use std::fmt;
+
+use vortex_dtype::DType;
+use vortex_dtype::ExtID;
+use vortex_dtype::Nullability;
+use vortex_dtype::extension::ExtDTypeVTable;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+
+use crate::Scalar;
+use crate::ScalarValue;
+use crate::extension::ExtScalarVTable;
+use crate::extension::ExtScalarValue;
+
+// --- Metadata ---
+
+/// Metadata storing the expected number of characters (via `chars().count()`) for validation.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct GraphemeMetadata {
+    grapheme_count: usize,
+}
+
+impl fmt::Display for GraphemeMetadata {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "graphemes={}", self.grapheme_count)
+    }
+}
+
+// --- Value type ---
+
+/// A borrowed view of a grapheme-counted UTF-8 value, carrying both the string and its character
+/// count from the extension metadata.
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct GraphemeStr<'a> {
+    text: &'a str,
+    grapheme_count: usize,
+}
+
+impl PartialOrd for GraphemeStr<'_> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for GraphemeStr<'_> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.text.cmp(other.text)
+    }
+}
+
+impl fmt::Display for GraphemeStr<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{} ({} chars)", self.text, self.grapheme_count)
+    }
+}
+
+// --- VTable ---
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+struct GraphemeUtf8ExtVTable;
+
+impl ExtDTypeVTable for GraphemeUtf8ExtVTable {
+    type Metadata = GraphemeMetadata;
+
+    fn id(&self) -> ExtID {
+        ExtID::new_ref("grapheme_utf8")
+    }
+
+    fn validate_dtype(
+        &self,
+        _metadata: &Self::Metadata,
+        storage_dtype: &DType,
+    ) -> VortexResult<()> {
+        vortex_ensure!(storage_dtype.is_utf8(), "storage dtype must be UTF-8");
+        Ok(())
+    }
+}
+
+impl ExtScalarVTable for GraphemeUtf8ExtVTable {
+    type Value<'a> = GraphemeStr<'a>;
+
+    fn unpack<'a>(
+        &self,
+        metadata: &'a <Self as ExtDTypeVTable>::Metadata,
+        _storage_dtype: &'a DType,
+        storage_value: &'a ScalarValue,
+    ) -> Self::Value<'a> {
+        GraphemeStr {
+            text: storage_value.as_utf8().as_ref(),
+            grapheme_count: metadata.grapheme_count,
+        }
+    }
+
+    fn validate_scalar_value(
+        &self,
+        metadata: &<Self as ExtDTypeVTable>::Metadata,
+        _storage_dtype: &DType,
+        storage_value: &ScalarValue,
+    ) -> VortexResult<()> {
+        let text: &str = storage_value.as_utf8().as_ref();
+        let actual_count = text.chars().count();
+        vortex_ensure!(
+            actual_count == metadata.grapheme_count,
+            "grapheme count mismatch: metadata says {} but string has {}",
+            metadata.grapheme_count,
+            actual_count
+        );
+        Ok(())
+    }
+}
+
+// --- Helpers ---
+
+fn grapheme_scalar(s: &str) -> Scalar {
+    let metadata = GraphemeMetadata {
+        grapheme_count: s.chars().count(),
+    };
+    Scalar::extension::<GraphemeUtf8ExtVTable>(metadata, Scalar::utf8(s, Nullability::NonNullable))
+}
+
+fn grapheme_metadata(s: &str) -> GraphemeMetadata {
+    GraphemeMetadata {
+        grapheme_count: s.chars().count(),
+    }
+}
+
+// --- Tests ---
+
+#[test]
+fn test_equality() {
+    let s1 = grapheme_scalar("hello");
+    let s2 = grapheme_scalar("hello");
+    let s3 = grapheme_scalar("world");
+
+    let e1 = s1.as_extension();
+    let e2 = s2.as_extension();
+    let e3 = s3.as_extension();
+    let v1 = e1.as_value::<GraphemeUtf8ExtVTable>();
+    let v2 = e2.as_value::<GraphemeUtf8ExtVTable>();
+    let v3 = e3.as_value::<GraphemeUtf8ExtVTable>();
+
+    assert_eq!(v1, v2);
+    assert_ne!(v1, v3);
+}
+
+#[test]
+fn test_lexicographic_ordering() {
+    let apple = grapheme_scalar("apple");
+    let banana = grapheme_scalar("banana");
+    let abc = grapheme_scalar("abc");
+    let abd = grapheme_scalar("abd");
+
+    let e_apple = apple.as_extension();
+    let e_banana = banana.as_extension();
+    let e_abc = abc.as_extension();
+    let e_abd = abd.as_extension();
+    let v_apple = e_apple.as_value::<GraphemeUtf8ExtVTable>();
+    let v_banana = e_banana.as_value::<GraphemeUtf8ExtVTable>();
+    let v_abc = e_abc.as_value::<GraphemeUtf8ExtVTable>();
+    let v_abd = e_abd.as_value::<GraphemeUtf8ExtVTable>();
+
+    assert!(v_apple < v_banana);
+    assert!(v_banana > v_apple);
+    assert!(v_abc < v_abd);
+}
+
+#[test]
+fn test_prefix_ordering() {
+    // A shorter string is less than a longer one that shares the same prefix.
+    let ab = grapheme_scalar("ab");
+    let abc = grapheme_scalar("abc");
+
+    let e_ab = ab.as_extension();
+    let e_abc = abc.as_extension();
+    let v_ab = e_ab.as_value::<GraphemeUtf8ExtVTable>();
+    let v_abc = e_abc.as_value::<GraphemeUtf8ExtVTable>();
+
+    assert!(v_ab < v_abc);
+}
+
+#[test]
+fn test_unicode_ordering() {
+    // Multi-byte characters still compare lexicographically by UTF-8 byte ordering.
+    let cafe = grapheme_scalar("caf\u{00e9}");
+    let caff = grapheme_scalar("caff");
+
+    let e_cafe = cafe.as_extension();
+    let e_caff = caff.as_extension();
+    let v_cafe = e_cafe.as_value::<GraphemeUtf8ExtVTable>();
+    let v_caff = e_caff.as_value::<GraphemeUtf8ExtVTable>();
+
+    // U+00E9 encodes as bytes 0xC3 0xA9, which sorts after 'f' (0x66).
+    assert!(v_cafe > v_caff);
+}
+
+#[test]
+fn test_hash_consistency() {
+    use vortex_utils::aliases::hash_set::HashSet;
+
+    let s1 = grapheme_scalar("hello");
+    let s2 = grapheme_scalar("hello");
+
+    let mut set = HashSet::new();
+    set.insert(s1);
+    set.insert(s2);
+    assert_eq!(set.len(), 1);
+
+    let s3 = grapheme_scalar("world");
+    set.insert(s3);
+    assert_eq!(set.len(), 2);
+}
+
+#[test]
+fn test_storage_roundtrip() {
+    let storage = Scalar::utf8("hello", Nullability::NonNullable);
+    let ext =
+        Scalar::extension::<GraphemeUtf8ExtVTable>(grapheme_metadata("hello"), storage.clone());
+
+    assert_eq!(ext.as_extension().to_storage_scalar(), storage);
+}
+
+#[test]
+fn test_grapheme_count_in_value() {
+    // Verify the unpacked value carries the correct grapheme count from metadata.
+    let s = grapheme_scalar("caf\u{00e9}");
+    let ext = s.as_extension();
+    let v = ext.as_value::<GraphemeUtf8ExtVTable>().unwrap();
+
+    assert_eq!(v.grapheme_count, 4);
+    assert_eq!(v.text, "caf\u{00e9}");
+}
+
+#[test]
+fn test_validation_rejects_wrong_grapheme_count() {
+    use vortex_dtype::ExtDType;
+
+    let bad_metadata = GraphemeMetadata { grapheme_count: 99 };
+    let ext_dtype = ExtDType::try_new(bad_metadata, DType::Utf8(Nullability::NonNullable)).unwrap();
+
+    let result = ExtScalarValue::<GraphemeUtf8ExtVTable>::try_new(
+        ext_dtype,
+        ScalarValue::Utf8("hello".into()),
+    );
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_display() {
+    let s = grapheme_scalar("hello");
+    let ext = s.as_extension();
+    let v = ext.as_value::<GraphemeUtf8ExtVTable>().unwrap();
+
+    assert_eq!(format!("{v}"), "hello (5 chars)");
+}
diff --git a/vortex-scalar/src/extension/tests/mod.rs b/vortex-scalar/src/extension/tests/mod.rs
new file mode 100644
index 00000000000..60010f7585f
--- /dev/null
+++ b/vortex-scalar/src/extension/tests/mod.rs
@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod apples;
+mod grapheme_utf8;
+mod trivial_ext;
+// mod cast;
diff --git a/vortex-scalar/src/extension/tests/trivial_ext.rs b/vortex-scalar/src/extension/tests/trivial_ext.rs
new file mode 100644
index 00000000000..b769a0a59fa
--- /dev/null
+++ b/vortex-scalar/src/extension/tests/trivial_ext.rs
@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_dtype::DType;
+use vortex_dtype::ExtDType;
+use vortex_dtype::ExtID;
+use vortex_dtype::Nullability;
+use vortex_dtype::PType;
+use vortex_dtype::extension::EmptyMetadata;
+use vortex_dtype::extension::ExtDTypeVTable;
+use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
+
+use crate::Scalar;
+use crate::ScalarValue;
+use crate::extension::ExtScalarVTable;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct TrivialI32ExtVTable;
+
+impl ExtDTypeVTable for TrivialI32ExtVTable {
+    type Metadata = EmptyMetadata;
+
+    fn id(&self) -> ExtID {
+        ExtID::new_ref("trivial_ext")
+    }
+
+    fn validate_dtype(
+        &self,
+        _options: &Self::Metadata,
+        _storage_dtype: &DType,
+    ) -> VortexResult<()> {
+        Ok(())
+    }
+}
+
+impl ExtScalarVTable for TrivialI32ExtVTable {
+    type Value<'a> = i32;
+
+    fn unpack<'a>(
+        &self,
+        _metadata: &'a <Self as ExtDTypeVTable>::Metadata,
+        storage_dtype: &'a DType,
+        storage_value: &'a ScalarValue,
+    ) -> Self::Value<'a> {
+        assert!(storage_dtype.is_primitive());
+        storage_value.as_primitive().as_i32().unwrap()
+    }
+
+    fn validate_scalar_value(
+        &self,
+        _metadata: &<Self as ExtDTypeVTable>::Metadata,
+        storage_dtype: &DType,
+        storage_value: &ScalarValue,
+    ) -> VortexResult<()> {
+        vortex_ensure!(storage_dtype.is_primitive());
+        vortex_ensure!(storage_value.as_primitive().as_i32().is_some());
+
+        Ok(())
+    }
+}
+
+#[test]
+fn test_trivial_ext_scalar_equality() {
+    let scalar1 = Scalar::extension::<TrivialI32ExtVTable>(
+        EmptyMetadata,
+        Scalar::primitive(42i32, Nullability::NonNullable),
+    );
+    let scalar2 = Scalar::extension::<TrivialI32ExtVTable>(
+        EmptyMetadata,
+        Scalar::primitive(42i32, Nullability::NonNullable),
+    );
+    let scalar3 = Scalar::extension::<TrivialI32ExtVTable>(
+        EmptyMetadata,
+        Scalar::primitive(43i32, Nullability::NonNullable),
+    );
+
+    let ext1 = scalar1.as_extension().as_value::<TrivialI32ExtVTable>();
+    let ext2 = scalar2.as_extension().as_value::<TrivialI32ExtVTable>();
+    let ext3 = scalar3.as_extension().as_value::<TrivialI32ExtVTable>();
+
+    assert_eq!(ext1, ext2);
+    assert_ne!(ext1, ext3);
+}
+
+#[test]
+fn test_trivial_ext_scalar_partial_ord() {
+    let scalar1 = Scalar::extension::<TrivialI32ExtVTable>(
+        EmptyMetadata,
+        Scalar::primitive(10i32, Nullability::NonNullable),
+    );
+    let scalar2 = Scalar::extension::<TrivialI32ExtVTable>(
+        EmptyMetadata,
+        Scalar::primitive(20i32, Nullability::NonNullable),
+    );
+
+    let ext1 = scalar1.as_extension().as_value::<TrivialI32ExtVTable>();
+    let ext2 = scalar2.as_extension().as_value::<TrivialI32ExtVTable>();
+
+    assert!(ext1 < ext2);
+    assert!(ext2 > ext1);
+}
+
+#[test]
+fn test_trivial_ext_scalar_hash() {
+    use vortex_utils::aliases::hash_set::HashSet;
+
+    let scalar1 = Scalar::extension::<TrivialI32ExtVTable>(
+        EmptyMetadata,
+        Scalar::primitive(42i32, Nullability::NonNullable),
+    );
+    let scalar2 = Scalar::extension::<TrivialI32ExtVTable>(
+        EmptyMetadata,
+        Scalar::primitive(42i32, Nullability::NonNullable),
+    );
+
+    let mut set = HashSet::new();
+    set.insert(scalar2);
+    set.insert(scalar1);
+
+    // Same value should hash the same
+    assert_eq!(set.len(), 1);
+
+    // Different value should hash differently
+    let scalar3 = Scalar::extension::<TrivialI32ExtVTable>(
+        EmptyMetadata,
+        Scalar::primitive(43i32, Nullability::NonNullable),
+    );
+    set.insert(scalar3);
+    assert_eq!(set.len(), 2);
+}
+
+#[test]
+fn test_trivial_ext_scalar_storage() {
+    let storage_scalar = Scalar::primitive(42i32, Nullability::NonNullable);
+    let ext_scalar =
+        Scalar::extension::<TrivialI32ExtVTable>(EmptyMetadata, storage_scalar.clone());
+
+    let ext = ext_scalar.as_extension();
+    assert_eq!(ext.to_storage_scalar(), storage_scalar);
+}
+
+#[test]
+fn test_trivial_ext_scalar_ext_dtype() {
+    let ext_dtype: ExtDType<TrivialI32ExtVTable> = ExtDType::try_new(
+        EmptyMetadata,
+        DType::Primitive(PType::I32, Nullability::NonNullable),
+    )
+    .unwrap();
+
+    let scalar = Scalar::extension::<TrivialI32ExtVTable>(
+        EmptyMetadata.clone(),
+        Scalar::primitive(42i32, Nullability::NonNullable),
+    );
+
+    let ext = scalar.as_extension();
+    assert_eq!(ext.ext_dtype().id(), ext_dtype.id());
+    assert_eq!(ext.ext_dtype(), &ext_dtype.erased());
+}
diff --git a/vortex-scalar/src/extension/vtable.rs b/vortex-scalar/src/extension/vtable.rs
new file mode 100644
index 00000000000..cd428bd0d7b
--- /dev/null
+++ b/vortex-scalar/src/extension/vtable.rs
@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Definition of [`ExtScalarVTable`].
+
+use std::fmt::Debug;
+use std::fmt::Display;
+
+use vortex_dtype::DType;
+use vortex_dtype::ExtDTypeRef;
+use vortex_dtype::ExtID;
+use vortex_dtype::extension::ExtDTypeVTable;
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
+
+use crate::ScalarValue;
+use crate::extension::ExtScalarValue;
+use crate::extension::ExtScalarValueRef;
+
+/// API for defining the scalar behavior of an extension DType.
+pub trait ExtScalarVTable: ExtDTypeVTable {
+    /// Extract a native Rust value type from a storage value.
+    ///
+    /// The value only represents non-null values. We denote nullable values as `Option<Value>`.
+    type Value<'a>: Display;
+
+    /// Unpack a native value from the storage ScalarValue.
+    ///
+    /// This call is infallible assuming the [`ExtScalarVTable::validate_scalar_value`] function has
+    /// been called previously.
+    fn unpack<'a>(
+        &self,
+        metadata: &'a <Self as ExtDTypeVTable>::Metadata,
+        storage_dtype: &'a DType,
+        storage_value: &'a ScalarValue,
+    ) -> Self::Value<'a>;
+
+    /// Validate the given storage value is compatible with the extension type.
+    ///
+    /// Note that [`ExtDTypeVTable::validate_dtype`] is always called first to validate the storage
+    /// [`DType`].
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the storage [`ScalarValue`] is not compatible with the extension type.
+    fn validate_scalar_value(
+        &self,
+        metadata: &<Self as ExtDTypeVTable>::Metadata,
+        storage_dtype: &DType,
+        storage_value: &ScalarValue,
+    ) -> VortexResult<()>;
+}
+
+/// A dynamic vtable for extension scalars, used for type-erased deserialization.
+pub trait DynExtScalarVTable: 'static + Send + Sync + Debug {
+    /// Returns the ID for this extension type.
+    fn id(&self) -> ExtID;
+
+    /// Creates a [`ExtScalarValueRef`] from a [`ScalarValue`] and a type-erased [`ExtDTypeRef`].
+    ///
+    /// The reason we need this is that the internal implementation is the only thing that can
+    /// access the [`ExtScalarVTable`].
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the storage value is not compatible with the extension type.
+    fn create_ext_scalar_value_ref(
+        &self,
+        ext_dtype: ExtDTypeRef,
+        storage: ScalarValue,
+    ) -> VortexResult<ExtScalarValueRef>;
+}
+
+impl<V: ExtScalarVTable> DynExtScalarVTable for V {
+    fn id(&self) -> ExtID {
+        ExtDTypeVTable::id(self)
+    }
+
+    fn create_ext_scalar_value_ref(
+        &self,
+        ext_dtype: ExtDTypeRef,
+        storage: ScalarValue,
+    ) -> VortexResult<ExtScalarValueRef> {
+        let typed_ext_dtype = ext_dtype
+            .try_downcast::<V>()
+            .map_err(|_| vortex_err!("unable to downcast the extension dtype with the vtable"))?;
+
+        let owned = ExtScalarValue::<V>::try_new(typed_ext_dtype, storage)?;
+        Ok(owned.erased())
+    }
+}
diff --git a/vortex-scalar/src/lib.rs b/vortex-scalar/src/lib.rs
index ef956f32c23..0aaa6c01b70 100644
--- a/vortex-scalar/src/lib.rs
+++ b/vortex-scalar/src/lib.rs
@@ -18,6 +18,7 @@
 #[cfg(feature = "arbitrary")]
 pub mod arbitrary;
 mod arrow;
+mod extension;
 
 mod cast;
 mod constructor;
@@ -25,6 +26,7 @@ mod convert;
 mod display;
 mod downcast;
 mod proto;
+mod session;
 
 mod scalar;
 mod scalar_value;
diff --git a/vortex-scalar/src/proto.rs b/vortex-scalar/src/proto.rs
index 1b41b0af85b..1ed8a3dd194 100644
--- a/vortex-scalar/src/proto.rs
+++ b/vortex-scalar/src/proto.rs
@@ -110,6 +110,9 @@ impl From<&ScalarValue> for pb::ScalarValue {
                     kind: Some(Kind::ListValue(ListValue { values })),
                 }
             }
+            ScalarValue::Extension(ext_scalar_value_ref) => {
+                Self::from(ext_scalar_value_ref.storage_value())
+            }
         }
     }
 }
@@ -167,8 +170,12 @@ impl Scalar {
     /// # Errors
     ///
     /// Returns an error if type validation fails.
-    pub fn from_proto_value(value: &pb::ScalarValue, dtype: &DType) -> VortexResult<Self> {
-        let scalar_value = ScalarValue::from_proto(value, dtype)?;
+    pub fn from_proto_value(
+        value: &pb::ScalarValue,
+        dtype: &DType,
+        session: &VortexSession,
+    ) -> VortexResult<Self> {
+        let scalar_value = ScalarValue::from_proto(value, dtype, session)?;
 
         Scalar::try_new(dtype.clone(), scalar_value)
     }
@@ -192,7 +199,7 @@ impl Scalar {
             .as_ref()
             .ok_or_else(|| vortex_err!(InvalidSerde: "Scalar missing value"))?;
 
-        let value: Option<ScalarValue> = ScalarValue::from_proto(pb_scalar_value, &dtype)?;
+        let value: Option<ScalarValue> = ScalarValue::from_proto(pb_scalar_value, &dtype, session)?;
 
         Scalar::try_new(dtype, value)
     }
@@ -207,9 +214,13 @@ impl ScalarValue {
     /// # Errors
     ///
     /// Returns an error if decoding or type validation fails.
-    pub fn from_proto_bytes(bytes: &[u8], dtype: &DType) -> VortexResult<Option<Self>> {
+    pub fn from_proto_bytes(
+        bytes: &[u8],
+        dtype: &DType,
+        session: &VortexSession,
+    ) -> VortexResult<Option<Self>> {
         let proto = pb::ScalarValue::decode(bytes)?;
-        Self::from_proto(&proto, dtype)
+        Self::from_proto(&proto, dtype, session)
     }
 
     /// Creates a [`ScalarValue`] from its [protobuf](pb::ScalarValue) representation.
@@ -220,16 +231,24 @@ impl ScalarValue {
     /// # Errors
     ///
     /// Returns an error if the protobuf value cannot be converted to the given [`DType`].
-    pub fn from_proto(value: &pb::ScalarValue, dtype: &DType) -> VortexResult<Option<Self>> {
+    pub fn from_proto(
+        value: &pb::ScalarValue,
+        dtype: &DType,
+        session: &VortexSession,
+    ) -> VortexResult<Option<Self>> {
         let kind = value
             .kind
             .as_ref()
             .ok_or_else(|| vortex_err!(InvalidSerde: "Scalar value missing kind"))?;
 
-        // `DType::Extension` store their serialized values using the storage `DType`.
-        let dtype = match dtype {
-            DType::Extension(ext) => ext.storage_dtype(),
-            _ => dtype,
+        // If we want to deserialize an extension type, we need the extension registry + special
+        // logic.
+        if let Some(ext_dtype) = dtype.as_extension_opt() {
+            let storage_value = Self::from_proto(value, ext_dtype.storage_dtype(), session)?;
+
+            return storage_value
+                .map(|sv| ScalarValue::extension_value(ext_dtype, sv, session))
+                .transpose();
         };
 
         Ok(Some(match kind {
@@ -242,7 +261,7 @@ impl ScalarValue {
             Kind::F64Value(v) => f64_from_proto(*v, dtype)?,
             Kind::StringValue(s) => string_from_proto(s, dtype)?,
             Kind::BytesValue(b) => bytes_from_proto(b, dtype)?,
-            Kind::ListValue(v) => list_from_proto(v, dtype)?,
+            Kind::ListValue(v) => list_from_proto(v, dtype, session)?,
         }))
     }
 }
@@ -379,417 +398,23 @@ fn bytes_from_proto(bytes: &[u8], dtype: &DType) -> VortexResult<ScalarValue> {
 }
 
 /// Deserialize a [`ScalarValue::List`] from a protobuf `ListValue`.
-fn list_from_proto(v: &ListValue, dtype: &DType) -> VortexResult<ScalarValue> {
+fn list_from_proto(
+    v: &ListValue,
+    dtype: &DType,
+    session: &VortexSession,
+) -> VortexResult<ScalarValue> {
     let element_dtype = dtype.as_list_element_opt().ok_or_else(
         || vortex_err!(InvalidSerde: "expected List dtype for ListValue, got {dtype}"),
     )?;
 
     let mut values = Vec::with_capacity(v.values.len());
     for elem in v.values.iter() {
-        values.push(ScalarValue::from_proto(elem, element_dtype.as_ref())?);
+        values.push(ScalarValue::from_proto(
+            elem,
+            element_dtype.as_ref(),
+            session,
+        )?);
     }
 
     Ok(ScalarValue::List(values))
 }
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use vortex_buffer::BufferString;
-    use vortex_dtype::DType;
-    use vortex_dtype::DecimalDType;
-    use vortex_dtype::Nullability;
-    use vortex_dtype::PType;
-    use vortex_dtype::half::f16;
-    use vortex_error::vortex_panic;
-    use vortex_proto::scalar as pb;
-    use vortex_session::VortexSession;
-
-    use super::*;
-    use crate::DecimalValue;
-    use crate::Scalar;
-    use crate::ScalarValue;
-
-    fn session() -> VortexSession {
-        VortexSession::empty()
-    }
-
-    fn round_trip(scalar: Scalar) {
-        assert_eq!(
-            scalar,
-            Scalar::from_proto(&pb::Scalar::from(&scalar), &session()).unwrap(),
-        );
-    }
-
-    #[test]
-    fn test_null() {
-        round_trip(Scalar::null(DType::Null));
-    }
-
-    #[test]
-    fn test_bool() {
-        round_trip(Scalar::new(
-            DType::Bool(Nullability::Nullable),
-            Some(ScalarValue::Bool(true)),
-        ));
-    }
-
-    #[test]
-    fn test_primitive() {
-        round_trip(Scalar::new(
-            DType::Primitive(PType::I32, Nullability::Nullable),
-            Some(ScalarValue::Primitive(42i32.into())),
-        ));
-    }
-
-    #[test]
-    fn test_buffer() {
-        round_trip(Scalar::new(
-            DType::Binary(Nullability::Nullable),
-            Some(ScalarValue::Binary(vec![1, 2, 3].into())),
-        ));
-    }
-
-    #[test]
-    fn test_buffer_string() {
-        round_trip(Scalar::new(
-            DType::Utf8(Nullability::Nullable),
-            Some(ScalarValue::Utf8(BufferString::from("hello".to_string()))),
-        ));
-    }
-
-    #[test]
-    fn test_list() {
-        round_trip(Scalar::new(
-            DType::List(
-                Arc::new(DType::Primitive(PType::I32, Nullability::Nullable)),
-                Nullability::Nullable,
-            ),
-            Some(ScalarValue::List(vec![
-                Some(ScalarValue::Primitive(42i32.into())),
-                Some(ScalarValue::Primitive(43i32.into())),
-            ])),
-        ));
-    }
-
-    #[test]
-    fn test_f16() {
-        round_trip(Scalar::primitive(
-            f16::from_f32(0.42),
-            Nullability::Nullable,
-        ));
-    }
-
-    #[test]
-    fn test_i8() {
-        round_trip(Scalar::new(
-            DType::Primitive(PType::I8, Nullability::Nullable),
-            Some(ScalarValue::Primitive(i8::MIN.into())),
-        ));
-
-        round_trip(Scalar::new(
-            DType::Primitive(PType::I8, Nullability::Nullable),
-            Some(ScalarValue::Primitive(0i8.into())),
-        ));
-
-        round_trip(Scalar::new(
-            DType::Primitive(PType::I8, Nullability::Nullable),
-            Some(ScalarValue::Primitive(i8::MAX.into())),
-        ));
-    }
-
-    #[test]
-    fn test_decimal_i32_roundtrip() {
-        // A typical decimal with moderate precision and scale.
-        round_trip(Scalar::decimal(
-            DecimalValue::I32(123_456),
-            DecimalDType::new(10, 2),
-            Nullability::NonNullable,
-        ));
-    }
-
-    #[test]
-    fn test_decimal_i128_roundtrip() {
-        // A large decimal value that requires i128 storage.
-        round_trip(Scalar::decimal(
-            DecimalValue::I128(99_999_999_999_999_999_999),
-            DecimalDType::new(38, 6),
-            Nullability::Nullable,
-        ));
-    }
-
-    #[test]
-    fn test_decimal_null_roundtrip() {
-        round_trip(Scalar::null(DType::Decimal(
-            DecimalDType::new(10, 2),
-            Nullability::Nullable,
-        )));
-    }
-
-    #[test]
-    fn test_scalar_value_serde_roundtrip_binary() {
-        round_trip(Scalar::binary(
-            ByteBuffer::copy_from(b"hello"),
-            Nullability::NonNullable,
-        ));
-    }
-
-    #[test]
-    fn test_scalar_value_serde_roundtrip_utf8() {
-        round_trip(Scalar::utf8("hello", Nullability::NonNullable));
-    }
-
-    #[test]
-    fn test_backcompat_f16_serialized_as_u64() {
-        // Backwards compatibility test for the legacy f16 serialization format.
-        //
-        // Previously, f16 ScalarValues were serialized as `Uint64Value(v.to_bits() as u64)` because
-        // the proto schema only had 64-bit integer types, and f16's underlying representation is
-        // u16 which got widened to u64.
-        //
-        // The current implementation uses a dedicated `F16Value` proto field, but we must still be
-        // able to deserialize the old format. This test verifies that:
-        //
-        // 1. A `Uint64Value` containing f16 bits can be read as a U64 primitive (the raw bits).
-        // 2. When wrapped in a Scalar with F16 dtype, the value is correctly interpreted as f16.
-        //
-        // This ensures data written with the old serialization format remains readable.
-
-        // Simulate the old serialization: f16(0.42) stored as Uint64Value with its bit pattern.
-        let f16_value = f16::from_f32(0.42);
-        let f16_bits_as_u64 = f16_value.to_bits() as u64; // 14008
-
-        let pb_scalar_value = pb::ScalarValue {
-            kind: Some(Kind::Uint64Value(f16_bits_as_u64)),
-        };
-
-        // Step 1: Verify the normal U64 scalar.
-        let scalar_value = ScalarValue::from_proto(
-            &pb_scalar_value,
-            &DType::Primitive(PType::U64, Nullability::NonNullable),
-        )
-        .unwrap();
-        assert_eq!(
-            scalar_value.as_ref().map(|v| v.as_primitive()),
-            Some(&PValue::U64(14008u64)),
-        );
-
-        // Step 2: Verify that when we use F16 dtype, the Uint64Value is correctly interpreted.
-        let scalar_value_f16 = ScalarValue::from_proto(
-            &pb_scalar_value,
-            &DType::Primitive(PType::F16, Nullability::Nullable),
-        )
-        .unwrap();
-
-        let scalar = Scalar::new(
-            DType::Primitive(PType::F16, Nullability::Nullable),
-            scalar_value_f16,
-        );
-
-        assert_eq!(
-            scalar.as_primitive().pvalue().unwrap(),
-            PValue::F16(f16::from_f32(0.42)),
-            "Uint64Value should be correctly interpreted as f16 when dtype is F16"
-        );
-    }
-
-    #[test]
-    fn test_scalar_value_direct_roundtrip_f16() {
-        // Test that ScalarValue with f16 roundtrips correctly without going through Scalar.
-        let f16_values = vec![
-            f16::from_f32(0.0),
-            f16::from_f32(1.0),
-            f16::from_f32(-1.0),
-            f16::from_f32(0.42),
-            f16::from_f32(5.722046e-6),
-            f16::from_f32(std::f32::consts::PI),
-            f16::INFINITY,
-            f16::NEG_INFINITY,
-            f16::NAN,
-        ];
-
-        for f16_val in f16_values {
-            let scalar_value = ScalarValue::Primitive(PValue::F16(f16_val));
-            let pb_value = ScalarValue::to_proto(Some(&scalar_value));
-            let read_back = ScalarValue::from_proto(
-                &pb_value,
-                &DType::Primitive(PType::F16, Nullability::NonNullable),
-            )
-            .unwrap();
-
-            match (&scalar_value, read_back.as_ref()) {
-                (
-                    ScalarValue::Primitive(PValue::F16(original)),
-                    Some(ScalarValue::Primitive(PValue::F16(roundtripped))),
-                ) => {
-                    if original.is_nan() && roundtripped.is_nan() {
-                        // NaN values are equal for our purposes.
-                        continue;
-                    }
-                    assert_eq!(
-                        original, roundtripped,
-                        "F16 value {original:?} did not roundtrip correctly"
-                    );
-                }
-                _ => {
-                    vortex_panic!(
-                        "Expected f16 primitive values, got {scalar_value:?} and {read_back:?}"
-                    )
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_scalar_value_direct_roundtrip_preserves_values() {
-        // Test that ScalarValue roundtripping preserves values (but not necessarily exact types).
-        // Note: Proto encoding consolidates integer types (u8/u16/u32 → u64, i8/i16/i32 → i64).
-
-        // Test cases that should roundtrip exactly.
-        let exact_roundtrip_cases: Vec<(&str, Option<ScalarValue>, DType)> = vec![
-            ("null", None, DType::Null),
-            (
-                "bool_true",
-                Some(ScalarValue::Bool(true)),
-                DType::Bool(Nullability::Nullable),
-            ),
-            (
-                "bool_false",
-                Some(ScalarValue::Bool(false)),
-                DType::Bool(Nullability::Nullable),
-            ),
-            (
-                "u64",
-                Some(ScalarValue::Primitive(PValue::U64(18446744073709551615))),
-                DType::Primitive(PType::U64, Nullability::Nullable),
-            ),
-            (
-                "i64",
-                Some(ScalarValue::Primitive(PValue::I64(-9223372036854775808))),
-                DType::Primitive(PType::I64, Nullability::Nullable),
-            ),
-            (
-                "f32",
-                Some(ScalarValue::Primitive(PValue::F32(std::f32::consts::E))),
-                DType::Primitive(PType::F32, Nullability::Nullable),
-            ),
-            (
-                "f64",
-                Some(ScalarValue::Primitive(PValue::F64(std::f64::consts::PI))),
-                DType::Primitive(PType::F64, Nullability::Nullable),
-            ),
-            (
-                "string",
-                Some(ScalarValue::Utf8(BufferString::from("test"))),
-                DType::Utf8(Nullability::Nullable),
-            ),
-            (
-                "bytes",
-                Some(ScalarValue::Binary(vec![1, 2, 3, 4, 5].into())),
-                DType::Binary(Nullability::Nullable),
-            ),
-        ];
-
-        for (name, value, dtype) in exact_roundtrip_cases {
-            let pb_value = ScalarValue::to_proto(value.as_ref());
-            let read_back = ScalarValue::from_proto(&pb_value, &dtype).unwrap();
-
-            let original_debug = format!("{value:?}");
-            let roundtrip_debug = format!("{read_back:?}");
-            assert_eq!(
-                original_debug, roundtrip_debug,
-                "ScalarValue {name} did not roundtrip exactly"
-            );
-        }
-
-        // Test cases where type changes but value is preserved.
-        // Unsigned integers consolidate to U64.
-        let unsigned_cases = vec![
-            (
-                "u8",
-                ScalarValue::Primitive(PValue::U8(255)),
-                DType::Primitive(PType::U8, Nullability::Nullable),
-                255u64,
-            ),
-            (
-                "u16",
-                ScalarValue::Primitive(PValue::U16(65535)),
-                DType::Primitive(PType::U16, Nullability::Nullable),
-                65535u64,
-            ),
-            (
-                "u32",
-                ScalarValue::Primitive(PValue::U32(4294967295)),
-                DType::Primitive(PType::U32, Nullability::Nullable),
-                4294967295u64,
-            ),
-        ];
-
-        for (name, value, dtype, expected) in unsigned_cases {
-            let pb_value = ScalarValue::to_proto(Some(&value));
-            let read_back = ScalarValue::from_proto(&pb_value, &dtype).unwrap();
-
-            match read_back.as_ref() {
-                Some(ScalarValue::Primitive(pv)) => {
-                    let v = match pv {
-                        PValue::U8(v) => *v as u64,
-                        PValue::U16(v) => *v as u64,
-                        PValue::U32(v) => *v as u64,
-                        PValue::U64(v) => *v,
-                        _ => vortex_panic!("Unexpected primitive type for {name}: {pv:?}"),
-                    };
-                    assert_eq!(
-                        v, expected,
-                        "ScalarValue {name} value not preserved: expected {expected}, got {v}"
-                    );
-                }
-                _ => vortex_panic!("Unexpected type after roundtrip for {name}: {read_back:?}"),
-            }
-        }
-
-        // Signed integers consolidate to I64.
-        let signed_cases = vec![
-            (
-                "i8",
-                ScalarValue::Primitive(PValue::I8(-128)),
-                DType::Primitive(PType::I8, Nullability::Nullable),
-                -128i64,
-            ),
-            (
-                "i16",
-                ScalarValue::Primitive(PValue::I16(-32768)),
-                DType::Primitive(PType::I16, Nullability::Nullable),
-                -32768i64,
-            ),
-            (
-                "i32",
-                ScalarValue::Primitive(PValue::I32(-2147483648)),
-                DType::Primitive(PType::I32, Nullability::Nullable),
-                -2147483648i64,
-            ),
-        ];
-
-        for (name, value, dtype, expected) in signed_cases {
-            let pb_value = ScalarValue::to_proto(Some(&value));
-            let read_back = ScalarValue::from_proto(&pb_value, &dtype).unwrap();
-
-            match read_back.as_ref() {
-                Some(ScalarValue::Primitive(pv)) => {
-                    let v = match pv {
-                        PValue::I8(v) => *v as i64,
-                        PValue::I16(v) => *v as i64,
-                        PValue::I32(v) => *v as i64,
-                        PValue::I64(v) => *v,
-                        _ => vortex_panic!("Unexpected primitive type for {name}: {pv:?}"),
-                    };
-                    assert_eq!(
-                        v, expected,
-                        "ScalarValue {name} value not preserved: expected {expected}, got {v}"
-                    );
-                }
-                _ => vortex_panic!("Unexpected type after roundtrip for {name}: {read_back:?}"),
-            }
-        }
-    }
-}
diff --git a/vortex-scalar/src/scalar.rs b/vortex-scalar/src/scalar.rs
index 448007e9a1c..d5b53056563 100644
--- a/vortex-scalar/src/scalar.rs
+++ b/vortex-scalar/src/scalar.rs
@@ -11,6 +11,7 @@ use vortex_dtype::DType;
 use vortex_dtype::NativeDType;
 use vortex_dtype::PType;
 use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_ensure_eq;
 use vortex_error::vortex_panic;
@@ -102,11 +103,7 @@ impl Scalar {
     ///
     /// Returns an error if the given [`DType`] and [`ScalarValue`] are incompatible.
     pub fn try_new(dtype: DType, value: Option<ScalarValue>) -> VortexResult<Self> {
-        vortex_ensure!(
-            Self::is_compatible(&dtype, value.as_ref()),
-            "Incompatible dtype {dtype} with value {}",
-            value.map(|v| format!("{}", v)).unwrap_or_default()
-        );
+        Self::validate(&dtype, value.as_ref())?;
 
         Ok(Self { dtype, value })
     }
@@ -155,16 +152,27 @@ impl Scalar {
 
     // Other methods.
 
-    /// Check if the given [`ScalarValue`] is compatible with the given [`DType`].
-    pub fn is_compatible(dtype: &DType, value: Option<&ScalarValue>) -> bool {
+    /// Validate that the given [`ScalarValue`] is compatible with the given [`DType`].
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the given [`DType`] and [`ScalarValue`] are incompatible.
+    pub fn validate(dtype: &DType, value: Option<&ScalarValue>) -> VortexResult<()> {
         let Some(value) = value else {
-            return dtype.is_nullable();
+            vortex_ensure!(
+                dtype.is_nullable(),
+                "Cannot use null value with non-nullable dtype {dtype}"
+            );
+            return Ok(());
         };
         // From here on, we know that the value is not null.
 
         match dtype {
-            DType::Null => false,
-            DType::Bool(_) => matches!(value, ScalarValue::Bool(_)),
+            DType::Null => vortex_bail!("Cannot use non-null value with DType::Null"),
+            DType::Bool(_) => vortex_ensure!(
+                matches!(value, ScalarValue::Bool(_)),
+                "Expected Bool scalar value for dtype {dtype}, got {value}"
+            ),
             DType::Primitive(ptype, _) => {
                 if let ScalarValue::Primitive(pvalue) = value {
                     // Note that this is a backwards compatibility check for poor design in the
@@ -174,61 +182,101 @@ impl Scalar {
                     let f16_backcompat_still_works =
                         matches!(ptype, &PType::F16) && matches!(pvalue, PValue::U64(_));
 
-                    f16_backcompat_still_works || pvalue.ptype() == *ptype
+                    vortex_ensure!(
+                        f16_backcompat_still_works || pvalue.ptype() == *ptype,
+                        "Expected primitive type {ptype} for dtype {dtype}, got {}",
+                        pvalue.ptype()
+                    );
                 } else {
-                    false
+                    vortex_bail!("Expected Primitive scalar value for dtype {dtype}, got {value}");
                 }
             }
             DType::Decimal(dec_dtype, _) => {
                 if let ScalarValue::Decimal(dvalue) = value {
-                    dvalue.fits_in_precision(*dec_dtype)
+                    vortex_ensure!(
+                        dvalue.fits_in_precision(*dec_dtype),
+                        "Decimal value {dvalue} does not fit in precision of {dec_dtype}"
+                    );
                 } else {
-                    false
+                    vortex_bail!("Expected Decimal scalar value for dtype {dtype}, got {value}");
                 }
             }
-            DType::Utf8(_) => matches!(value, ScalarValue::Utf8(_)),
-            DType::Binary(_) => matches!(value, ScalarValue::Binary(_)),
+            DType::Utf8(_) => vortex_ensure!(
+                matches!(value, ScalarValue::Utf8(_)),
+                "Expected Utf8 scalar value for dtype {dtype}, got {value}"
+            ),
+            DType::Binary(_) => vortex_ensure!(
+                matches!(value, ScalarValue::Binary(_)),
+                "Expected Binary scalar value for dtype {dtype}, got {value}"
+            ),
             DType::List(elem_dtype, _) => {
                 if let ScalarValue::List(elements) = value {
-                    elements
-                        .iter()
-                        .all(|element| Self::is_compatible(elem_dtype.as_ref(), element.as_ref()))
+                    for (i, element) in elements.iter().enumerate() {
+                        Self::validate(elem_dtype.as_ref(), element.as_ref()).map_err(|e| {
+                            vortex_error::vortex_err!("List element {i} incompatible: {e}")
+                        })?;
+                    }
                 } else {
-                    false
+                    vortex_bail!("Expected List scalar value for dtype {dtype}, got {value}");
                 }
             }
             DType::FixedSizeList(elem_dtype, size, _) => {
                 if let ScalarValue::List(elements) = value {
-                    if elements.len() != *size as usize {
-                        return false;
+                    vortex_ensure!(
+                        elements.len() == *size as usize,
+                        "Expected {} elements for FixedSizeList, got {}",
+                        size,
+                        elements.len()
+                    );
+                    for (i, element) in elements.iter().enumerate() {
+                        Self::validate(elem_dtype.as_ref(), element.as_ref()).map_err(|e| {
+                            vortex_error::vortex_err!("FixedSizeList element {i} incompatible: {e}")
+                        })?;
                     }
-                    elements
-                        .iter()
-                        .all(|element| Self::is_compatible(elem_dtype.as_ref(), element.as_ref()))
                 } else {
-                    false
+                    vortex_bail!(
+                        "Expected List scalar value for FixedSizeList dtype {dtype}, got {value}"
+                    );
                 }
             }
             DType::Struct(fields, _) => {
                 if let ScalarValue::List(values) = value {
-                    if values.len() != fields.nfields() {
-                        return false;
-                    }
-                    for (field, field_value) in fields.fields().zip(values.iter()) {
-                        if !Self::is_compatible(&field, field_value.as_ref()) {
-                            return false;
-                        }
+                    vortex_ensure!(
+                        values.len() == fields.nfields(),
+                        "Expected {} fields for Struct, got {}",
+                        fields.nfields(),
+                        values.len()
+                    );
+                    for (i, (field, field_value)) in fields.fields().zip(values.iter()).enumerate()
+                    {
+                        Self::validate(&field, field_value.as_ref()).map_err(|e| {
+                            vortex_error::vortex_err!("Struct field {i} incompatible: {e}")
+                        })?;
                     }
-                    true
                 } else {
-                    false
+                    vortex_bail!(
+                        "Expected List scalar value for Struct dtype {dtype}, got {value}"
+                    );
                 }
             }
             DType::Extension(ext_dtype) => {
-                // TODO(connor): Fix this when adding the correct extension scalars!
-                Self::is_compatible(ext_dtype.storage_dtype(), Some(value))
+                if let ScalarValue::Extension(ext_scalar_value_ref) = value {
+                    ext_scalar_value_ref.validate(ext_dtype)?;
+                } else {
+                    vortex_bail!(
+                        "Expected Extension scalar value for dtype {dtype}, \
+                            got non-extension value {value}"
+                    );
+                }
             }
         }
+
+        Ok(())
+    }
+
+    /// Check if the given [`ScalarValue`] is compatible with the given [`DType`].
+    pub fn is_compatible(dtype: &DType, value: Option<&ScalarValue>) -> bool {
+        Self::validate(dtype, value).is_ok()
     }
 
     /// Check if two scalars are equal, ignoring nullability of the [`DType`].
diff --git a/vortex-scalar/src/scalar_value.rs b/vortex-scalar/src/scalar_value.rs
index 789f56823ef..f94e68b00dc 100644
--- a/vortex-scalar/src/scalar_value.rs
+++ b/vortex-scalar/src/scalar_value.rs
@@ -11,11 +11,16 @@ use itertools::Itertools;
 use vortex_buffer::BufferString;
 use vortex_buffer::ByteBuffer;
 use vortex_dtype::DType;
+use vortex_dtype::ExtDTypeRef;
+use vortex_error::VortexResult;
+use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
+use vortex_session::VortexSession;
 
 use crate::DecimalValue;
-// use crate::ExtScalarValueRef;
 use crate::PValue;
+use crate::extension::ExtScalarValueRef;
+use crate::session::ScalarSessionExt;
 
 /// The value stored in a [`Scalar`][crate::Scalar].
 ///
@@ -35,11 +40,11 @@ pub enum ScalarValue {
     Binary(ByteBuffer),
     /// A list of potentially null scalar values.
     List(Vec<Option<ScalarValue>>),
-    // /// An extension value reference.
-    // ///
-    // /// This internally contains a `ScalarValue` and an vtable that implements
-    // /// [`ExtScalarVTable`](crate::ExtScalarVTable)
-    // Extension(ExtScalarValueRef),
+    /// An extension value reference.
+    ///
+    /// This internally contains a `ScalarValue` and an vtable that implements
+    /// [`ExtScalarVTable`](crate::ExtScalarVTable)
+    Extension(ExtScalarValueRef),
 }
 
 impl ScalarValue {
@@ -83,7 +88,14 @@ impl ScalarValue {
                     .collect();
                 Self::List(field_values)
             }
-            DType::Extension(ext_dtype) => Self::zero_value(ext_dtype.storage_dtype()), // TODO(connor): Fix this!
+            DType::Extension(ext_dtype) => {
+                // Since we have no way to define a "zero" extension value (since we have no idea
+                // what the semantics of the extension is), a best effort attempt is to just use the
+                // zero storage value and try to make an extension scalar from that.
+                let zero_storage_value = Self::zero_value(ext_dtype.storage_dtype());
+
+                Self::extension_value(ext_dtype, zero_storage_value, session)
+            }
         }
     }
 
@@ -117,65 +129,38 @@ impl ScalarValue {
             DType::Extension(ext_dtype) => Self::default_value(ext_dtype.storage_dtype())?, // TODO(connor): Fix this!
         })
     }
-}
-
-impl ScalarValue {
-    /// Returns the boolean value, panicking if the value is not a [`Bool`][ScalarValue::Bool].
-    pub fn as_bool(&self) -> bool {
-        match self {
-            ScalarValue::Bool(b) => *b,
-            _ => vortex_panic!("ScalarValue is not a Bool"),
-        }
-    }
-
-    /// Returns the primitive value, panicking if the value is not a
-    /// [`Primitive`][ScalarValue::Primitive].
-    pub fn as_primitive(&self) -> &PValue {
-        match self {
-            ScalarValue::Primitive(p) => p,
-            _ => vortex_panic!("ScalarValue is not a Primitive"),
-        }
-    }
-
-    /// Returns the decimal value, panicking if the value is not a
-    /// [`Decimal`][ScalarValue::Decimal].
-    pub fn as_decimal(&self) -> &DecimalValue {
-        match self {
-            ScalarValue::Decimal(d) => d,
-            _ => vortex_panic!("ScalarValue is not a Decimal"),
-        }
-    }
 
-    /// Returns the UTF-8 string value, panicking if the value is not a [`Utf8`][ScalarValue::Utf8].
-    pub fn as_utf8(&self) -> &BufferString {
-        match self {
-            ScalarValue::Utf8(s) => s,
-            _ => vortex_panic!("ScalarValue is not a Utf8"),
-        }
-    }
-
-    /// Returns the binary value, panicking if the value is not a [`Binary`][ScalarValue::Binary].
-    pub fn as_binary(&self) -> &ByteBuffer {
-        match self {
-            ScalarValue::Binary(b) => b,
-            _ => vortex_panic!("ScalarValue is not a Binary"),
-        }
-    }
-
-    /// Returns the list elements, panicking if the value is not a [`List`][ScalarValue::List].
-    pub fn as_list(&self) -> &[Option<ScalarValue>] {
-        match self {
-            ScalarValue::List(elements) => elements,
-            _ => vortex_panic!("ScalarValue is not a List"),
-        }
+    /// Creates an extension [`ScalarValue`] from a storage value and an extension dtype.
+    ///
+    /// This looks up the appropriate [`ExtScalarVTable`](crate::ExtScalarVTable) for the given
+    /// extension dtype in the session's scalar registry, and uses it to wrap the storage value
+    /// into an [`ExtScalarValueRef`].
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the extension type's scalar vtable is not found in the session's
+    /// registry, or if creating the [`ExtScalarValueRef`] fails.
+    pub fn extension_value(
+        ext_dtype: &ExtDTypeRef,
+        storage_value: ScalarValue,
+        session: &VortexSession,
+    ) -> VortexResult<ScalarValue> {
+        let ext_scalar_registry = session.scalars();
+        let dyn_scalar_vtable = ext_scalar_registry
+            .registry()
+            .find(&ext_dtype.id())
+            .ok_or_else(|| {
+                vortex_err!(
+                    "extension type scalar {} did not exist in the registry",
+                    ext_dtype.id()
+                )
+            })?;
+
+        let ext_value =
+            dyn_scalar_vtable.create_ext_scalar_value_ref(ext_dtype.clone(), storage_value)?;
+
+        Ok(ScalarValue::Extension(ext_value))
     }
-
-    // pub fn as_extension(&self) -> &ExtScalarValueRef {
-    //     match self {
-    //         ScalarValue::Extension(e) => e,
-    //         _ => vortex_panic!("ScalarValue is not an Extension"),
-    //     }
-    // }
 }
 
 impl PartialOrd for ScalarValue {
@@ -236,8 +221,15 @@ impl Display for ScalarValue {
                     }
                 }
                 write!(f, "]")
-            } //
-              // ScalarValue::Extension(e) => write!(f, "{}", e),
+            }
+            ScalarValue::Extension(ext_scalar_value_ref) => {
+                write!(
+                    f,
+                    "(ext<{}> storage) {}",
+                    ext_scalar_value_ref.id(),
+                    ext_scalar_value_ref.storage_value()
+                )
+            }
         }
     }
 }
diff --git a/vortex-scalar/src/session.rs b/vortex-scalar/src/session.rs
new file mode 100644
index 00000000000..a3aae88af97
--- /dev/null
+++ b/vortex-scalar/src/session.rs
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Module for managing extension dtypes in a Vortex session.
+
+use std::sync::Arc;
+
+use vortex_dtype::datetime::Date;
+use vortex_dtype::datetime::Time;
+use vortex_dtype::datetime::Timestamp;
+use vortex_session::Ref;
+use vortex_session::SessionExt;
+use vortex_session::registry::Registry;
+
+use crate::extension::DynExtScalarVTable;
+use crate::extension::ExtScalarVTable;
+
+/// Registry for extension dtypes.
+pub type ExtScalarRegistry = Registry<Arc<dyn DynExtScalarVTable>>;
+
+/// Session for managing extension dtypes.
+#[derive(Debug)]
+pub struct ScalarSession {
+    /// Registry of extension scalar vtables.
+    registry: ExtScalarRegistry,
+}
+
+impl Default for ScalarSession {
+    fn default() -> Self {
+        let this = Self {
+            registry: Registry::default(),
+        };
+
+        // Register built-in temporal extension scalars
+        this.register(Date);
+        this.register(Time);
+        this.register(Timestamp);
+
+        this
+    }
+}
+
+impl ScalarSession {
+    /// Register an extension Scalar with the Vortex session.
+    pub fn register<V: ExtScalarVTable>(&self, vtable: V) {
+        self.registry
+            .register(vtable.id(), Arc::new(vtable) as Arc<dyn DynExtScalarVTable>);
+    }
+
+    /// Return the registry of extension scalars.
+    pub fn registry(&self) -> &ExtScalarRegistry {
+        &self.registry
+    }
+}
+
+/// Extension trait for accessing the Scalar session.
+pub trait ScalarSessionExt: SessionExt {
+    /// Get the Scalar session.
+    fn scalars(&self) -> Ref<'_, ScalarSession>;
+}
+
+impl<S: SessionExt> ScalarSessionExt for S {
+    fn scalars(&self) -> Ref<'_, ScalarSession> {
+        self.get::<ScalarSession>()
+    }
+}
diff --git a/vortex-scalar/src/tests/casting.rs b/vortex-scalar/src/tests/casting.rs
index 8918bb6dce3..e57f2b931aa 100644
--- a/vortex-scalar/src/tests/casting.rs
+++ b/vortex-scalar/src/tests/casting.rs
@@ -5,6 +5,7 @@
 
 #[cfg(test)]
 mod tests {
+    use std::fmt::Display;
     use std::sync::Arc;
 
     use vortex_dtype::DType;
@@ -18,52 +19,93 @@ mod tests {
     use vortex_dtype::half::f16;
     use vortex_error::VortexExpect;
     use vortex_error::VortexResult;
+    use vortex_error::vortex_err;
 
     use crate::PValue;
     use crate::Scalar;
     use crate::ScalarValue;
+    use crate::extension::ExtScalarVTable;
 
     #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-    struct Apples;
+    struct MultiplyVTable;
 
-    impl ExtDTypeVTable for Apples {
+    impl ExtDTypeVTable for MultiplyVTable {
         type Metadata = usize;
 
         fn id(&self) -> ExtID {
-            ExtID::new_ref("apples")
+            ExtID::new_ref("simple_ext")
         }
 
         fn validate_dtype(
             &self,
             _options: &Self::Metadata,
-            _storage_dtype: &DType,
+            storage_dtype: &DType,
         ) -> VortexResult<()> {
-            Ok(())
+            match storage_dtype {
+                DType::Primitive(..) => Ok(()),
+                _ => Err(vortex_err!("Expected primitive dtype for simple extension")),
+            }
         }
     }
 
-    impl Apples {
-        fn new() -> ExtDType<Apples> {
-            ExtDType::try_new(0, DType::Primitive(PType::U16, Nullability::NonNullable))
-                .vortex_expect("valid apples dtype")
+    impl ExtScalarVTable for MultiplyVTable {
+        type Value<'a> = usize;
+
+        fn unpack<'a>(
+            &self,
+            metadata: &'a <Self as ExtDTypeVTable>::Metadata,
+            _storage_dtype: &'a DType,
+            storage_value: &'a ScalarValue,
+        ) -> Self::Value<'a> {
+            let pvalue = storage_value
+                .as_primitive_opt()
+                .vortex_expect("storage value was not a primitive");
+
+            let raw_value = match *pvalue {
+                PValue::U8(v) => v as usize,
+                PValue::U16(v) => v as usize,
+                PValue::U32(v) => v as usize,
+                PValue::U64(v) => usize::try_from(v).vortex_expect("unable to convert to usize"),
+                PValue::I8(v) => v as usize,
+                PValue::I16(v) => v as usize,
+                PValue::I32(v) => v as usize,
+                PValue::I64(v) => usize::try_from(v).vortex_expect("unable to convert to usize"),
+                _ => panic!("Expected an integer PValue"),
+            };
+
+            raw_value * metadata
+        }
+
+        fn validate_scalar_value(
+            &self,
+            _metadata: &<Self as ExtDTypeVTable>::Metadata,
+            _storage_dtype: &DType,
+            _storage_value: &ScalarValue,
+        ) -> VortexResult<()> {
+            // Any primitive type is fine so we don't need to verify this.
+            Ok(())
         }
     }
 
     #[test]
     fn cast_to_from_extension_types() {
-        let apples = Apples::new();
-
-        let ext_dtype = DType::Extension(apples.clone().erased());
-        let ext_scalar = Scalar::new(
-            ext_dtype.clone(),
-            Some(ScalarValue::Primitive(PValue::U16(1000))),
-        );
-
+        // Multiply all values by 42.
+        let simple_ext = ExtDType::<MultiplyVTable>::try_new(
+            42,
+            DType::Primitive(PType::U16, Nullability::NonNullable),
+        )
+        .unwrap();
+
+        let ext_dtype = DType::Extension(simple_ext.clone().erased());
         let storage_scalar = Scalar::new(
-            DType::clone(apples.storage_dtype()),
+            DType::clone(simple_ext.storage_dtype()),
             Some(ScalarValue::Primitive(PValue::U16(1000))),
         );
 
+        // Multiply all values by 42.
+        let ext_scalar = Scalar::extension::<MultiplyVTable>(42, storage_scalar.clone());
+        assert_eq!(ext_scalar.dtype(), &ext_dtype);
+
         // to self
         let expected_dtype = &ext_dtype;
         let actual = ext_scalar.cast(expected_dtype).unwrap();
@@ -75,15 +117,18 @@ mod tests {
         assert_eq!(actual.dtype(), expected_dtype);
 
         // cast to the storage type
-        let expected_dtype = apples.storage_dtype();
+        let expected_dtype = simple_ext.storage_dtype();
         let actual = ext_scalar.cast(expected_dtype).unwrap();
         assert_eq!(actual.dtype(), expected_dtype);
 
         // cast to the storage type, nullable
-        let expected_dtype = &apples.storage_dtype().as_nullable();
+        let expected_dtype = &simple_ext.storage_dtype().as_nullable();
         let actual = ext_scalar.cast(expected_dtype).unwrap();
         assert_eq!(actual.dtype(), expected_dtype);
 
+        // TODO(connor): This is not possible without giving the cast method a session so it can
+        // look up the vtable of the extension type it wants to cast to.
+        /*
         // cast from storage type to extension
         let expected_dtype = &ext_dtype;
         let actual = storage_scalar.cast(expected_dtype).unwrap();
@@ -93,12 +138,15 @@ mod tests {
         let expected_dtype = &ext_dtype.as_nullable();
         let actual = storage_scalar.cast(expected_dtype).unwrap();
         assert_eq!(actual.dtype(), expected_dtype);
+        */
 
         // cast from *incompatible* storage type to extension
-        let apples_u8 =
-            ExtDType::<Apples>::try_new(0, DType::Primitive(PType::U8, Nullability::NonNullable))
-                .unwrap();
-        let expected_dtype = &DType::Extension(apples_u8.erased());
+        let simple_ext_u8 = ExtDType::<MultiplyVTable>::try_new(
+            0,
+            DType::Primitive(PType::U8, Nullability::NonNullable),
+        )
+        .unwrap();
+        let expected_dtype = &DType::Extension(simple_ext_u8.erased());
         let result = storage_scalar.cast(expected_dtype);
         assert!(
             result
@@ -245,18 +293,49 @@ mod tests {
             }
         }
 
+        struct Nothing;
+
+        impl Display for Nothing {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(f, "Nothing")
+            }
+        }
+
+        impl ExtScalarVTable for F16Ext {
+            type Value<'a> = Nothing;
+
+            fn unpack<'a>(
+                &self,
+                _metadata: &'a <Self as ExtDTypeVTable>::Metadata,
+                _storage_dtype: &'a DType,
+                _storage_value: &'a ScalarValue,
+            ) -> Self::Value<'a> {
+                Nothing
+            }
+
+            fn validate_scalar_value(
+                &self,
+                _metadata: &<Self as ExtDTypeVTable>::Metadata,
+                _storage_dtype: &DType,
+                _storage_value: &ScalarValue,
+            ) -> VortexResult<()> {
+                Ok(())
+            }
+        }
+
         let storage_dtype = DType::Primitive(PType::F16, Nullability::NonNullable);
-        let ext_dtype = ExtDType::<F16Ext>::try_new(0, storage_dtype).unwrap();
 
         // Test f16 value stored as u64 gets coerced through extension type
         let f16_value = f16::from_f32(0.42);
         let u64_bits = f16_value.to_bits() as u64;
 
-        let scalar = Scalar::new(
-            DType::Extension(ext_dtype.erased()),
+        let storage_scalar = Scalar::new(
+            storage_dtype,
             Some(ScalarValue::Primitive(PValue::U64(u64_bits))),
         );
 
+        let scalar = Scalar::extension::<F16Ext>(0, storage_scalar);
+
         // Verify the value was coerced to f16
         assert_eq!(
             scalar
@@ -290,6 +369,36 @@ mod tests {
             }
         }
 
+        struct Nothing;
+
+        impl Display for Nothing {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(f, "Nothing")
+            }
+        }
+
+        impl ExtScalarVTable for StructExt {
+            type Value<'a> = Nothing;
+
+            fn unpack<'a>(
+                &self,
+                _metadata: &'a <Self as ExtDTypeVTable>::Metadata,
+                _storage_dtype: &'a DType,
+                _storage_value: &'a ScalarValue,
+            ) -> Self::Value<'a> {
+                Nothing
+            }
+
+            fn validate_scalar_value(
+                &self,
+                _metadata: &<Self as ExtDTypeVTable>::Metadata,
+                _storage_dtype: &DType,
+                _storage_value: &ScalarValue,
+            ) -> VortexResult<()> {
+                Ok(())
+            }
+        }
+
         let struct_dtype = DType::Struct(
             StructFields::from_iter([
                 (
@@ -303,7 +412,6 @@ mod tests {
             ]),
             Nullability::NonNullable,
         );
-        let ext_dtype = ExtDType::<StructExt>::try_new(0, struct_dtype).unwrap();
 
         // Create struct value with f16 stored as u64
         let f16_value = f16::from_f32(1.5);
@@ -314,10 +422,9 @@ mod tests {
             ))),
         ];
 
-        let scalar = Scalar::new(
-            DType::Extension(ext_dtype.erased()),
-            Some(ScalarValue::List(field_values)),
-        );
+        let storage_scalar = Scalar::new(struct_dtype, Some(ScalarValue::List(field_values)));
+
+        let scalar = Scalar::extension::<StructExt>(0, storage_scalar);
 
         // Verify the struct field was coerced
         let list_elems = scalar
diff --git a/vortex-scalar/src/tests/mod.rs b/vortex-scalar/src/tests/mod.rs
index bdae7b9d4b1..a5fa5c4a77c 100644
--- a/vortex-scalar/src/tests/mod.rs
+++ b/vortex-scalar/src/tests/mod.rs
@@ -8,6 +8,7 @@ mod consistency;
 mod nested;
 mod nullability;
 mod primitives;
+mod proto;
 mod round_trip;
 
 use std::sync::LazyLock;
@@ -15,5 +16,10 @@ use std::sync::LazyLock;
 use vortex_dtype::session::DTypeSession;
 use vortex_session::VortexSession;
 
-pub(crate) static SESSION: LazyLock<VortexSession> =
-    LazyLock::new(|| VortexSession::empty().with::<DTypeSession>());
+use crate::session::ScalarSession;
+
+pub(crate) static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+    VortexSession::empty()
+        .with::<DTypeSession>()
+        .with::<ScalarSession>()
+});
diff --git a/vortex-scalar/src/tests/proto.rs b/vortex-scalar/src/tests/proto.rs
new file mode 100644
index 00000000000..e74d25e2379
--- /dev/null
+++ b/vortex-scalar/src/tests/proto.rs
@@ -0,0 +1,407 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::Arc;
+
+use vortex_buffer::BufferString;
+use vortex_buffer::ByteBuffer;
+use vortex_dtype::DType;
+use vortex_dtype::DecimalDType;
+use vortex_dtype::Nullability;
+use vortex_dtype::PType;
+use vortex_dtype::half::f16;
+use vortex_error::vortex_panic;
+use vortex_proto::scalar as pb;
+use vortex_proto::scalar::scalar_value::Kind;
+use vortex_session::VortexSession;
+
+use crate::DecimalValue;
+use crate::PValue;
+use crate::Scalar;
+use crate::ScalarValue;
+use crate::tests::SESSION;
+
+fn session() -> VortexSession {
+    VortexSession::empty()
+}
+
+fn round_trip(scalar: Scalar) {
+    assert_eq!(
+        scalar,
+        Scalar::from_proto(&pb::Scalar::from(&scalar), &session()).unwrap(),
+    );
+}
+
+#[test]
+fn test_null() {
+    round_trip(Scalar::null(DType::Null));
+}
+
+#[test]
+fn test_bool() {
+    round_trip(Scalar::new(
+        DType::Bool(Nullability::Nullable),
+        Some(ScalarValue::Bool(true)),
+    ));
+}
+
+#[test]
+fn test_primitive() {
+    round_trip(Scalar::new(
+        DType::Primitive(PType::I32, Nullability::Nullable),
+        Some(ScalarValue::Primitive(42i32.into())),
+    ));
+}
+
+#[test]
+fn test_buffer() {
+    round_trip(Scalar::new(
+        DType::Binary(Nullability::Nullable),
+        Some(ScalarValue::Binary(vec![1, 2, 3].into())),
+    ));
+}
+
+#[test]
+fn test_buffer_string() {
+    round_trip(Scalar::new(
+        DType::Utf8(Nullability::Nullable),
+        Some(ScalarValue::Utf8(BufferString::from("hello".to_string()))),
+    ));
+}
+
+#[test]
+fn test_list() {
+    round_trip(Scalar::new(
+        DType::List(
+            Arc::new(DType::Primitive(PType::I32, Nullability::Nullable)),
+            Nullability::Nullable,
+        ),
+        Some(ScalarValue::List(vec![
+            Some(ScalarValue::Primitive(42i32.into())),
+            Some(ScalarValue::Primitive(43i32.into())),
+        ])),
+    ));
+}
+
+#[test]
+fn test_f16() {
+    round_trip(Scalar::primitive(
+        f16::from_f32(0.42),
+        Nullability::Nullable,
+    ));
+}
+
+#[test]
+fn test_i8() {
+    round_trip(Scalar::new(
+        DType::Primitive(PType::I8, Nullability::Nullable),
+        Some(ScalarValue::Primitive(i8::MIN.into())),
+    ));
+
+    round_trip(Scalar::new(
+        DType::Primitive(PType::I8, Nullability::Nullable),
+        Some(ScalarValue::Primitive(0i8.into())),
+    ));
+
+    round_trip(Scalar::new(
+        DType::Primitive(PType::I8, Nullability::Nullable),
+        Some(ScalarValue::Primitive(i8::MAX.into())),
+    ));
+}
+
+#[test]
+fn test_decimal_i32_roundtrip() {
+    // A typical decimal with moderate precision and scale.
+    round_trip(Scalar::decimal(
+        DecimalValue::I32(123_456),
+        DecimalDType::new(10, 2),
+        Nullability::NonNullable,
+    ));
+}
+
+#[test]
+fn test_decimal_i128_roundtrip() {
+    // A large decimal value that requires i128 storage.
+    round_trip(Scalar::decimal(
+        DecimalValue::I128(99_999_999_999_999_999_999),
+        DecimalDType::new(38, 6),
+        Nullability::Nullable,
+    ));
+}
+
+#[test]
+fn test_decimal_null_roundtrip() {
+    round_trip(Scalar::null(DType::Decimal(
+        DecimalDType::new(10, 2),
+        Nullability::Nullable,
+    )));
+}
+
+#[test]
+fn test_scalar_value_serde_roundtrip_binary() {
+    round_trip(Scalar::binary(
+        ByteBuffer::copy_from(b"hello"),
+        Nullability::NonNullable,
+    ));
+}
+
+#[test]
+fn test_scalar_value_serde_roundtrip_utf8() {
+    round_trip(Scalar::utf8("hello", Nullability::NonNullable));
+}
+
+#[test]
+fn test_backcompat_f16_serialized_as_u64() {
+    // Backwards compatibility test for the legacy f16 serialization format.
+    //
+    // Previously, f16 ScalarValues were serialized as `Uint64Value(v.to_bits() as u64)` because
+    // the proto schema only had 64-bit integer types, and f16's underlying representation is
+    // u16 which got widened to u64.
+    //
+    // The current implementation uses a dedicated `F16Value` proto field, but we must still be
+    // able to deserialize the old format. This test verifies that:
+    //
+    // 1. A `Uint64Value` containing f16 bits can be read as a U64 primitive (the raw bits).
+    // 2. When wrapped in a Scalar with F16 dtype, the value is correctly interpreted as f16.
+    //
+    // This ensures data written with the old serialization format remains readable.
+
+    // Simulate the old serialization: f16(0.42) stored as Uint64Value with its bit pattern.
+    let f16_value = f16::from_f32(0.42);
+    let f16_bits_as_u64 = f16_value.to_bits() as u64; // 14008
+
+    let pb_scalar_value = pb::ScalarValue {
+        kind: Some(Kind::Uint64Value(f16_bits_as_u64)),
+    };
+
+    // Step 1: Verify the normal U64 scalar.
+    let scalar_value = ScalarValue::from_proto(
+        &pb_scalar_value,
+        &DType::Primitive(PType::U64, Nullability::NonNullable),
+        &SESSION,
+    )
+    .unwrap();
+    assert_eq!(
+        scalar_value.as_ref().map(|v| v.as_primitive()),
+        Some(&PValue::U64(14008u64)),
+    );
+
+    // Step 2: Verify that when we use F16 dtype, the Uint64Value is correctly interpreted.
+    let scalar_value_f16 = ScalarValue::from_proto(
+        &pb_scalar_value,
+        &DType::Primitive(PType::F16, Nullability::Nullable),
+        &SESSION,
+    )
+    .unwrap();
+
+    let scalar = Scalar::new(
+        DType::Primitive(PType::F16, Nullability::Nullable),
+        scalar_value_f16,
+    );
+
+    assert_eq!(
+        scalar.as_primitive().pvalue().unwrap(),
+        PValue::F16(f16::from_f32(0.42)),
+        "Uint64Value should be correctly interpreted as f16 when dtype is F16"
+    );
+}
+
+#[test]
+fn test_scalar_value_direct_roundtrip_f16() {
+    // Test that ScalarValue with f16 roundtrips correctly without going through Scalar.
+    let f16_values = vec![
+        f16::from_f32(0.0),
+        f16::from_f32(1.0),
+        f16::from_f32(-1.0),
+        f16::from_f32(0.42),
+        f16::from_f32(5.722046e-6),
+        f16::from_f32(std::f32::consts::PI),
+        f16::INFINITY,
+        f16::NEG_INFINITY,
+        f16::NAN,
+    ];
+
+    for f16_val in f16_values {
+        let scalar_value = ScalarValue::Primitive(PValue::F16(f16_val));
+        let pb_value = ScalarValue::to_proto(Some(&scalar_value));
+        let read_back = ScalarValue::from_proto(
+            &pb_value,
+            &DType::Primitive(PType::F16, Nullability::NonNullable),
+            &SESSION,
+        )
+        .unwrap();
+
+        match (&scalar_value, read_back.as_ref()) {
+            (
+                ScalarValue::Primitive(PValue::F16(original)),
+                Some(ScalarValue::Primitive(PValue::F16(roundtripped))),
+            ) => {
+                if original.is_nan() && roundtripped.is_nan() {
+                    // NaN values are equal for our purposes.
+                    continue;
+                }
+                assert_eq!(
+                    original, roundtripped,
+                    "F16 value {original:?} did not roundtrip correctly"
+                );
+            }
+            _ => {
+                vortex_panic!(
+                    "Expected f16 primitive values, got {scalar_value:?} and {read_back:?}"
+                )
+            }
+        }
+    }
+}
+
+#[test]
+fn test_scalar_value_direct_roundtrip_preserves_values() {
+    // Test that ScalarValue roundtripping preserves values (but not necessarily exact types).
+    // Note: Proto encoding consolidates integer types (u8/u16/u32 → u64, i8/i16/i32 → i64).
+
+    // Test cases that should roundtrip exactly.
+    let exact_roundtrip_cases: Vec<(&str, Option<ScalarValue>, DType)> = vec![
+        ("null", None, DType::Null),
+        (
+            "bool_true",
+            Some(ScalarValue::Bool(true)),
+            DType::Bool(Nullability::Nullable),
+        ),
+        (
+            "bool_false",
+            Some(ScalarValue::Bool(false)),
+            DType::Bool(Nullability::Nullable),
+        ),
+        (
+            "u64",
+            Some(ScalarValue::Primitive(PValue::U64(18446744073709551615))),
+            DType::Primitive(PType::U64, Nullability::Nullable),
+        ),
+        (
+            "i64",
+            Some(ScalarValue::Primitive(PValue::I64(-9223372036854775808))),
+            DType::Primitive(PType::I64, Nullability::Nullable),
+        ),
+        (
+            "f32",
+            Some(ScalarValue::Primitive(PValue::F32(std::f32::consts::E))),
+            DType::Primitive(PType::F32, Nullability::Nullable),
+        ),
+        (
+            "f64",
+            Some(ScalarValue::Primitive(PValue::F64(std::f64::consts::PI))),
+            DType::Primitive(PType::F64, Nullability::Nullable),
+        ),
+        (
+            "string",
+            Some(ScalarValue::Utf8(BufferString::from("test"))),
+            DType::Utf8(Nullability::Nullable),
+        ),
+        (
+            "bytes",
+            Some(ScalarValue::Binary(vec![1, 2, 3, 4, 5].into())),
+            DType::Binary(Nullability::Nullable),
+        ),
+    ];
+
+    for (name, value, dtype) in exact_roundtrip_cases {
+        let pb_value = ScalarValue::to_proto(value.as_ref());
+        let read_back = ScalarValue::from_proto(&pb_value, &dtype, &SESSION).unwrap();
+
+        let original_debug = format!("{value:?}");
+        let roundtrip_debug = format!("{read_back:?}");
+        assert_eq!(
+            original_debug, roundtrip_debug,
+            "ScalarValue {name} did not roundtrip exactly"
+        );
+    }
+
+    // Test cases where type changes but value is preserved.
+    // Unsigned integers consolidate to U64.
+    let unsigned_cases = vec![
+        (
+            "u8",
+            ScalarValue::Primitive(PValue::U8(255)),
+            DType::Primitive(PType::U8, Nullability::Nullable),
+            255u64,
+        ),
+        (
+            "u16",
+            ScalarValue::Primitive(PValue::U16(65535)),
+            DType::Primitive(PType::U16, Nullability::Nullable),
+            65535u64,
+        ),
+        (
+            "u32",
+            ScalarValue::Primitive(PValue::U32(4294967295)),
+            DType::Primitive(PType::U32, Nullability::Nullable),
+            4294967295u64,
+        ),
+    ];
+
+    for (name, value, dtype, expected) in unsigned_cases {
+        let pb_value = ScalarValue::to_proto(Some(&value));
+        let read_back = ScalarValue::from_proto(&pb_value, &dtype, &SESSION).unwrap();
+
+        match read_back.as_ref() {
+            Some(ScalarValue::Primitive(pv)) => {
+                let v = match pv {
+                    PValue::U8(v) => *v as u64,
+                    PValue::U16(v) => *v as u64,
+                    PValue::U32(v) => *v as u64,
+                    PValue::U64(v) => *v,
+                    _ => vortex_panic!("Unexpected primitive type for {name}: {pv:?}"),
+                };
+                assert_eq!(
+                    v, expected,
+                    "ScalarValue {name} value not preserved: expected {expected}, got {v}"
+                );
+            }
+            _ => vortex_panic!("Unexpected type after roundtrip for {name}: {read_back:?}"),
+        }
+    }
+
+    // Signed integers consolidate to I64.
+    let signed_cases = vec![
+        (
+            "i8",
+            ScalarValue::Primitive(PValue::I8(-128)),
+            DType::Primitive(PType::I8, Nullability::Nullable),
+            -128i64,
+        ),
+        (
+            "i16",
+            ScalarValue::Primitive(PValue::I16(-32768)),
+            DType::Primitive(PType::I16, Nullability::Nullable),
+            -32768i64,
+        ),
+        (
+            "i32",
+            ScalarValue::Primitive(PValue::I32(-2147483648)),
+            DType::Primitive(PType::I32, Nullability::Nullable),
+            -2147483648i64,
+        ),
+    ];
+
+    for (name, value, dtype, expected) in signed_cases {
+        let pb_value = ScalarValue::to_proto(Some(&value));
+        let read_back = ScalarValue::from_proto(&pb_value, &dtype, &SESSION).unwrap();
+
+        match read_back.as_ref() {
+            Some(ScalarValue::Primitive(pv)) => {
+                let v = match pv {
+                    PValue::I8(v) => *v as i64,
+                    PValue::I16(v) => *v as i64,
+                    PValue::I32(v) => *v as i64,
+                    PValue::I64(v) => *v,
+                    _ => vortex_panic!("Unexpected primitive type for {name}: {pv:?}"),
+                };
+                assert_eq!(
+                    v, expected,
+                    "ScalarValue {name} value not preserved: expected {expected}, got {v}"
+                );
+            }
+            _ => vortex_panic!("Unexpected type after roundtrip for {name}: {read_back:?}"),
+        }
+    }
+}
diff --git a/vortex-scalar/src/typed_view/ext.rs b/vortex-scalar/src/typed_view/ext.rs
new file mode 100644
index 00000000000..baaa3e12bb7
--- /dev/null
+++ b/vortex-scalar/src/typed_view/ext.rs
@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! [`ExtScalar`] typed view implementation.
+
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+use vortex_dtype::DType;
+use vortex_dtype::extension::ExtDTypeRef;
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_error::vortex_err;
+
+use crate::Scalar;
+use crate::ScalarValue;
+use crate::extension::ExtScalarValueRef;
+use crate::extension::Matcher;
+
+/// A scalar value representing an extension type.
+///
+/// Extension types allow wrapping a storage type with custom semantics.
+#[derive(Debug, Clone)]
+pub struct ExtScalar<'a> {
+    /// The dtype reference TODO better docs.
+    dtype: &'a DType,
+
+    /// The extension data type reference.
+    ext_dtype: &'a ExtDTypeRef,
+
+    /// The underlying downcasted extension, or [`None`] if null.
+    ext_value: Option<&'a ExtScalarValueRef>,
+}
+
+impl<'a> ExtScalar<'a> {
+    /// TODO docs.
+    ///
+    /// # Errors
+    ///
+    /// TODO errors.
+    pub fn try_new(dtype: &'a DType, value: Option<&'a ScalarValue>) -> VortexResult<Self> {
+        let ext_dtype = dtype
+            .as_extension_opt()
+            .ok_or_else(|| vortex_err!("Cannot create an ExtScalar with a non-extension dtype"))?;
+
+        let ext_value = value
+            .map(|value| {
+                value.as_extension_opt().ok_or_else(|| {
+                    vortex_err!("Cannot create an ExtScalar with a non-extension scalar value")
+                })
+            })
+            .transpose()?;
+
+        Ok(Self {
+            dtype,
+            ext_dtype,
+            ext_value,
+        })
+    }
+
+    /// Return the dtype of the extension scalar.
+    pub fn dtype(&self) -> &DType {
+        self.dtype
+    }
+
+    /// Return the type-erased dtype of the extension scalar.
+    pub fn ext_dtype(&self) -> &ExtDTypeRef {
+        self.ext_dtype
+    }
+
+    /// Return the typed-erased storage scalar value of the extension scalar.
+    pub fn ext_value(&self) -> Option<&ExtScalarValueRef> {
+        self.ext_value
+    }
+
+    /// Match on the extension type and extract an underlying value.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the matcher fails.
+    pub fn as_value<M: Matcher>(&self) -> M::Match<'_> {
+        self.as_value_opt::<M>()
+            .vortex_expect("Failed to match extension scalar value")
+    }
+
+    /// Match on the extension type and extract an underlying value.
+    pub fn as_value_opt<M: Matcher>(&self) -> Option<M::Match<'_>> {
+        M::try_match(self)
+    }
+
+    /// Return the underlying storage value.
+    pub fn storage_value(&self) -> Option<&ScalarValue> {
+        self.ext_value.as_ref().map(|s| s.storage_value())
+    }
+
+    /// Convert the underlying storage value into a standard [`Scalar`] that has a [`DType`] equal
+    /// to this [`ExtScalar`]'s storage type.
+    pub fn to_storage_scalar(&self) -> Scalar {
+        let storage_value = self.ext_value.as_ref().map(|s| s.storage_value()).cloned();
+
+        unsafe { Scalar::new_unchecked(self.ext_dtype.storage_dtype().clone(), storage_value) }
+    }
+
+    // TODO(connor): This is somewhat naive behavior...
+    /// Casts this scalar to the given `dtype`.
+    pub(crate) fn cast(&self, dtype: &DType) -> VortexResult<Scalar> {
+        if self.ext_value.is_none() && !dtype.is_nullable() {
+            vortex_bail!(
+                "cannot cast extension dtype with id {} and storage type {} to {}",
+                self.ext_dtype.id(),
+                self.ext_dtype.storage_dtype(),
+                dtype
+            );
+        }
+
+        if self.ext_dtype.storage_dtype().eq_ignore_nullability(dtype) {
+            // Casting from an extension type to the underlying storage type is OK.
+            return Scalar::try_new(dtype.clone(), self.storage_value().cloned());
+        }
+
+        if let DType::Extension(ext_dtype) = dtype
+            && self.ext_dtype.eq_ignore_nullability(ext_dtype)
+        {
+            return Scalar::try_new(dtype.clone(), self.storage_value().cloned());
+        }
+
+        vortex_bail!(
+            "cannot cast extension dtype with id {} and storage type {} to {}",
+            self.ext_dtype.id(),
+            self.ext_dtype.storage_dtype(),
+            dtype
+        );
+    }
+}
+
+impl Display for ExtScalar<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self.ext_value.as_ref() {
+            Some(scalar) => scalar.fmt_ext_scalar(self.ext_dtype, f),
+            None => write!(f, "null"),
+        }
+    }
+}
diff --git a/vortex-scalar/src/typed_view/extension/mod.rs b/vortex-scalar/src/typed_view/extension/mod.rs
deleted file mode 100644
index 937b5cdd9d6..00000000000
--- a/vortex-scalar/src/typed_view/extension/mod.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-//! [`ExtScalar`] typed view implementation.
-
-use std::fmt::Display;
-use std::fmt::Formatter;
-use std::hash::Hash;
-
-use vortex_dtype::DType;
-use vortex_dtype::datetime::AnyTemporal;
-use vortex_dtype::extension::ExtDTypeRef;
-use vortex_error::VortexExpect;
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-
-use crate::Scalar;
-use crate::ScalarValue;
-
-/// A scalar value representing an extension type.
-///
-/// Extension types allow wrapping a storage type with custom semantics.
-#[derive(Debug, Clone)]
-pub struct ExtScalar<'a> {
-    /// A reference to the `DType` of the extension type. This **must** be the [`DType::Extension`
-    /// variant.
-    dtype: &'a DType,
-
-    /// The extension data type reference.
-    ext_dtype: &'a ExtDTypeRef,
-
-    /// The underlying scalar value, or [`None`] if null.
-    value: Option<&'a ScalarValue>,
-}
-
-impl Display for ExtScalar<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        // Specialized handling for date/time/timestamp builtin extension types.
-        if let Some(temporal) = self.ext_dtype.metadata_opt::<AnyTemporal>() {
-            let maybe_timestamp = self
-                .to_storage_scalar()
-                .as_primitive()
-                .as_::<i64>()
-                .map(|maybe_timestamp| temporal.to_jiff(maybe_timestamp))
-                .transpose()
-                .map_err(|_| std::fmt::Error)?;
-
-            match maybe_timestamp {
-                None => write!(f, "null"),
-                Some(v) => write!(f, "{v}"),
-            }
-        } else {
-            write!(f, "{}({})", self.ext_dtype().id(), self.to_storage_scalar())
-        }
-    }
-}
-
-impl PartialEq for ExtScalar<'_> {
-    fn eq(&self, other: &Self) -> bool {
-        self.ext_dtype.eq_ignore_nullability(other.ext_dtype)
-            && self.to_storage_scalar() == other.to_storage_scalar()
-    }
-}
-
-impl Eq for ExtScalar<'_> {}
-
-// Ord is not implemented since it's undefined for different Extension DTypes
-impl PartialOrd for ExtScalar<'_> {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        if !self.ext_dtype.eq_ignore_nullability(other.ext_dtype) {
-            return None;
-        }
-        self.to_storage_scalar()
-            .partial_cmp(&other.to_storage_scalar())
-    }
-}
-
-impl Hash for ExtScalar<'_> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.ext_dtype.hash(state);
-        self.to_storage_scalar().hash(state);
-    }
-}
-
-impl<'a> ExtScalar<'a> {
-    // TODO(connor): This should really be validating the data on construction!!!
-    /// Creates a new extension scalar from a data type and scalar value.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the data type is not an extension type.
-    pub fn try_new(dtype: &'a DType, value: Option<&'a ScalarValue>) -> VortexResult<Self> {
-        let DType::Extension(ext_dtype) = dtype else {
-            vortex_bail!("Expected extension scalar, found {}", dtype)
-        };
-
-        Ok(Self {
-            dtype,
-            ext_dtype,
-            value,
-        })
-    }
-
-    /// Returns the storage scalar of the extension scalar.
-    pub fn to_storage_scalar(&self) -> Scalar {
-        Scalar::try_new(self.ext_dtype.storage_dtype().clone(), self.value.cloned())
-            .vortex_expect("ExtScalar is invalid")
-    }
-
-    /// Return the [`DType`] of the extension scalar.
-    pub fn dtype(&self) -> &DType {
-        self.dtype
-    }
-
-    /// Returns the extension data type.
-    pub fn ext_dtype(&self) -> &'a ExtDTypeRef {
-        self.ext_dtype
-    }
-
-    /// Casts this scalar to the given `dtype`.
-    pub(crate) fn cast(&self, dtype: &DType) -> VortexResult<Scalar> {
-        if self.value.is_none() && !dtype.is_nullable() {
-            vortex_bail!(
-                "cannot cast extension dtype with id {} and storage type {} to {}",
-                self.ext_dtype.id(),
-                self.ext_dtype.storage_dtype(),
-                dtype
-            );
-        }
-
-        if self.ext_dtype.storage_dtype().eq_ignore_nullability(dtype) {
-            // Casting from an extension type to the underlying storage type is OK.
-            return Scalar::try_new(dtype.clone(), self.value.cloned());
-        }
-
-        if let DType::Extension(ext_dtype) = dtype
-            && self.ext_dtype.eq_ignore_nullability(ext_dtype)
-        {
-            return Scalar::try_new(dtype.clone(), self.value.cloned());
-        }
-
-        vortex_bail!(
-            "cannot cast extension dtype with id {} and storage type {} to {}",
-            self.ext_dtype.id(),
-            self.ext_dtype.storage_dtype(),
-            dtype
-        );
-    }
-}
-
-#[cfg(test)]
-mod tests;
diff --git a/vortex-scalar/src/typed_view/extension/tests.rs b/vortex-scalar/src/typed_view/extension/tests.rs
deleted file mode 100644
index 737eddaad15..00000000000
--- a/vortex-scalar/src/typed_view/extension/tests.rs
+++ /dev/null
@@ -1,293 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use vortex_dtype::DType;
-use vortex_dtype::ExtDType;
-use vortex_dtype::ExtID;
-use vortex_dtype::Nullability;
-use vortex_dtype::PType;
-use vortex_dtype::extension::EmptyMetadata;
-use vortex_dtype::extension::ExtDTypeVTable;
-use vortex_error::VortexResult;
-
-use crate::ExtScalar;
-use crate::PValue;
-use crate::Scalar;
-use crate::ScalarValue;
-
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-struct TestI32Ext;
-impl ExtDTypeVTable for TestI32Ext {
-    type Metadata = EmptyMetadata;
-
-    fn id(&self) -> ExtID {
-        ExtID::new_ref("test_ext")
-    }
-
-    fn validate_dtype(
-        &self,
-        _options: &Self::Metadata,
-        _storage_dtype: &DType,
-    ) -> VortexResult<()> {
-        Ok(())
-    }
-}
-
-impl TestI32Ext {
-    fn new_non_nullable() -> ExtDType<TestI32Ext> {
-        ExtDType::try_new(
-            EmptyMetadata,
-            DType::Primitive(PType::I32, Nullability::NonNullable),
-        )
-        .unwrap()
-    }
-}
-
-#[test]
-fn test_ext_scalar_equality() {
-    let scalar1 = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata,
-        Scalar::primitive(42i32, Nullability::NonNullable),
-    );
-    let scalar2 = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata,
-        Scalar::primitive(42i32, Nullability::NonNullable),
-    );
-    let scalar3 = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata,
-        Scalar::primitive(43i32, Nullability::NonNullable),
-    );
-
-    let ext1 = scalar1.as_extension();
-    let ext2 = scalar2.as_extension();
-    let ext3 = scalar3.as_extension();
-
-    assert_eq!(ext1, ext2);
-    assert_ne!(ext1, ext3);
-}
-
-#[test]
-fn test_ext_scalar_partial_ord() {
-    let scalar1 = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata,
-        Scalar::primitive(10i32, Nullability::NonNullable),
-    );
-    let scalar2 = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata,
-        Scalar::primitive(20i32, Nullability::NonNullable),
-    );
-
-    let ext1 = scalar1.as_extension();
-    let ext2 = scalar2.as_extension();
-
-    assert!(ext1 < ext2);
-    assert!(ext2 > ext1);
-}
-
-#[test]
-fn test_ext_scalar_partial_ord_different_types() {
-    #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-    struct TestExt2;
-    impl ExtDTypeVTable for TestExt2 {
-        type Metadata = EmptyMetadata;
-
-        fn id(&self) -> ExtID {
-            ExtID::new_ref("test_ext_2")
-        }
-
-        fn validate_dtype(
-            &self,
-            _options: &Self::Metadata,
-            _storage_dtype: &DType,
-        ) -> VortexResult<()> {
-            Ok(())
-        }
-    }
-
-    let scalar1 = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata,
-        Scalar::primitive(10i32, Nullability::NonNullable),
-    );
-    let scalar2 = Scalar::extension::<TestExt2>(
-        EmptyMetadata,
-        Scalar::primitive(20i32, Nullability::NonNullable),
-    );
-
-    let ext1 = scalar1.as_extension();
-    let ext2 = scalar2.as_extension();
-
-    // Different extension types should not be comparable
-    assert_eq!(ext1.partial_cmp(&ext2), None);
-}
-
-#[test]
-fn test_ext_scalar_hash() {
-    use vortex_utils::aliases::hash_set::HashSet;
-
-    let scalar1 = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata,
-        Scalar::primitive(42i32, Nullability::NonNullable),
-    );
-    let scalar2 = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata,
-        Scalar::primitive(42i32, Nullability::NonNullable),
-    );
-
-    let mut set = HashSet::new();
-    set.insert(scalar2);
-    set.insert(scalar1);
-
-    // Same value should hash the same
-    assert_eq!(set.len(), 1);
-
-    // Different value should hash differently
-    let scalar3 = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata,
-        Scalar::primitive(43i32, Nullability::NonNullable),
-    );
-    set.insert(scalar3);
-    assert_eq!(set.len(), 2);
-}
-
-#[test]
-fn test_ext_scalar_storage() {
-    let storage_scalar = Scalar::primitive(42i32, Nullability::NonNullable);
-    let ext_scalar = Scalar::extension::<TestI32Ext>(EmptyMetadata, storage_scalar.clone());
-
-    let ext = ext_scalar.as_extension();
-    assert_eq!(ext.to_storage_scalar(), storage_scalar);
-}
-
-#[test]
-fn test_ext_scalar_ext_dtype() {
-    let ext_dtype = TestI32Ext::new_non_nullable();
-    let scalar = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata.clone(),
-        Scalar::primitive(42i32, Nullability::NonNullable),
-    );
-
-    let ext = scalar.as_extension();
-    assert_eq!(ext.ext_dtype().id(), ext_dtype.id());
-    assert_eq!(ext.ext_dtype(), &ext_dtype.erased());
-}
-
-#[test]
-fn test_ext_scalar_cast_to_storage() {
-    let scalar = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata,
-        Scalar::primitive(42i32, Nullability::NonNullable),
-    );
-
-    let ext = scalar.as_extension();
-
-    // Cast to storage type
-    let casted = ext
-        .cast(&DType::Primitive(PType::I32, Nullability::NonNullable))
-        .unwrap();
-    assert_eq!(
-        casted.dtype(),
-        &DType::Primitive(PType::I32, Nullability::NonNullable)
-    );
-    assert_eq!(casted.as_primitive().typed_value::<i32>(), Some(42));
-
-    // Cast to nullable storage type
-    let casted_nullable = ext
-        .cast(&DType::Primitive(PType::I32, Nullability::Nullable))
-        .unwrap();
-    assert_eq!(
-        casted_nullable.dtype(),
-        &DType::Primitive(PType::I32, Nullability::Nullable)
-    );
-    assert_eq!(
-        casted_nullable.as_primitive().typed_value::<i32>(),
-        Some(42)
-    );
-}
-
-#[test]
-fn test_ext_scalar_cast_to_self() {
-    let ext_dtype = TestI32Ext::new_non_nullable();
-
-    let scalar = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata,
-        Scalar::primitive(42i32, Nullability::NonNullable),
-    );
-
-    let ext = scalar.as_extension();
-    let ext_dtype = ext_dtype.erased();
-
-    // Cast to same extension type
-    let casted = ext.cast(&DType::Extension(ext_dtype.clone())).unwrap();
-    assert_eq!(casted.dtype(), &DType::Extension(ext_dtype.clone()));
-
-    // Cast to nullable version of same extension type
-    let nullable_ext = DType::Extension(ext_dtype).as_nullable();
-    let casted_nullable = ext.cast(&nullable_ext).unwrap();
-    assert_eq!(casted_nullable.dtype(), &nullable_ext);
-}
-
-#[test]
-fn test_ext_scalar_cast_incompatible() {
-    let scalar = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata,
-        Scalar::primitive(42i32, Nullability::NonNullable),
-    );
-
-    let ext = scalar.as_extension();
-
-    // Cast to incompatible type should fail
-    let result = ext.cast(&DType::Utf8(Nullability::NonNullable));
-    assert!(result.is_err());
-}
-
-#[test]
-fn test_ext_scalar_cast_null_to_non_nullable() {
-    let scalar = Scalar::extension::<TestI32Ext>(
-        EmptyMetadata,
-        Scalar::null(DType::Primitive(PType::I32, Nullability::Nullable)),
-    );
-
-    let ext = scalar.as_extension();
-
-    // Cast null to non-nullable should fail
-    let result = ext.cast(&DType::Primitive(PType::I32, Nullability::NonNullable));
-    assert!(result.is_err());
-}
-
-#[test]
-fn test_ext_scalar_try_new_non_extension() {
-    let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
-    let value = ScalarValue::Primitive(PValue::I32(42));
-
-    let result = ExtScalar::try_new(&dtype, Some(&value));
-    assert!(result.is_err());
-}
-
-#[test]
-fn test_ext_scalar_with_metadata() {
-    #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-    struct TestExtMetadata;
-    impl ExtDTypeVTable for TestExtMetadata {
-        type Metadata = usize;
-
-        fn id(&self) -> ExtID {
-            ExtID::new_ref("test_ext_metadata")
-        }
-
-        fn validate_dtype(
-            &self,
-            _options: &Self::Metadata,
-            _storage_dtype: &DType,
-        ) -> VortexResult<()> {
-            Ok(())
-        }
-    }
-
-    let scalar = Scalar::extension::<TestExtMetadata>(
-        1234,
-        Scalar::primitive(42i32, Nullability::NonNullable),
-    );
-
-    let ext = scalar.as_extension();
-    assert_eq!(ext.ext_dtype().metadata::<TestExtMetadata>(), &1234);
-}
diff --git a/vortex-scalar/src/typed_view/mod.rs b/vortex-scalar/src/typed_view/mod.rs
index 067e3a4d4a5..3d5869006bc 100644
--- a/vortex-scalar/src/typed_view/mod.rs
+++ b/vortex-scalar/src/typed_view/mod.rs
@@ -18,7 +18,7 @@
 mod binary;
 mod bool;
 mod decimal;
-mod extension;
+mod ext;
 mod list;
 mod primitive;
 mod struct_;
@@ -27,7 +27,7 @@ mod utf8;
 pub use binary::*;
 pub use bool::*;
 pub use decimal::*;
-pub use extension::*;
+pub use ext::*;
 pub use list::*;
 pub use primitive::*;
 pub use struct_::*;
diff --git a/vortex-scalar/src/typed_view/primitive/scalar.rs b/vortex-scalar/src/typed_view/primitive/scalar.rs
index da2fa8ccd12..63666c9fb99 100644
--- a/vortex-scalar/src/typed_view/primitive/scalar.rs
+++ b/vortex-scalar/src/typed_view/primitive/scalar.rs
@@ -75,6 +75,7 @@ impl PartialOrd for PrimitiveScalar<'_> {
 }
 
 impl<'a> PrimitiveScalar<'a> {
+    // TODO(connor): This panics if the value is not a primitive value.
     /// Creates a new primitive scalar from a data type and scalar value.
     ///
     /// # Errors

From 3c9309acb3c80605e8453e807ca0a77b1f02cbe8 Mon Sep 17 00:00:00 2001
From: Connor Tsui <connor.tsui20@gmail.com>
Date: Mon, 16 Feb 2026 09:41:37 +0000
Subject: [PATCH 2/2] rename some things

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>
---
 vortex-scalar/src/constructor.rs            | 13 ++++++++-----
 vortex-scalar/src/extension/scalar_value.rs | 19 +++----------------
 vortex-scalar/src/extension/vtable.rs       |  4 ++--
 vortex-scalar/src/scalar.rs                 | 19 +++++++++----------
 vortex-scalar/src/scalar_value.rs           |  3 +--
 vortex-scalar/src/typed_view/ext.rs         |  6 +++---
 6 files changed, 26 insertions(+), 38 deletions(-)

diff --git a/vortex-scalar/src/constructor.rs b/vortex-scalar/src/constructor.rs
index 48a983a5f24..69dd0e35365 100644
--- a/vortex-scalar/src/constructor.rs
+++ b/vortex-scalar/src/constructor.rs
@@ -183,10 +183,13 @@ impl Scalar {
     ///
     /// Panics if the storage dtype is incompatible with the extension type, or if the storage
     /// value fails validation.
-    pub fn extension<V: ExtScalarVTable + Default>(metadata: V::Metadata, value: Scalar) -> Self {
-        let ext_dtype = ExtDType::<V>::try_new(metadata, value.dtype().clone())
+    pub fn extension<V: ExtScalarVTable + Default>(
+        metadata: V::Metadata,
+        storage_scalar: Scalar,
+    ) -> Self {
+        let ext_dtype = ExtDType::<V>::try_new(metadata, storage_scalar.dtype().clone())
             .vortex_expect("Failed to create extension dtype");
-        let storage_value = value.into_value();
+        let storage_value = storage_scalar.into_value();
 
         let ext_value = storage_value.map(|sv| {
             let owned = ExtScalarValue::<V>::try_new(ext_dtype.clone(), sv)
@@ -201,10 +204,10 @@ impl Scalar {
     /// TODO docs.
     pub fn extension_ref(
         ext_dtype: ExtDTypeRef,
-        value: Scalar,
+        storage_scalar: Scalar,
         session: &VortexSession,
     ) -> VortexResult<Self> {
-        let (storage_dtype, storage_value) = value.into_parts();
+        let (storage_dtype, storage_value) = storage_scalar.into_parts();
         Self::extension_ref_from_value(ext_dtype, &storage_dtype, storage_value, session)
     }
 
diff --git a/vortex-scalar/src/extension/scalar_value.rs b/vortex-scalar/src/extension/scalar_value.rs
index 43f6871f8ef..22eb1e45f77 100644
--- a/vortex-scalar/src/extension/scalar_value.rs
+++ b/vortex-scalar/src/extension/scalar_value.rs
@@ -50,7 +50,7 @@ use crate::extension::ExtScalarVTable;
 /// [`try_downcast`]: ExtScalarValueRef::try_downcast
 /// [`downcast`]: ExtScalarValueRef::downcast
 #[derive(Clone)]
-pub struct ExtScalarValueRef(Arc<dyn ExtScalarValueAdapterImpl>);
+pub struct ExtScalarValueRef(Arc<dyn DynExtScalarValue>);
 
 /// A typed extension scalar value, parameterized by a concrete [`ExtScalarVTable`].
 ///
@@ -80,7 +80,7 @@ struct ExtScalarValueAdapter<V: ExtScalarVTable> {
     storage: ScalarValue,
 }
 
-impl<V: ExtScalarVTable> ExtScalarValueAdapterImpl for ExtScalarValueAdapter<V> {
+impl<V: ExtScalarVTable> DynExtScalarValue for ExtScalarValueAdapter<V> {
     fn as_any(&self) -> &dyn Any {
         self
     }
@@ -262,19 +262,6 @@ impl<V: ExtScalarVTable> ExtScalarValue<V> {
         self.0.storage_value()
     }
 
-    /// Formats the extension scalar using the provided [`ExtDTypeRef`] for metadata context.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the underlying [`fmt::Write`] operation fails.
-    pub fn fmt_ext_scalar(
-        &self,
-        ext_dtype: &ExtDTypeRef,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        self.0.fmt_ext_scalar(ext_dtype, f)
-    }
-
     // pub(crate) fn cast(&self, dtype: &DType) -> VortexResult<Scalar> {
     //     if self.value.is_none() && !dtype.is_nullable() {
     //         vortex_bail!(
@@ -361,7 +348,7 @@ mod sealed {
 /// [`ExtScalarValueAdapter`].
 ///
 /// [`ExtDTypeImpl`]: vortex_dtype::extension
-trait ExtScalarValueAdapterImpl: sealed::Sealed + 'static + Send + Sync {
+trait DynExtScalarValue: sealed::Sealed + 'static + Send + Sync {
     /// Returns `self` as a trait object for downcasting.
     fn as_any(&self) -> &dyn Any;
     /// Returns the [`ExtID`] identifying this extension type.
diff --git a/vortex-scalar/src/extension/vtable.rs b/vortex-scalar/src/extension/vtable.rs
index cd428bd0d7b..214e4f8c562 100644
--- a/vortex-scalar/src/extension/vtable.rs
+++ b/vortex-scalar/src/extension/vtable.rs
@@ -64,7 +64,7 @@ pub trait DynExtScalarVTable: 'static + Send + Sync + Debug {
     /// # Errors
     ///
     /// Returns an error if the storage value is not compatible with the extension type.
-    fn create_ext_scalar_value_ref(
+    fn build(
         &self,
         ext_dtype: ExtDTypeRef,
         storage: ScalarValue,
@@ -76,7 +76,7 @@ impl<V: ExtScalarVTable> DynExtScalarVTable for V {
         ExtDTypeVTable::id(self)
     }
 
-    fn create_ext_scalar_value_ref(
+    fn build(
         &self,
         ext_dtype: ExtDTypeRef,
         storage: ScalarValue,
diff --git a/vortex-scalar/src/scalar.rs b/vortex-scalar/src/scalar.rs
index d5b53056563..aa2ae2604e6 100644
--- a/vortex-scalar/src/scalar.rs
+++ b/vortex-scalar/src/scalar.rs
@@ -10,6 +10,7 @@ use std::hash::Hasher;
 use vortex_dtype::DType;
 use vortex_dtype::NativeDType;
 use vortex_dtype::PType;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
@@ -116,11 +117,14 @@ impl Scalar {
     /// The caller must ensure that the given [`DType`] and [`ScalarValue`] are compatible per the
     /// rules defined in [`Self::is_compatible`].
     pub unsafe fn new_unchecked(dtype: DType, value: Option<ScalarValue>) -> Self {
-        debug_assert!(
-            Self::is_compatible(&dtype, value.as_ref()),
-            "Incompatible dtype {dtype} with value {}",
-            value.map(|v| format!("{}", v)).unwrap_or_default()
-        );
+        #[cfg(debug_assertions)]
+        if let Err(e) = Self::validate(&dtype, value.as_ref()) {
+            let value_str = value
+                .as_ref()
+                .map(|v| format!("{}", v))
+                .unwrap_or_else(|| "none".to_string());
+            vortex_panic!("Incompatible dtype {dtype} with value {value_str}: {e}");
+        }
 
         Self { dtype, value }
     }
@@ -274,11 +278,6 @@ impl Scalar {
         Ok(())
     }
 
-    /// Check if the given [`ScalarValue`] is compatible with the given [`DType`].
-    pub fn is_compatible(dtype: &DType, value: Option<&ScalarValue>) -> bool {
-        Self::validate(dtype, value).is_ok()
-    }
-
     /// Check if two scalars are equal, ignoring nullability of the [`DType`].
     pub fn eq_ignore_nullability(&self, other: &Self) -> bool {
         self.dtype.eq_ignore_nullability(&other.dtype) && self.value == other.value
diff --git a/vortex-scalar/src/scalar_value.rs b/vortex-scalar/src/scalar_value.rs
index f94e68b00dc..c12f902f1aa 100644
--- a/vortex-scalar/src/scalar_value.rs
+++ b/vortex-scalar/src/scalar_value.rs
@@ -156,8 +156,7 @@ impl ScalarValue {
                 )
             })?;
 
-        let ext_value =
-            dyn_scalar_vtable.create_ext_scalar_value_ref(ext_dtype.clone(), storage_value)?;
+        let ext_value = dyn_scalar_vtable.build(ext_dtype.clone(), storage_value)?;
 
         Ok(ScalarValue::Extension(ext_value))
     }
diff --git a/vortex-scalar/src/typed_view/ext.rs b/vortex-scalar/src/typed_view/ext.rs
index baaa3e12bb7..4c0b31b64db 100644
--- a/vortex-scalar/src/typed_view/ext.rs
+++ b/vortex-scalar/src/typed_view/ext.rs
@@ -23,13 +23,13 @@ use crate::extension::Matcher;
 /// Extension types allow wrapping a storage type with custom semantics.
 #[derive(Debug, Clone)]
 pub struct ExtScalar<'a> {
-    /// The dtype reference TODO better docs.
+    /// The dtype reference..
     dtype: &'a DType,
 
-    /// The extension data type reference.
+    /// The extension dtype reference.
     ext_dtype: &'a ExtDTypeRef,
 
-    /// The underlying downcasted extension, or [`None`] if null.
+    /// The underlying erased extension value, or [`None`] if null.
     ext_value: Option<&'a ExtScalarValueRef>,
 }