diff --git a/encodings/alp/src/alp/compute/filter.rs b/encodings/alp/src/alp/compute/filter.rs
index 97b5b4af49e..f38a87f19b0 100644
--- a/encodings/alp/src/alp/compute/filter.rs
+++ b/encodings/alp/src/alp/compute/filter.rs
@@ -44,8 +44,8 @@ mod test {
     use rstest::rstest;
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::filter::test_filter_conformance;
     use vortex_buffer::buffer;
@@ -62,7 +62,7 @@ mod test {
         11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0
     ].into_array())]
     fn test_filter_alp_conformance(#[case] array: ArrayRef) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array_primitive = array.execute::<PrimitiveArray>(&mut ctx).unwrap();
         let alp = alp_encode(array_primitive.as_view(), None, &mut ctx).unwrap();
         test_filter_conformance(&alp.into_array());
diff --git a/encodings/alp/src/alp/compute/mask.rs b/encodings/alp/src/alp/compute/mask.rs
index 31f131f6e0c..b117ac216d0 100644
--- a/encodings/alp/src/alp/compute/mask.rs
+++ b/encodings/alp/src/alp/compute/mask.rs
@@ -56,8 +56,8 @@ impl MaskKernel for ALP {
 mod test {
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::mask::test_mask_conformance;
@@ -78,7 +78,7 @@ mod test {
         1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0
     ].into_array())]
     fn test_mask_alp_conformance(#[case] array: vortex_array::ArrayRef) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array_primitive = array.execute::<PrimitiveArray>(&mut ctx).unwrap();
         let alp = alp_encode(array_primitive.as_view(), None, &mut ctx).unwrap();
         test_mask_conformance(&alp.into_array());
@@ -87,7 +87,7 @@ mod test {
     #[test]
     fn test_mask_alp_with_patches() {
         use std::f64::consts::PI;
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // PI doesn't encode cleanly with ALP, so it creates patches.
         let values: Vec<f64> = (0..100)
             .map(|i| if i % 4 == 3 { PI } else { 1.0 })
@@ -100,7 +100,7 @@ mod test {
 
     #[test]
     fn test_mask_alp_with_patches_casts_surviving_patch_values_to_nullable() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let values = PrimitiveArray::from_iter([1.234f32, f32::NAN, 2.345, f32::INFINITY, 3.456]);
         let alp = alp_encode(values.as_view(), None, &mut ctx).unwrap();
         assert!(alp.patches().is_some(), "expected patches");
diff --git a/encodings/alp/src/alp/compute/mod.rs b/encodings/alp/src/alp/compute/mod.rs
index e5e5b657740..83a6c667893 100644
--- a/encodings/alp/src/alp/compute/mod.rs
+++ b/encodings/alp/src/alp/compute/mod.rs
@@ -12,41 +12,50 @@ mod take;
 
 #[cfg(test)]
 mod tests {
+    use std::sync::LazyLock;
+
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
+    use vortex_session::VortexSession;
 
     use crate::ALPArray;
     use crate::alp_encode;
 
+    static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+        let session = array_session();
+        crate::initialize(&session);
+        session
+    });
+
     #[rstest]
     // Basic float arrays
-    #[case::f32_array(alp_encode(PrimitiveArray::from_iter([1.23f32, 4.56, 7.89, 10.11, 12.13]).as_view(), None, &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
-    #[case::f64_array(alp_encode(PrimitiveArray::from_iter([100.1f64, 200.2, 300.3, 400.4, 500.5]).as_view(), None, &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
+    #[case::f32_array(alp_encode(PrimitiveArray::from_iter([1.23f32, 4.56, 7.89, 10.11, 12.13]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())]
+    #[case::f64_array(alp_encode(PrimitiveArray::from_iter([100.1f64, 200.2, 300.3, 400.4, 500.5]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())]
     // Nullable arrays
-    #[case::nullable_f32(alp_encode(PrimitiveArray::from_option_iter([Some(1.1f32), None, Some(2.2), Some(3.3), None]).as_view(), None, &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
-    #[case::nullable_f64(alp_encode(PrimitiveArray::from_option_iter([Some(1.1f64), None, Some(2.2), Some(3.3), None]).as_view(), None, &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
+    #[case::nullable_f32(alp_encode(PrimitiveArray::from_option_iter([Some(1.1f32), None, Some(2.2), Some(3.3), None]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())]
+    #[case::nullable_f64(alp_encode(PrimitiveArray::from_option_iter([Some(1.1f64), None, Some(2.2), Some(3.3), None]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())]
     // Edge cases
-    #[case::single_element(alp_encode(PrimitiveArray::from_iter([42.42f64]).as_view(), None, &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
+    #[case::single_element(alp_encode(PrimitiveArray::from_iter([42.42f64]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())]
     // Large arrays
-    #[case::large_f32(alp_encode(PrimitiveArray::from_iter((0..1000).map(|i| i as f32 * 0.1)).as_view(), None, &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
+    #[case::large_f32(alp_encode(PrimitiveArray::from_iter((0..1000).map(|i| i as f32 * 0.1)).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())]
     // Arrays with patterns
-    #[case::repeating_pattern(alp_encode(PrimitiveArray::from_iter([1.1f32, 2.2, 3.3, 1.1, 2.2, 3.3, 1.1, 2.2, 3.3]).as_view(), None, &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
-    #[case::close_values(alp_encode(PrimitiveArray::from_iter([100.001f64, 100.002, 100.003, 100.004, 100.005]).as_view(), None, &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
+    #[case::repeating_pattern(alp_encode(PrimitiveArray::from_iter([1.1f32, 2.2, 3.3, 1.1, 2.2, 3.3, 1.1, 2.2, 3.3]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())]
+    #[case::close_values(alp_encode(PrimitiveArray::from_iter([100.001f64, 100.002, 100.003, 100.004, 100.005]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())]
     fn test_alp_consistency(#[case] array: ALPArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx());
     }
 
     #[rstest]
-    #[case::f32_basic(alp_encode(PrimitiveArray::from_iter([1.23f32, 4.56, 7.89, 10.11, 12.13]).as_view(), None, &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
-    #[case::f64_basic(alp_encode(PrimitiveArray::from_iter([100.1f64, 200.2, 300.3, 400.4, 500.5]).as_view(), None, &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
-    #[case::f32_large(alp_encode(PrimitiveArray::from_iter((0..100).map(|i| i as f32 * 1.5)).as_view(), None, &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
-    #[case::f64_large(alp_encode(PrimitiveArray::from_iter((0..100).map(|i| i as f64 * 2.5)).as_view(), None, &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
+    #[case::f32_basic(alp_encode(PrimitiveArray::from_iter([1.23f32, 4.56, 7.89, 10.11, 12.13]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())]
+    #[case::f64_basic(alp_encode(PrimitiveArray::from_iter([100.1f64, 200.2, 300.3, 400.4, 500.5]).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())]
+    #[case::f32_large(alp_encode(PrimitiveArray::from_iter((0..100).map(|i| i as f32 * 1.5)).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())]
+    #[case::f64_large(alp_encode(PrimitiveArray::from_iter((0..100).map(|i| i as f64 * 2.5)).as_view(), None, &mut array_session().create_execution_ctx()).unwrap())]
     fn test_alp_binary_numeric(#[case] array: ALPArray) {
-        test_binary_numeric_array(array.into_array());
+        test_binary_numeric_array(&array.into_array(), &mut SESSION.create_execution_ctx());
     }
 }
diff --git a/encodings/alp/src/alp/compute/take.rs b/encodings/alp/src/alp/compute/take.rs
index 3b2b35ceaa9..9b193a3cfbe 100644
--- a/encodings/alp/src/alp/compute/take.rs
+++ b/encodings/alp/src/alp/compute/take.rs
@@ -42,8 +42,8 @@ impl TakeExecute for ALP {
 mod test {
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::take::test_take_conformance;
     use vortex_buffer::buffer;
@@ -56,7 +56,7 @@ mod test {
     #[case(PrimitiveArray::from_option_iter([Some(1.1f32), None, Some(2.2), Some(3.3), None]).into_array())]
     #[case(buffer![42.42f64].into_array())]
     fn test_take_alp_conformance(#[case] array: vortex_array::ArrayRef) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array_primitive = array.execute::<PrimitiveArray>(&mut ctx).unwrap();
         let alp = alp_encode(array_primitive.as_view(), None, &mut ctx).unwrap();
         test_take_conformance(&alp.into_array());
diff --git a/encodings/alp/src/alp_rd/compute/cast.rs b/encodings/alp/src/alp_rd/compute/cast.rs
index c110475b880..717b97b760e 100644
--- a/encodings/alp/src/alp_rd/compute/cast.rs
+++ b/encodings/alp/src/alp_rd/compute/cast.rs
@@ -50,8 +50,8 @@ impl CastReduce for ALPRD {
 mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::builtins::ArrayBuiltins;
     use vortex_array::compute::conformance::cast::test_cast_conformance;
@@ -63,7 +63,7 @@ mod tests {
 
     #[test]
     fn test_cast_alprd_f32_to_f64() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let values = vec![1.0f32, 1.1, 1.2, 1.3, 1.4];
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
@@ -87,7 +87,7 @@ mod tests {
 
     #[test]
     fn test_cast_alprd_nullable() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let arr =
             PrimitiveArray::from_option_iter([Some(10.0f64), None, Some(10.1), Some(10.2), None]);
         let values = vec![10.0f64, 10.1, 10.2];
@@ -122,31 +122,31 @@ mod tests {
         let values = vec![1.23f32, 4.56, 7.89, 10.11, 12.13];
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut array_session().create_execution_ctx())
     })]
     #[case::f64({
         let values = vec![100.1f64, 200.2, 300.3, 400.4, 500.5];
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut array_session().create_execution_ctx())
     })]
     #[case::single({
         let values = vec![42.42f64];
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut array_session().create_execution_ctx())
     })]
     #[case::negative({
         let values = vec![0.0f32, -1.5, 2.5, -3.5, 4.5];
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut array_session().create_execution_ctx())
     })]
     #[case::nullable({
         let arr = PrimitiveArray::from_option_iter([Some(1.1f32), None, Some(2.2), Some(3.3), None]);
         let values = vec![1.1f32, 2.2, 3.3];
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut array_session().create_execution_ctx())
     })]
     fn test_cast_alprd_conformance(#[case] alprd: crate::alp_rd::ALPRDArray) {
         test_cast_conformance(&alprd.into_array());
diff --git a/encodings/alp/src/alp_rd/compute/filter.rs b/encodings/alp/src/alp_rd/compute/filter.rs
index 44d6d39c00a..38d3fa96156 100644
--- a/encodings/alp/src/alp_rd/compute/filter.rs
+++ b/encodings/alp/src/alp_rd/compute/filter.rs
@@ -46,6 +46,7 @@ mod test {
     use rstest::rstest;
     use vortex_array::IntoArray;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::conformance::filter::test_filter_conformance;
@@ -59,7 +60,7 @@ mod test {
     use crate::RDEncoder;
 
     static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
-        let session = vortex_array::array_session();
+        let session = array_session();
         crate::initialize(&session);
         session
     });
diff --git a/encodings/alp/src/alp_rd/compute/mask.rs b/encodings/alp/src/alp_rd/compute/mask.rs
index 47a2f2a6b67..cac98683adb 100644
--- a/encodings/alp/src/alp_rd/compute/mask.rs
+++ b/encodings/alp/src/alp_rd/compute/mask.rs
@@ -43,8 +43,8 @@ impl MaskReduce for ALPRD {
 mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::mask::test_mask_conformance;
 
@@ -55,7 +55,7 @@ mod tests {
     #[case(0.1f32, 0.2f32, 3e25f32)]
     #[case(0.1f64, 0.2f64, 3e100f64)]
     fn test_mask_simple<T: ALPRDFloat>(#[case] a: T, #[case] b: T, #[case] outlier: T) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         test_mask_conformance(
             &RDEncoder::new(&[a, b])
                 .encode(
@@ -70,7 +70,7 @@ mod tests {
     #[case(0.1f32, 3e25f32)]
     #[case(0.5f64, 1e100f64)]
     fn test_mask_with_nulls<T: ALPRDFloat>(#[case] a: T, #[case] outlier: T) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         test_mask_conformance(
             &RDEncoder::new(&[a])
                 .encode(
diff --git a/encodings/alp/src/alp_rd/compute/mod.rs b/encodings/alp/src/alp_rd/compute/mod.rs
index 7d03eddaf40..f74b23fc2c2 100644
--- a/encodings/alp/src/alp_rd/compute/mod.rs
+++ b/encodings/alp/src/alp_rd/compute/mod.rs
@@ -8,67 +8,77 @@ mod take;
 
 #[cfg(test)]
 mod tests {
+    use std::sync::LazyLock;
+
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
+    use vortex_session::VortexSession;
 
     use crate::ALPRDArray;
     use crate::RDEncoder;
 
+    static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+        let session = array_session();
+        crate::initialize(&session);
+        session
+    });
+
     #[rstest]
     // Basic float arrays with RD (reference delta) encoding
     #[case::f32_array({
         let values = vec![1.0f32, 1.1, 1.2, 1.3, 1.4];
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut SESSION.create_execution_ctx())
     })]
     #[case::f64_array({
         let values = vec![100.0f64, 100.01, 100.02, 100.03, 100.04];
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut SESSION.create_execution_ctx())
     })]
     // Nullable arrays
     #[case::nullable_f32({
         let values = vec![1.0f32, 1.2, 1.3];
         let arr = PrimitiveArray::from_option_iter([Some(1.0f32), None, Some(1.2), Some(1.3), None]);
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut SESSION.create_execution_ctx())
     })]
     #[case::nullable_f64({
         let values = vec![10.0f64, 10.2, 10.3];
         let arr = PrimitiveArray::from_option_iter([Some(10.0f64), None, Some(10.2), Some(10.3), None]);
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut SESSION.create_execution_ctx())
     })]
     // Edge cases
     #[case::single_element({
         let values = vec![42.42f64];
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut SESSION.create_execution_ctx())
     })]
     // Arrays with small deltas (good for RD encoding)
     #[case::small_deltas({
         let values = vec![1000.0f32, 1000.001, 1000.002, 1000.003, 1000.004];
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut SESSION.create_execution_ctx())
     })]
     // Large arrays
     #[case::large_f32({
         let values: Vec<f32> = (0..1000).map(|i| 100.0 + i as f32 * 0.01).collect();
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut SESSION.create_execution_ctx())
     })]
     fn test_alp_rd_consistency(#[case] array: ALPRDArray) {
-        test_array_consistency(&array.into_array());
+        let ctx = &mut SESSION.create_execution_ctx();
+        test_array_consistency(&array.into_array(), ctx);
     }
 
     #[rstest]
@@ -76,27 +86,27 @@ mod tests {
         let values = vec![1.0f32, 1.1, 1.2, 1.3, 1.4];
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut SESSION.create_execution_ctx())
     })]
     #[case::f64_basic({
         let values = vec![100.0f64, 100.01, 100.02, 100.03, 100.04];
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut SESSION.create_execution_ctx())
     })]
     #[case::f32_large({
         let values: Vec<f32> = (0..100).map(|i| 50.0 + i as f32 * 0.1).collect();
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut SESSION.create_execution_ctx())
     })]
     #[case::f64_large({
         let values: Vec<f64> = (0..100).map(|i| 1000.0 + i as f64 * 0.01).collect();
         let arr = PrimitiveArray::from_iter(values.clone());
         let encoder = RDEncoder::new(&values);
-        encoder.encode(arr.as_view(), &mut LEGACY_SESSION.create_execution_ctx())
+        encoder.encode(arr.as_view(), &mut SESSION.create_execution_ctx())
     })]
     fn test_alp_rd_binary_numeric(#[case] array: ALPRDArray) {
-        test_binary_numeric_array(array.into_array());
+        test_binary_numeric_array(&array.into_array(), &mut SESSION.create_execution_ctx());
     }
 }
diff --git a/encodings/alp/src/alp_rd/compute/take.rs b/encodings/alp/src/alp_rd/compute/take.rs
index 827d2ecbeaa..dee2454ea05 100644
--- a/encodings/alp/src/alp_rd/compute/take.rs
+++ b/encodings/alp/src/alp_rd/compute/take.rs
@@ -62,6 +62,7 @@ mod test {
     use rstest::rstest;
     use vortex_array::IntoArray;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::conformance::take::test_take_conformance;
@@ -72,7 +73,7 @@ mod test {
     use crate::RDEncoder;
 
     static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
-        let session = vortex_array::array_session();
+        let session = array_session();
         crate::initialize(&session);
         session
     });
diff --git a/encodings/bytebool/src/compute.rs b/encodings/bytebool/src/compute.rs
index 1870a0b56b5..112abc921a4 100644
--- a/encodings/bytebool/src/compute.rs
+++ b/encodings/bytebool/src/compute.rs
@@ -167,6 +167,7 @@ mod tests {
 
     use rstest::rstest;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::BoolArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::builtins::ArrayBuiltins;
@@ -185,7 +186,7 @@ mod tests {
     use crate::ByteBoolArray;
 
     static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
-        let session = vortex_array::array_session();
+        let session = array_session();
         crate::initialize(&session);
         session
     });
@@ -350,6 +351,7 @@ mod tests {
     #[case::single_null(bb_opt(vec![None]))]
     #[case::mixed_with_nulls(bb_opt(vec![Some(true), None, Some(false), None, Some(true)]))]
     fn test_bytebool_consistency(#[case] array: ByteBoolArray) {
-        test_array_consistency(&array.into_array());
+        let ctx = &mut array_session().create_execution_ctx();
+        test_array_consistency(&array.into_array(), ctx);
     }
 }
diff --git a/encodings/bytebool/src/lib.rs b/encodings/bytebool/src/lib.rs
index 9d0d98e8c0a..a803dacd776 100644
--- a/encodings/bytebool/src/lib.rs
+++ b/encodings/bytebool/src/lib.rs
@@ -16,7 +16,7 @@
 //! to a canonical [`BoolArray`][vortex_array::arrays::BoolArray]:
 //!
 //! ```
-//! # use vortex_array::{IntoArray, LEGACY_SESSION, VortexSessionExecute};
+//! # use vortex_array::{IntoArray, VortexSessionExecute, array_session};
 //! # use vortex_array::arrays::BoolArray;
 //! # use vortex_array::arrays::bool::BoolArrayExt;
 //! # use vortex_array::buffer::BufferHandle;
@@ -25,7 +25,7 @@
 //! # use vortex_bytebool::ByteBool;
 //! # use vortex_error::VortexResult;
 //! # fn main() -> VortexResult<()> {
-//! # let mut ctx = LEGACY_SESSION.create_execution_ctx();
+//! # let mut ctx = array_session().create_execution_ctx();
 //! let handle = BufferHandle::new_host(ByteBuffer::from(vec![0u8, 1, 42, 0]));
 //! let array = ByteBool::new(handle, Validity::NonNullable);
 //!
diff --git a/encodings/datetime-parts/src/compress.rs b/encodings/datetime-parts/src/compress.rs
index 6caf3c9f643..a3ab3e6f23b 100644
--- a/encodings/datetime-parts/src/compress.rs
+++ b/encodings/datetime-parts/src/compress.rs
@@ -62,8 +62,8 @@ pub fn split_temporal(array: TemporalArray, ctx: &mut ExecutionCtx) -> VortexRes
 mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::TemporalArray;
     use vortex_array::extension::datetime::TimeUnit;
@@ -80,7 +80,7 @@ mod tests {
     #[case(Validity::AllInvalid)]
     #[case(Validity::from_iter([true, false, true]))]
     fn test_split_temporal(#[case] validity: Validity) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let milliseconds = PrimitiveArray::new(
             buffer![
                 86_400i64,            // element with only day component
diff --git a/encodings/datetime-parts/src/compute/cast.rs b/encodings/datetime-parts/src/compute/cast.rs
index ccc3cc0cd91..90aba343ae3 100644
--- a/encodings/datetime-parts/src/compute/cast.rs
+++ b/encodings/datetime-parts/src/compute/cast.rs
@@ -37,8 +37,8 @@ mod tests {
     use vortex_array::ArrayRef;
     use vortex_array::Canonical;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::TemporalArray;
     use vortex_array::builtins::ArrayBuiltins;
@@ -66,7 +66,7 @@ mod tests {
                 TimeUnit::Milliseconds,
                 Some("UTC".into()),
             ),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
         .into_array()
@@ -95,7 +95,7 @@ mod tests {
     #[case(Validity::AllInvalid)]
     #[case(Validity::from_iter([true, false, true]))]
     fn test_bad_cast_fails(#[case] validity: Validity) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = date_time_array(validity);
         // Cast to incompatible type - force evaluation via execute::<Canonical>
         let result = array
@@ -121,7 +121,7 @@ mod tests {
         ].into_array(),
         TimeUnit::Milliseconds,
         Some("UTC".into())
-    ), &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
+    ), &mut array_session().create_execution_ctx()).unwrap())]
     #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp(
         PrimitiveArray::from_option_iter([
             Some(0i64),
@@ -132,12 +132,12 @@ mod tests {
         ]).into_array(),
         TimeUnit::Milliseconds,
         Some("UTC".into())
-    ), &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
+    ), &mut array_session().create_execution_ctx()).unwrap())]
     #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp(
         buffer![86_400_000_000_000i64].into_array(), // 1 day in ns
         TimeUnit::Nanoseconds,
         Some("UTC".into())
-    ), &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
+    ), &mut array_session().create_execution_ctx()).unwrap())]
     fn test_cast_datetime_parts_conformance(#[case] array: DateTimePartsArray) {
         use vortex_array::compute::conformance::cast::test_cast_conformance;
         test_cast_conformance(&array.into_array());
diff --git a/encodings/datetime-parts/src/compute/compare.rs b/encodings/datetime-parts/src/compute/compare.rs
index 9f854b0e0f9..0791861df79 100644
--- a/encodings/datetime-parts/src/compute/compare.rs
+++ b/encodings/datetime-parts/src/compute/compare.rs
@@ -204,9 +204,9 @@ mod test {
     use rstest::rstest;
     use vortex_array::ArrayRef;
     use vortex_array::ExecutionCtx;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
     use vortex_array::aggregate_fn::fns::sum::sum;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::TemporalArray;
     use vortex_array::dtype::IntegerPType;
@@ -228,7 +228,7 @@ mod test {
                 TimeUnit::Seconds,
                 Some("UTC".into()),
             ),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .expect("Failed to construct DateTimePartsArray from TemporalArray")
     }
@@ -248,7 +248,7 @@ mod test {
     #[case(Validity::AllValid, Validity::NonNullable)]
     #[case(Validity::AllValid, Validity::AllValid)]
     fn compare_date_time_parts_eq(#[case] lhs_validity: Validity, #[case] rhs_validity: Validity) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let lhs = dtp_array_from_timestamp(86400i64, lhs_validity); // January 2, 1970, 00:00:00 UTC
         let rhs = dtp_array_from_timestamp(86400i64, rhs_validity.clone()); // January 2, 1970, 00:00:00 UTC
         let comparison = lhs
@@ -272,7 +272,7 @@ mod test {
     #[case(Validity::AllValid, Validity::NonNullable)]
     #[case(Validity::AllValid, Validity::AllValid)]
     fn compare_date_time_parts_ne(#[case] lhs_validity: Validity, #[case] rhs_validity: Validity) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let lhs = dtp_array_from_timestamp(86400i64, lhs_validity); // January 2, 1970, 00:00:00 UTC
         let rhs = dtp_array_from_timestamp(86401i64, rhs_validity.clone()); // January 2, 1970, 00:00:01 UTC
         let comparison = lhs
@@ -296,7 +296,7 @@ mod test {
     #[case(Validity::AllValid, Validity::NonNullable)]
     #[case(Validity::AllValid, Validity::AllValid)]
     fn compare_date_time_parts_lt(#[case] lhs_validity: Validity, #[case] rhs_validity: Validity) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let lhs = dtp_array_from_timestamp(0i64, lhs_validity); // January 1, 1970, 01:00:00 UTC
         let rhs = dtp_array_from_timestamp(86400i64, rhs_validity); // January 2, 1970, 00:00:00 UTC
 
@@ -313,7 +313,7 @@ mod test {
     #[case(Validity::AllValid, Validity::NonNullable)]
     #[case(Validity::AllValid, Validity::AllValid)]
     fn compare_date_time_parts_gt(#[case] lhs_validity: Validity, #[case] rhs_validity: Validity) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let lhs = dtp_array_from_timestamp(86400i64, lhs_validity); // January 2, 1970, 02:00:00 UTC
         let rhs = dtp_array_from_timestamp(0i64, rhs_validity); // January 1, 1970, 01:00:00 UTC
 
@@ -333,7 +333,7 @@ mod test {
         #[case] lhs_validity: Validity,
         #[case] rhs_validity: Validity,
     ) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let temporal_array = TemporalArray::new_timestamp(
             PrimitiveArray::new(buffer![0i64], lhs_validity.clone()).into_array(),
             TimeUnit::Seconds,
diff --git a/encodings/datetime-parts/src/compute/filter.rs b/encodings/datetime-parts/src/compute/filter.rs
index 149574f53d4..696660510d5 100644
--- a/encodings/datetime-parts/src/compute/filter.rs
+++ b/encodings/datetime-parts/src/compute/filter.rs
@@ -27,8 +27,8 @@ impl FilterReduce for DateTimeParts {
 #[cfg(test)]
 mod test {
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::TemporalArray;
     use vortex_array::compute::conformance::filter::test_filter_conformance;
@@ -39,7 +39,7 @@ mod test {
 
     #[test]
     fn test_filter_datetime_parts() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // Create temporal arrays and convert to DateTimePartsArray
         let timestamps = buffer![
             0i64,
diff --git a/encodings/datetime-parts/src/compute/mod.rs b/encodings/datetime-parts/src/compute/mod.rs
index 5d25757c20d..4196b6b9832 100644
--- a/encodings/datetime-parts/src/compute/mod.rs
+++ b/encodings/datetime-parts/src/compute/mod.rs
@@ -15,8 +15,8 @@ mod take;
 mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::TemporalArray;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
@@ -27,7 +27,7 @@ mod tests {
     use crate::DateTimePartsArray;
 
     fn dtp_from_temporal(temporal: TemporalArray) -> DateTimePartsArray {
-        DateTimeParts::try_from_temporal(temporal, &mut LEGACY_SESSION.create_execution_ctx())
+        DateTimeParts::try_from_temporal(temporal, &mut array_session().create_execution_ctx())
             .unwrap()
     }
 
@@ -79,6 +79,7 @@ mod tests {
     )))]
 
     fn test_datetime_parts_consistency(#[case] array: DateTimePartsArray) {
-        test_array_consistency(&array.into_array());
+        let ctx = &mut array_session().create_execution_ctx();
+        test_array_consistency(&array.into_array(), ctx);
     }
 }
diff --git a/encodings/datetime-parts/src/compute/rules.rs b/encodings/datetime-parts/src/compute/rules.rs
index bba19ceea47..84f58310ac1 100644
--- a/encodings/datetime-parts/src/compute/rules.rs
+++ b/encodings/datetime-parts/src/compute/rules.rs
@@ -180,9 +180,9 @@ fn is_constant_zero(array: &ArrayRef) -> bool {
 mod tests {
     use vortex_array::ArrayRef;
     use vortex_array::ExecutionCtx;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
     use vortex_array::aggregate_fn::fns::sum::sum;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::TemporalArray;
     use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
@@ -230,7 +230,7 @@ mod tests {
             time_unit,
             None,
         );
-        DateTimeParts::try_from_temporal(temporal, &mut LEGACY_SESSION.create_execution_ctx())
+        DateTimeParts::try_from_temporal(temporal, &mut array_session().create_execution_ctx())
             .vortex_expect("TemporalArray must produce valid DateTimeParts")
     }
 
@@ -296,7 +296,7 @@ mod tests {
         );
 
         // Verify correctness: days [0, 1, 2] <= 1 should give [true, true, false]
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(true_count(&optimized, &mut ctx), 2);
     }
 
@@ -325,7 +325,7 @@ mod tests {
         let optimized = between.optimize().unwrap();
 
         // Verify correctness: days [0, 1, 2, 3, 4] between 1 and 3 should give [false, true, true, true, false]
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(true_count(&optimized, &mut ctx), 3);
     }
 
@@ -348,7 +348,7 @@ mod tests {
         // (optimization doesn't apply, so we keep the original structure)
         // Just verify it still computes correctly
         // days [0, 1, 2] at midnight <= day 1 at noon: [true, true, false]
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(true_count(&optimized, &mut ctx), 2);
     }
 
@@ -366,7 +366,7 @@ mod tests {
             TimeUnit::Seconds,
             None,
         );
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtp = DateTimeParts::try_from_temporal(temporal, &mut ctx).unwrap();
         let len = dtp.len();
 
diff --git a/encodings/datetime-parts/src/compute/take.rs b/encodings/datetime-parts/src/compute/take.rs
index 8b09e2d78ef..9f5a50d3a9b 100644
--- a/encodings/datetime-parts/src/compute/take.rs
+++ b/encodings/datetime-parts/src/compute/take.rs
@@ -96,8 +96,8 @@ impl TakeExecute for DateTimeParts {
 mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::TemporalArray;
     use vortex_array::compute::conformance::take::test_take_conformance;
@@ -118,7 +118,7 @@ mod tests {
         ].into_array(),
         TimeUnit::Milliseconds,
         Some("UTC".into())
-    ), &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
+    ), &mut array_session().create_execution_ctx()).unwrap())]
     #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp(
         PrimitiveArray::from_option_iter([
             Some(0i64),
@@ -129,12 +129,12 @@ mod tests {
         ]).into_array(),
         TimeUnit::Milliseconds,
         Some("UTC".into())
-    ), &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
+    ), &mut array_session().create_execution_ctx()).unwrap())]
     #[case(DateTimeParts::try_from_temporal(TemporalArray::new_timestamp(
         buffer![86_400_000i64].into_array(),
         TimeUnit::Milliseconds,
         Some("UTC".into())
-    ), &mut LEGACY_SESSION.create_execution_ctx()).unwrap())]
+    ), &mut array_session().create_execution_ctx()).unwrap())]
     fn test_take_datetime_parts_conformance(#[case] array: DateTimePartsArray) {
         test_take_conformance(&array.into_array());
     }
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/cast.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/cast.rs
index 882d07bbaef..376ad12f564 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/cast.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/cast.rs
@@ -40,8 +40,8 @@ mod tests {
     use rstest::rstest;
     use vortex_array::Canonical;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::DecimalArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::builtins::ArrayBuiltins;
@@ -56,7 +56,7 @@ mod tests {
 
     #[test]
     fn test_cast_decimal_byte_parts_nullability() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let decimal_dtype = DecimalDType::new(10, 2);
         let array =
             DecimalByteParts::try_new(buffer![100i32, 200, 300, 400].into_array(), decimal_dtype)
@@ -79,7 +79,7 @@ mod tests {
 
     #[test]
     fn test_cast_decimal_byte_parts_nullable_to_non_nullable() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let decimal_dtype = DecimalDType::new(10, 2);
         let array = DecimalByteParts::try_new(
             PrimitiveArray::from_option_iter([Some(100i32), None, Some(300)]).into_array(),
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mod.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mod.rs
index 35da5be40b6..0a5477e93cf 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mod.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/compute/mod.rs
@@ -13,6 +13,8 @@ mod take;
 mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
     use vortex_array::dtype::DecimalDType;
@@ -69,6 +71,7 @@ mod tests {
     ).unwrap())]
 
     fn test_decimal_byte_parts_consistency(#[case] array: DecimalBytePartsArray) {
-        test_array_consistency(&array.into_array());
+        let ctx = &mut array_session().create_execution_ctx();
+        test_array_consistency(&array.into_array(), ctx);
     }
 }
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs
index 1b5cba48ff3..8f4e9fed409 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs
@@ -320,8 +320,8 @@ impl ValidityChild<DecimalByteParts> for DecimalByteParts {
 #[cfg(test)]
 mod tests {
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::dtype::DType;
@@ -353,7 +353,7 @@ mod tests {
         assert_eq!(
             Scalar::null(dtype.clone()),
             array
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
         assert_eq!(
@@ -363,13 +363,13 @@ mod tests {
             )
             .unwrap(),
             array
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(1, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
         assert_eq!(
             Scalar::try_new(dtype, Some(ScalarValue::Decimal(DecimalValue::I64(400)))).unwrap(),
             array
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(2, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
     }
diff --git a/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs b/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs
index 23f0f96aed4..3c77e146ad0 100644
--- a/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs
+++ b/encodings/fastlanes/src/bitpacking/array/unpack_iter.rs
@@ -62,7 +62,7 @@ impl<T: PhysicalPType<Physical: BitPacking>> UnpackStrategy<T> for BitPackingStr
 /// use vortex_fastlanes::BitPackedArrayExt;
 /// use vortex_fastlanes::unpack_iter::BitUnpackedChunks;
 ///
-/// let mut ctx = vortex_array::LEGACY_SESSION.create_execution_ctx();
+/// let mut ctx = vortex_array::array_session().create_execution_ctx();
 /// let array = BitPackedData::encode(&buffer![2, 3, 4, 5].into_array(), 2, &mut ctx).unwrap();
 /// let mut unpacked_chunks: BitUnpackedChunks<i32> = array.unpacked_chunks().unwrap();
 ///
diff --git a/encodings/fastlanes/src/bitpacking/compute/is_constant.rs b/encodings/fastlanes/src/bitpacking/compute/is_constant.rs
index 0a743f9269b..3b4e2b9770a 100644
--- a/encodings/fastlanes/src/bitpacking/compute/is_constant.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/is_constant.rs
@@ -185,9 +185,9 @@ fn apply_patches_idx_typed<T: BitPackedUnpack, I: IntegerPType>(
 #[cfg(test)]
 mod tests {
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
     use vortex_array::aggregate_fn::fns::is_constant::is_constant;
+    use vortex_array::array_session;
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
 
@@ -195,7 +195,7 @@ mod tests {
 
     #[test]
     fn is_constant_with_patches() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = BitPackedData::encode(&buffer![4; 1025].into_array(), 2, &mut ctx)?;
         assert!(is_constant(&array.into_array(), &mut ctx)?);
         Ok(())
diff --git a/encodings/fastlanes/src/bitpacking/compute/mod.rs b/encodings/fastlanes/src/bitpacking/compute/mod.rs
index 06a4b4597b0..38f86f781bb 100644
--- a/encodings/fastlanes/src/bitpacking/compute/mod.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/mod.rs
@@ -46,8 +46,8 @@ fn chunked_indices<F: FnMut(usize, &[usize])>(
 mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
@@ -61,7 +61,7 @@ mod tests {
             array,
             bit_width,
             None,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
     }
@@ -98,7 +98,8 @@ mod tests {
     #[case::alternating_bits(bp(&PrimitiveArray::from_iter([0u16, 255, 0, 255, 0, 255]), 8))]
 
     fn test_bitpacked_consistency(#[case] array: BitPackedArray) {
-        test_array_consistency(&array.into_array());
+        let ctx = &mut array_session().create_execution_ctx();
+        test_array_consistency(&array.into_array(), ctx);
     }
 
     #[rstest]
@@ -109,6 +110,9 @@ mod tests {
     #[case::i32_basic(bp(&PrimitiveArray::from_iter([10i32, 20, 30, 40, 50]), 7))]
     #[case::large_u32(bp(&PrimitiveArray::from_iter((0..100).map(|i| i as u32)), 7))]
     fn test_bitpacked_binary_numeric(#[case] array: BitPackedArray) {
-        test_binary_numeric_array(array.into_array());
+        test_binary_numeric_array(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/encodings/fastlanes/src/bitpacking/compute/slice.rs b/encodings/fastlanes/src/bitpacking/compute/slice.rs
index c019cccd003..996565a2672 100644
--- a/encodings/fastlanes/src/bitpacking/compute/slice.rs
+++ b/encodings/fastlanes/src/bitpacking/compute/slice.rs
@@ -72,8 +72,8 @@ fn slice_bitpacked(
 #[cfg(test)]
 mod tests {
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::SliceArray;
     use vortex_error::VortexResult;
@@ -83,7 +83,7 @@ mod tests {
 
     #[test]
     fn test_reduce_parent_returns_bitpacked_slice() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let values = PrimitiveArray::from_iter(0u32..2048);
         let bitpacked = bitpack_encode(&values, 11, None, &mut ctx)?;
 
diff --git a/encodings/fastlanes/src/delta/vtable/operations.rs b/encodings/fastlanes/src/delta/vtable/operations.rs
index 60bf86db97e..7ed57a0886d 100644
--- a/encodings/fastlanes/src/delta/vtable/operations.rs
+++ b/encodings/fastlanes/src/delta/vtable/operations.rs
@@ -31,6 +31,7 @@ mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array;
@@ -44,7 +45,7 @@ mod tests {
     use crate::DeltaArray;
 
     static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
-        let session = vortex_array::array_session();
+        let session = array_session();
         crate::initialize(&session);
         session
     });
@@ -256,7 +257,10 @@ mod tests {
     #[case::delta_large_i32((-1024i32..1024).collect())]
     #[case::delta_single_negative(PrimitiveArray::new(buffer![-42i32], Validity::NonNullable))]
     fn test_delta_consistency(#[case] array: PrimitiveArray) {
-        test_array_consistency(&da(&array).into_array());
+        test_array_consistency(
+            &da(&array).into_array(),
+            &mut SESSION.create_execution_ctx(),
+        );
     }
 
     #[rstest]
@@ -268,6 +272,9 @@ mod tests {
     #[case::delta_i8_basic(PrimitiveArray::new(buffer![-1i8, -1, -1, -1, -1], Validity::NonNullable))]
     #[case::delta_i32_basic(PrimitiveArray::new(buffer![-1i32, -1, -1, -1, -1], Validity::NonNullable))]
     fn test_delta_binary_numeric(#[case] array: PrimitiveArray) {
-        test_binary_numeric_array(da(&array).into_array());
+        test_binary_numeric_array(
+            &da(&array).into_array(),
+            &mut SESSION.create_execution_ctx(),
+        );
     }
 }
diff --git a/encodings/fastlanes/src/for/compute/is_sorted.rs b/encodings/fastlanes/src/for/compute/is_sorted.rs
index 6b72af5902b..a850f25583e 100644
--- a/encodings/fastlanes/src/for/compute/is_sorted.rs
+++ b/encodings/fastlanes/src/for/compute/is_sorted.rs
@@ -60,9 +60,9 @@ impl DynAggregateKernel for FoRIsSortedKernel {
 #[cfg(test)]
 mod test {
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
     use vortex_array::aggregate_fn::fns::is_sorted::is_sorted;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::validity::Validity;
     use vortex_buffer::buffer;
@@ -72,7 +72,7 @@ mod test {
 
     #[test]
     fn test_sorted() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         let a = PrimitiveArray::new(buffer![-1, 0, i8::MAX], Validity::NonNullable);
         let b = FoRData::encode(a).unwrap();
diff --git a/encodings/fastlanes/src/for/compute/mod.rs b/encodings/fastlanes/src/for/compute/mod.rs
index 7307b50d776..84e8812b598 100644
--- a/encodings/fastlanes/src/for/compute/mod.rs
+++ b/encodings/fastlanes/src/for/compute/mod.rs
@@ -102,6 +102,8 @@ mod tests {
     use rstest::rstest;
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
@@ -145,7 +147,10 @@ mod tests {
     #[case::for_large_deltas(fa(buffer![100i64, 200, 300, 400, 500].into_array(), Scalar::from(100i64)))]
 
     fn test_for_consistency(#[case] array: FoRArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 
     #[rstest]
@@ -158,6 +163,9 @@ mod tests {
         Scalar::from(2000i32)
     ))]
     fn test_for_binary_numeric(#[case] array: FoRArray) {
-        test_binary_numeric_array(array.into_array());
+        test_binary_numeric_array(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/encodings/fsst/src/array.rs b/encodings/fsst/src/array.rs
index e3b5d74c9d7..2526f0a697f 100644
--- a/encodings/fsst/src/array.rs
+++ b/encodings/fsst/src/array.rs
@@ -839,9 +839,9 @@ mod test {
     use prost::Message;
     use vortex_array::ArrayPlugin;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
     use vortex_array::accessor::ArrayAccessor;
+    use vortex_array::array_session;
     use vortex_array::arrays::VarBinViewArray;
     use vortex_array::buffer::BufferHandle;
     use vortex_array::dtype::DType;
@@ -867,7 +867,7 @@ mod test {
         let symbol_lengths = Buffer::<u8>::copy_from([3, 8]);
 
         let compressor = Compressor::rebuild_from(symbols.as_slice(), symbol_lengths.as_slice());
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let strings = VarBinViewArray::from_iter_str(["abcabcab", "defghijk", "abcxyz"]);
         let fsst_array = fsst_compress(&strings.into_array(), &compressor, &mut ctx)?;
 
@@ -911,7 +911,7 @@ mod test {
         let symbol_lengths = Buffer::<u8>::copy_from([3, 8]);
 
         let compressor = Compressor::rebuild_from(symbols.as_slice(), symbol_lengths.as_slice());
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let input = VarBinViewArray::from_iter_str(["abcabcab", "defghijk"]);
         let fsst_array = fsst_compress(&input.into_array(), &compressor, &mut ctx).unwrap();
 
@@ -949,12 +949,12 @@ mod test {
             .encode_to_vec(),
             &buffers,
             &children.as_slice(),
-            &LEGACY_SESSION,
+            &array_session(),
         )
         .unwrap();
 
         let decompressed = fsst
-            .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<VarBinViewArray>(&mut array_session().create_execution_ctx())
             .unwrap();
         decompressed
             .with_iterator(|it| {
diff --git a/encodings/fsst/src/compute/mod.rs b/encodings/fsst/src/compute/mod.rs
index fafa05d293b..0065e0f499a 100644
--- a/encodings/fsst/src/compute/mod.rs
+++ b/encodings/fsst/src/compute/mod.rs
@@ -61,8 +61,8 @@ mod tests {
     use rstest::rstest;
     use vortex_array::ExecutionCtx;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::VarBinArray;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
@@ -77,7 +77,7 @@ mod tests {
 
     #[test]
     fn test_take_null() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let arr =
             VarBinArray::from_iter([Some("h")], DType::Utf8(Nullability::NonNullable)).into_array();
         let compr = fsst_train_compressor(&arr, &mut ctx)?;
@@ -113,7 +113,7 @@ mod tests {
         DType::Utf8(Nullability::NonNullable),
     ))]
     fn test_take_fsst_conformance(#[case] varbin: VarBinArray) -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let varbin = varbin.into_array();
         let compressor = fsst_train_compressor(&varbin, &mut ctx)?;
         let array = fsst_compress(&varbin, &compressor, &mut ctx)?;
@@ -190,8 +190,11 @@ mod tests {
     })]
 
     fn test_fsst_consistency(#[case] build: FsstBuilder) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = build(&mut ctx);
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/encodings/parquet-variant/src/operations.rs b/encodings/parquet-variant/src/operations.rs
index 10f11e2bf2c..3cc3d2e5b4a 100644
--- a/encodings/parquet-variant/src/operations.rs
+++ b/encodings/parquet-variant/src/operations.rs
@@ -387,8 +387,8 @@ mod tests {
     use parquet_variant::VariantBuilder;
     use parquet_variant_compute::VariantArray as ArrowVariantArray;
     use parquet_variant_compute::VariantArrayBuilder;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
     use vortex_array::scalar::Scalar;
@@ -420,7 +420,7 @@ mod tests {
                 Some(ScalarValue::Variant(Box::new(expected_inner))),
             )?;
             assert_eq!(
-                vortex_arr.execute_scalar(index, &mut LEGACY_SESSION.create_execution_ctx())?,
+                vortex_arr.execute_scalar(index, &mut array_session().create_execution_ctx())?,
                 expected
             );
         }
@@ -452,17 +452,17 @@ mod tests {
 
         assert!(
             vortex_arr
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())?
+                .execute_scalar(1, &mut array_session().create_execution_ctx())?
                 .is_null()
         );
         assert!(
             !vortex_arr
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())?
+                .execute_scalar(0, &mut array_session().create_execution_ctx())?
                 .is_null()
         );
         assert!(
             !vortex_arr
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())?
+                .execute_scalar(2, &mut array_session().create_execution_ctx())?
                 .is_null()
         );
 
@@ -487,7 +487,7 @@ mod tests {
         let vortex_arr = ParquetVariant::from_arrow_variant(&arrow_variant)?;
 
         let present_variant_null =
-            vortex_arr.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())?;
+            vortex_arr.execute_scalar(0, &mut array_session().create_execution_ctx())?;
         assert!(!present_variant_null.is_null());
         assert_eq!(
             present_variant_null.as_variant().is_variant_null(),
@@ -495,12 +495,12 @@ mod tests {
         );
 
         let outer_null =
-            vortex_arr.execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())?;
+            vortex_arr.execute_scalar(1, &mut array_session().create_execution_ctx())?;
         assert!(outer_null.is_null());
         assert_eq!(outer_null.as_variant().is_variant_null(), None);
 
         let present_value =
-            vortex_arr.execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())?;
+            vortex_arr.execute_scalar(2, &mut array_session().create_execution_ctx())?;
         assert!(!present_value.is_null());
         assert_eq!(present_value.as_variant().is_variant_null(), Some(false));
 
@@ -526,17 +526,17 @@ mod tests {
         assert_eq!(vortex_arr.dtype(), &DType::Variant(Nullability::Nullable));
         assert!(
             vortex_arr
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())?
+                .execute_scalar(0, &mut array_session().create_execution_ctx())?
                 .is_null()
         );
         assert!(
             vortex_arr
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())?
+                .execute_scalar(1, &mut array_session().create_execution_ctx())?
                 .is_null()
         );
 
         let inner_pv = vortex_arr.as_opt::<ParquetVariant>().unwrap();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let roundtripped = inner_pv.to_arrow(&mut ctx)?;
         assert_eq!(roundtripped.inner().null_count(), 2);
 
@@ -558,12 +558,12 @@ mod tests {
         );
         assert!(
             !vortex_arr
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())?
+                .execute_scalar(0, &mut array_session().create_execution_ctx())?
                 .is_null()
         );
         assert!(
             !vortex_arr
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())?
+                .execute_scalar(1, &mut array_session().create_execution_ctx())?
                 .is_null()
         );
         assert_scalar_at_matches_arrow_try_value(&arrow_variant, [0, 1])?;
@@ -673,7 +673,7 @@ mod tests {
         let arrow_variant = ArrowVariantArray::try_new(&struct_array)?;
         let vortex_arr = ParquetVariant::from_arrow_variant(&arrow_variant)?;
 
-        let row0 = vortex_arr.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let row0 = vortex_arr.execute_scalar(0, &mut array_session().create_execution_ctx())?;
         let row0 = row0.as_variant().value().unwrap().as_list();
         assert_eq!(row0.len(), 2);
         assert_eq!(
@@ -697,7 +697,7 @@ mod tests {
             Some(20)
         );
 
-        let row1 = vortex_arr.execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let row1 = vortex_arr.execute_scalar(1, &mut array_session().create_execution_ctx())?;
         let row1 = row1.as_variant().value().unwrap().as_list();
         assert_eq!(row1.len(), 1);
         assert_eq!(
@@ -764,7 +764,7 @@ mod tests {
 
         let arrow_variant = ArrowVariantArray::try_new(&struct_array)?;
         let vortex_arr = ParquetVariant::from_arrow_variant(&arrow_variant)?;
-        let object = vortex_arr.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let object = vortex_arr.execute_scalar(0, &mut array_session().create_execution_ctx())?;
         let object = object.as_variant().value().unwrap().as_struct();
 
         assert_eq!(
diff --git a/encodings/pco/src/array.rs b/encodings/pco/src/array.rs
index 5d073b56fbf..cb43ddb812f 100644
--- a/encodings/pco/src/array.rs
+++ b/encodings/pco/src/array.rs
@@ -669,8 +669,8 @@ impl OperationsVTable<Pco> for Pco {
 #[cfg(test)]
 mod tests {
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::validity::Validity;
@@ -680,7 +680,7 @@ mod tests {
 
     #[test]
     fn test_slice_nullable() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // Create a nullable array with some nulls
         let values = PrimitiveArray::new(
             buffer![10u32, 20, 30, 40, 50, 60],
diff --git a/encodings/pco/src/compute/mod.rs b/encodings/pco/src/compute/mod.rs
index 036a639ae31..d86c3d4b0a3 100644
--- a/encodings/pco/src/compute/mod.rs
+++ b/encodings/pco/src/compute/mod.rs
@@ -7,8 +7,8 @@ mod cast;
 mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
 
@@ -21,7 +21,7 @@ mod tests {
             values.as_view(),
             0,
             128,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
     }
@@ -32,7 +32,7 @@ mod tests {
             values.as_view(),
             0,
             128,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
     }
@@ -43,7 +43,7 @@ mod tests {
             values.as_view(),
             0,
             128,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
     }
@@ -54,7 +54,7 @@ mod tests {
             values.as_view(),
             0,
             128,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
     }
@@ -65,7 +65,7 @@ mod tests {
             values.as_view(),
             0,
             128,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
     }
@@ -76,7 +76,7 @@ mod tests {
             values.as_view(),
             0,
             128,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
     }
@@ -87,7 +87,7 @@ mod tests {
             values.as_view(),
             0,
             128,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
     }
@@ -98,7 +98,7 @@ mod tests {
             values.as_view(),
             3,
             128,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
     }
@@ -113,6 +113,9 @@ mod tests {
     #[case::single(pco_single())]
     #[case::large(pco_large())]
     fn test_pco_consistency(#[case] array: PcoArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/encodings/pco/src/tests.rs b/encodings/pco/src/tests.rs
index 692e3f370db..573bd6a0fb4 100644
--- a/encodings/pco/src/tests.rs
+++ b/encodings/pco/src/tests.rs
@@ -6,7 +6,6 @@ use std::sync::LazyLock;
 
 use vortex_array::ArrayContext;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::PrimitiveArray;
@@ -40,7 +39,7 @@ static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
 use crate::Pco;
 #[test]
 fn test_compress_decompress() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = SESSION.create_execution_ctx();
     let data: Vec<i32> = (0..200).collect();
     let array = PrimitiveArray::from_iter(data.clone());
     let compressed = Pco::from_primitive(array.as_view(), 3, 0, &mut ctx).unwrap();
@@ -76,7 +75,7 @@ fn test_compress_decompress() {
 
 #[test]
 fn test_compress_decompress_small() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = SESSION.create_execution_ctx();
     let array = PrimitiveArray::from_option_iter([None, Some(1)]);
     let compressed = Pco::from_primitive(array.as_view(), 3, 0, &mut ctx).unwrap();
 
@@ -93,7 +92,7 @@ fn test_compress_decompress_small() {
 
 #[test]
 fn test_empty() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = SESSION.create_execution_ctx();
     let data: Vec<i32> = vec![];
     let array = PrimitiveArray::from_iter(data.clone());
     let compressed = Pco::from_primitive(array.as_view(), 3, 100, &mut ctx).unwrap();
@@ -107,7 +106,7 @@ fn test_empty() {
 
 #[test]
 fn test_validity_and_multiple_chunks_and_pages() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = SESSION.create_execution_ctx();
     let data: Vec<i32> = (0..200).collect();
     let mut validity: Vec<bool> = vec![true; 200];
     validity[7..15].fill(false);
@@ -165,7 +164,7 @@ fn test_validity_and_multiple_chunks_and_pages() {
 
 #[test]
 fn test_validity_vtable() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = SESSION.create_execution_ctx();
     let data: Vec<i32> = (0..5).collect();
     let mask_bools = vec![false, true, true, false, true];
     let array = PrimitiveArray::new(
@@ -221,14 +220,13 @@ fn test_serde() -> VortexResult<()> {
         &ReadContext::new(context.to_ids()),
         &SESSION,
     )?;
-    let data_type = LEGACY_SESSION.arrow().to_arrow_field("", data.dtype())?;
-    let pco_arrow = LEGACY_SESSION
+    let data_type = SESSION.arrow().to_arrow_field("", data.dtype())?;
+    let pco_arrow = SESSION
         .arrow()
         .execute_arrow(pco, Some(&data_type), &mut ctx)?;
-    let decoded_arrow =
-        LEGACY_SESSION
-            .arrow()
-            .execute_arrow(decoded, Some(&data_type), &mut ctx)?;
+    let decoded_arrow = SESSION
+        .arrow()
+        .execute_arrow(decoded, Some(&data_type), &mut ctx)?;
     assert!(pco_arrow == decoded_arrow);
     Ok(())
 }
diff --git a/encodings/runend/src/compute/mod.rs b/encodings/runend/src/compute/mod.rs
index 32926f41c45..fc7fc8804ec 100644
--- a/encodings/runend/src/compute/mod.rs
+++ b/encodings/runend/src/compute/mod.rs
@@ -62,6 +62,6 @@ mod tests {
     ).unwrap())]
 
     fn test_runend_consistency(#[case] array: RunEndArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx());
     }
 }
diff --git a/encodings/sequence/src/compute/mod.rs b/encodings/sequence/src/compute/mod.rs
index 9a99ff235c4..22b4e3ac05b 100644
--- a/encodings/sequence/src/compute/mod.rs
+++ b/encodings/sequence/src/compute/mod.rs
@@ -14,6 +14,8 @@ mod take;
 mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
+    use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
     use vortex_array::dtype::Nullability;
 
@@ -84,6 +86,9 @@ mod tests {
     ).unwrap())] // Results in [1000, 1100, 1200, ..., 150900]
 
     fn test_sequence_consistency(#[case] array: SequenceArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/encodings/sequence/src/compute/take.rs b/encodings/sequence/src/compute/take.rs
index 6e1ebe263df..4b056d0ae7f 100644
--- a/encodings/sequence/src/compute/take.rs
+++ b/encodings/sequence/src/compute/take.rs
@@ -104,8 +104,8 @@ mod test {
     use rstest::rstest;
     use vortex_array::Canonical;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::dtype::Nullability;
 
@@ -174,7 +174,7 @@ mod test {
         let _array = array
             .take(indices.into_array())
             .unwrap()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<Canonical>(&mut array_session().create_execution_ctx())
             .unwrap();
     }
 }
diff --git a/encodings/sparse/src/compute/mod.rs b/encodings/sparse/src/compute/mod.rs
index a64ccc869e2..bdae87e560d 100644
--- a/encodings/sparse/src/compute/mod.rs
+++ b/encodings/sparse/src/compute/mod.rs
@@ -14,7 +14,8 @@ pub(crate) mod sum;
 mod take;
 
 #[cfg(test)]
-mod test {
+mod tests {
+    use std::f32;
     use std::sync::LazyLock;
 
     use rstest::fixture;
@@ -22,10 +23,12 @@ mod test {
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::builtins::ArrayBuiltins;
     use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array;
+    use vortex_array::compute::conformance::consistency::test_array_consistency;
     use vortex_array::compute::conformance::mask::test_mask_conformance;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
@@ -37,9 +40,10 @@ mod test {
     use vortex_session::VortexSession;
 
     use crate::Sparse;
+    use crate::SparseArray;
 
     static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
-        let session = vortex_array::array_session();
+        let session = array_session();
         crate::initialize(&session);
         session
     });
@@ -115,8 +119,8 @@ mod test {
     }
 
     #[rstest]
-    fn test_sparse_binary_numeric(array: ArrayRef) {
-        test_binary_numeric_array(array)
+    fn test_sparse_binary_numeric_default(array: ArrayRef) {
+        test_binary_numeric_array(&array, &mut SESSION.create_execution_ctx());
     }
 
     #[test]
@@ -148,26 +152,6 @@ mod test {
             .into_array(),
         )
     }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::f32;
-
-    use rstest::rstest;
-    use vortex_array::IntoArray;
-    use vortex_array::arrays::PrimitiveArray;
-    use vortex_array::builtins::ArrayBuiltins;
-    use vortex_array::compute::conformance::binary_numeric::test_binary_numeric_array;
-    use vortex_array::compute::conformance::consistency::test_array_consistency;
-    use vortex_array::dtype::DType;
-    use vortex_array::dtype::Nullability;
-    use vortex_array::dtype::PType;
-    use vortex_array::scalar::Scalar;
-    use vortex_buffer::buffer;
-
-    use crate::Sparse;
-    use crate::SparseArray;
 
     #[rstest]
     // Basic sparse arrays
@@ -229,9 +213,8 @@ mod tests {
             null_fill_value
         ).unwrap()
     })]
-
     fn test_sparse_consistency(#[case] array: SparseArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx());
     }
 
     #[rstest]
@@ -272,6 +255,6 @@ mod tests {
         Scalar::from(0i32)
     ).unwrap())]
     fn test_sparse_binary_numeric(#[case] array: SparseArray) {
-        test_binary_numeric_array(array.into_array());
+        test_binary_numeric_array(&array.into_array(), &mut SESSION.create_execution_ctx());
     }
 }
diff --git a/encodings/zigzag/src/array.rs b/encodings/zigzag/src/array.rs
index 281c23ca4c9..8c4be0d5544 100644
--- a/encodings/zigzag/src/array.rs
+++ b/encodings/zigzag/src/array.rs
@@ -261,8 +261,8 @@ impl ValidityChild<ZigZag> for ZigZag {
 #[cfg(test)]
 mod test {
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::scalar::Scalar;
     use vortex_buffer::buffer;
@@ -272,7 +272,7 @@ mod test {
 
     #[test]
     fn test_compute_statistics() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = buffer![1i32, -5i32, 2, 3, 4, 5, 6, 7, 8, 9, 10]
             .into_array()
             .execute::<PrimitiveArray>(&mut ctx)?;
diff --git a/encodings/zigzag/src/compute/mod.rs b/encodings/zigzag/src/compute/mod.rs
index 41e83d187e2..1da341989c5 100644
--- a/encodings/zigzag/src/compute/mod.rs
+++ b/encodings/zigzag/src/compute/mod.rs
@@ -218,7 +218,7 @@ mod tests {
     #[case::zigzag_large_i32(zigzag_encode(PrimitiveArray::from_iter(-500..500).as_view()).unwrap())]
     #[case::zigzag_large_i64(zigzag_encode(PrimitiveArray::from_iter((-1000..1000).map(|i| i as i64 * 100)).as_view()).unwrap())]
     fn test_zigzag_consistency(#[case] array: ZigZagArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx());
     }
 
     #[rstest]
@@ -228,6 +228,6 @@ mod tests {
     #[case::zigzag_i64_basic(zigzag_encode(PrimitiveArray::from_iter([-10000i64, -5000, 0, 5000, 10000]).as_view()).unwrap())]
     #[case::zigzag_i32_large(zigzag_encode(PrimitiveArray::from_iter((-50..50).map(|i| i * 10)).as_view()).unwrap())]
     fn test_zigzag_binary_numeric(#[case] array: ZigZagArray) {
-        test_binary_numeric_array(array.into_array());
+        test_binary_numeric_array(&array.into_array(), &mut SESSION.create_execution_ctx());
     }
 }
diff --git a/encodings/zstd/src/compute/mod.rs b/encodings/zstd/src/compute/mod.rs
index de175eb3154..75ef5273ca5 100644
--- a/encodings/zstd/src/compute/mod.rs
+++ b/encodings/zstd/src/compute/mod.rs
@@ -7,8 +7,8 @@ mod cast;
 mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::consistency::test_array_consistency;
     use vortex_buffer::buffer;
@@ -18,23 +18,23 @@ mod tests {
 
     fn zstd_i32() -> ZstdArray {
         let values = PrimitiveArray::from_iter([100i32, 200, 300, 400, 500]);
-        Zstd::from_primitive(&values, 0, 0, &mut LEGACY_SESSION.create_execution_ctx()).unwrap()
+        Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap()
     }
 
     fn zstd_f64() -> ZstdArray {
         let values = PrimitiveArray::from_iter([1.1f64, 2.2, 3.3, 4.4, 5.5]);
-        Zstd::from_primitive(&values, 0, 0, &mut LEGACY_SESSION.create_execution_ctx()).unwrap()
+        Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap()
     }
 
     fn zstd_u32() -> ZstdArray {
         let values = PrimitiveArray::from_iter([10u32, 20, 30, 40, 50]);
-        Zstd::from_primitive(&values, 0, 0, &mut LEGACY_SESSION.create_execution_ctx()).unwrap()
+        Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap()
     }
 
     fn zstd_nullable_i64() -> ZstdArray {
         let values =
             PrimitiveArray::from_option_iter([Some(1000i64), None, Some(3000), Some(4000), None]);
-        Zstd::from_primitive(&values, 0, 0, &mut LEGACY_SESSION.create_execution_ctx()).unwrap()
+        Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap()
     }
 
     fn zstd_single() -> ZstdArray {
@@ -42,7 +42,7 @@ mod tests {
             buffer![42i64],
             vortex_array::validity::Validity::NonNullable,
         );
-        Zstd::from_primitive(&values, 0, 0, &mut LEGACY_SESSION.create_execution_ctx()).unwrap()
+        Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap()
     }
 
     fn zstd_large() -> ZstdArray {
@@ -50,7 +50,7 @@ mod tests {
             buffer![0u32..1000],
             vortex_array::validity::Validity::NonNullable,
         );
-        Zstd::from_primitive(&values, 3, 0, &mut LEGACY_SESSION.create_execution_ctx()).unwrap()
+        Zstd::from_primitive(&values, 3, 0, &mut array_session().create_execution_ctx()).unwrap()
     }
 
     fn zstd_all_same() -> ZstdArray {
@@ -58,12 +58,12 @@ mod tests {
             buffer![42i32; 100],
             vortex_array::validity::Validity::NonNullable,
         );
-        Zstd::from_primitive(&values, 0, 0, &mut LEGACY_SESSION.create_execution_ctx()).unwrap()
+        Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap()
     }
 
     fn zstd_negative() -> ZstdArray {
         let values = PrimitiveArray::from_iter([-100i32, -50, 0, 50, 100]);
-        Zstd::from_primitive(&values, 0, 0, &mut LEGACY_SESSION.create_execution_ctx()).unwrap()
+        Zstd::from_primitive(&values, 0, 0, &mut array_session().create_execution_ctx()).unwrap()
     }
 
     #[rstest]
@@ -76,6 +76,9 @@ mod tests {
     #[case::all_same(zstd_all_same())]
     #[case::negative(zstd_negative())]
     fn test_zstd_consistency(#[case] array: ZstdArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/encodings/zstd/src/test.rs b/encodings/zstd/src/test.rs
index e52cea12afa..cf45eb97c04 100644
--- a/encodings/zstd/src/test.rs
+++ b/encodings/zstd/src/test.rs
@@ -3,8 +3,8 @@
 #![expect(clippy::cast_possible_truncation)]
 
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
+use vortex_array::array_session;
 use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::VarBinViewArray;
@@ -21,7 +21,7 @@ use crate::Zstd;
 
 #[test]
 fn test_zstd_compress_decompress() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let data: Vec<i32> = (0..200).collect();
     let array = PrimitiveArray::from_iter(data.clone());
 
@@ -55,7 +55,7 @@ fn test_zstd_compress_decompress() {
 
 #[test]
 fn test_zstd_empty() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let data: Vec<i32> = vec![];
     let array = PrimitiveArray::new(
         data.iter().cloned().collect::<Buffer<_>>(),
@@ -69,7 +69,7 @@ fn test_zstd_empty() {
 
 #[test]
 fn test_zstd_with_validity_and_multi_frame() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let data: Vec<i32> = (0..200).collect();
     let mut validity: Vec<bool> = vec![false; 200];
     validity[3] = true;
@@ -123,7 +123,7 @@ fn test_zstd_with_validity_and_multi_frame() {
 
 #[test]
 fn test_zstd_with_dict() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let data: Vec<i32> = (0..200).collect();
     let array = PrimitiveArray::new(
         data.iter().cloned().collect::<Buffer<_>>(),
@@ -153,7 +153,7 @@ fn test_zstd_with_dict() {
 
 #[test]
 fn test_validity_vtable() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let mask_bools = vec![false, true, true, false, true];
     let array = PrimitiveArray::new(
         (0..5).collect::<Buffer<_>>(),
@@ -164,7 +164,7 @@ fn test_validity_vtable() {
     assert_eq!(
         arr.validity()
             .unwrap()
-            .execute_mask(arr.len(), &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_mask(arr.len(), &mut array_session().create_execution_ctx())
             .unwrap(),
         Mask::from_iter(mask_bools)
     );
@@ -173,7 +173,7 @@ fn test_validity_vtable() {
         sliced
             .validity()
             .unwrap()
-            .execute_mask(sliced.len(), &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_mask(sliced.len(), &mut array_session().create_execution_ctx())
             .unwrap(),
         Mask::from_iter(vec![true, true, false])
     );
@@ -181,7 +181,7 @@ fn test_validity_vtable() {
 
 #[test]
 fn test_zstd_var_bin_view() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let data: [Option<&'static [u8]>; 5] = [
         Some(b"foo"),
         Some(b"bar"),
@@ -207,7 +207,7 @@ fn test_zstd_var_bin_view() {
 
 #[test]
 fn test_zstd_decompress_var_bin_view() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let data: [Option<&'static [u8]>; 5] = [
         Some(b"foo"),
         Some(b"bar"),
@@ -238,7 +238,7 @@ fn test_zstd_decompress_var_bin_view() {
 
 #[test]
 fn test_sliced_array_children() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let data: Vec<Option<i32>> = (0..10).map(|v| (v != 5).then_some(v)).collect();
     let compressed =
         Zstd::from_primitive(&PrimitiveArray::from_option_iter(data), 0, 100, &mut ctx).unwrap();
@@ -250,7 +250,7 @@ fn test_sliced_array_children() {
 /// the buffer alignment when compressing primitive arrays.
 #[test]
 fn test_zstd_frame_start_buffer_alignment() {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let data = vec![0u8; 2];
     let aligned_buffer = Buffer::copy_from_aligned(&data, Alignment::new(8));
     // u8 array now has a 8-byte alignment.
diff --git a/encodings/zstd/src/zstd_buffers.rs b/encodings/zstd/src/zstd_buffers.rs
index df6ee882d6f..a23d9dd13fd 100644
--- a/encodings/zstd/src/zstd_buffers.rs
+++ b/encodings/zstd/src/zstd_buffers.rs
@@ -492,8 +492,8 @@ mod tests {
     use rstest::rstest;
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::VarBinViewArray;
     use vortex_array::assert_arrays_eq;
@@ -544,12 +544,12 @@ mod tests {
     #[case::empty_primitive(make_empty_primitive_array())]
     #[case::inlined_varbinview(make_inlined_varbinview_array())]
     fn test_roundtrip(#[case] input: ArrayRef) -> VortexResult<()> {
-        let compressed = ZstdBuffers::compress(&input, 3, &LEGACY_SESSION)?;
+        let compressed = ZstdBuffers::compress(&input, 3, &array_session())?;
 
         assert_eq!(compressed.len(), input.len());
         assert_eq!(compressed.dtype(), input.dtype());
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let decompressed = compressed.into_array().execute::<ArrayRef>(&mut ctx)?;
 
         assert_arrays_eq!(input, decompressed, &mut ctx);
@@ -561,7 +561,7 @@ mod tests {
         let input = make_primitive_array();
         input.statistics().set(Stat::Min, Precision::exact(0i32));
 
-        let compressed = ZstdBuffers::compress(&input, 3, &LEGACY_SESSION)?;
+        let compressed = ZstdBuffers::compress(&input, 3, &array_session())?;
 
         assert!(!compressed.statistics().get(Stat::Min).is_absent());
         Ok(())
@@ -570,9 +570,9 @@ mod tests {
     #[test]
     fn test_validity_delegates_for_nullable_input() -> VortexResult<()> {
         let input = make_nullable_primitive_array();
-        let compressed = ZstdBuffers::compress(&input, 3, &LEGACY_SESSION)?.into_array();
+        let compressed = ZstdBuffers::compress(&input, 3, &array_session())?.into_array();
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(compressed.all_valid(&mut ctx)?, input.all_valid(&mut ctx)?);
         assert_eq!(
             compressed.all_invalid(&mut ctx)?,
diff --git a/fuzz/src/array/fill_null.rs b/fuzz/src/array/fill_null.rs
index 7b3ebdbdf22..f3a49b25637 100644
--- a/fuzz/src/array/fill_null.rs
+++ b/fuzz/src/array/fill_null.rs
@@ -300,8 +300,8 @@ fn fill_varbinview_array(
 mod tests {
     use vortex_array::Canonical;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::DecimalArray;
     use vortex_array::arrays::PrimitiveArray;
@@ -322,13 +322,13 @@ mod tests {
     fn canonical(array: impl IntoArray) -> Canonical {
         array
             .into_array()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<Canonical>(&mut array_session().create_execution_ctx())
             .unwrap()
     }
 
     #[test]
     fn test_fill_null_primitive() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None, Some(5)]);
         let fill_value = Scalar::from(42i32);
 
@@ -340,7 +340,7 @@ mod tests {
 
     #[test]
     fn test_fill_null_bool() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let data_buffer = BitBuffer::from(vec![true, false, false, false]);
         let validity_buffer = BitBuffer::from(vec![true, false, true, false]);
         let array = BoolArray::new(data_buffer, Validity::from(validity_buffer));
@@ -354,7 +354,7 @@ mod tests {
 
     #[test]
     fn test_fill_null_string() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = VarBinViewArray::from_iter(
             [Some("hello"), None, Some("world")].iter().copied(),
             DType::Utf8(Nullability::Nullable),
@@ -369,7 +369,7 @@ mod tests {
 
     #[test]
     fn test_fill_null_all_invalid() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::from_option_iter([None::<i32>, None, None]);
         let fill_value = Scalar::from(100i32);
 
@@ -381,7 +381,7 @@ mod tests {
 
     #[test]
     fn test_fill_null_no_nulls() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::from_iter([1i32, 2, 3]);
         let fill_value = Scalar::from(42i32);
 
@@ -394,7 +394,7 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_fill_null_with_null_value_errors() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3)]);
         let fill_value = Scalar::null(DType::Primitive(PType::I32, Nullability::Nullable));
 
@@ -411,7 +411,7 @@ mod tests {
 
     #[test]
     fn test_fill_null_decimal_i32() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = DecimalArray::from_option_iter(
             [Some(100i32), None, Some(300i32), None, Some(500i32)],
             DecimalDType::new(10, 2),
@@ -433,7 +433,7 @@ mod tests {
 
     #[test]
     fn test_fill_null_decimal_i64() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = DecimalArray::from_option_iter(
             [Some(1000i64), None, Some(3000i64)],
             DecimalDType::new(15, 3),
@@ -453,7 +453,7 @@ mod tests {
 
     #[test]
     fn test_fill_null_decimal_i128() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = DecimalArray::from_option_iter(
             [Some(10000i128), None, Some(30000i128), None],
             DecimalDType::new(20, 4),
@@ -475,7 +475,7 @@ mod tests {
 
     #[test]
     fn test_fill_null_decimal_all_invalid() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array =
             DecimalArray::from_option_iter([None::<i64>, None, None], DecimalDType::new(10, 2));
         let fill_value = Scalar::decimal(
@@ -498,7 +498,7 @@ mod tests {
 
     #[test]
     fn test_fill_null_decimal_no_nulls() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = DecimalArray::from_option_iter(
             [Some(100i32), Some(200i32), Some(300i32)],
             DecimalDType::new(10, 2),
diff --git a/fuzz/src/array/mask.rs b/fuzz/src/array/mask.rs
index 537421d4bd0..f3cecec2b10 100644
--- a/fuzz/src/array/mask.rs
+++ b/fuzz/src/array/mask.rs
@@ -156,9 +156,10 @@ pub fn mask_canonical_array(
 #[cfg(test)]
 mod tests {
     use vortex_array::Canonical;
+    use vortex_array::ExecutionCtx;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::DecimalArray;
     use vortex_array::arrays::FixedSizeListArray;
@@ -175,20 +176,17 @@ mod tests {
 
     use super::mask_canonical_array;
 
-    fn canonical(array: impl IntoArray) -> Canonical {
-        array
-            .into_array()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
-            .unwrap()
+    fn canonical(array: impl IntoArray, ctx: &mut ExecutionCtx) -> Canonical {
+        array.into_array().execute::<Canonical>(ctx).unwrap()
     }
 
     #[test]
     fn test_mask_null_array() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = NullArray::new(5);
         let mask = Mask::from_iter([true, false, true, false, true]);
 
-        let result = mask_canonical_array(canonical(array), &mask, &mut ctx).unwrap();
+        let result = mask_canonical_array(canonical(array, &mut ctx), &mask, &mut ctx).unwrap();
 
         assert_eq!(result.len(), 5);
         // All values should still be null
@@ -199,11 +197,11 @@ mod tests {
 
     #[test]
     fn test_mask_bool_array() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = BoolArray::from_iter([true, false, true, false, true]);
         let mask = Mask::from_iter([false, true, true, false, true]);
 
-        let result = mask_canonical_array(canonical(array), &mask, &mut ctx).unwrap();
+        let result = mask_canonical_array(canonical(array, &mut ctx), &mask, &mut ctx).unwrap();
 
         let expected = BoolArray::from_iter([None, Some(false), Some(true), None, Some(true)]);
         assert_arrays_eq!(result, expected, &mut ctx);
@@ -211,11 +209,11 @@ mod tests {
 
     #[test]
     fn test_mask_primitive_array() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]);
         let mask = Mask::from_iter([true, false, true, false, true]);
 
-        let result = mask_canonical_array(canonical(array), &mask, &mut ctx).unwrap();
+        let result = mask_canonical_array(canonical(array, &mut ctx), &mask, &mut ctx).unwrap();
 
         let expected = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None, Some(5)]);
         assert_arrays_eq!(result, expected, &mut ctx);
@@ -223,11 +221,11 @@ mod tests {
 
     #[test]
     fn test_mask_primitive_array_with_nulls() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), Some(4), None]);
         let mask = Mask::from_iter([false, true, true, false, true]);
 
-        let result = mask_canonical_array(canonical(array), &mask, &mut ctx).unwrap();
+        let result = mask_canonical_array(canonical(array, &mut ctx), &mask, &mut ctx).unwrap();
 
         let expected = PrimitiveArray::from_option_iter([None, None, Some(3i32), None, None]);
         assert_arrays_eq!(result, expected, &mut ctx);
@@ -235,7 +233,7 @@ mod tests {
 
     #[test]
     fn test_mask_decimal_array() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DecimalDType::new(10, 2);
         let array = DecimalArray::from_option_iter(
             [Some(1i128), Some(2), Some(3), Some(4), Some(5)],
@@ -243,7 +241,7 @@ mod tests {
         );
         let mask = Mask::from_iter([true, true, false, true, true]);
 
-        let result = mask_canonical_array(canonical(array), &mask, &mut ctx).unwrap();
+        let result = mask_canonical_array(canonical(array, &mut ctx), &mask, &mut ctx).unwrap();
 
         let expected =
             DecimalArray::from_option_iter([Some(1i128), Some(2), None, Some(4), Some(5)], dtype);
@@ -252,11 +250,11 @@ mod tests {
 
     #[test]
     fn test_mask_varbinview_array() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = VarBinViewArray::from_iter_str(["one", "two", "three", "four", "five"]);
         let mask = Mask::from_iter([false, true, false, true, false]);
 
-        let result = mask_canonical_array(canonical(array), &mask, &mut ctx).unwrap();
+        let result = mask_canonical_array(canonical(array, &mut ctx), &mask, &mut ctx).unwrap();
 
         let expected =
             VarBinViewArray::from_iter_nullable_str([None, Some("two"), None, Some("four"), None]);
@@ -265,7 +263,7 @@ mod tests {
 
     #[test]
     fn test_mask_list_array() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let elements = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5, 6]).into_array();
         let offsets = PrimitiveArray::from_iter([0i32, 2, 4]).into_array();
         let sizes = PrimitiveArray::from_iter([2i32, 2, 2]).into_array();
@@ -276,7 +274,7 @@ mod tests {
 
         let mask = Mask::from_iter([true, false, true]);
 
-        let result = mask_canonical_array(canonical(array), &mask, &mut ctx).unwrap();
+        let result = mask_canonical_array(canonical(array, &mut ctx), &mask, &mut ctx).unwrap();
 
         assert_eq!(result.len(), 3);
         assert!(result.is_valid(0, &mut ctx).unwrap());
@@ -286,14 +284,14 @@ mod tests {
 
     #[test]
     fn test_mask_fixed_size_list_array() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let elements = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5, 6]).into_array();
         let array =
             FixedSizeListArray::try_new(elements, 2, Nullability::NonNullable.into(), 3).unwrap();
 
         let mask = Mask::from_iter([false, true, false]);
 
-        let result = mask_canonical_array(canonical(array), &mask, &mut ctx).unwrap();
+        let result = mask_canonical_array(canonical(array, &mut ctx), &mask, &mut ctx).unwrap();
 
         assert_eq!(result.len(), 3);
         assert!(!result.is_valid(0, &mut ctx).unwrap());
@@ -303,7 +301,7 @@ mod tests {
 
     #[test]
     fn test_mask_struct_array() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let field1 = PrimitiveArray::from_iter([1i32, 2, 3]).into_array();
         let field2 = PrimitiveArray::from_iter([4i32, 5, 6]).into_array();
         let fields = vec![field1, field2];
@@ -318,7 +316,7 @@ mod tests {
 
         let mask = Mask::from_iter([true, false, true]);
 
-        let result = mask_canonical_array(canonical(array), &mask, &mut ctx).unwrap();
+        let result = mask_canonical_array(canonical(array, &mut ctx), &mask, &mut ctx).unwrap();
 
         assert_eq!(result.len(), 3);
         assert!(result.is_valid(0, &mut ctx).unwrap());
@@ -328,11 +326,11 @@ mod tests {
 
     #[test]
     fn test_mask_all_false() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]);
         let mask = Mask::AllFalse(5);
 
-        let result = mask_canonical_array(canonical(array), &mask, &mut ctx).unwrap();
+        let result = mask_canonical_array(canonical(array, &mut ctx), &mask, &mut ctx).unwrap();
 
         let expected = PrimitiveArray::from_option_iter([None, None, None, None, None::<i32>]);
         assert_arrays_eq!(result, expected, &mut ctx);
@@ -340,11 +338,11 @@ mod tests {
 
     #[test]
     fn test_mask_all_true() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::from_iter([1i32, 2, 3, 4, 5]);
         let mask = Mask::AllTrue(5);
 
-        let result = mask_canonical_array(canonical(array), &mask, &mut ctx).unwrap();
+        let result = mask_canonical_array(canonical(array, &mut ctx), &mask, &mut ctx).unwrap();
 
         let expected =
             PrimitiveArray::from_option_iter([Some(1i32), Some(2), Some(3), Some(4), Some(5)]);
@@ -353,10 +351,11 @@ mod tests {
 
     #[test]
     fn test_mask_empty_array() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::from_iter(Vec::<i32>::new());
         for mask in [Mask::AllFalse(0), Mask::AllTrue(0)] {
-            let result = mask_canonical_array(canonical(array.clone()), &mask, &mut ctx).unwrap();
+            let result =
+                mask_canonical_array(canonical(array.clone(), &mut ctx), &mask, &mut ctx).unwrap();
             assert_eq!(result.len(), 0);
         }
     }
diff --git a/vortex-array/src/aggregate_fn/fns/all_nan/mod.rs b/vortex-array/src/aggregate_fn/fns/all_nan/mod.rs
index cd703af7529..44bed7406f3 100644
--- a/vortex-array/src/aggregate_fn/fns/all_nan/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/all_nan/mod.rs
@@ -133,12 +133,12 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::DynAccumulator;
     use crate::aggregate_fn::EmptyOptions;
     use crate::aggregate_fn::fns::all_nan::AllNan;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -146,7 +146,7 @@ mod tests {
 
     #[test]
     fn all_nan_aggregate_fn() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::F32, Nullability::Nullable);
         let mut acc = Accumulator::try_new(AllNan, EmptyOptions, dtype)?;
 
@@ -159,7 +159,7 @@ mod tests {
 
     #[test]
     fn all_nan_false_with_non_nan() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::F32, Nullability::Nullable);
         let mut acc = Accumulator::try_new(AllNan, EmptyOptions, dtype)?;
 
@@ -179,7 +179,7 @@ mod tests {
 
     #[test]
     fn all_nan_false_with_null() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::F32, Nullability::Nullable);
         let mut acc = Accumulator::try_new(AllNan, EmptyOptions, dtype)?;
 
diff --git a/vortex-array/src/aggregate_fn/fns/all_non_distinct/tests.rs b/vortex-array/src/aggregate_fn/fns/all_non_distinct/tests.rs
index 86fe5b2faf9..ab513670c18 100644
--- a/vortex-array/src/aggregate_fn/fns/all_non_distinct/tests.rs
+++ b/vortex-array/src/aggregate_fn/fns/all_non_distinct/tests.rs
@@ -9,8 +9,8 @@ use super::all_non_distinct;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
+use crate::array_session;
 use crate::arrays::BoolArray;
 use crate::arrays::ChunkedArray;
 use crate::arrays::DecimalArray;
@@ -43,7 +43,7 @@ fn scalar_baseline(a: &ArrayRef, b: &ArrayRef, ctx: &mut ExecutionCtx) -> Vortex
 
 /// Assert that `all_non_distinct` agrees with the scalar baseline.
 fn assert_matches_baseline(a: &ArrayRef, b: &ArrayRef) -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let expected = scalar_baseline(a, b, &mut ctx)?;
     let actual = all_non_distinct(a, b, &mut ctx)?;
     assert_eq!(
@@ -88,7 +88,7 @@ fn bool_non_nullable(
 ) -> VortexResult<()> {
     let a = BoolArray::from_iter(a.iter().copied()).into_array();
     let b = BoolArray::from_iter(b.iter().copied()).into_array();
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     assert_eq!(all_non_distinct(&a, &b, &mut ctx)?, expected);
     assert_matches_baseline(&a, &b)
 }
@@ -121,7 +121,7 @@ fn bool_nullable(
 ) -> VortexResult<()> {
     let a = BoolArray::from_iter(a.iter().copied()).into_array();
     let b = BoolArray::from_iter(b.iter().copied()).into_array();
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     assert_eq!(all_non_distinct(&a, &b, &mut ctx)?, expected);
     assert_matches_baseline(&a, &b)
 }
@@ -140,7 +140,7 @@ fn primitive_i32(
 ) -> VortexResult<()> {
     let a = PrimitiveArray::from_iter(a).into_array();
     let b = PrimitiveArray::from_iter(b).into_array();
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     assert_eq!(all_non_distinct(&a, &b, &mut ctx)?, expected);
     assert_matches_baseline(&a, &b)
 }
@@ -206,7 +206,7 @@ fn primitive_nullable(
 ) -> VortexResult<()> {
     let a = PrimitiveArray::from_option_iter(a.iter().copied()).into_array();
     let b = PrimitiveArray::from_option_iter(b.iter().copied()).into_array();
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     assert_eq!(all_non_distinct(&a, &b, &mut ctx)?, expected);
     assert_matches_baseline(&a, &b)
 }
@@ -235,7 +235,7 @@ fn strings_non_nullable(
 ) -> VortexResult<()> {
     let a = VarBinViewArray::from_iter_str(a.iter().copied()).into_array();
     let b = VarBinViewArray::from_iter_str(b.iter().copied()).into_array();
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     assert_eq!(all_non_distinct(&a, &b, &mut ctx)?, expected);
     assert_matches_baseline(&a, &b)
 }
@@ -258,7 +258,7 @@ fn strings_nullable(
 ) -> VortexResult<()> {
     let a = VarBinViewArray::from_iter_nullable_str(a.iter().copied()).into_array();
     let b = VarBinViewArray::from_iter_nullable_str(b.iter().copied()).into_array();
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     assert_eq!(all_non_distinct(&a, &b, &mut ctx)?, expected);
     assert_matches_baseline(&a, &b)
 }
diff --git a/vortex-array/src/aggregate_fn/fns/all_non_nan/mod.rs b/vortex-array/src/aggregate_fn/fns/all_non_nan/mod.rs
index a1786eee500..4ce3aed9da9 100644
--- a/vortex-array/src/aggregate_fn/fns/all_non_nan/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/all_non_nan/mod.rs
@@ -123,12 +123,12 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::DynAccumulator;
     use crate::aggregate_fn::EmptyOptions;
     use crate::aggregate_fn::fns::all_non_nan::AllNonNan;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -136,7 +136,7 @@ mod tests {
 
     #[test]
     fn all_non_nan_aggregate_fn() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::F32, Nullability::Nullable);
         let mut acc = Accumulator::try_new(AllNonNan, EmptyOptions, dtype)?;
 
@@ -149,7 +149,7 @@ mod tests {
 
     #[test]
     fn all_non_nan_false_with_nan() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::F32, Nullability::Nullable);
         let mut acc = Accumulator::try_new(AllNonNan, EmptyOptions, dtype)?;
 
@@ -178,7 +178,7 @@ mod tests {
 
     #[test]
     fn all_non_nan_true_with_nulls() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::F32, Nullability::Nullable);
         let mut acc = Accumulator::try_new(AllNonNan, EmptyOptions, dtype)?;
 
diff --git a/vortex-array/src/aggregate_fn/fns/all_non_null/mod.rs b/vortex-array/src/aggregate_fn/fns/all_non_null/mod.rs
index f318c2586a4..9ce37669f02 100644
--- a/vortex-array/src/aggregate_fn/fns/all_non_null/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/all_non_null/mod.rs
@@ -113,12 +113,12 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::DynAccumulator;
     use crate::aggregate_fn::EmptyOptions;
     use crate::aggregate_fn::fns::all_non_null::AllNonNull;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -126,7 +126,7 @@ mod tests {
 
     #[test]
     fn all_non_null_aggregate_fn() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullability::Nullable);
         let mut acc = Accumulator::try_new(AllNonNull, EmptyOptions, dtype)?;
 
@@ -139,7 +139,7 @@ mod tests {
 
     #[test]
     fn all_non_null_false_with_nulls() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullability::Nullable);
         let mut acc = Accumulator::try_new(AllNonNull, EmptyOptions, dtype)?;
 
@@ -152,7 +152,7 @@ mod tests {
 
     #[test]
     fn all_non_null_true_for_empty_input() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullability::Nullable);
         let mut acc = Accumulator::try_new(AllNonNull, EmptyOptions, dtype)?;
 
diff --git a/vortex-array/src/aggregate_fn/fns/all_null/mod.rs b/vortex-array/src/aggregate_fn/fns/all_null/mod.rs
index 838f0502e4f..54bf37d502d 100644
--- a/vortex-array/src/aggregate_fn/fns/all_null/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/all_null/mod.rs
@@ -116,12 +116,12 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::DynAccumulator;
     use crate::aggregate_fn::EmptyOptions;
     use crate::aggregate_fn::fns::all_null::AllNull;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -129,7 +129,7 @@ mod tests {
 
     #[test]
     fn all_null_aggregate_fn() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullability::Nullable);
         let mut acc = Accumulator::try_new(AllNull, EmptyOptions, dtype)?;
 
@@ -142,7 +142,7 @@ mod tests {
 
     #[test]
     fn all_null_false_with_non_nulls() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullability::Nullable);
         let mut acc = Accumulator::try_new(AllNull, EmptyOptions, dtype)?;
 
@@ -155,7 +155,7 @@ mod tests {
 
     #[test]
     fn all_null_true_for_empty_input() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullability::Nullable);
         let mut acc = Accumulator::try_new(AllNull, EmptyOptions, dtype)?;
 
diff --git a/vortex-array/src/aggregate_fn/fns/bounded_max/mod.rs b/vortex-array/src/aggregate_fn/fns/bounded_max/mod.rs
index a39f08745e5..8da704d7c9f 100644
--- a/vortex-array/src/aggregate_fn/fns/bounded_max/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/bounded_max/mod.rs
@@ -321,7 +321,6 @@ mod tests {
     use vortex_session::VortexSession;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::AggregateFnSatisfaction;
@@ -334,6 +333,7 @@ mod tests {
     use crate::aggregate_fn::fns::bounded_max::make_bounded_max_partial_dtype;
     use crate::aggregate_fn::fns::max::Max;
     use crate::aggregate_fn::fns::min::Min;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::VarBinViewArray;
     use crate::dtype::Nullability;
@@ -345,12 +345,12 @@ mod tests {
     }
 
     fn fresh_session() -> VortexSession {
-        crate::array_session()
+        array_session()
     }
 
     #[test]
     fn bounded_max_truncates_utf8_to_upper_bound() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = VarBinViewArray::from_iter_str(["aardvark", "char🪩"]).into_array();
         let mut acc = Accumulator::try_new(
             BoundedMax,
@@ -368,7 +368,7 @@ mod tests {
 
     #[test]
     fn bounded_max_unknown_upper_bound_returns_null() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = VarBinViewArray::from_iter_bin([&[255u8, 255, 255][..]]).into_array();
         let mut acc = Accumulator::try_new(
             BoundedMax,
@@ -386,7 +386,7 @@ mod tests {
 
     #[test]
     fn bounded_max_empty_does_not_poison_later_values() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let empty = VarBinViewArray::from_iter_bin(Vec::<&[u8]>::new()).into_array();
         let values = VarBinViewArray::from_iter_bin([&[1u8][..]]).into_array();
         let mut acc = Accumulator::try_new(
@@ -409,7 +409,7 @@ mod tests {
 
     #[test]
     fn bounded_max_unknown_poisons_later_values() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let unknown = VarBinViewArray::from_iter_bin([&[255u8, 255, 255][..]]).into_array();
         let values = VarBinViewArray::from_iter_bin([&[1u8][..]]).into_array();
         let mut acc = Accumulator::try_new(
@@ -479,7 +479,7 @@ mod tests {
 
     #[test]
     fn bounded_max_keeps_fixed_width_values_exact() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::new(buffer![10i32, 20, 5], Validity::NonNullable).into_array();
         let mut acc = Accumulator::try_new(
             BoundedMax,
diff --git a/vortex-array/src/aggregate_fn/fns/bounded_min/mod.rs b/vortex-array/src/aggregate_fn/fns/bounded_min/mod.rs
index 1078cbbf5c8..dbe1e0594bd 100644
--- a/vortex-array/src/aggregate_fn/fns/bounded_min/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/bounded_min/mod.rs
@@ -238,7 +238,6 @@ mod tests {
     use vortex_session::VortexSession;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::AggregateFnSatisfaction;
@@ -250,6 +249,7 @@ mod tests {
     use crate::aggregate_fn::fns::bounded_min::BoundedMinOptions;
     use crate::aggregate_fn::fns::max::Max;
     use crate::aggregate_fn::fns::min::Min;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::VarBinViewArray;
     use crate::dtype::Nullability;
@@ -261,12 +261,12 @@ mod tests {
     }
 
     fn fresh_session() -> VortexSession {
-        crate::array_session()
+        array_session()
     }
 
     #[test]
     fn bounded_min_truncates_utf8_to_lower_bound() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array =
             VarBinViewArray::from_iter_str(["snowman⛄️snowman", "untruncated"]).into_array();
         let mut acc = Accumulator::try_new(
@@ -288,7 +288,7 @@ mod tests {
 
     #[test]
     fn bounded_min_keeps_fixed_width_values_exact() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::new(buffer![10i32, 20, 5], Validity::NonNullable).into_array();
         let mut acc = Accumulator::try_new(
             BoundedMin,
diff --git a/vortex-array/src/aggregate_fn/fns/first/mod.rs b/vortex-array/src/aggregate_fn/fns/first/mod.rs
index 22e9ef7e39d..8d04b62cdc6 100644
--- a/vortex-array/src/aggregate_fn/fns/first/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/first/mod.rs
@@ -130,7 +130,6 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::AggregateFnVTable;
@@ -138,6 +137,7 @@ mod tests {
     use crate::aggregate_fn::EmptyOptions;
     use crate::aggregate_fn::fns::first::First;
     use crate::aggregate_fn::fns::first::first;
+    use crate::array_session;
     use crate::arrays::ChunkedArray;
     use crate::arrays::ConstantArray;
     use crate::arrays::PrimitiveArray;
@@ -152,7 +152,7 @@ mod tests {
     #[test]
     fn first_non_null() -> VortexResult<()> {
         let array = PrimitiveArray::new(buffer![10i32, 20, 30], Validity::NonNullable).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(first(&array, &mut ctx)?, Scalar::primitive(10i32, Nullable));
         Ok(())
     }
@@ -161,7 +161,7 @@ mod tests {
     fn first_skips_leading_nulls() -> VortexResult<()> {
         let array =
             PrimitiveArray::from_option_iter([None, None, Some(7i32), Some(8)]).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(first(&array, &mut ctx)?, Scalar::primitive(7i32, Nullable));
         Ok(())
     }
@@ -169,7 +169,7 @@ mod tests {
     #[test]
     fn first_all_null() -> VortexResult<()> {
         let array = PrimitiveArray::from_option_iter::<i32, _>([None, None, None]).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullable);
         assert_eq!(first(&array, &mut ctx)?, Scalar::null(dtype));
         Ok(())
@@ -187,7 +187,7 @@ mod tests {
     #[test]
     fn first_constant() -> VortexResult<()> {
         let array = ConstantArray::new(42i32, 10).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(first(&array, &mut ctx)?, Scalar::primitive(42i32, Nullable));
         Ok(())
     }
@@ -196,7 +196,7 @@ mod tests {
     fn first_constant_null() -> VortexResult<()> {
         let dtype = DType::Primitive(PType::I32, Nullable);
         let array = ConstantArray::new(Scalar::null(dtype.clone()), 10).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(first(&array, &mut ctx)?, Scalar::null(dtype));
         Ok(())
     }
@@ -208,14 +208,14 @@ mod tests {
             DType::Utf8(Nullable),
         )
         .into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(first(&array, &mut ctx)?, Scalar::utf8("hello", Nullable));
         Ok(())
     }
 
     #[test]
     fn first_multi_batch_picks_earliest_non_null() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullable);
         let mut acc = Accumulator::try_new(First, EmptyOptions, dtype)?;
 
@@ -240,7 +240,7 @@ mod tests {
 
     #[test]
     fn first_finish_resets_state() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
         let mut acc = Accumulator::try_new(First, EmptyOptions, dtype)?;
 
@@ -278,7 +278,7 @@ mod tests {
         let chunk2 = PrimitiveArray::from_option_iter([None, Some(42i32), Some(100)]);
         let dtype = chunk1.dtype().clone();
         let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?;
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(
             first(&chunked.into_array(), &mut ctx)?,
             Scalar::primitive(42i32, Nullable)
diff --git a/vortex-array/src/aggregate_fn/fns/is_constant/mod.rs b/vortex-array/src/aggregate_fn/fns/is_constant/mod.rs
index 9fa5cecc6ba..ae62f71ca45 100644
--- a/vortex-array/src/aggregate_fn/fns/is_constant/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/is_constant/mod.rs
@@ -439,9 +439,9 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray as _;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::fns::is_constant::is_constant;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::arrays::ChunkedArray;
     use crate::arrays::DecimalArray;
@@ -459,7 +459,7 @@ mod tests {
     // Tests migrated from compute/is_constant.rs
     #[test]
     fn is_constant_min_max_no_nan() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         let arr = buffer![0, 1].into_array();
         arr.statistics()
@@ -478,7 +478,7 @@ mod tests {
 
     #[test]
     fn is_constant_min_max_with_nan() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         let arr = PrimitiveArray::from_iter([0.0, 0.0, f32::NAN]).into_array();
         arr.statistics()
@@ -505,7 +505,7 @@ mod tests {
     }, false)]
     fn test_bool_is_constant(#[case] input: Vec<bool>, #[case] expected: bool) -> VortexResult<()> {
         let array = BoolArray::from_iter(input);
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(is_constant(&array.into_array(), &mut ctx)?, expected);
         Ok(())
     }
@@ -525,7 +525,7 @@ mod tests {
         )?
         .into_array();
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert!(is_constant(&chunked, &mut ctx)?);
         Ok(())
     }
@@ -533,7 +533,7 @@ mod tests {
     // Tests migrated from arrays/decimal/compute/is_constant.rs
     #[test]
     fn test_decimal_is_constant() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         let array = DecimalArray::new(
             buffer![0i128, 1i128, 2i128],
@@ -554,7 +554,7 @@ mod tests {
     // Tests migrated from arrays/list/compute/is_constant.rs
     #[test]
     fn test_is_constant_nested_list() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         let xs = ListArray::try_new(
             buffer![0i32, 1, 0, 1].into_array(),
@@ -612,7 +612,7 @@ mod tests {
             Validity::NonNullable,
         )?;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(is_constant(&list_array.into_array(), &mut ctx)?, expected);
         Ok(())
     }
@@ -630,7 +630,7 @@ mod tests {
             Validity::NonNullable,
         )?;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // Both outer lists contain [[1], [2]], so should be constant
         assert!(is_constant(&outer_list.into_array(), &mut ctx)?);
         Ok(())
@@ -675,7 +675,7 @@ mod tests {
             Validity::NonNullable,
         )?;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(is_constant(&list_array.into_array(), &mut ctx)?, expected);
         Ok(())
     }
diff --git a/vortex-array/src/aggregate_fn/fns/is_sorted/mod.rs b/vortex-array/src/aggregate_fn/fns/is_sorted/mod.rs
index a4a94fc5211..57ee2d342a0 100644
--- a/vortex-array/src/aggregate_fn/fns/is_sorted/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/is_sorted/mod.rs
@@ -558,10 +558,10 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::fns::is_sorted::is_sorted;
     use crate::aggregate_fn::fns::is_sorted::is_strict_sorted;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::arrays::PrimitiveArray;
     use crate::validity::Validity;
@@ -569,7 +569,7 @@ mod tests {
     // Tests migrated from compute/is_sorted.rs
     #[test]
     fn test_is_sorted() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         let arr = PrimitiveArray::new(buffer!(0, 1, 2, 3), Validity::AllValid).into_array();
         assert!(is_sorted(&arr, &mut ctx)?);
@@ -603,7 +603,7 @@ mod tests {
 
     #[test]
     fn test_is_strict_sorted() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         let arr = PrimitiveArray::new(buffer!(0, 1, 2, 3), Validity::AllValid).into_array();
         assert!(is_strict_sorted(&arr, &mut ctx)?);
@@ -640,7 +640,7 @@ mod tests {
     #[case(PrimitiveArray::from_option_iter([None, None, Some(1i32), Some(1)]), true)]
     #[case(PrimitiveArray::from_option_iter([None, Some(5_u8), None]), false)]
     fn test_primitive_is_sorted(#[case] array: PrimitiveArray, #[case] expected: bool) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(
             is_sorted(&array.into_array(), &mut ctx)
                 .vortex_expect("operation should succeed in test"),
@@ -655,7 +655,7 @@ mod tests {
     #[case(PrimitiveArray::from_option_iter([None, None, Some(1i32), Some(1), None]), false)]
     #[case(PrimitiveArray::from_option_iter([None, Some(5_u8), None]), false)]
     fn test_primitive_is_strict_sorted(#[case] array: PrimitiveArray, #[case] expected: bool) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(
             is_strict_sorted(&array.into_array(), &mut ctx)
                 .vortex_expect("operation should succeed in test"),
@@ -672,7 +672,7 @@ mod tests {
         use crate::arrays::DecimalArray;
         use crate::dtype::DecimalDType;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DecimalDType::new(19, 2);
         let i100 = parse_decimal::<Decimal128Type>("100.00", dtype.precision(), dtype.scale())?;
         let i200 = parse_decimal::<Decimal128Type>("200.00", dtype.precision(), dtype.scale())?;
@@ -697,7 +697,7 @@ mod tests {
         use crate::arrays::DecimalArray;
         use crate::dtype::DecimalDType;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DecimalDType::new(19, 2);
         let i100 = parse_decimal::<Decimal128Type>("100.00", dtype.precision(), dtype.scale())?;
         let i200 = parse_decimal::<Decimal128Type>("200.00", dtype.precision(), dtype.scale())?;
diff --git a/vortex-array/src/aggregate_fn/fns/last/mod.rs b/vortex-array/src/aggregate_fn/fns/last/mod.rs
index a0034d0820b..61c1277ad13 100644
--- a/vortex-array/src/aggregate_fn/fns/last/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/last/mod.rs
@@ -128,7 +128,6 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::AggregateFnVTable;
@@ -136,6 +135,7 @@ mod tests {
     use crate::aggregate_fn::EmptyOptions;
     use crate::aggregate_fn::fns::last::Last;
     use crate::aggregate_fn::fns::last::last;
+    use crate::array_session;
     use crate::arrays::ChunkedArray;
     use crate::arrays::ConstantArray;
     use crate::arrays::PrimitiveArray;
@@ -150,7 +150,7 @@ mod tests {
     #[test]
     fn last_non_null() -> VortexResult<()> {
         let array = PrimitiveArray::new(buffer![10i32, 20, 30], Validity::NonNullable).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(last(&array, &mut ctx)?, Scalar::primitive(30i32, Nullable));
         Ok(())
     }
@@ -159,7 +159,7 @@ mod tests {
     fn last_skips_trailing_nulls() -> VortexResult<()> {
         let array =
             PrimitiveArray::from_option_iter([Some(7i32), Some(8), None, None]).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(last(&array, &mut ctx)?, Scalar::primitive(8i32, Nullable));
         Ok(())
     }
@@ -167,7 +167,7 @@ mod tests {
     #[test]
     fn last_all_null() -> VortexResult<()> {
         let array = PrimitiveArray::from_option_iter::<i32, _>([None, None, None]).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullable);
         assert_eq!(last(&array, &mut ctx)?, Scalar::null(dtype));
         Ok(())
@@ -185,7 +185,7 @@ mod tests {
     #[test]
     fn last_constant() -> VortexResult<()> {
         let array = ConstantArray::new(42i32, 10).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(last(&array, &mut ctx)?, Scalar::primitive(42i32, Nullable));
         Ok(())
     }
@@ -194,7 +194,7 @@ mod tests {
     fn last_constant_null() -> VortexResult<()> {
         let dtype = DType::Primitive(PType::I32, Nullable);
         let array = ConstantArray::new(Scalar::null(dtype.clone()), 10).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(last(&array, &mut ctx)?, Scalar::null(dtype));
         Ok(())
     }
@@ -206,14 +206,14 @@ mod tests {
             DType::Utf8(Nullable),
         )
         .into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(last(&array, &mut ctx)?, Scalar::utf8("world", Nullable));
         Ok(())
     }
 
     #[test]
     fn last_multi_batch_picks_latest_non_null() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullable);
         let mut acc = Accumulator::try_new(Last, EmptyOptions, dtype)?;
 
@@ -237,7 +237,7 @@ mod tests {
 
     #[test]
     fn last_finish_resets_state() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
         let mut acc = Accumulator::try_new(Last, EmptyOptions, dtype)?;
 
@@ -275,7 +275,7 @@ mod tests {
         let chunk2 = PrimitiveArray::from_option_iter::<i32, _>([None, None]);
         let dtype = chunk1.dtype().clone();
         let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?;
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(
             last(&chunked.into_array(), &mut ctx)?,
             Scalar::primitive(100i32, Nullable)
diff --git a/vortex-array/src/aggregate_fn/fns/max/mod.rs b/vortex-array/src/aggregate_fn/fns/max/mod.rs
index 6cced7133b2..79194f56941 100644
--- a/vortex-array/src/aggregate_fn/fns/max/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/max/mod.rs
@@ -218,12 +218,12 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray as _;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::DynAccumulator;
     use crate::aggregate_fn::NumericalAggregateOpts;
     use crate::aggregate_fn::fns::max::Max;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -236,7 +236,7 @@ mod tests {
 
     #[test]
     fn max_aggregate_fn() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
         let mut acc = Accumulator::try_new(Max, NumericalAggregateOpts::default(), dtype)?;
 
@@ -267,7 +267,7 @@ mod tests {
 
     #[test]
     fn max_with_nan_not_skipping() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::F64, Nullability::NonNullable);
         let mut acc = Accumulator::try_new(Max, NumericalAggregateOpts::include_nans(), dtype)?;
 
@@ -288,7 +288,7 @@ mod tests {
 
     #[test]
     fn max_not_skipping_shortcircuits_on_exact_nan_count_stat() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // The array has no NaNs; a planted exact NaNCount stat proves the poisoning came from
         // the stat rather than a scan.
         let batch = PrimitiveArray::new(buffer![1.0f64, 2.0], Validity::NonNullable).into_array();
@@ -315,7 +315,7 @@ mod tests {
     fn max_nan_including_nullable_cached_stat() -> VortexResult<()> {
         // A nullable float array's cached Max stat is reconstructed as a nullable scalar. The
         // NaN-including shortcircuit merges it as-is; `to_scalar` re-casts to the result dtype.
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array =
             PrimitiveArray::from_option_iter([Some(1.0f64), Some(2.0), Some(3.0)]).into_array();
         array
@@ -339,7 +339,7 @@ mod tests {
 
     #[test]
     fn max_casts_nonnullable_legacy_stat_to_nullable_partial() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let batch = PrimitiveArray::new(buffer![10i32, 20], Validity::NonNullable).into_array();
         batch
             .statistics()
diff --git a/vortex-array/src/aggregate_fn/fns/mean/mod.rs b/vortex-array/src/aggregate_fn/fns/mean/mod.rs
index 3edc3a105a1..061ed92c4b1 100644
--- a/vortex-array/src/aggregate_fn/fns/mean/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/mean/mod.rs
@@ -168,8 +168,8 @@ mod tests {
 
     use super::*;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::arrays::ChunkedArray;
     use crate::arrays::ConstantArray;
@@ -180,7 +180,7 @@ mod tests {
     fn mean_all_valid() -> VortexResult<()> {
         let array = PrimitiveArray::new(buffer![1.0f64, 2.0, 3.0, 4.0, 5.0], Validity::NonNullable)
             .into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mean(&array, &mut ctx)?;
         assert_eq!(result.as_primitive().as_::<f64>(), Some(3.0));
         Ok(())
@@ -189,7 +189,7 @@ mod tests {
     #[test]
     fn mean_with_nulls() -> VortexResult<()> {
         let array = PrimitiveArray::from_option_iter([Some(2.0f64), None, Some(4.0)]).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mean(&array, &mut ctx)?;
         assert_eq!(result.as_primitive().as_::<f64>(), Some(3.0));
         Ok(())
@@ -198,7 +198,7 @@ mod tests {
     #[test]
     fn mean_integers() -> VortexResult<()> {
         let array = PrimitiveArray::new(buffer![10i32, 20, 30], Validity::NonNullable).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mean(&array, &mut ctx)?;
         assert_eq!(result.as_primitive().as_::<f64>(), Some(20.0));
         Ok(())
@@ -207,7 +207,7 @@ mod tests {
     #[test]
     fn mean_bool() -> VortexResult<()> {
         let array: BoolArray = [true, false, true, true].into_iter().collect();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mean(&array.into_array(), &mut ctx)?;
         assert_eq!(result.as_primitive().as_::<f64>(), Some(0.75));
         Ok(())
@@ -216,7 +216,7 @@ mod tests {
     #[test]
     fn mean_constant_non_null() -> VortexResult<()> {
         let array = ConstantArray::new(5.0f64, 4);
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mean(&array.into_array(), &mut ctx)?;
         assert_eq!(result.as_primitive().as_::<f64>(), Some(5.0));
         Ok(())
@@ -228,7 +228,7 @@ mod tests {
         let chunk2 = PrimitiveArray::from_option_iter([Some(5.0f64), None]);
         let dtype = chunk1.dtype().clone();
         let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?;
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mean(&chunked.into_array(), &mut ctx)?;
         assert_eq!(result.as_primitive().as_::<f64>(), Some(3.0));
         Ok(())
@@ -239,7 +239,7 @@ mod tests {
         // NaNs are excluded from both the sum and the count.
         let array =
             PrimitiveArray::new(buffer![1.0f64, f64::NAN, 3.0], Validity::NonNullable).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mean(&array, &mut ctx)?;
         assert_eq!(result.as_primitive().as_::<f64>(), Some(2.0));
         Ok(())
@@ -249,7 +249,7 @@ mod tests {
     fn mean_with_nan_not_skipping() -> VortexResult<()> {
         let array =
             PrimitiveArray::new(buffer![1.0f64, f64::NAN, 3.0], Validity::NonNullable).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let keep_nans = NumericalAggregateOpts::include_nans();
         let mut acc = Accumulator::try_new(
             Mean::combined(),
@@ -265,7 +265,7 @@ mod tests {
     #[test]
     fn mean_all_null_returns_nan() -> VortexResult<()> {
         let array = PrimitiveArray::from_option_iter::<f64, _>([None, None, None]).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mean(&array, &mut ctx)?;
         assert!(result.as_primitive().as_::<f64>().is_some_and(f64::is_nan));
         Ok(())
@@ -273,7 +273,7 @@ mod tests {
 
     #[test]
     fn mean_multi_batch() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::F64, Nullability::NonNullable);
         let mut acc = Accumulator::try_new(
             Mean::combined(),
diff --git a/vortex-array/src/aggregate_fn/fns/min/mod.rs b/vortex-array/src/aggregate_fn/fns/min/mod.rs
index 202d2b1117a..8a0fbd889ed 100644
--- a/vortex-array/src/aggregate_fn/fns/min/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/min/mod.rs
@@ -218,12 +218,12 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray as _;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::DynAccumulator;
     use crate::aggregate_fn::NumericalAggregateOpts;
     use crate::aggregate_fn::fns::min::Min;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -236,7 +236,7 @@ mod tests {
 
     #[test]
     fn min_aggregate_fn() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
         let mut acc = Accumulator::try_new(Min, NumericalAggregateOpts::default(), dtype)?;
 
@@ -267,7 +267,7 @@ mod tests {
 
     #[test]
     fn min_with_nan_not_skipping() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::F64, Nullability::NonNullable);
         let mut acc = Accumulator::try_new(Min, NumericalAggregateOpts::include_nans(), dtype)?;
 
@@ -288,7 +288,7 @@ mod tests {
 
     #[test]
     fn min_not_skipping_shortcircuits_on_exact_nan_count_stat() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // The array has no NaNs; a planted exact NaNCount stat proves the poisoning came from
         // the stat rather than a scan.
         let batch = PrimitiveArray::new(buffer![1.0f64, 2.0], Validity::NonNullable).into_array();
@@ -315,7 +315,7 @@ mod tests {
     fn min_nan_including_nullable_cached_stat() -> VortexResult<()> {
         // A nullable float array's cached Min stat is reconstructed as a nullable scalar. The
         // NaN-including shortcircuit merges it as-is; `to_scalar` re-casts to the result dtype.
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array =
             PrimitiveArray::from_option_iter([Some(1.0f64), Some(2.0), Some(3.0)]).into_array();
         array
@@ -339,7 +339,7 @@ mod tests {
 
     #[test]
     fn min_casts_nonnullable_legacy_stat_to_nullable_partial() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let batch = PrimitiveArray::new(buffer![10i32, 20], Validity::NonNullable).into_array();
         batch
             .statistics()
diff --git a/vortex-array/src/aggregate_fn/fns/nan_count/mod.rs b/vortex-array/src/aggregate_fn/fns/nan_count/mod.rs
index 20ac7843065..e66b3b0fb33 100644
--- a/vortex-array/src/aggregate_fn/fns/nan_count/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/nan_count/mod.rs
@@ -185,7 +185,6 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::AggregateFnVTable;
@@ -193,6 +192,7 @@ mod tests {
     use crate::aggregate_fn::EmptyOptions;
     use crate::aggregate_fn::fns::nan_count::NanCount;
     use crate::aggregate_fn::fns::nan_count::nan_count;
+    use crate::array_session;
     use crate::arrays::ChunkedArray;
     use crate::arrays::ConstantArray;
     use crate::arrays::PrimitiveArray;
@@ -204,7 +204,7 @@ mod tests {
 
     #[test]
     fn nan_count_multi_batch() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::F64, Nullability::NonNullable);
         let mut acc = Accumulator::try_new(NanCount, EmptyOptions, dtype)?;
 
@@ -224,7 +224,7 @@ mod tests {
 
     #[test]
     fn nan_count_finish_resets_state() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::F64, Nullability::NonNullable);
         let mut acc = Accumulator::try_new(NanCount, EmptyOptions, dtype)?;
 
@@ -262,7 +262,7 @@ mod tests {
     #[test]
     fn nan_count_constant_nan() -> VortexResult<()> {
         let array = ConstantArray::new(f64::NAN, 10);
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(nan_count(&array.into_array(), &mut ctx)?, 10);
         Ok(())
     }
@@ -270,7 +270,7 @@ mod tests {
     #[test]
     fn nan_count_constant_non_nan() -> VortexResult<()> {
         let array = ConstantArray::new(1.0f64, 10);
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(nan_count(&array.into_array(), &mut ctx)?, 0);
         Ok(())
     }
@@ -290,7 +290,7 @@ mod tests {
         let chunk2 = PrimitiveArray::from_option_iter([Some(f64::NAN), Some(f64::NAN), None]);
         let dtype = chunk1.dtype().clone();
         let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?;
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(nan_count(&chunked.into_array(), &mut ctx)?, 3);
         Ok(())
     }
@@ -298,7 +298,7 @@ mod tests {
     #[test]
     fn nan_count_all_null() -> VortexResult<()> {
         let p = PrimitiveArray::from_option_iter::<f64, _>([None, None, None]);
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(nan_count(&p.into_array(), &mut ctx)?, 0);
         Ok(())
     }
diff --git a/vortex-array/src/aggregate_fn/fns/nan_count/primitive.rs b/vortex-array/src/aggregate_fn/fns/nan_count/primitive.rs
index 8d8358235cc..c9da090c7ab 100644
--- a/vortex-array/src/aggregate_fn/fns/nan_count/primitive.rs
+++ b/vortex-array/src/aggregate_fn/fns/nan_count/primitive.rs
@@ -42,9 +42,9 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::fns::nan_count::nan_count;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::validity::Validity;
 
@@ -62,7 +62,7 @@ mod tests {
             ],
             Validity::NonNullable,
         );
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(nan_count(&p.into_array(), &mut ctx)?, 2);
         Ok(())
     }
@@ -70,7 +70,7 @@ mod tests {
     #[test]
     fn primitive_nan_count_with_nulls() -> VortexResult<()> {
         let p = PrimitiveArray::from_option_iter([Some(f64::NAN), None, Some(f64::NAN), Some(1.0)]);
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(nan_count(&p.into_array(), &mut ctx)?, 2);
         Ok(())
     }
@@ -78,7 +78,7 @@ mod tests {
     #[test]
     fn primitive_nan_count_all_valid_no_nans() -> VortexResult<()> {
         let p = PrimitiveArray::new(buffer![1.0f64, 2.0, 3.0], Validity::NonNullable);
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(nan_count(&p.into_array(), &mut ctx)?, 0);
         Ok(())
     }
diff --git a/vortex-array/src/aggregate_fn/fns/null_count/mod.rs b/vortex-array/src/aggregate_fn/fns/null_count/mod.rs
index 6e3f0264e26..e06f570169d 100644
--- a/vortex-array/src/aggregate_fn/fns/null_count/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/null_count/mod.rs
@@ -155,13 +155,13 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::DynAccumulator;
     use crate::aggregate_fn::EmptyOptions;
     use crate::aggregate_fn::fns::null_count::NullCount;
     use crate::aggregate_fn::fns::null_count::null_count;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -174,7 +174,7 @@ mod tests {
     fn null_count_with_nulls() -> VortexResult<()> {
         let array =
             PrimitiveArray::from_option_iter([Some(1i32), None, Some(3), None]).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         assert_eq!(null_count(&array, &mut ctx)?, 2);
         assert_eq!(
@@ -186,7 +186,7 @@ mod tests {
 
     #[test]
     fn null_count_multi_batch() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullability::Nullable);
         let mut acc = Accumulator::try_new(NullCount, EmptyOptions, dtype)?;
 
diff --git a/vortex-array/src/aggregate_fn/fns/sum/bool.rs b/vortex-array/src/aggregate_fn/fns/sum/bool.rs
index 3c10901f96f..b3993840586 100644
--- a/vortex-array/src/aggregate_fn/fns/sum/bool.rs
+++ b/vortex-array/src/aggregate_fn/fns/sum/bool.rs
@@ -37,13 +37,13 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::AggregateFnVTable;
     use crate::aggregate_fn::DynAccumulator;
     use crate::aggregate_fn::NumericalAggregateOpts;
     use crate::aggregate_fn::fns::sum::Sum;
     use crate::aggregate_fn::fns::sum::sum;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -55,7 +55,7 @@ mod tests {
         let arr: BoolArray = [true, true, true].into_iter().collect();
         let result = sum(
             &arr.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         assert_eq!(result.as_primitive().typed_value::<u64>(), Some(3));
         Ok(())
@@ -66,7 +66,7 @@ mod tests {
         let arr: BoolArray = [true, false, true, false, true].into_iter().collect();
         let result = sum(
             &arr.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         assert_eq!(result.as_primitive().typed_value::<u64>(), Some(3));
         Ok(())
@@ -77,7 +77,7 @@ mod tests {
         let arr: BoolArray = [false, false, false].into_iter().collect();
         let result = sum(
             &arr.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         assert_eq!(result.as_primitive().typed_value::<u64>(), Some(0));
         Ok(())
@@ -88,7 +88,7 @@ mod tests {
         let arr = BoolArray::from_iter([Some(true), None, Some(true), Some(false)]);
         let result = sum(
             &arr.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         assert_eq!(result.as_primitive().typed_value::<u64>(), Some(2));
         Ok(())
@@ -99,7 +99,7 @@ mod tests {
         let arr = BoolArray::from_iter([None::<bool>, None, None]);
         let result = sum(
             &arr.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         assert_eq!(result.as_primitive().typed_value::<u64>(), Some(0));
         Ok(())
@@ -116,7 +116,7 @@ mod tests {
 
     #[test]
     fn sum_bool_finish_resets_state() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Bool(Nullability::NonNullable);
         let mut acc = Accumulator::try_new(Sum, NumericalAggregateOpts::default(), dtype)?;
 
@@ -147,7 +147,7 @@ mod tests {
     #[test]
     fn sum_boolean_from_iter() -> VortexResult<()> {
         let arr = BoolArray::from_iter([true, false, false, true]).into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result.as_primitive().as_::<i32>(), Some(2));
         Ok(())
     }
diff --git a/vortex-array/src/aggregate_fn/fns/sum/constant.rs b/vortex-array/src/aggregate_fn/fns/sum/constant.rs
index c55b66a71cc..0f366620e5c 100644
--- a/vortex-array/src/aggregate_fn/fns/sum/constant.rs
+++ b/vortex-array/src/aggregate_fn/fns/sum/constant.rs
@@ -92,9 +92,9 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::fns::sum::sum;
+    use crate::array_session;
     use crate::arrays::ConstantArray;
     use crate::dtype::DType;
     use crate::dtype::DecimalDType;
@@ -109,7 +109,7 @@ mod tests {
     #[test]
     fn sum_constant_unsigned() -> VortexResult<()> {
         let array = ConstantArray::new(5u64, 10).into_array();
-        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&array, &mut array_session().create_execution_ctx())?;
         assert_eq!(result, 50u64.into());
         Ok(())
     }
@@ -117,7 +117,7 @@ mod tests {
     #[test]
     fn sum_constant_signed() -> VortexResult<()> {
         let array = ConstantArray::new(-5i64, 10).into_array();
-        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&array, &mut array_session().create_execution_ctx())?;
         assert_eq!(result, (-50i64).into());
         Ok(())
     }
@@ -126,7 +126,7 @@ mod tests {
     fn sum_constant_nullable_value() -> VortexResult<()> {
         let array = ConstantArray::new(Scalar::null(DType::Primitive(PType::U32, Nullable)), 10)
             .into_array();
-        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&array, &mut array_session().create_execution_ctx())?;
         assert_eq!(result, Scalar::primitive(0u64, Nullable));
         Ok(())
     }
@@ -134,7 +134,7 @@ mod tests {
     #[test]
     fn sum_constant_bool_false() -> VortexResult<()> {
         let array = ConstantArray::new(false, 10).into_array();
-        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&array, &mut array_session().create_execution_ctx())?;
         assert_eq!(result, 0u64.into());
         Ok(())
     }
@@ -142,7 +142,7 @@ mod tests {
     #[test]
     fn sum_constant_bool_true() -> VortexResult<()> {
         let array = ConstantArray::new(true, 10).into_array();
-        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&array, &mut array_session().create_execution_ctx())?;
         assert_eq!(result, 10u64.into());
         Ok(())
     }
@@ -150,7 +150,7 @@ mod tests {
     #[test]
     fn sum_constant_bool_null() -> VortexResult<()> {
         let array = ConstantArray::new(Scalar::null(DType::Bool(Nullable)), 10).into_array();
-        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&array, &mut array_session().create_execution_ctx())?;
         assert_eq!(result, Scalar::primitive(0u64, Nullable));
         Ok(())
     }
@@ -168,7 +168,7 @@ mod tests {
         )
         .into_array();
 
-        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&array, &mut array_session().create_execution_ctx())?;
 
         assert_eq!(
             result.as_decimal().decimal_value(),
@@ -184,7 +184,7 @@ mod tests {
         let array = ConstantArray::new(Scalar::null(DType::Decimal(decimal_dtype, Nullable)), 10)
             .into_array();
 
-        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&array, &mut array_session().create_execution_ctx())?;
         assert_eq!(
             result,
             Scalar::decimal(
@@ -209,7 +209,7 @@ mod tests {
         )
         .into_array();
 
-        let result = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&array, &mut array_session().create_execution_ctx())?;
         assert_eq!(
             result.as_decimal().decimal_value(),
             Some(DecimalValue::I256(i256::from_i128(99_999_999_900)))
diff --git a/vortex-array/src/aggregate_fn/fns/sum/decimal.rs b/vortex-array/src/aggregate_fn/fns/sum/decimal.rs
index a98ca218040..872e5769a01 100644
--- a/vortex-array/src/aggregate_fn/fns/sum/decimal.rs
+++ b/vortex-array/src/aggregate_fn/fns/sum/decimal.rs
@@ -112,12 +112,12 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::AggregateFnVTable;
     use crate::aggregate_fn::NumericalAggregateOpts;
     use crate::aggregate_fn::fns::sum::Sum;
     use crate::aggregate_fn::fns::sum::sum;
+    use crate::array_session;
     use crate::arrays::DecimalArray;
     use crate::dtype::DType;
     use crate::dtype::DecimalDType;
@@ -139,7 +139,7 @@ mod tests {
 
         let result = sum(
             &decimal.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
 
         let expected = Scalar::try_new(
@@ -161,7 +161,7 @@ mod tests {
 
         let result = sum(
             &decimal.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
 
         let expected = Scalar::try_new(
@@ -183,7 +183,7 @@ mod tests {
 
         let result = sum(
             &decimal.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
 
         let expected = Scalar::try_new(
@@ -206,7 +206,7 @@ mod tests {
 
         let result = sum(
             &decimal.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
 
         let expected_sum = near_max as i64 + 500 + 400;
@@ -230,7 +230,7 @@ mod tests {
 
         let result = sum(
             &decimal.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
 
         let expected_sum = (large_val as i128) * 4 + 1;
@@ -253,7 +253,7 @@ mod tests {
 
         let result = sum(
             &decimal.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
 
         let expected = Scalar::try_new(
@@ -272,7 +272,7 @@ mod tests {
 
         let result = sum(
             &decimal.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
 
         let expected = Scalar::try_new(
@@ -294,7 +294,7 @@ mod tests {
 
         let result = sum(
             &decimal.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
 
         let expected = Scalar::try_new(
@@ -317,7 +317,7 @@ mod tests {
 
         let result = sum(
             &decimal.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
 
         let expected_sum =
@@ -343,7 +343,7 @@ mod tests {
         assert_eq!(
             sum(
                 &decimal.into_array(),
-                &mut LEGACY_SESSION.create_execution_ctx()
+                &mut array_session().create_execution_ctx()
             )
             .vortex_expect("operation should succeed in test"),
             Scalar::null(DType::Decimal(decimal_dtype, Nullable))
@@ -460,7 +460,7 @@ mod tests {
 
         // Drive accumulate through the vtable directly.
         let columnar = crate::Columnar::Canonical(crate::Canonical::Decimal(decimal));
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         Sum.accumulate(&mut state, &columnar, &mut ctx)?;
 
         let result = Sum.to_scalar(&state)?;
diff --git a/vortex-array/src/aggregate_fn/fns/sum/grouped.rs b/vortex-array/src/aggregate_fn/fns/sum/grouped.rs
index 8f65737c48e..efe0825d4d6 100644
--- a/vortex-array/src/aggregate_fn/fns/sum/grouped.rs
+++ b/vortex-array/src/aggregate_fn/fns/sum/grouped.rs
@@ -159,7 +159,6 @@ mod tests {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::DynGroupedAccumulator;
     use crate::aggregate_fn::GroupedAccumulator;
@@ -185,7 +184,7 @@ mod tests {
             NumericalAggregateOpts::default(),
             elem_dtype.clone(),
         )?;
-        acc.accumulate_list(groups, &mut LEGACY_SESSION.create_execution_ctx())?;
+        acc.accumulate_list(groups, &mut array_session().create_execution_ctx())?;
         acc.finish()
     }
 
@@ -199,7 +198,7 @@ mod tests {
     ) -> VortexResult<ArrayRef> {
         use crate::aggregate_fn::AggregateFnVTable;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let sum_dtype = Sum
             .partial_dtype(&NumericalAggregateOpts::default(), elem_dtype)
             .expect("sum partial dtype");
@@ -335,7 +334,7 @@ mod tests {
 
         // Group 0: NaN skipped -> 3.0. Group 1: INF + -INF = NaN. (Avoid array equality here since
         // NaN != NaN; compare element scalars against the reference path instead.)
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let expected = grouped_sum_reference(&elements, &ranges, &valid, &elem_dtype)?;
         let g0 = actual.execute_scalar(0, &mut ctx)?;
         assert_eq!(g0.as_primitive().typed_value::<f64>(), Some(3.0));
@@ -371,10 +370,10 @@ mod tests {
 
         let mut acc =
             GroupedAccumulator::try_new(Sum, NumericalAggregateOpts::include_nans(), elem_dtype)?;
-        acc.accumulate_list(&groups, &mut LEGACY_SESSION.create_execution_ctx())?;
+        acc.accumulate_list(&groups, &mut array_session().create_execution_ctx())?;
         let actual = acc.finish()?;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // Group 0 contains a NaN -> NaN sum; group 1 sums normally.
         let g0 = actual.execute_scalar(0, &mut ctx)?;
         assert!(g0.as_primitive().typed_value::<f64>().unwrap().is_nan());
diff --git a/vortex-array/src/aggregate_fn/fns/sum/mod.rs b/vortex-array/src/aggregate_fn/fns/sum/mod.rs
index e31fc7b8058..f1922aa95fa 100644
--- a/vortex-array/src/aggregate_fn/fns/sum/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/sum/mod.rs
@@ -394,7 +394,6 @@ mod tests {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::AggregateFnVTable;
@@ -429,7 +428,7 @@ mod tests {
 
     /// Sum an array with an initial value (test-only helper).
     fn sum_with_accumulator(array: &ArrayRef, accumulator: &Scalar) -> VortexResult<Scalar> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         if accumulator.is_null() {
             return Ok(accumulator.clone());
         }
@@ -485,7 +484,7 @@ mod tests {
 
     #[test]
     fn sum_multi_batch() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
         let mut acc = Accumulator::try_new(Sum, NumericalAggregateOpts::default(), dtype)?;
 
@@ -502,7 +501,7 @@ mod tests {
 
     #[test]
     fn sum_finish_resets_state() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
         let mut acc = Accumulator::try_new(Sum, NumericalAggregateOpts::default(), dtype)?;
 
@@ -553,7 +552,7 @@ mod tests {
         // compute sum with accumulator to populate stats
         sum_with_accumulator(&array, &Scalar::primitive(2i64, Nullable))?;
 
-        let sum_without_acc = sum(&array, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let sum_without_acc = sum(&array, &mut array_session().create_execution_ctx())?;
         assert_eq!(sum_without_acc, Scalar::primitive(9i64, Nullable));
         Ok(())
     }
@@ -581,7 +580,7 @@ mod tests {
             NumericalAggregateOpts::default(),
             elem_dtype.clone(),
         )?;
-        acc.accumulate_list(groups, &mut LEGACY_SESSION.create_execution_ctx())?;
+        acc.accumulate_list(groups, &mut array_session().create_execution_ctx())?;
         acc.finish()
     }
 
@@ -666,7 +665,7 @@ mod tests {
 
     #[test]
     fn grouped_sum_finish_resets() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let elem_dtype = DType::Primitive(PType::I32, Nullability::NonNullable);
         let mut acc =
             GroupedAccumulator::try_new(Sum, NumericalAggregateOpts::default(), elem_dtype)?;
@@ -730,7 +729,7 @@ mod tests {
 
         let result = sum(
             &chunked.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         assert_eq!(result.as_primitive().as_::<f64>(), Some(20.8));
         Ok(())
@@ -744,7 +743,7 @@ mod tests {
         let chunked = ChunkedArray::try_new(vec![chunk1.into_array(), chunk2.into_array()], dtype)?;
         let result = sum(
             &chunked.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         assert_eq!(result, Scalar::primitive(0f64, Nullable));
         Ok(())
@@ -767,7 +766,7 @@ mod tests {
 
         let result = sum(
             &chunked.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         assert_eq!(result.as_primitive().as_::<f64>(), Some(36.0));
         Ok(())
@@ -782,7 +781,7 @@ mod tests {
 
         let result = sum(
             &chunked.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         assert_eq!(result.as_primitive().as_::<u64>(), Some(1));
         Ok(())
@@ -814,7 +813,7 @@ mod tests {
 
         let result = sum(
             &chunked.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         let decimal_result = result.as_decimal();
         assert_eq!(
@@ -850,7 +849,7 @@ mod tests {
 
         let result = sum(
             &chunked.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         let decimal_result = result.as_decimal();
         assert_eq!(
@@ -884,7 +883,7 @@ mod tests {
 
         let result = sum(
             &chunked.into_array(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         let decimal_result = result.as_decimal();
         assert_eq!(
diff --git a/vortex-array/src/aggregate_fn/fns/sum/primitive.rs b/vortex-array/src/aggregate_fn/fns/sum/primitive.rs
index 4fad859fc46..87d8da4b143 100644
--- a/vortex-array/src/aggregate_fn/fns/sum/primitive.rs
+++ b/vortex-array/src/aggregate_fn/fns/sum/primitive.rs
@@ -184,13 +184,13 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::DynAccumulator;
     use crate::aggregate_fn::NumericalAggregateOpts;
     use crate::aggregate_fn::fns::sum::Sum;
     use crate::aggregate_fn::fns::sum::sum;
+    use crate::array_session;
     use crate::arrays::ConstantArray;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::DType;
@@ -206,7 +206,7 @@ mod tests {
     #[test]
     fn sum_i32() -> VortexResult<()> {
         let arr = PrimitiveArray::new(buffer![1i32, 2, 3, 4], Validity::NonNullable).into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result.as_primitive().typed_value::<i64>(), Some(10));
         Ok(())
     }
@@ -214,7 +214,7 @@ mod tests {
     #[test]
     fn sum_u8() -> VortexResult<()> {
         let arr = PrimitiveArray::new(buffer![10u8, 20, 30], Validity::NonNullable).into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result.as_primitive().typed_value::<u64>(), Some(60));
         Ok(())
     }
@@ -223,7 +223,7 @@ mod tests {
     fn sum_f64() -> VortexResult<()> {
         let arr =
             PrimitiveArray::new(buffer![1.5f64, 2.5, 3.0], Validity::NonNullable).into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result.as_primitive().typed_value::<f64>(), Some(7.0));
         Ok(())
     }
@@ -231,7 +231,7 @@ mod tests {
     #[test]
     fn sum_with_nulls() -> VortexResult<()> {
         let arr = PrimitiveArray::from_option_iter([Some(2i32), None, Some(4)]).into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result.as_primitive().typed_value::<i64>(), Some(6));
         Ok(())
     }
@@ -251,7 +251,7 @@ mod tests {
             Some(6),
         ])
         .into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result.as_primitive().typed_value::<i64>(), Some(21));
         Ok(())
     }
@@ -259,7 +259,7 @@ mod tests {
     #[test]
     fn sum_all_null() -> VortexResult<()> {
         let arr = PrimitiveArray::from_option_iter([None::<i32>, None, None]).into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result.as_primitive().typed_value::<i64>(), Some(0));
         Ok(())
     }
@@ -267,7 +267,7 @@ mod tests {
     #[test]
     fn sum_all_invalid_float() -> VortexResult<()> {
         let arr = PrimitiveArray::from_option_iter::<f32, _>([None, None, None]).into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result, Scalar::primitive(0f64, Nullable));
         Ok(())
     }
@@ -275,7 +275,7 @@ mod tests {
     #[test]
     fn sum_buffer_i32() -> VortexResult<()> {
         let arr = buffer![1, 1, 1, 1].into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result.as_primitive().as_::<i32>(), Some(4));
         Ok(())
     }
@@ -283,7 +283,7 @@ mod tests {
     #[test]
     fn sum_buffer_f64() -> VortexResult<()> {
         let arr = buffer![1., 1., 1., 1.].into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result.as_primitive().as_::<f32>(), Some(4.));
         Ok(())
     }
@@ -313,7 +313,7 @@ mod tests {
             Validity::NonNullable,
         )
         .into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result.as_primitive().typed_value::<f64>(), Some(6.0));
         Ok(())
     }
@@ -322,7 +322,7 @@ mod tests {
     fn sum_f32_with_nan() -> VortexResult<()> {
         let arr =
             PrimitiveArray::new(buffer![1.0f32, f32::NAN, 4.0], Validity::NonNullable).into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result.as_primitive().typed_value::<f64>(), Some(5.0));
         Ok(())
     }
@@ -331,7 +331,7 @@ mod tests {
     fn sum_f64_with_nan_and_nulls() -> VortexResult<()> {
         let arr = PrimitiveArray::from_option_iter([Some(1.0f64), None, Some(f64::NAN), Some(3.0)])
             .into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result.as_primitive().typed_value::<f64>(), Some(4.0));
         Ok(())
     }
@@ -340,7 +340,7 @@ mod tests {
     fn sum_all_nan() -> VortexResult<()> {
         let arr =
             PrimitiveArray::new(buffer![f64::NAN, f64::NAN], Validity::NonNullable).into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert_eq!(result.as_primitive().typed_value::<f64>(), Some(0.0));
         Ok(())
     }
@@ -351,7 +351,7 @@ mod tests {
         options: NumericalAggregateOpts,
     ) -> VortexResult<Scalar> {
         let mut acc = Accumulator::try_new(Sum, options, arr.dtype().clone())?;
-        acc.accumulate(arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        acc.accumulate(arr, &mut array_session().create_execution_ctx())?;
         acc.finish()
     }
 
@@ -419,7 +419,7 @@ mod tests {
             Validity::NonNullable,
         )
         .into_array();
-        let acc = sum(&batch, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let acc = sum(&batch, &mut array_session().create_execution_ctx())?;
         // INFINITY + NEG_INFINITY = NaN, which is treated as saturated
         assert!(acc.as_primitive().typed_value::<f64>().unwrap().is_nan());
 
@@ -428,7 +428,7 @@ mod tests {
             NumericalAggregateOpts::default(),
             DType::Primitive(PType::F64, Nullability::NonNullable),
         )?;
-        acc.accumulate(&batch, &mut LEGACY_SESSION.create_execution_ctx())?;
+        acc.accumulate(&batch, &mut array_session().create_execution_ctx())?;
         assert!(acc.is_saturated());
         Ok(())
     }
@@ -436,7 +436,7 @@ mod tests {
     #[test]
     fn sum_checked_overflow() -> VortexResult<()> {
         let arr = PrimitiveArray::new(buffer![i64::MAX, 1i64], Validity::NonNullable).into_array();
-        let result = sum(&arr, &mut LEGACY_SESSION.create_execution_ctx())?;
+        let result = sum(&arr, &mut array_session().create_execution_ctx())?;
         assert!(result.is_null());
         Ok(())
     }
@@ -449,7 +449,7 @@ mod tests {
 
         let batch =
             PrimitiveArray::new(buffer![i64::MAX, 1i64], Validity::NonNullable).into_array();
-        acc.accumulate(&batch, &mut LEGACY_SESSION.create_execution_ctx())?;
+        acc.accumulate(&batch, &mut array_session().create_execution_ctx())?;
         assert!(acc.is_saturated());
 
         // finish resets state, clearing saturation
diff --git a/vortex-array/src/aggregate_fn/fns/uncompressed_size_in_bytes/mod.rs b/vortex-array/src/aggregate_fn/fns/uncompressed_size_in_bytes/mod.rs
index 7a08054ef86..0b07c7cf98b 100644
--- a/vortex-array/src/aggregate_fn/fns/uncompressed_size_in_bytes/mod.rs
+++ b/vortex-array/src/aggregate_fn/fns/uncompressed_size_in_bytes/mod.rs
@@ -316,7 +316,6 @@ mod tests {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::AggregateFnVTable;
@@ -324,6 +323,7 @@ mod tests {
     use crate::aggregate_fn::EmptyOptions;
     use crate::aggregate_fn::fns::uncompressed_size_in_bytes::UncompressedSizeInBytes;
     use crate::aggregate_fn::fns::uncompressed_size_in_bytes::uncompressed_size_in_bytes;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::arrays::ChunkedArray;
     use crate::arrays::ConstantArray;
@@ -360,7 +360,7 @@ mod tests {
     }
 
     fn aggregate(array: &ArrayRef) -> VortexResult<u64> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut acc =
             Accumulator::try_new(UncompressedSizeInBytes, EmptyOptions, array.dtype().clone())?;
         acc.accumulate(array, &mut ctx)?;
@@ -545,7 +545,7 @@ mod tests {
     fn variant_stat_is_unsupported() -> VortexResult<()> {
         let child = ConstantArray::new(Scalar::variant(Scalar::from(42i32)), 3).into_array();
         let array = VariantArray::try_new(child, None)?.into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         assert_eq!(
             array
@@ -598,7 +598,7 @@ mod tests {
     #[test]
     fn helper_caches_result() -> VortexResult<()> {
         let array = PrimitiveArray::new(buffer![1i32, 2, 3], Validity::NonNullable).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         let size = uncompressed_size_in_bytes(&array, &mut ctx)?;
 
diff --git a/vortex-array/src/arrays/bool/compute/mod.rs b/vortex-array/src/arrays/bool/compute/mod.rs
index f15817ffc57..6037cac8c36 100644
--- a/vortex-array/src/arrays/bool/compute/mod.rs
+++ b/vortex-array/src/arrays/bool/compute/mod.rs
@@ -16,6 +16,8 @@ mod tests {
     use rstest::rstest;
 
     use crate::IntoArray;
+    use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::compute::conformance::consistency::test_array_consistency;
 
@@ -41,6 +43,9 @@ mod tests {
         None, None, Some(true), None, None, None, Some(false), None, None
     ]))]
     fn test_bool_consistency(#[case] array: BoolArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/vortex-array/src/arrays/bool/compute/zip.rs b/vortex-array/src/arrays/bool/compute/zip.rs
index bad41eb19c4..80e7de80c82 100644
--- a/vortex-array/src/arrays/bool/compute/zip.rs
+++ b/vortex-array/src/arrays/bool/compute/zip.rs
@@ -89,8 +89,8 @@ mod tests {
     use super::zip_value_bits;
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::Bool;
     use crate::arrays::BoolArray;
     use crate::assert_arrays_eq;
@@ -132,7 +132,7 @@ mod tests {
         let bits: Vec<bool> = (0..len).map(|i| i.is_multiple_of(5) || i == 64).collect();
         let mask = Mask::from_iter(bits.iter().copied());
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mask
             .into_array()
             .zip(if_true, if_false)?
@@ -167,7 +167,7 @@ mod tests {
         let bits: Vec<bool> = (0..len).map(|i| i.is_multiple_of(2)).collect();
         let mask = Mask::from_iter(bits.iter().copied());
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mask
             .into_array()
             .zip(if_true, if_false)?
diff --git a/vortex-array/src/arrays/bool/test_harness.rs b/vortex-array/src/arrays/bool/test_harness.rs
index 4e13d62e3ef..1b6aca704a3 100644
--- a/vortex-array/src/arrays/bool/test_harness.rs
+++ b/vortex-array/src/arrays/bool/test_harness.rs
@@ -4,19 +4,15 @@
 use vortex_error::VortexExpect;
 use vortex_error::vortex_panic;
 
-use crate::LEGACY_SESSION;
-use crate::VortexSessionExecute;
+use crate::ExecutionCtx;
 use crate::arrays::BoolArray;
 use crate::arrays::bool::BoolArrayExt;
 
 impl BoolArray {
-    pub fn opt_bool_vec(&self) -> Vec<Option<bool>> {
+    pub fn opt_bool_vec(&self, ctx: &mut ExecutionCtx) -> Vec<Option<bool>> {
         self.validity()
             .vortex_expect("failed to get validity")
-            .execute_mask(
-                self.as_ref().len(),
-                &mut LEGACY_SESSION.create_execution_ctx(),
-            )
+            .execute_mask(self.as_ref().len(), ctx)
             .vortex_expect("Failed to compute validity mask")
             .to_bit_buffer()
             .iter()
@@ -25,13 +21,10 @@ impl BoolArray {
             .collect()
     }
 
-    pub fn bool_vec(&self) -> Vec<bool> {
+    pub fn bool_vec(&self, ctx: &mut ExecutionCtx) -> Vec<bool> {
         self.validity()
             .vortex_expect("failed to get validity")
-            .execute_mask(
-                self.as_ref().len(),
-                &mut LEGACY_SESSION.create_execution_ctx(),
-            )
+            .execute_mask(self.as_ref().len(), ctx)
             .vortex_expect("Failed to compute validity mask")
             .to_bit_buffer()
             .iter()
diff --git a/vortex-array/src/arrays/chunked/array.rs b/vortex-array/src/arrays/chunked/array.rs
index bd6b3d2d06d..54544ba1b4d 100644
--- a/vortex-array/src/arrays/chunked/array.rs
+++ b/vortex-array/src/arrays/chunked/array.rs
@@ -278,7 +278,6 @@ mod test {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::ChunkedArray;
@@ -374,11 +373,11 @@ mod test {
             ChunkedArray::try_new(chunks, DType::Primitive(PType::U64, Nullability::Nullable))?;
 
         // Should be all_valid since all non-empty chunks are all_valid
-        assert!(chunked.all_valid(&mut LEGACY_SESSION.create_execution_ctx())?);
+        assert!(chunked.all_valid(&mut array_session().create_execution_ctx())?);
         assert!(
             !chunked
                 .into_array()
-                .all_invalid(&mut LEGACY_SESSION.create_execution_ctx())?
+                .all_invalid(&mut array_session().create_execution_ctx())?
         );
 
         Ok(())
@@ -398,11 +397,11 @@ mod test {
             ChunkedArray::try_new(chunks, DType::Primitive(PType::U64, Nullability::Nullable))?;
 
         // Should be all_invalid since all non-empty chunks are all_invalid
-        assert!(!chunked.all_valid(&mut LEGACY_SESSION.create_execution_ctx())?);
+        assert!(!chunked.all_valid(&mut array_session().create_execution_ctx())?);
         assert!(
             chunked
                 .into_array()
-                .all_invalid(&mut LEGACY_SESSION.create_execution_ctx())?
+                .all_invalid(&mut array_session().create_execution_ctx())?
         );
 
         Ok(())
@@ -422,11 +421,11 @@ mod test {
             ChunkedArray::try_new(chunks, DType::Primitive(PType::U64, Nullability::Nullable))?;
 
         // Should be neither all_valid nor all_invalid
-        assert!(!chunked.all_valid(&mut LEGACY_SESSION.create_execution_ctx())?);
+        assert!(!chunked.all_valid(&mut array_session().create_execution_ctx())?);
         assert!(
             !chunked
                 .into_array()
-                .all_invalid(&mut LEGACY_SESSION.create_execution_ctx())?
+                .all_invalid(&mut array_session().create_execution_ctx())?
         );
 
         Ok(())
diff --git a/vortex-array/src/arrays/chunked/compute/aggregate.rs b/vortex-array/src/arrays/chunked/compute/aggregate.rs
index fe042c4c945..149c72f499e 100644
--- a/vortex-array/src/arrays/chunked/compute/aggregate.rs
+++ b/vortex-array/src/arrays/chunked/compute/aggregate.rs
@@ -43,12 +43,12 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::DynAccumulator;
     use crate::aggregate_fn::NumericalAggregateOpts;
     use crate::aggregate_fn::fns::sum::Sum;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::arrays::ChunkedArray;
     use crate::arrays::PrimitiveArray;
@@ -58,7 +58,7 @@ mod tests {
     use crate::scalar::Scalar;
 
     fn run_sum(batch: &crate::ArrayRef) -> VortexResult<Scalar> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut acc = Accumulator::try_new(
             Sum,
             NumericalAggregateOpts::default(),
diff --git a/vortex-array/src/arrays/chunked/compute/mod.rs b/vortex-array/src/arrays/chunked/compute/mod.rs
index bbc9029657a..f7c9a4e9d61 100644
--- a/vortex-array/src/arrays/chunked/compute/mod.rs
+++ b/vortex-array/src/arrays/chunked/compute/mod.rs
@@ -18,6 +18,8 @@ mod tests {
     use vortex_buffer::buffer;
 
     use crate::IntoArray;
+    use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::ChunkedArray;
     use crate::arrays::PrimitiveArray;
     use crate::compute::conformance::binary_numeric::test_binary_numeric_array;
@@ -79,7 +81,10 @@ mod tests {
     ).unwrap())]
 
     fn test_chunked_consistency(#[case] array: ChunkedArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 
     #[rstest]
@@ -154,6 +159,9 @@ mod tests {
         DType::Primitive(PType::I32, Nullability::NonNullable),
     ).unwrap())]
     fn test_chunked_binary_numeric(#[case] array: ChunkedArray) {
-        test_binary_numeric_array(array.into_array())
+        test_binary_numeric_array(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        )
     }
 }
diff --git a/vortex-array/src/arrays/chunked/compute/zip.rs b/vortex-array/src/arrays/chunked/compute/zip.rs
index 1d7873888a3..4037fd1dc49 100644
--- a/vortex-array/src/arrays/chunked/compute/zip.rs
+++ b/vortex-array/src/arrays/chunked/compute/zip.rs
@@ -51,10 +51,10 @@ mod tests {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     #[expect(deprecated)]
     use crate::ToCanonical as _;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::Chunked;
     use crate::arrays::ChunkedArray;
     use crate::arrays::chunked::ChunkedArrayExt;
@@ -94,7 +94,7 @@ mod tests {
         // One step of execution will push down the zip.
         let zipped = zipped
             .clone()
-            .execute::<ArrayRef>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<ArrayRef>(&mut array_session().create_execution_ctx())
             .unwrap();
         let zipped = zipped
             .as_opt::<Chunked>()
diff --git a/vortex-array/src/arrays/constant/compute/fill_null.rs b/vortex-array/src/arrays/constant/compute/fill_null.rs
index f69a23c7ab0..1c9c2aaf903 100644
--- a/vortex-array/src/arrays/constant/compute/fill_null.rs
+++ b/vortex-array/src/arrays/constant/compute/fill_null.rs
@@ -22,8 +22,8 @@ impl FillNullReduce for Constant {
 #[cfg(test)]
 mod test {
     use crate::IntoArray as _;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::ConstantArray;
     use crate::arrow::ArrowSessionExt;
     use crate::builtins::ArrayBuiltins;
@@ -34,7 +34,7 @@ mod test {
 
     #[test]
     fn test_null() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let actual = ConstantArray::new(Scalar::null_native::<i32>(), 3)
             .into_array()
             .fill_null(Scalar::from(1))
@@ -43,11 +43,11 @@ mod test {
 
         assert!(!actual.dtype().is_nullable());
 
-        let actual_arrow = LEGACY_SESSION
+        let actual_arrow = array_session()
             .arrow()
             .execute_arrow(actual.clone(), None, &mut ctx)
             .unwrap();
-        let expected_arrow = LEGACY_SESSION
+        let expected_arrow = array_session()
             .arrow()
             .execute_arrow(expected.clone(), None, &mut ctx)
             .unwrap();
@@ -62,7 +62,7 @@ mod test {
 
     #[test]
     fn test_non_null() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let actual = ConstantArray::new(Scalar::from(Some(1)), 3)
             .into_array()
             .fill_null(Scalar::from(1))
@@ -71,11 +71,11 @@ mod test {
 
         assert!(!actual.dtype().is_nullable());
 
-        let actual_arrow = LEGACY_SESSION
+        let actual_arrow = array_session()
             .arrow()
             .execute_arrow(actual.clone(), None, &mut ctx)
             .unwrap();
-        let expected_arrow = LEGACY_SESSION
+        let expected_arrow = array_session()
             .arrow()
             .execute_arrow(expected.clone(), None, &mut ctx)
             .unwrap();
@@ -90,7 +90,7 @@ mod test {
 
     #[test]
     fn test_non_nullable_with_nullable() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let actual = ConstantArray::new(Scalar::from(1), 3)
             .into_array()
             .fill_null(Scalar::new(
@@ -104,11 +104,11 @@ mod test {
 
         assert!(actual.dtype().is_nullable());
 
-        let actual_arrow = LEGACY_SESSION
+        let actual_arrow = array_session()
             .arrow()
             .execute_arrow(actual.clone(), None, &mut ctx)
             .unwrap();
-        let expected_arrow = LEGACY_SESSION
+        let expected_arrow = array_session()
             .arrow()
             .execute_arrow(expected.clone(), None, &mut ctx)
             .unwrap();
diff --git a/vortex-array/src/arrays/constant/compute/mod.rs b/vortex-array/src/arrays/constant/compute/mod.rs
index bc9f25466f6..80fab02dc88 100644
--- a/vortex-array/src/arrays/constant/compute/mod.rs
+++ b/vortex-array/src/arrays/constant/compute/mod.rs
@@ -18,6 +18,8 @@ mod test {
     use rstest::rstest;
 
     use crate::IntoArray;
+    use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::ConstantArray;
     use crate::compute::conformance::consistency::test_array_consistency;
     use crate::compute::conformance::filter::test_filter_conformance;
@@ -62,6 +64,9 @@ mod test {
     #[case::constant_single(ConstantArray::new(Scalar::from(99u64), 1))]
     #[case::constant_large(ConstantArray::new(Scalar::from("hello"), 1000))]
     fn test_constant_consistency(#[case] array: ConstantArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/vortex-array/src/arrays/constant/compute/take.rs b/vortex-array/src/arrays/constant/compute/take.rs
index 2330cd28f88..9fb1373a5cf 100644
--- a/vortex-array/src/arrays/constant/compute/take.rs
+++ b/vortex-array/src/arrays/constant/compute/take.rs
@@ -73,7 +73,6 @@ mod tests {
     use vortex_mask::AllOr;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     #[expect(deprecated)]
     use crate::ToCanonical as _;
     use crate::VortexSessionExecute;
@@ -117,7 +116,7 @@ mod tests {
             taken
                 .validity()
                 .unwrap()
-                .execute_mask(taken.len(), &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_mask(taken.len(), &mut array_session().create_execution_ctx())
                 .unwrap()
                 .indices(),
             AllOr::Some(valid_indices)
@@ -145,7 +144,7 @@ mod tests {
             taken
                 .validity()
                 .unwrap()
-                .execute_mask(taken.len(), &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_mask(taken.len(), &mut array_session().create_execution_ctx())
                 .unwrap()
                 .indices(),
             AllOr::All
diff --git a/vortex-array/src/arrays/constant/compute/uncompressed_size.rs b/vortex-array/src/arrays/constant/compute/uncompressed_size.rs
index b9654d5840c..f8a4d4f92a4 100644
--- a/vortex-array/src/arrays/constant/compute/uncompressed_size.rs
+++ b/vortex-array/src/arrays/constant/compute/uncompressed_size.rs
@@ -10,13 +10,13 @@ mod tests {
     use crate::ArrayRef;
     use crate::Canonical;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::DynAccumulator;
     use crate::aggregate_fn::EmptyOptions;
     use crate::aggregate_fn::fns::uncompressed_size_in_bytes::UncompressedSizeInBytes;
     use crate::aggregate_fn::fns::uncompressed_size_in_bytes::canonical_uncompressed_size_in_bytes;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::arrays::ConstantArray;
     use crate::arrays::PrimitiveArray;
@@ -27,7 +27,7 @@ mod tests {
     use crate::validity::Validity;
 
     fn aggregate(array: &ArrayRef) -> VortexResult<u64> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut acc =
             Accumulator::try_new(UncompressedSizeInBytes, EmptyOptions, array.dtype().clone())?;
         acc.accumulate(array, &mut ctx)?;
@@ -82,7 +82,7 @@ mod tests {
     #[test]
     fn constant_utf8_matches_canonical_size() -> VortexResult<()> {
         let constant = ConstantArray::new("abcdefghijkl".to_string(), 10).into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let canonical = constant.clone().execute::<Canonical>(&mut ctx)?;
         let expected = canonical_uncompressed_size_in_bytes(&canonical, &mut ctx)?;
 
diff --git a/vortex-array/src/arrays/decimal/compute/cast.rs b/vortex-array/src/arrays/decimal/compute/cast.rs
index 432313d3cb6..0546542fa29 100644
--- a/vortex-array/src/arrays/decimal/compute/cast.rs
+++ b/vortex-array/src/arrays/decimal/compute/cast.rs
@@ -187,8 +187,8 @@ mod tests {
 
     use super::upcast_decimal_values;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::DecimalArray;
     use crate::builtins::ArrayBuiltins;
     #[expect(deprecated)]
@@ -440,7 +440,7 @@ mod tests {
             .unwrap()
             .execute_mask(
                 casted.as_ref().len(),
-                &mut LEGACY_SESSION.create_execution_ctx(),
+                &mut array_session().create_execution_ctx(),
             )
             .unwrap();
         assert!(mask.value(0));
diff --git a/vortex-array/src/arrays/decimal/compute/fill_null.rs b/vortex-array/src/arrays/decimal/compute/fill_null.rs
index 3ab8762e875..1c2904b7b6b 100644
--- a/vortex-array/src/arrays/decimal/compute/fill_null.rs
+++ b/vortex-array/src/arrays/decimal/compute/fill_null.rs
@@ -89,7 +89,6 @@ mod tests {
     use vortex_buffer::buffer;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::DecimalArray;
@@ -134,7 +133,10 @@ mod tests {
             p.as_ref()
                 .validity()
                 .unwrap()
-                .execute_mask(p.as_ref().len(), &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_mask(
+                    p.as_ref().len(),
+                    &mut array_session().create_execution_ctx()
+                )
                 .unwrap()
                 .all_true()
         );
diff --git a/vortex-array/src/arrays/decimal/compute/mod.rs b/vortex-array/src/arrays/decimal/compute/mod.rs
index 09faba913c0..b2f21fa8398 100644
--- a/vortex-array/src/arrays/decimal/compute/mod.rs
+++ b/vortex-array/src/arrays/decimal/compute/mod.rs
@@ -14,6 +14,8 @@ mod tests {
     use vortex_buffer::buffer;
 
     use crate::IntoArray;
+    use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::DecimalArray;
     use crate::compute::conformance::consistency::test_array_consistency;
     use crate::dtype::DecimalDType;
@@ -53,6 +55,9 @@ mod tests {
         Validity::NonNullable,
     ))]
     fn test_decimal_consistency(#[case] array: DecimalArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/vortex-array/src/arrays/decimal/vtable/operations.rs b/vortex-array/src/arrays/decimal/vtable/operations.rs
index aca0f912583..257f26127ae 100644
--- a/vortex-array/src/arrays/decimal/vtable/operations.rs
+++ b/vortex-array/src/arrays/decimal/vtable/operations.rs
@@ -32,8 +32,8 @@ mod tests {
     use vortex_buffer::buffer;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::Decimal;
     use crate::arrays::DecimalArray;
     use crate::dtype::DecimalDType;
@@ -81,7 +81,7 @@ mod tests {
 
         assert_eq!(
             array
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::decimal(
                 DecimalValue::I128(100),
diff --git a/vortex-array/src/arrays/dict/array.rs b/vortex-array/src/arrays/dict/array.rs
index ad777ddcad9..de6b765d8b0 100644
--- a/vortex-array/src/arrays/dict/array.rs
+++ b/vortex-array/src/arrays/dict/array.rs
@@ -307,7 +307,6 @@ mod test {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     #[expect(deprecated)]
     use crate::ToCanonical as _;
     use crate::VortexSessionExecute;
@@ -341,7 +340,7 @@ mod test {
             .unwrap()
             .execute_mask(
                 dict.as_ref().len(),
-                &mut LEGACY_SESSION.create_execution_ctx(),
+                &mut array_session().create_execution_ctx(),
             )
             .unwrap();
         let AllOr::Some(indices) = mask.indices() else {
@@ -367,7 +366,7 @@ mod test {
             .unwrap()
             .execute_mask(
                 dict.as_ref().len(),
-                &mut LEGACY_SESSION.create_execution_ctx(),
+                &mut array_session().create_execution_ctx(),
             )
             .unwrap();
         let AllOr::Some(indices) = mask.indices() else {
@@ -397,7 +396,7 @@ mod test {
             .unwrap()
             .execute_mask(
                 dict.as_ref().len(),
-                &mut LEGACY_SESSION.create_execution_ctx(),
+                &mut array_session().create_execution_ctx(),
             )
             .unwrap();
         let AllOr::Some(indices) = mask.indices() else {
@@ -423,7 +422,7 @@ mod test {
             .unwrap()
             .execute_mask(
                 dict.as_ref().len(),
-                &mut LEGACY_SESSION.create_execution_ctx(),
+                &mut array_session().create_execution_ctx(),
             )
             .unwrap();
         let AllOr::Some(indices) = mask.indices() else {
@@ -472,7 +471,10 @@ mod test {
             &DType::Primitive(PType::U64, NonNullable),
             len * chunk_count,
         );
-        array.append_to_builder(builder.as_mut(), &mut LEGACY_SESSION.create_execution_ctx())?;
+        array.append_to_builder(
+            builder.as_mut(),
+            &mut array_session().create_execution_ctx(),
+        )?;
 
         #[expect(deprecated)]
         let into_prim = array.to_primitive();
diff --git a/vortex-array/src/arrays/dict/compute/mod.rs b/vortex-array/src/arrays/dict/compute/mod.rs
index 0e330c8d820..7ba4edd18f1 100644
--- a/vortex-array/src/arrays/dict/compute/mod.rs
+++ b/vortex-array/src/arrays/dict/compute/mod.rs
@@ -366,6 +366,6 @@ mod tests {
     #[case::dict_all_same(dict_encode(&buffer![5i32, 5, 5, 5, 5].into_array(), &mut SESSION.create_execution_ctx()).unwrap())]
     #[case::dict_large(dict_encode(&PrimitiveArray::from_iter((0..1000).map(|i| i % 10)).into_array(), &mut SESSION.create_execution_ctx()).unwrap())]
     fn test_dict_consistency(#[case] array: DictArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(&array.into_array(), &mut SESSION.create_execution_ctx());
     }
 }
diff --git a/vortex-array/src/arrays/extension/compute/mod.rs b/vortex-array/src/arrays/extension/compute/mod.rs
index ce25ab2c0ea..8309ae43be2 100644
--- a/vortex-array/src/arrays/extension/compute/mod.rs
+++ b/vortex-array/src/arrays/extension/compute/mod.rs
@@ -87,6 +87,8 @@ mod tests {
     use vortex_buffer::buffer;
 
     use crate::IntoArray;
+    use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::ExtensionArray;
     use crate::arrays::PrimitiveArray;
     use crate::compute::conformance::consistency::test_array_consistency;
@@ -114,6 +116,9 @@ mod tests {
         ExtensionArray::new(ext_dtype, storage)
     })]
     fn test_extension_consistency(#[case] array: ExtensionArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/vortex-array/src/arrays/filter/execute/listview.rs b/vortex-array/src/arrays/filter/execute/listview.rs
index c8118143e94..0507452c89d 100644
--- a/vortex-array/src/arrays/filter/execute/listview.rs
+++ b/vortex-array/src/arrays/filter/execute/listview.rs
@@ -65,7 +65,6 @@ mod test {
     use vortex_session::VortexSession;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::ListViewArray;
@@ -329,7 +328,7 @@ mod test {
         let list0 = result_list.list_elements_at(0).unwrap();
         assert_eq!(
             list0
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut SESSION.create_execution_ctx())
                 .unwrap()
                 .as_primitive()
                 .as_::<i32>()
@@ -338,7 +337,7 @@ mod test {
         );
         assert_eq!(
             list0
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(1, &mut SESSION.create_execution_ctx())
                 .unwrap()
                 .as_primitive()
                 .as_::<i32>()
diff --git a/vortex-array/src/arrays/fixed_size_list/tests/basic.rs b/vortex-array/src/arrays/fixed_size_list/tests/basic.rs
index f910bd4a05f..961801094d8 100644
--- a/vortex-array/src/arrays/fixed_size_list/tests/basic.rs
+++ b/vortex-array/src/arrays/fixed_size_list/tests/basic.rs
@@ -6,8 +6,8 @@ use std::sync::Arc;
 use vortex_buffer::buffer;
 
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
+use crate::array_session;
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
 use crate::dtype::DType;
@@ -40,19 +40,19 @@ fn test_basic_fixed_size_list() {
     let first_list = fsl.fixed_size_list_elements_at(0).unwrap();
     assert_eq!(
         first_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         1i32.into()
     );
     assert_eq!(
         first_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         2i32.into()
     );
     assert_eq!(
         first_list
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(2, &mut array_session().create_execution_ctx())
             .unwrap(),
         3i32.into()
     );
@@ -60,19 +60,19 @@ fn test_basic_fixed_size_list() {
     let second_list = fsl.fixed_size_list_elements_at(1).unwrap();
     assert_eq!(
         second_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         4i32.into()
     );
     assert_eq!(
         second_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         5i32.into()
     );
     assert_eq!(
         second_list
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(2, &mut array_session().create_execution_ctx())
             .unwrap(),
         6i32.into()
     );
@@ -80,19 +80,19 @@ fn test_basic_fixed_size_list() {
     let third_list = fsl.fixed_size_list_elements_at(2).unwrap();
     assert_eq!(
         third_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         7i32.into()
     );
     assert_eq!(
         third_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         8i32.into()
     );
     assert_eq!(
         third_list
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(2, &mut array_session().create_execution_ctx())
             .unwrap(),
         9i32.into()
     );
@@ -100,19 +100,19 @@ fn test_basic_fixed_size_list() {
     let fourth_list = fsl.fixed_size_list_elements_at(3).unwrap();
     assert_eq!(
         fourth_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         10i32.into()
     );
     assert_eq!(
         fourth_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         11i32.into()
     );
     assert_eq!(
         fourth_list
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(2, &mut array_session().create_execution_ctx())
             .unwrap(),
         12i32.into()
     );
@@ -128,7 +128,7 @@ fn test_scalar_at() {
 
     // First list: [1, 2, 3].
     let first = fsl
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut array_session().create_execution_ctx())
         .unwrap();
     assert_eq!(
         first,
@@ -143,26 +143,26 @@ fn test_scalar_at() {
     let first_list = fsl.fixed_size_list_elements_at(0).unwrap();
     assert_eq!(
         first_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         1i32.into()
     );
     assert_eq!(
         first_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         2i32.into()
     );
     assert_eq!(
         first_list
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(2, &mut array_session().create_execution_ctx())
             .unwrap(),
         3i32.into()
     );
 
     // Second list: [4, 5, 6].
     let second = fsl
-        .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(1, &mut array_session().create_execution_ctx())
         .unwrap();
     assert_eq!(
         second,
@@ -177,19 +177,19 @@ fn test_scalar_at() {
     let second_list = fsl.fixed_size_list_elements_at(1).unwrap();
     assert_eq!(
         second_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         4i32.into()
     );
     assert_eq!(
         second_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         5i32.into()
     );
     assert_eq!(
         second_list
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(2, &mut array_session().create_execution_ctx())
             .unwrap(),
         6i32.into()
     );
@@ -208,13 +208,13 @@ fn test_fixed_size_list_at() {
     assert_eq!(first_list.len(), list_size as usize);
     assert_eq!(
         first_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         1.0f64.into()
     );
     assert_eq!(
         first_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         2.0f64.into()
     );
@@ -224,13 +224,13 @@ fn test_fixed_size_list_at() {
     assert_eq!(third_list.len(), list_size as usize);
     assert_eq!(
         third_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         5.0f64.into()
     );
     assert_eq!(
         third_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         6.0f64.into()
     );
diff --git a/vortex-array/src/arrays/fixed_size_list/tests/degenerate.rs b/vortex-array/src/arrays/fixed_size_list/tests/degenerate.rs
index 39a7ada3af3..f609fd72405 100644
--- a/vortex-array/src/arrays/fixed_size_list/tests/degenerate.rs
+++ b/vortex-array/src/arrays/fixed_size_list/tests/degenerate.rs
@@ -6,8 +6,8 @@ use std::sync::Arc;
 use vortex_buffer::buffer;
 
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
+use crate::array_session;
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::PrimitiveArray;
 use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
@@ -57,7 +57,7 @@ fn test_fsl_size_0_length_1_non_nullable() {
 
     // Get the single empty list.
     let scalar = fsl
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!scalar.is_null());
     assert_eq!(
@@ -85,7 +85,7 @@ fn test_fsl_size_0_huge_length_non_nullable() {
 
     // Spot check a few lists.
     let scalar_first = fsl
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!scalar_first.is_null());
     assert_eq!(
@@ -98,7 +98,7 @@ fn test_fsl_size_0_huge_length_non_nullable() {
     );
 
     let scalar_middle = fsl
-        .execute_scalar(500_000_000_000, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(500_000_000_000, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!scalar_middle.is_null());
     assert_eq!(
@@ -111,7 +111,7 @@ fn test_fsl_size_0_huge_length_non_nullable() {
     );
 
     let scalar_end = fsl
-        .execute_scalar(999_999_999_999, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(999_999_999_999, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!scalar_end.is_null());
     assert_eq!(
@@ -163,7 +163,7 @@ fn test_fsl_size_0_length_1_nullable_valid() {
 
     // Get the single empty list (should be valid).
     let scalar = fsl
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!scalar.is_null());
     assert_eq!(
@@ -188,7 +188,7 @@ fn test_fsl_size_0_length_1_nullable_null() {
 
     // The single list should be null.
     let scalar = fsl
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(scalar.is_null());
 }
@@ -215,7 +215,7 @@ fn test_fsl_size_0_length_10_nullable_mixed() {
     ];
     for i in 0..len {
         let scalar = fsl
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut array_session().create_execution_ctx())
             .unwrap();
         if expected_valid[i] {
             assert!(!scalar.is_null());
@@ -256,7 +256,7 @@ fn test_fsl_size_0_nullable_elements() {
     // All lists should be empty but valid.
     for i in 0..len {
         let scalar = fsl
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut array_session().create_execution_ctx())
             .unwrap();
         assert!(!scalar.is_null());
     }
diff --git a/vortex-array/src/arrays/fixed_size_list/tests/nested.rs b/vortex-array/src/arrays/fixed_size_list/tests/nested.rs
index 8fca62c0097..44420d22cb3 100644
--- a/vortex-array/src/arrays/fixed_size_list/tests/nested.rs
+++ b/vortex-array/src/arrays/fixed_size_list/tests/nested.rs
@@ -6,10 +6,10 @@ use std::sync::Arc;
 use vortex_buffer::buffer;
 
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 #[expect(deprecated)]
 use crate::ToCanonical as _;
 use crate::VortexSessionExecute;
+use crate::array_session;
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::PrimitiveArray;
 use crate::arrays::StructArray;
@@ -76,7 +76,7 @@ fn test_fsl_of_fsl_basic() {
     // The first outer list should contain 3 inner lists.
     // We can check by slicing and examining scalars.
     let first_scalar = outer_fsl
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!first_scalar.is_null());
 
@@ -92,13 +92,13 @@ fn test_fsl_of_fsl_basic() {
         .unwrap();
     assert_eq!(
         inner_list_0
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         1i32.into()
     );
     assert_eq!(
         inner_list_0
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         2i32.into()
     );
@@ -111,13 +111,13 @@ fn test_fsl_of_fsl_basic() {
         .unwrap();
     assert_eq!(
         inner_list_1
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         3i32.into()
     );
     assert_eq!(
         inner_list_1
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         4i32.into()
     );
@@ -130,13 +130,13 @@ fn test_fsl_of_fsl_basic() {
         .unwrap();
     assert_eq!(
         inner_list_2
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         5i32.into()
     );
     assert_eq!(
         inner_list_2
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         6i32.into()
     );
@@ -152,13 +152,13 @@ fn test_fsl_of_fsl_basic() {
         .unwrap();
     assert_eq!(
         inner_list_0
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         7i32.into()
     );
     assert_eq!(
         inner_list_0
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         8i32.into()
     );
@@ -171,13 +171,13 @@ fn test_fsl_of_fsl_basic() {
         .unwrap();
     assert_eq!(
         inner_list_1
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         9i32.into()
     );
     assert_eq!(
         inner_list_1
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         10i32.into()
     );
@@ -190,13 +190,13 @@ fn test_fsl_of_fsl_basic() {
         .unwrap();
     assert_eq!(
         inner_list_2
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         11i32.into()
     );
     assert_eq!(
         inner_list_2
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         12i32.into()
     );
@@ -246,7 +246,7 @@ fn test_fsl_of_fsl_with_nulls() {
     // First outer list is valid.
     assert!(
         !outer_fsl
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
@@ -254,7 +254,7 @@ fn test_fsl_of_fsl_with_nulls() {
     // Second outer list is null.
     assert!(
         outer_fsl
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
@@ -262,7 +262,7 @@ fn test_fsl_of_fsl_with_nulls() {
     // Third outer list is valid.
     assert!(
         !outer_fsl
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(2, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
@@ -326,13 +326,13 @@ fn test_deeply_nested_fsl() {
         .unwrap();
     assert_eq!(
         level1_0_0
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         1i32.into()
     );
     assert_eq!(
         level1_0_0
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         2i32.into()
     );
@@ -344,13 +344,13 @@ fn test_deeply_nested_fsl() {
         .unwrap();
     assert_eq!(
         level1_0_1
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         3i32.into()
     );
     assert_eq!(
         level1_0_1
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         4i32.into()
     );
@@ -363,13 +363,13 @@ fn test_deeply_nested_fsl() {
         .unwrap();
     assert_eq!(
         level1_1_0
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         5i32.into()
     );
     assert_eq!(
         level1_1_0
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         6i32.into()
     );
@@ -381,13 +381,13 @@ fn test_deeply_nested_fsl() {
         .unwrap();
     assert_eq!(
         level1_1_1
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         7i32.into()
     );
     assert_eq!(
         level1_1_1
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         8i32.into()
     );
diff --git a/vortex-array/src/arrays/fixed_size_list/tests/nullability.rs b/vortex-array/src/arrays/fixed_size_list/tests/nullability.rs
index 20deef502ed..f5e5339e756 100644
--- a/vortex-array/src/arrays/fixed_size_list/tests/nullability.rs
+++ b/vortex-array/src/arrays/fixed_size_list/tests/nullability.rs
@@ -6,8 +6,8 @@ use std::sync::Arc;
 use vortex_buffer::buffer;
 
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
+use crate::array_session;
 use crate::arrays::BoolArray;
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::PrimitiveArray;
@@ -33,7 +33,7 @@ fn test_nullable_fsl_with_nulls() {
 
     // First list is valid: [1, 2].
     let first = fsl
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!first.is_null());
     assert_eq!(
@@ -49,26 +49,26 @@ fn test_nullable_fsl_with_nulls() {
     let first_list = fsl.fixed_size_list_elements_at(0).unwrap();
     assert_eq!(
         first_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         1i32.into()
     );
     assert_eq!(
         first_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         2i32.into()
     );
 
     // Second list is null.
     let second = fsl
-        .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(1, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(second.is_null());
 
     // Third list is valid: [5, 6].
     let third = fsl
-        .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(2, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!third.is_null());
     assert_eq!(
@@ -84,20 +84,20 @@ fn test_nullable_fsl_with_nulls() {
     let third_list = fsl.fixed_size_list_elements_at(2).unwrap();
     assert_eq!(
         third_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         5i32.into()
     );
     assert_eq!(
         third_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         6i32.into()
     );
 
     // Fourth list is null.
     let fourth = fsl
-        .execute_scalar(3, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(3, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(fourth.is_null());
 }
@@ -123,7 +123,7 @@ fn test_nullable_elements_non_nullable_lists() {
 
     // First list: [Some(1), None, Some(3)].
     let first = fsl
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!first.is_null());
     assert_eq!(
@@ -137,7 +137,7 @@ fn test_nullable_elements_non_nullable_lists() {
 
     // Second list: [Some(4), Some(5), None].
     let second = fsl
-        .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(1, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!second.is_null());
     assert_eq!(
@@ -165,7 +165,7 @@ fn test_nullable_elements_and_nullable_lists() {
 
     // First list is valid: [Some(10), None].
     let first = fsl
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!first.is_null());
     assert_eq!(
@@ -181,26 +181,26 @@ fn test_nullable_elements_and_nullable_lists() {
     let first_list = fsl.fixed_size_list_elements_at(0).unwrap();
     assert_eq!(
         first_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         Some(10u16).into()
     );
     assert_eq!(
         first_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         None::<u16>.into()
     );
 
     // Second list is null (but elements would be [Some(20), Some(30)]).
     let second = fsl
-        .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(1, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(second.is_null());
 
     // Third list is valid: [None, None].
     let third = fsl
-        .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(2, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!third.is_null());
     assert_eq!(
@@ -216,13 +216,13 @@ fn test_nullable_elements_and_nullable_lists() {
     let third_list = fsl.fixed_size_list_elements_at(2).unwrap();
     assert_eq!(
         third_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         None::<u16>.into()
     );
     assert_eq!(
         third_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         None::<u16>.into()
     );
@@ -243,7 +243,7 @@ fn test_alternating_nulls() {
     // Check alternating pattern.
     for i in 0..len {
         let scalar = fsl
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut array_session().create_execution_ctx())
             .unwrap();
         if i % 2 == 0 {
             assert!(!scalar.is_null());
@@ -275,7 +275,7 @@ fn test_validity_types() {
         let fsl = FixedSizeListArray::new(elements.clone(), list_size, Validity::AllInvalid, len);
         for i in 0..len {
             assert!(
-                fsl.execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                fsl.execute_scalar(i, &mut array_session().create_execution_ctx())
                     .unwrap()
                     .is_null()
             );
@@ -293,22 +293,22 @@ fn test_validity_types() {
         );
 
         assert!(
-            !fsl.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            !fsl.execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null()
         );
         assert!(
-            !fsl.execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            !fsl.execute_scalar(1, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null()
         );
         assert!(
-            fsl.execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+            fsl.execute_scalar(2, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null()
         );
         assert!(
-            !fsl.execute_scalar(3, &mut LEGACY_SESSION.create_execution_ctx())
+            !fsl.execute_scalar(3, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null()
         );
@@ -338,31 +338,31 @@ fn test_mixed_nullability_patterns() {
 
     // List 0: valid with [Some(1), None].
     let list0 = fsl
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!list0.is_null());
 
     // List 1: null.
     let list1 = fsl
-        .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(1, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(list1.is_null());
 
     // List 2: valid with [Some(5), Some(6)].
     let list2 = fsl
-        .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(2, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!list2.is_null());
 
     // List 3: valid with [Some(7), None].
     let list3 = fsl
-        .execute_scalar(3, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(3, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!list3.is_null());
 
     // List 4: valid with [None, Some(10)].
     let list4 = fsl
-        .execute_scalar(4, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(4, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!list4.is_null());
 }
diff --git a/vortex-array/src/arrays/fixed_size_list/tests/take.rs b/vortex-array/src/arrays/fixed_size_list/tests/take.rs
index b0c41c30d27..e75139e5fc8 100644
--- a/vortex-array/src/arrays/fixed_size_list/tests/take.rs
+++ b/vortex-array/src/arrays/fixed_size_list/tests/take.rs
@@ -11,7 +11,6 @@ use super::common::create_nullable_fsl;
 use super::common::create_single_element_fsl;
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
 use crate::array_session;
 use crate::arrays::FixedSizeListArray;
@@ -99,7 +98,7 @@ fn test_take_degenerate_lists(
     for (i, expected_null) in expected_nulls.iter().enumerate() {
         assert_eq!(
             result
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null(),
             *expected_null
@@ -236,7 +235,7 @@ fn test_take_nullable_arrays_fsl_specific(
     for (i, expected_null) in expected_nulls.iter().enumerate() {
         assert_eq!(
             result
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null(),
             *expected_null
diff --git a/vortex-array/src/arrays/interleave/mod.rs b/vortex-array/src/arrays/interleave/mod.rs
index b085d9571e1..8dfebe098bc 100644
--- a/vortex-array/src/arrays/interleave/mod.rs
+++ b/vortex-array/src/arrays/interleave/mod.rs
@@ -404,8 +404,8 @@ mod tests {
 
     use super::*;
     use crate::Canonical;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::arrays::PrimitiveArray;
     use crate::assert_arrays_eq;
@@ -496,7 +496,7 @@ mod tests {
             InterleaveArray::try_new(values.clone(), array_indices.clone(), row_indices.clone())?
                 .into_array();
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let reference = interleave_reference(&values, &array_indices, &row_indices, &mut ctx)?;
 
         assert_arrays_eq!(interleaved, reference, &mut ctx);
@@ -613,7 +613,7 @@ mod tests {
         let interleaved = InterleaveArray::try_new(vec![v0, v1], array_indices, row_indices)
             .vortex_expect("primitive values should construct")
             .into_array();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         interleaved.execute::<Canonical>(&mut ctx).ok();
     }
 }
diff --git a/vortex-array/src/arrays/list/compute/cast.rs b/vortex-array/src/arrays/list/compute/cast.rs
index c297d378392..084d9613e75 100644
--- a/vortex-array/src/arrays/list/compute/cast.rs
+++ b/vortex-array/src/arrays/list/compute/cast.rs
@@ -71,7 +71,6 @@ mod tests {
 
     use crate::Canonical;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::RecursiveCanonical;
     use crate::VortexSessionExecute;
     use crate::arrays::BoolArray;
@@ -169,7 +168,7 @@ mod tests {
         );
 
         let result = list.into_array().cast(target_dtype).and_then(|a| {
-            a.execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())
+            a.execute::<RecursiveCanonical>(&mut SESSION.create_execution_ctx())
                 .map(|c| c.0.into_array())
         });
         assert!(result.is_err());
diff --git a/vortex-array/src/arrays/list/compute/mod.rs b/vortex-array/src/arrays/list/compute/mod.rs
index ac81556d050..d8ddbd37583 100644
--- a/vortex-array/src/arrays/list/compute/mod.rs
+++ b/vortex-array/src/arrays/list/compute/mod.rs
@@ -19,6 +19,8 @@ mod tests {
     use vortex_buffer::buffer;
 
     use crate::IntoArray;
+    use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::arrays::ListArray;
     use crate::arrays::PrimitiveArray;
@@ -78,6 +80,9 @@ mod tests {
         Validity::NonNullable,
     ).unwrap())]
     fn test_list_consistency(#[case] array: ListArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/vortex-array/src/arrays/list/compute/take.rs b/vortex-array/src/arrays/list/compute/take.rs
index f96cac5cf32..2c6089e0c58 100644
--- a/vortex-array/src/arrays/list/compute/take.rs
+++ b/vortex-array/src/arrays/list/compute/take.rs
@@ -212,10 +212,10 @@ mod test {
     use vortex_buffer::buffer;
 
     use crate::IntoArray as _;
-    use crate::LEGACY_SESSION;
     #[expect(deprecated)]
     use crate::ToCanonical as _;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::arrays::ListArray;
     use crate::arrays::PrimitiveArray;
@@ -258,12 +258,12 @@ mod test {
 
         assert!(
             result
-                .is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(0, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
         assert_eq!(
             result
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::list(
                 Arc::clone(&element_dtype),
@@ -274,18 +274,18 @@ mod test {
 
         assert!(
             result
-                .is_invalid(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_invalid(1, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
 
         assert!(
             result
-                .is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(2, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
         assert_eq!(
             result
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(2, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::list(
                 Arc::clone(&element_dtype),
@@ -296,12 +296,12 @@ mod test {
 
         assert!(
             result
-                .is_valid(3, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(3, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
         assert_eq!(
             result
-                .execute_scalar(3, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(3, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::list(element_dtype, vec![], Nullability::Nullable)
         );
@@ -361,12 +361,12 @@ mod test {
 
         assert!(
             result
-                .is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(0, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
         assert_eq!(
             result
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::list(
                 Arc::clone(&element_dtype),
@@ -377,12 +377,12 @@ mod test {
 
         assert!(
             result
-                .is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(1, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
         assert_eq!(
             result
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(1, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::list(
                 Arc::clone(&element_dtype),
@@ -393,12 +393,12 @@ mod test {
 
         assert!(
             result
-                .is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(2, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
         assert_eq!(
             result
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(2, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::list(element_dtype, vec![], Nullability::NonNullable)
         );
@@ -488,12 +488,12 @@ mod test {
         assert_eq!(result_view.len(), 2);
         assert!(
             result_view
-                .is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(0, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
         assert!(
             result_view
-                .is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(1, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
     }
@@ -518,17 +518,17 @@ mod test {
         assert_eq!(result_view.len(), 3);
         assert!(
             result_view
-                .is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(0, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
         assert!(
             result_view
-                .is_invalid(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_invalid(1, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
         assert!(
             result_view
-                .is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(2, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
     }
diff --git a/vortex-array/src/arrays/listview/compute/zip.rs b/vortex-array/src/arrays/listview/compute/zip.rs
index f682dbe8714..46537f1fafe 100644
--- a/vortex-array/src/arrays/listview/compute/zip.rs
+++ b/vortex-array/src/arrays/listview/compute/zip.rs
@@ -170,8 +170,8 @@ mod tests {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::arrays::Chunked;
     use crate::arrays::ChunkedArray;
@@ -216,7 +216,7 @@ mod tests {
         );
         let mask = Mask::from_iter([true, false, true]);
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mask
             .into_array()
             .zip(if_true, if_false)?
@@ -256,7 +256,7 @@ mod tests {
         // true -> if_true, false -> if_false
         let mask = Mask::from_iter([false, true, true]);
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mask
             .into_array()
             .zip(if_true, if_false)?
@@ -293,7 +293,7 @@ mod tests {
         );
         let mask = Mask::from_iter([true, true, false]);
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mask
             .into_array()
             .zip(if_true, if_false)?
@@ -336,7 +336,7 @@ mod tests {
         );
         let mask = Mask::from_iter([true, false]);
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mask
             .into_array()
             .zip(if_true, if_false)?
diff --git a/vortex-array/src/arrays/listview/tests/basic.rs b/vortex-array/src/arrays/listview/tests/basic.rs
index 7fb90bc5e04..3d4d6db284d 100644
--- a/vortex-array/src/arrays/listview/tests/basic.rs
+++ b/vortex-array/src/arrays/listview/tests/basic.rs
@@ -8,7 +8,6 @@ use vortex_buffer::buffer;
 use vortex_error::VortexResult;
 
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
 use crate::array_session;
 use crate::arrays::BoolArray;
@@ -58,7 +57,7 @@ fn test_basic_listview_comprehensive() {
 
     // Test scalar_at which returns entire lists as Scalar values.
     let first_scalar = listview
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut array_session().create_execution_ctx())
         .unwrap();
     assert_eq!(
         first_scalar,
@@ -136,7 +135,7 @@ fn test_from_list_array() -> VortexResult<()> {
     let validity = Validity::from_iter([true, false, true]);
 
     let list_array = ListArray::try_new(elements, offsets, validity)?;
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let list_view = list_view_from_list(list_array, &mut ctx)?;
 
     assert_eq!(list_view.len(), 3);
@@ -149,9 +148,9 @@ fn test_from_list_array() -> VortexResult<()> {
     );
 
     // Check validity is preserved.
-    assert!(list_view.is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())?);
-    assert!(list_view.is_invalid(1, &mut LEGACY_SESSION.create_execution_ctx())?);
-    assert!(list_view.is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())?);
+    assert!(list_view.is_valid(0, &mut array_session().create_execution_ctx())?);
+    assert!(list_view.is_invalid(1, &mut array_session().create_execution_ctx())?);
+    assert!(list_view.is_valid(2, &mut array_session().create_execution_ctx())?);
 
     // Check third list.
     assert_arrays_eq!(
@@ -214,7 +213,7 @@ fn test_listview_with_constant_arrays(#[case] const_sizes: bool, #[case] const_o
             listview
                 .list_elements_at(0)
                 .unwrap()
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             1i32.into()
         );
@@ -222,7 +221,7 @@ fn test_listview_with_constant_arrays(#[case] const_sizes: bool, #[case] const_o
             listview
                 .list_elements_at(1)
                 .unwrap()
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             1i32.into()
         );
@@ -230,7 +229,7 @@ fn test_listview_with_constant_arrays(#[case] const_sizes: bool, #[case] const_o
             listview
                 .list_elements_at(2)
                 .unwrap()
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             1i32.into()
         );
diff --git a/vortex-array/src/arrays/listview/tests/filter.rs b/vortex-array/src/arrays/listview/tests/filter.rs
index 97b73d3591a..25cc0de4aa8 100644
--- a/vortex-array/src/arrays/listview/tests/filter.rs
+++ b/vortex-array/src/arrays/listview/tests/filter.rs
@@ -14,7 +14,6 @@ use super::common::create_large_listview;
 use super::common::create_nullable_listview;
 use super::common::create_overlapping_listview;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
 use crate::arrays::ConstantArray;
 use crate::arrays::ListViewArray;
@@ -201,7 +200,7 @@ fn test_filter_extreme_offsets() {
     let list0 = result_list.list_elements_at(0).unwrap();
     assert_eq!(
         list0
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut SESSION.create_execution_ctx())
             .unwrap()
             .as_primitive()
             .as_::<i32>()
@@ -210,7 +209,7 @@ fn test_filter_extreme_offsets() {
     );
     assert_eq!(
         list0
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut SESSION.create_execution_ctx())
             .unwrap()
             .as_primitive()
             .as_::<i32>()
diff --git a/vortex-array/src/arrays/listview/tests/nested.rs b/vortex-array/src/arrays/listview/tests/nested.rs
index 4aa3edd75d5..4b2676f4491 100644
--- a/vortex-array/src/arrays/listview/tests/nested.rs
+++ b/vortex-array/src/arrays/listview/tests/nested.rs
@@ -4,8 +4,8 @@
 use vortex_buffer::buffer;
 
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
+use crate::array_session;
 use crate::arrays::ListView;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
@@ -74,7 +74,7 @@ fn test_listview_of_listview_with_overlapping() {
     // inner[0] should be [1, 2, 3].
     assert_eq!(
         inner0
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_primitive()
             .as_::<i32>()
@@ -83,7 +83,7 @@ fn test_listview_of_listview_with_overlapping() {
     );
     assert_eq!(
         inner0
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(2, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_primitive()
             .as_::<i32>()
@@ -94,7 +94,7 @@ fn test_listview_of_listview_with_overlapping() {
     // inner[1] should be [3, 4, 5] - shares element 3 with inner[0].
     assert_eq!(
         inner1
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_primitive()
             .as_::<i32>()
@@ -103,7 +103,7 @@ fn test_listview_of_listview_with_overlapping() {
     );
     assert_eq!(
         inner1
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_primitive()
             .as_::<i32>()
@@ -287,7 +287,7 @@ fn test_listview_zero_and_overlapping() {
     assert_eq!(inner1.len(), 3); // [1, 2, 3]
     assert_eq!(
         inner1
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_primitive()
             .as_::<i32>()
@@ -306,7 +306,7 @@ fn test_listview_zero_and_overlapping() {
     assert_eq!(inner3.len(), 3); // [2, 3, 4]
     assert_eq!(
         inner3
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_primitive()
             .as_::<i32>()
@@ -385,7 +385,7 @@ fn test_listview_of_struct_with_nulls() {
     // The middle element (struct[2]) should be null.
     assert!(
         list1
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
diff --git a/vortex-array/src/arrays/listview/tests/nullability.rs b/vortex-array/src/arrays/listview/tests/nullability.rs
index ff3f9c44c6c..4889b73de21 100644
--- a/vortex-array/src/arrays/listview/tests/nullability.rs
+++ b/vortex-array/src/arrays/listview/tests/nullability.rs
@@ -7,8 +7,8 @@ use rstest::rstest;
 use vortex_buffer::buffer;
 
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
+use crate::array_session;
 use crate::arrays::BoolArray;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
@@ -38,17 +38,17 @@ fn test_nullable_listview_comprehensive() {
     // Check validity.
     assert!(
         listview
-            .is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(0, &mut array_session().create_execution_ctx())
             .unwrap()
     );
     assert!(
         listview
-            .is_invalid(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_invalid(1, &mut array_session().create_execution_ctx())
             .unwrap()
     );
     assert!(
         listview
-            .is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(2, &mut array_session().create_execution_ctx())
             .unwrap()
     );
 
@@ -60,7 +60,7 @@ fn test_nullable_listview_comprehensive() {
 
     // Test scalar_at with nulls.
     let first = listview
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!first.is_null());
     assert_eq!(
@@ -73,12 +73,12 @@ fn test_nullable_listview_comprehensive() {
     );
 
     let second = listview
-        .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(1, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(second.is_null());
 
     let third = listview
-        .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(2, &mut array_session().create_execution_ctx())
         .unwrap();
     assert!(!third.is_null());
     assert_eq!(
@@ -95,13 +95,13 @@ fn test_nullable_listview_comprehensive() {
     assert_eq!(null_list_data.len(), 2);
     assert_eq!(
         null_list_data
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         3i32.into()
     );
     assert_eq!(
         null_list_data
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         4i32.into()
     );
@@ -123,7 +123,7 @@ fn test_nullable_patterns(#[case] validity: Validity, #[case] expected_validity:
     for (i, &expected) in expected_validity.iter().enumerate() {
         assert_eq!(
             listview
-                .is_valid(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(i, &mut array_session().create_execution_ctx())
                 .unwrap(),
             expected
         );
@@ -150,19 +150,19 @@ fn test_nullable_elements() {
     assert_eq!(first_list.len(), 2);
     assert!(
         !first_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
     assert_eq!(
         first_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         1i32.into()
     );
     assert!(
         first_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
@@ -171,19 +171,19 @@ fn test_nullable_elements() {
     let second_list = listview.list_elements_at(1).unwrap();
     assert!(
         !second_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
     assert_eq!(
         second_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         3i32.into()
     );
     assert!(
         second_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
@@ -192,25 +192,25 @@ fn test_nullable_elements() {
     let third_list = listview.list_elements_at(2).unwrap();
     assert!(
         !third_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
     assert_eq!(
         third_list
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         5i32.into()
     );
     assert!(
         !third_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
     assert_eq!(
         third_list
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap(),
         6i32.into()
     );
diff --git a/vortex-array/src/arrays/listview/tests/operations.rs b/vortex-array/src/arrays/listview/tests/operations.rs
index 8460fd956ac..f49680a854e 100644
--- a/vortex-array/src/arrays/listview/tests/operations.rs
+++ b/vortex-array/src/arrays/listview/tests/operations.rs
@@ -13,7 +13,6 @@ use super::common::create_large_listview;
 use super::common::create_nullable_listview;
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 #[expect(deprecated)]
 use crate::ToCanonical as _;
 use crate::VortexSessionExecute;
@@ -65,10 +64,10 @@ fn test_slice_comprehensive() {
         assert_eq!(
             full_list
                 .array()
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .unwrap(),
             listview
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .unwrap(),
             "Mismatch at index {}",
             i
@@ -164,13 +163,13 @@ fn test_slice_with_nulls() {
     assert!(
         sliced_list
             .array()
-            .is_invalid(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_invalid(0, &mut array_session().create_execution_ctx())
             .unwrap()
     ); // Original index 1 was null.
     assert!(
         sliced_list
             .array()
-            .is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(1, &mut array_session().create_execution_ctx())
             .unwrap()
     ); // Original index 2 was valid.
 
@@ -300,12 +299,12 @@ fn test_cast_with_nulls() {
     let result_list = result.to_listview();
     assert!(
         result_list
-            .is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(0, &mut array_session().create_execution_ctx())
             .unwrap()
     );
     assert!(
         result_list
-            .is_invalid(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_invalid(1, &mut array_session().create_execution_ctx())
             .unwrap()
     );
 }
@@ -417,7 +416,7 @@ fn test_zip_widens_false_element_nullability() -> VortexResult<()> {
     let result = mask
         .into_array()
         .zip(if_true, if_false)?
-        .execute::<ArrayRef>(&mut LEGACY_SESSION.create_execution_ctx())?;
+        .execute::<ArrayRef>(&mut array_session().create_execution_ctx())?;
     assert!(result.is::<ListView>());
     assert_eq!(
         result.dtype(),
@@ -463,7 +462,7 @@ fn test_zip_widens_true_element_nullability() -> VortexResult<()> {
     let result = mask
         .into_array()
         .zip(if_true, if_false)?
-        .execute::<ArrayRef>(&mut LEGACY_SESSION.create_execution_ctx())?;
+        .execute::<ArrayRef>(&mut array_session().create_execution_ctx())?;
     assert!(result.is::<ListView>());
     assert_eq!(
         result.dtype(),
@@ -541,7 +540,7 @@ fn test_is_constant_basic(
     )
     .into_array();
 
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     assert_eq!(is_constant(&listview, &mut ctx).unwrap(), expected);
 }
 
@@ -560,7 +559,7 @@ fn test_constant_with_constant_elements() {
     .into_array();
 
     // All lists contain [42, 42] so should be constant.
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     assert!(is_constant(&listview, &mut ctx).unwrap());
 }
 
@@ -584,7 +583,7 @@ fn test_constant_with_nulls() {
         .with_zero_copy_to_list(true)
     }
     .into_array();
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     assert!(!is_constant(&listview_mixed, &mut ctx).unwrap());
 
     // Case 2: All nulls - should be constant.
@@ -594,7 +593,7 @@ fn test_constant_with_nulls() {
             .with_zero_copy_to_list(true)
     }
     .into_array();
-    let mut ctx2 = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx2 = array_session().create_execution_ctx();
     assert!(is_constant(&listview_all_null, &mut ctx2).unwrap());
 }
 
@@ -609,7 +608,7 @@ fn test_constant_repeated_same_lists() {
     let listview = ListViewArray::new(elements, offsets, sizes, Validity::NonNullable).into_array();
 
     // All lists are [10, 20, 30] so should be constant.
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     assert!(is_constant(&listview, &mut ctx).unwrap());
 }
 
@@ -651,22 +650,22 @@ fn test_mask_preserves_structure() {
     // Check validity: true in selection means null.
     assert!(
         !result_list
-            .is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(0, &mut array_session().create_execution_ctx())
             .unwrap()
     ); // Masked.
     assert!(
         result_list
-            .is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(1, &mut array_session().create_execution_ctx())
             .unwrap()
     ); // Not masked.
     assert!(
         !result_list
-            .is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(2, &mut array_session().create_execution_ctx())
             .unwrap()
     ); // Masked.
     assert!(
         !result_list
-            .is_valid(3, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(3, &mut array_session().create_execution_ctx())
             .unwrap()
     ); // Masked.
 
@@ -705,17 +704,17 @@ fn test_mask_with_existing_nulls() {
     // Check combined validity:
     assert!(
         result_list
-            .is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(0, &mut array_session().create_execution_ctx())
             .unwrap()
     ); // Was valid, mask is false -> valid.
     assert!(
         !result_list
-            .is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(1, &mut array_session().create_execution_ctx())
             .unwrap()
     ); // Was invalid, mask is true -> invalid.
     assert!(
         !result_list
-            .is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(2, &mut array_session().create_execution_ctx())
             .unwrap()
     ); // Was valid, mask is true -> invalid.
 }
@@ -738,17 +737,17 @@ fn test_mask_with_gaps() {
     assert_eq!(result_list.len(), 3);
     assert!(
         !result_list
-            .is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(0, &mut array_session().create_execution_ctx())
             .unwrap()
     ); // Masked
     assert!(
         result_list
-            .is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(1, &mut array_session().create_execution_ctx())
             .unwrap()
     ); // Not masked
     assert!(
         result_list
-            .is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(2, &mut array_session().create_execution_ctx())
             .unwrap()
     ); // Not masked
 
@@ -783,17 +782,17 @@ fn test_mask_constant_arrays() {
     assert_eq!(result_list.len(), 3);
     assert!(
         result_list
-            .is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(0, &mut array_session().create_execution_ctx())
             .unwrap()
     );
     assert!(
         !result_list
-            .is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(1, &mut array_session().create_execution_ctx())
             .unwrap()
     ); // Masked
     assert!(
         result_list
-            .is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(2, &mut array_session().create_execution_ctx())
             .unwrap()
     );
 
diff --git a/vortex-array/src/arrays/listview/tests/take.rs b/vortex-array/src/arrays/listview/tests/take.rs
index b33243b56ee..2a68f711d30 100644
--- a/vortex-array/src/arrays/listview/tests/take.rs
+++ b/vortex-array/src/arrays/listview/tests/take.rs
@@ -13,7 +13,6 @@ use super::common::create_large_listview;
 use super::common::create_nullable_listview;
 use super::common::create_overlapping_listview;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
 use crate::arrays::ConstantArray;
 use crate::arrays::ListViewArray;
@@ -190,7 +189,7 @@ fn test_take_extreme_offsets() {
     let list0 = result_list.list_elements_at(0).unwrap();
     assert_eq!(
         list0
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut SESSION.create_execution_ctx())
             .unwrap()
             .as_primitive()
             .as_::<i32>()
@@ -199,7 +198,7 @@ fn test_take_extreme_offsets() {
     );
     assert_eq!(
         list0
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut SESSION.create_execution_ctx())
             .unwrap()
             .as_primitive()
             .as_::<i32>()
diff --git a/vortex-array/src/arrays/masked/tests.rs b/vortex-array/src/arrays/masked/tests.rs
index 7fc5f6f8dc4..60b045d521d 100644
--- a/vortex-array/src/arrays/masked/tests.rs
+++ b/vortex-array/src/arrays/masked/tests.rs
@@ -8,7 +8,6 @@ use vortex_error::VortexResult;
 use super::*;
 use crate::Canonical;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 #[expect(deprecated)]
 use crate::ToCanonical as _;
 use crate::VortexSessionExecute;
@@ -52,7 +51,7 @@ fn test_canonical_dtype_matches_array_dtype() -> VortexResult<()> {
     let canonical = array
         .clone()
         .into_array()
-        .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?;
+        .execute::<Canonical>(&mut array_session().create_execution_ctx())?;
     assert_eq!(canonical.dtype(), array.dtype());
     Ok(())
 }
@@ -68,28 +67,28 @@ fn test_masked_child_with_validity() {
     let prim = array.as_array().to_primitive();
 
     // Positions where validity is false should be null in masked_child.
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     assert_eq!(prim.valid_count(&mut ctx).unwrap(), 3);
     assert!(
-        prim.is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+        prim.is_valid(0, &mut array_session().create_execution_ctx())
             .unwrap()
     );
     assert!(
         !prim
-            .is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(1, &mut array_session().create_execution_ctx())
             .unwrap()
     );
     assert!(
-        prim.is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())
+        prim.is_valid(2, &mut array_session().create_execution_ctx())
             .unwrap()
     );
     assert!(
         !prim
-            .is_valid(3, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(3, &mut array_session().create_execution_ctx())
             .unwrap()
     );
     assert!(
-        prim.is_valid(4, &mut LEGACY_SESSION.create_execution_ctx())
+        prim.is_valid(4, &mut array_session().create_execution_ctx())
             .unwrap()
     );
 }
@@ -104,7 +103,7 @@ fn test_masked_child_all_valid() {
     assert_eq!(array.len(), 3);
     assert_eq!(
         array
-            .valid_count(&mut LEGACY_SESSION.create_execution_ctx())
+            .valid_count(&mut array_session().create_execution_ctx())
             .unwrap(),
         3
     );
@@ -132,7 +131,7 @@ fn test_masked_child_preserves_length(#[case] validity: Validity) {
 
     assert_eq!(array.len(), len);
 
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     assert!(
         array
             .validity()
diff --git a/vortex-array/src/arrays/masked/vtable/canonical.rs b/vortex-array/src/arrays/masked/vtable/canonical.rs
index 90bd999b8ed..32a5e334afa 100644
--- a/vortex-array/src/arrays/masked/vtable/canonical.rs
+++ b/vortex-array/src/arrays/masked/vtable/canonical.rs
@@ -8,8 +8,8 @@ mod tests {
 
     use crate::Canonical;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::MaskedArray;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::Nullability;
@@ -41,7 +41,7 @@ mod tests {
         let canonical = array
             .clone()
             .into_array()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?;
+            .execute::<Canonical>(&mut array_session().create_execution_ctx())?;
         assert_eq!(canonical.dtype().nullability(), expected_nullability);
         assert_eq!(canonical.dtype(), array.dtype());
         Ok(())
@@ -56,17 +56,17 @@ mod tests {
 
         let canonical = array
             .into_array()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?;
+            .execute::<Canonical>(&mut array_session().create_execution_ctx())?;
         let prim = canonical.into_primitive();
 
         // Check that null positions match validity.
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(prim.valid_count(&mut ctx)?, 3);
-        assert!(prim.is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())?);
-        assert!(!prim.is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())?);
-        assert!(prim.is_valid(2, &mut LEGACY_SESSION.create_execution_ctx())?);
-        assert!(!prim.is_valid(3, &mut LEGACY_SESSION.create_execution_ctx())?);
-        assert!(prim.is_valid(4, &mut LEGACY_SESSION.create_execution_ctx())?);
+        assert!(prim.is_valid(0, &mut array_session().create_execution_ctx())?);
+        assert!(!prim.is_valid(1, &mut array_session().create_execution_ctx())?);
+        assert!(prim.is_valid(2, &mut array_session().create_execution_ctx())?);
+        assert!(!prim.is_valid(3, &mut array_session().create_execution_ctx())?);
+        assert!(prim.is_valid(4, &mut array_session().create_execution_ctx())?);
         Ok(())
     }
 
@@ -79,12 +79,12 @@ mod tests {
 
         let canonical = array
             .into_array()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?;
+            .execute::<Canonical>(&mut array_session().create_execution_ctx())?;
         assert_eq!(canonical.dtype().nullability(), Nullability::Nullable);
         assert_eq!(
             canonical
                 .into_array()
-                .valid_count(&mut LEGACY_SESSION.create_execution_ctx())?,
+                .valid_count(&mut array_session().create_execution_ctx())?,
             3
         );
         Ok(())
diff --git a/vortex-array/src/arrays/masked/vtable/mod.rs b/vortex-array/src/arrays/masked/vtable/mod.rs
index ed5ea67cd62..70f7f566e41 100644
--- a/vortex-array/src/arrays/masked/vtable/mod.rs
+++ b/vortex-array/src/arrays/masked/vtable/mod.rs
@@ -206,8 +206,8 @@ mod tests {
     use crate::ArrayContext;
     use crate::Canonical;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::Masked;
     use crate::arrays::MaskedArray;
     use crate::arrays::PrimitiveArray;
@@ -243,7 +243,7 @@ mod tests {
         let serialized = array
             .clone()
             .into_array()
-            .serialize(&ctx, &LEGACY_SESSION, &SerializeOptions::default())
+            .serialize(&ctx, &array_session(), &SerializeOptions::default())
             .unwrap();
 
         // Concat into a single buffer.
@@ -259,7 +259,7 @@ mod tests {
                 &dtype,
                 len,
                 &ReadContext::new(ctx.to_ids()),
-                &LEGACY_SESSION,
+                &array_session(),
             )
             .unwrap();
 
@@ -287,7 +287,7 @@ mod tests {
         assert_eq!(array.dtype().nullability(), Nullability::Nullable);
 
         // Execute the array. This should produce a Canonical with Nullable dtype.
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result: Canonical = array.into_array().execute(&mut ctx)?;
 
         assert_eq!(
diff --git a/vortex-array/src/arrays/null/compute/cast.rs b/vortex-array/src/arrays/null/compute/cast.rs
index be6c73ad7d5..a2527e5fb73 100644
--- a/vortex-array/src/arrays/null/compute/cast.rs
+++ b/vortex-array/src/arrays/null/compute/cast.rs
@@ -32,8 +32,8 @@ mod tests {
     use rstest::rstest;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::NullArray;
     use crate::builtins::ArrayBuiltins;
     use crate::compute::conformance::cast::test_cast_conformance;
@@ -68,7 +68,7 @@ mod tests {
         for i in 0..5 {
             assert!(
                 result
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .unwrap()
                     .is_null()
             );
diff --git a/vortex-array/src/arrays/null/compute/mod.rs b/vortex-array/src/arrays/null/compute/mod.rs
index df2bc1547ae..5e756da27d0 100644
--- a/vortex-array/src/arrays/null/compute/mod.rs
+++ b/vortex-array/src/arrays/null/compute/mod.rs
@@ -15,10 +15,10 @@ mod test {
     use vortex_mask::Mask;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     #[expect(deprecated)]
     use crate::ToCanonical as _;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::NullArray;
     use crate::compute::conformance::consistency::test_array_consistency;
     use crate::compute::conformance::filter::test_filter_conformance;
@@ -38,7 +38,10 @@ mod test {
             sliced_arr
                 .validity()
                 .unwrap()
-                .execute_mask(sliced_arr.len(), &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_mask(
+                    sliced_arr.len(),
+                    &mut array_session().create_execution_ctx()
+                )
                 .unwrap(),
             Mask::AllFalse(4)
         ));
@@ -59,7 +62,7 @@ mod test {
             taken_arr
                 .validity()
                 .unwrap()
-                .execute_mask(taken_arr.len(), &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_mask(taken_arr.len(), &mut array_session().create_execution_ctx())
                 .unwrap(),
             Mask::AllFalse(5)
         ));
@@ -70,7 +73,7 @@ mod test {
         let nulls = NullArray::new(10);
 
         let scalar = nulls
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap();
         assert!(scalar.is_null());
         assert_eq!(scalar.dtype().clone(), DType::Null);
@@ -104,6 +107,9 @@ mod test {
     #[case::null_array_large(NullArray::new(1000))]
     #[case::null_array_empty(NullArray::new(0))]
     fn test_null_consistency(#[case] array: NullArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/vortex-array/src/arrays/null/mod.rs b/vortex-array/src/arrays/null/mod.rs
index dd31ef16853..78fe191b6a0 100644
--- a/vortex-array/src/arrays/null/mod.rs
+++ b/vortex-array/src/arrays/null/mod.rs
@@ -123,7 +123,7 @@ impl VTable for Null {
 /// ```
 /// # fn main() -> vortex_error::VortexResult<()> {
 /// use vortex_array::arrays::NullArray;
-/// use vortex_array::{IntoArray, LEGACY_SESSION, VortexSessionExecute};
+/// use vortex_array::{IntoArray, VortexSessionExecute, array_session};
 ///
 /// // Create a null array with 5 elements
 /// let array = NullArray::new(5);
@@ -133,7 +133,7 @@ impl VTable for Null {
 /// assert_eq!(sliced.len(), 2);
 ///
 /// // All elements are null
-/// let mut ctx = LEGACY_SESSION.create_execution_ctx();
+/// let mut ctx = array_session().create_execution_ctx();
 /// let scalar = array.execute_scalar(0, &mut ctx).unwrap();
 /// assert!(scalar.is_null());
 /// # Ok(())
diff --git a/vortex-array/src/arrays/patched/vtable/mod.rs b/vortex-array/src/arrays/patched/vtable/mod.rs
index 58452857476..dbcb4c220dc 100644
--- a/vortex-array/src/arrays/patched/vtable/mod.rs
+++ b/vortex-array/src/arrays/patched/vtable/mod.rs
@@ -354,8 +354,8 @@ mod tests {
     use crate::ArraySlots;
     use crate::Canonical;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::Patched;
     use crate::arrays::PatchedArray;
     use crate::arrays::PrimitiveArray;
@@ -382,7 +382,7 @@ mod tests {
         )
         .unwrap();
 
-        let session = crate::array_session();
+        let session = array_session();
         let mut ctx = session.create_execution_ctx();
 
         let array = Patched::from_array_and_patches(values, &patches, &mut ctx)
@@ -415,7 +415,7 @@ mod tests {
         )
         .unwrap();
 
-        let session = crate::array_session();
+        let session = array_session();
         let mut ctx = session.create_execution_ctx();
 
         let array = Patched::from_array_and_patches(values, &patches, &mut ctx)
@@ -448,7 +448,7 @@ mod tests {
         )
         .unwrap();
 
-        let session = crate::array_session();
+        let session = array_session();
         let mut ctx = session.create_execution_ctx();
 
         let array = Patched::from_array_and_patches(values, &patches, &mut ctx)
@@ -481,7 +481,7 @@ mod tests {
         )
         .unwrap();
 
-        let session = crate::array_session();
+        let session = array_session();
         let mut ctx = session.create_execution_ctx();
 
         let array = Patched::from_array_and_patches(values, &patches, &mut ctx)
@@ -518,7 +518,7 @@ mod tests {
         )
         .unwrap();
 
-        let session = crate::array_session();
+        let session = array_session();
         let mut ctx = session.create_execution_ctx();
 
         let array = Patched::from_array_and_patches(values, &patches, &mut ctx)
@@ -562,7 +562,7 @@ mod tests {
 
         let patches = Patches::new(len, 0, indices, patch_vals, None)?;
 
-        let session = crate::array_session();
+        let session = array_session();
         let mut ctx = session.create_execution_ctx();
 
         Patched::from_array_and_patches(array, &patches, &mut ctx)
@@ -583,11 +583,12 @@ mod tests {
         let dtype = array.dtype().clone();
         let len = array.len();
 
-        LEGACY_SESSION.arrays().register(Patched);
+        let session = array_session();
+        session.arrays().register(Patched);
 
-        let ctx = ArrayContext::empty().with_registry(LEGACY_SESSION.arrays().registry().clone());
+        let ctx = ArrayContext::empty().with_registry(session.arrays().registry().clone());
         let serialized = array
-            .serialize(&ctx, &LEGACY_SESSION, &SerializeOptions::default())
+            .serialize(&ctx, &session, &SerializeOptions::default())
             .unwrap();
 
         // Concat into a single buffer.
@@ -599,12 +600,7 @@ mod tests {
 
         let parts = SerializedArray::try_from(concat).unwrap();
         let decoded = parts
-            .decode(
-                &dtype,
-                len,
-                &ReadContext::new(ctx.to_ids()),
-                &LEGACY_SESSION,
-            )
+            .decode(&dtype, len, &ReadContext::new(ctx.to_ids()), &session)
             .unwrap();
 
         assert!(decoded.is::<Patched>());
@@ -639,7 +635,7 @@ mod tests {
         assert_eq!(array_ref.dtype(), new_array.dtype());
 
         // Execute both and compare results
-        let mut ctx = crate::array_session().create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let original_executed = array_ref.execute::<Canonical>(&mut ctx)?.into_primitive();
         let new_executed = new_array.execute::<Canonical>(&mut ctx)?.into_primitive();
 
@@ -665,7 +661,7 @@ mod tests {
         let new_array = array_ref.with_slots(slots.into_slots())?;
 
         // Execute and verify the inner values changed (except at patch positions)
-        let mut ctx = crate::array_session().create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let executed = new_array.execute::<Canonical>(&mut ctx)?.into_primitive();
 
         // Expected: all 5s except indices 1, 2, 3 which are patched to 10, 20, 30
diff --git a/vortex-array/src/arrays/patched/vtable/operations.rs b/vortex-array/src/arrays/patched/vtable/operations.rs
index a6468ef03aa..51dd1fc9e3c 100644
--- a/vortex-array/src/arrays/patched/vtable/operations.rs
+++ b/vortex-array/src/arrays/patched/vtable/operations.rs
@@ -61,8 +61,8 @@ mod tests {
     use vortex_session::VortexSession;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::Patched;
     use crate::dtype::Nullability;
     use crate::optimizer::ArrayOptimizer;
@@ -90,25 +90,25 @@ mod tests {
 
         assert_eq!(
             array
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::primitive(0u16, Nullability::NonNullable)
         );
         assert_eq!(
             array
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(1, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::primitive(1u16, Nullability::NonNullable)
         );
         assert_eq!(
             array
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(2, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::primitive(1u16, Nullability::NonNullable)
         );
         assert_eq!(
             array
-                .execute_scalar(3, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(3, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::primitive(1u16, Nullability::NonNullable)
         );
@@ -135,7 +135,7 @@ mod tests {
 
         for index in 0..array.len() {
             let value = array
-                .execute_scalar(index, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(index, &mut array_session().create_execution_ctx())
                 .unwrap();
 
             if [1, 2, 3].contains(&index) {
@@ -173,14 +173,14 @@ mod tests {
 
         assert_eq!(
             array
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             1u16.into()
         );
         for index in 1..array.len() {
             assert_eq!(
                 array
-                    .execute_scalar(index, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(index, &mut array_session().create_execution_ctx())
                     .unwrap(),
                 0u16.into()
             );
diff --git a/vortex-array/src/arrays/primitive/array/mod.rs b/vortex-array/src/arrays/primitive/array/mod.rs
index ad74bd7974d..98bd993c7f9 100644
--- a/vortex-array/src/arrays/primitive/array/mod.rs
+++ b/vortex-array/src/arrays/primitive/array/mod.rs
@@ -71,7 +71,7 @@ pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["validity"];
 /// ```
 /// # fn main() -> vortex_error::VortexResult<()> {
 /// use vortex_array::arrays::PrimitiveArray;
-/// use vortex_array::{LEGACY_SESSION, VortexSessionExecute};
+/// use vortex_array::{VortexSessionExecute, array_session};
 ///
 /// // Create from iterator using FromIterator impl
 /// let array: PrimitiveArray = [1i32, 2, 3, 4, 5].into_iter().collect();
@@ -80,7 +80,7 @@ pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["validity"];
 /// let sliced = array.slice(1..3)?;
 ///
 /// // Access individual values
-/// let mut ctx = LEGACY_SESSION.create_execution_ctx();
+/// let mut ctx = array_session().create_execution_ctx();
 /// let value = sliced.execute_scalar(0, &mut ctx).unwrap();
 /// assert_eq!(value, 2i32.into());
 ///
diff --git a/vortex-array/src/arrays/primitive/compute/cast.rs b/vortex-array/src/arrays/primitive/compute/cast.rs
index a83cc293e4d..36b95b4c554 100644
--- a/vortex-array/src/arrays/primitive/compute/cast.rs
+++ b/vortex-array/src/arrays/primitive/compute/cast.rs
@@ -272,7 +272,6 @@ mod test {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::PrimitiveArray;
@@ -410,7 +409,10 @@ mod test {
             p.as_ref()
                 .validity()
                 .unwrap()
-                .execute_mask(p.as_ref().len(), &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_mask(
+                    p.as_ref().len(),
+                    &mut array_session().create_execution_ctx()
+                )
                 .unwrap(),
             Mask::from(BitBuffer::from(vec![false, true, true]))
         );
diff --git a/vortex-array/src/arrays/primitive/compute/fill_null.rs b/vortex-array/src/arrays/primitive/compute/fill_null.rs
index c9376de2ee5..d73442a150e 100644
--- a/vortex-array/src/arrays/primitive/compute/fill_null.rs
+++ b/vortex-array/src/arrays/primitive/compute/fill_null.rs
@@ -51,7 +51,6 @@ mod test {
     use vortex_buffer::buffer;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::PrimitiveArray;
@@ -82,7 +81,10 @@ mod test {
             p.as_ref()
                 .validity()
                 .unwrap()
-                .execute_mask(p.as_ref().len(), &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_mask(
+                    p.as_ref().len(),
+                    &mut array_session().create_execution_ctx()
+                )
                 .unwrap()
                 .all_true()
         );
@@ -108,7 +110,10 @@ mod test {
             p.as_ref()
                 .validity()
                 .unwrap()
-                .execute_mask(p.as_ref().len(), &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_mask(
+                    p.as_ref().len(),
+                    &mut array_session().create_execution_ctx()
+                )
                 .unwrap()
                 .all_true()
         );
@@ -136,7 +141,10 @@ mod test {
             p.as_ref()
                 .validity()
                 .unwrap()
-                .execute_mask(p.as_ref().len(), &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_mask(
+                    p.as_ref().len(),
+                    &mut array_session().create_execution_ctx()
+                )
                 .unwrap()
                 .all_true()
         );
@@ -157,7 +165,10 @@ mod test {
             p.as_ref()
                 .validity()
                 .unwrap()
-                .execute_mask(p.as_ref().len(), &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_mask(
+                    p.as_ref().len(),
+                    &mut array_session().create_execution_ctx()
+                )
                 .unwrap()
                 .all_true()
         );
diff --git a/vortex-array/src/arrays/primitive/compute/mod.rs b/vortex-array/src/arrays/primitive/compute/mod.rs
index bd59efed20b..1ca4b17d3d5 100644
--- a/vortex-array/src/arrays/primitive/compute/mod.rs
+++ b/vortex-array/src/arrays/primitive/compute/mod.rs
@@ -15,7 +15,10 @@ mod tests {
     use rstest::rstest;
 
     use crate::IntoArray;
+    use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
+    use crate::compute::conformance::binary_numeric::test_binary_numeric_array;
     use crate::compute::conformance::consistency::test_array_consistency;
 
     #[rstest]
@@ -36,7 +39,10 @@ mod tests {
     #[case::i16_negative(PrimitiveArray::from_iter([-100i16, -50, 0, 50, 100]))]
     #[case::f64_special(PrimitiveArray::from_iter([0.0f64, 1.0, -1.0, f64::INFINITY, f64::NEG_INFINITY]))]
     fn test_primitive_consistency(#[case] array: PrimitiveArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 
     #[rstest]
@@ -46,7 +52,9 @@ mod tests {
     #[case::f32(PrimitiveArray::from_iter([1.5f32, 2.5, 3.5, 4.5, 5.5]))]
     #[case::f64(PrimitiveArray::from_iter([10.1f64, 20.2, 30.3, 40.4, 50.5]))]
     fn test_primitive_binary_numeric(#[case] array: PrimitiveArray) {
-        use crate::compute::conformance::binary_numeric::test_binary_numeric_array;
-        test_binary_numeric_array(array.into_array());
+        test_binary_numeric_array(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/vortex-array/src/arrays/primitive/compute/take/mod.rs b/vortex-array/src/arrays/primitive/compute/take/mod.rs
index db37a820a37..9294659708e 100644
--- a/vortex-array/src/arrays/primitive/compute/take/mod.rs
+++ b/vortex-array/src/arrays/primitive/compute/take/mod.rs
@@ -152,8 +152,8 @@ mod test {
     use vortex_error::VortexExpect;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::primitive::compute::take::take_primitive_scalar;
@@ -181,21 +181,21 @@ mod test {
         let actual = values.take(indices.into_array()).unwrap();
         assert_eq!(
             actual
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .vortex_expect("no fail"),
             Scalar::from(Some(1))
         );
         // position 3 is null
         assert_eq!(
             actual
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(1, &mut array_session().create_execution_ctx())
                 .vortex_expect("no fail"),
             Scalar::null_native::<i32>()
         );
         // the third index is null
         assert_eq!(
             actual
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(2, &mut array_session().create_execution_ctx())
                 .vortex_expect("no fail"),
             Scalar::null_native::<i32>()
         );
diff --git a/vortex-array/src/arrays/primitive/compute/zip.rs b/vortex-array/src/arrays/primitive/compute/zip.rs
index 99b92c78703..83f03b10614 100644
--- a/vortex-array/src/arrays/primitive/compute/zip.rs
+++ b/vortex-array/src/arrays/primitive/compute/zip.rs
@@ -152,8 +152,8 @@ mod tests {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::Primitive;
     use crate::arrays::PrimitiveArray;
     use crate::assert_arrays_eq;
@@ -170,7 +170,7 @@ mod tests {
         let bits: Vec<bool> = (0..len).map(|i| i.is_multiple_of(3) || i == 64).collect();
         let mask = Mask::from_iter(bits.iter().copied());
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mask
             .into_array()
             .zip(if_true, if_false)?
@@ -201,7 +201,7 @@ mod tests {
         let bits: Vec<bool> = (0..len).map(|i| i.is_multiple_of(2)).collect();
         let mask = Mask::from_iter(bits.iter().copied());
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mask
             .into_array()
             .zip(if_true, if_false)?
diff --git a/vortex-array/src/arrays/scalar_fn/vtable/operations.rs b/vortex-array/src/arrays/scalar_fn/vtable/operations.rs
index 2e6b0240004..c19e3e2288c 100644
--- a/vortex-array/src/arrays/scalar_fn/vtable/operations.rs
+++ b/vortex-array/src/arrays/scalar_fn/vtable/operations.rs
@@ -60,7 +60,6 @@ mod tests {
 
     use crate::Canonical;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::BoolArray;
@@ -88,7 +87,7 @@ mod tests {
 
         let result = scalar_fn_array
             .into_array()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?
+            .execute::<Canonical>(&mut array_session().create_execution_ctx())?
             .into_array();
         let expected = buffer![11i32, 22, 33].into_array();
         assert_arrays_eq!(result, expected, &mut ctx);
@@ -141,7 +140,7 @@ mod tests {
 
         let result = scalar_fn_array
             .into_array()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?
+            .execute::<Canonical>(&mut array_session().create_execution_ctx())?
             .into_array();
         let expected = buffer![10i32, 18, 28].into_array();
         assert_arrays_eq!(result, expected, &mut ctx);
@@ -164,7 +163,7 @@ mod tests {
 
         let result = scalar_fn_array
             .into_array()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?
+            .execute::<Canonical>(&mut array_session().create_execution_ctx())?
             .into_array();
         let expected = PrimitiveArray::new(
             buffer![11i32, 0, 33],
@@ -187,7 +186,7 @@ mod tests {
 
         let result = scalar_fn_array
             .into_array()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?
+            .execute::<Canonical>(&mut array_session().create_execution_ctx())?
             .into_array();
         let expected = BoolArray::from_iter([false, true, false]).into_array();
         assert_arrays_eq!(result, expected, &mut ctx);
diff --git a/vortex-array/src/arrays/struct_/array.rs b/vortex-array/src/arrays/struct_/array.rs
index 7feffb5484c..4bea2e3641a 100644
--- a/vortex-array/src/arrays/struct_/array.rs
+++ b/vortex-array/src/arrays/struct_/array.rs
@@ -57,7 +57,7 @@ pub(super) const FIELDS_OFFSET: usize = 1;
 /// use vortex_array::arrays::{StructArray, BoolArray};
 /// use vortex_array::validity::Validity;
 /// use vortex_array::dtype::FieldNames;
-/// use vortex_array::{IntoArray, LEGACY_SESSION, VortexSessionExecute};
+/// use vortex_array::{IntoArray, VortexSessionExecute, array_session};
 /// use vortex_buffer::buffer;
 ///
 /// // Create struct with all non-null fields but struct-level nulls
@@ -71,7 +71,7 @@ pub(super) const FIELDS_OFFSET: usize = 1;
 ///     2,
 ///     Validity::Array(BoolArray::from_iter([true, false]).into_array()), // row 1 is null
 /// ).unwrap();
-/// let mut ctx = LEGACY_SESSION.create_execution_ctx();
+/// let mut ctx = array_session().create_execution_ctx();
 ///
 /// // Row 0 is valid - returns a struct scalar with field values
 /// let row0 = struct_array.execute_scalar(0, &mut ctx).unwrap();
@@ -92,7 +92,7 @@ pub(super) const FIELDS_OFFSET: usize = 1;
 /// use vortex_array::arrays::struct_::StructArrayExt;
 /// use vortex_array::validity::Validity;
 /// use vortex_array::dtype::FieldNames;
-/// use vortex_array::{IntoArray, LEGACY_SESSION, VortexSessionExecute};
+/// use vortex_array::{IntoArray, VortexSessionExecute, array_session};
 /// use vortex_buffer::buffer;
 ///
 /// // Create struct with duplicate "data" field names
@@ -108,7 +108,7 @@ pub(super) const FIELDS_OFFSET: usize = 1;
 ///
 /// // field_by_name returns the FIRST "data" field
 /// let first_data = struct_array.unmasked_field_by_name("data").unwrap();
-/// let mut ctx = LEGACY_SESSION.create_execution_ctx();
+/// let mut ctx = array_session().create_execution_ctx();
 /// assert_eq!(first_data.execute_scalar(0, &mut ctx).unwrap(), 1i32.into());
 /// ```
 ///
diff --git a/vortex-array/src/arrays/struct_/compute/mod.rs b/vortex-array/src/arrays/struct_/compute/mod.rs
index 36a355bd3de..c1539a638bf 100644
--- a/vortex-array/src/arrays/struct_/compute/mod.rs
+++ b/vortex-array/src/arrays/struct_/compute/mod.rs
@@ -19,7 +19,6 @@ mod tests {
 
     use crate::Canonical;
     use crate::IntoArray as _;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::fns::is_constant::is_constant;
     use crate::array_session;
@@ -70,13 +69,13 @@ mod tests {
         let taken = struct_arr
             .take(indices.into_array())
             .unwrap()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<Canonical>(&mut array_session().create_execution_ctx())
             .unwrap();
         assert_eq!(taken.len(), 1);
         assert!(
             taken
                 .into_array()
-                .all_invalid(&mut LEGACY_SESSION.create_execution_ctx())
+                .all_invalid(&mut array_session().create_execution_ctx())
                 .unwrap()
         );
     }
@@ -88,7 +87,7 @@ mod tests {
         let taken = arr
             .take(indices.into_array())
             .unwrap()
-            .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<Canonical>(&mut array_session().create_execution_ctx())
             .unwrap();
         assert_eq!(taken.len(), 1);
     }
@@ -259,7 +258,7 @@ mod tests {
     #[test]
     fn test_empty_struct_is_constant() {
         let array = StructArray::new_fieldless_with_len(2);
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = is_constant(&array.into_array(), &mut ctx)
             .vortex_expect("operation should succeed in test");
         assert!(result);
@@ -420,6 +419,9 @@ mod tests {
         StructArray::try_new(["xs", "ys"].into(), vec![xs, ys], 100, Validity::NonNullable).unwrap()
     })]
     fn test_struct_consistency(#[case] array: StructArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/vortex-array/src/arrays/struct_/tests.rs b/vortex-array/src/arrays/struct_/tests.rs
index 62b0b3c8701..3eb65e0c018 100644
--- a/vortex-array/src/arrays/struct_/tests.rs
+++ b/vortex-array/src/arrays/struct_/tests.rs
@@ -6,7 +6,6 @@ use vortex_error::VortexResult;
 
 use crate::Canonical;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
 use crate::array_session;
 use crate::arrays::BoolArray;
@@ -162,12 +161,12 @@ fn test_uncompressed_size_in_bytes() -> VortexResult<()> {
     let canonical_size = struct_array
         .clone()
         .into_array()
-        .execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?
+        .execute::<Canonical>(&mut array_session().create_execution_ctx())?
         .into_array()
         .nbytes();
     let uncompressed_size = struct_array
         .statistics()
-        .compute_uncompressed_size_in_bytes(&mut LEGACY_SESSION.create_execution_ctx());
+        .compute_uncompressed_size_in_bytes(&mut array_session().create_execution_ctx());
 
     assert_eq!(canonical_size, 2);
     assert_eq!(uncompressed_size, Some(4000));
diff --git a/vortex-array/src/arrays/varbin/builder.rs b/vortex-array/src/arrays/varbin/builder.rs
index ad76eaa981b..404f574af52 100644
--- a/vortex-array/src/arrays/varbin/builder.rs
+++ b/vortex-array/src/arrays/varbin/builder.rs
@@ -130,8 +130,8 @@ impl<O: IntegerPType> VarBinBuilder<O> {
 mod tests {
     use vortex_error::VortexResult;
 
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::varbin::VarBinArrayExt;
     use crate::arrays::varbin::builder::VarBinBuilder;
     use crate::dtype::DType;
@@ -153,13 +153,13 @@ mod tests {
         assert_eq!(array.dtype().nullability(), Nullable);
         assert_eq!(
             array
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::utf8("hello".to_string(), Nullable)
         );
         assert!(
             array
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(1, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null()
         );
diff --git a/vortex-array/src/arrays/varbin/compute/compare.rs b/vortex-array/src/arrays/varbin/compute/compare.rs
index 32b795009f1..ede3c409d94 100644
--- a/vortex-array/src/arrays/varbin/compute/compare.rs
+++ b/vortex-array/src/arrays/varbin/compute/compare.rs
@@ -159,10 +159,10 @@ mod test {
     use vortex_buffer::ByteBuffer;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     #[expect(deprecated)]
     use crate::ToCanonical as _;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::ConstantArray;
     use crate::arrays::VarBinArray;
     use crate::arrays::VarBinViewArray;
@@ -200,7 +200,7 @@ mod test {
                 .unwrap()
                 .execute_mask(
                     result.as_ref().len(),
-                    &mut LEGACY_SESSION.create_execution_ctx()
+                    &mut array_session().create_execution_ctx()
                 )
                 .unwrap()
                 .to_bit_buffer(),
@@ -236,7 +236,7 @@ mod test {
                 .unwrap()
                 .execute_mask(
                     result.as_ref().len(),
-                    &mut LEGACY_SESSION.create_execution_ctx()
+                    &mut array_session().create_execution_ctx()
                 )
                 .unwrap()
                 .to_bit_buffer(),
diff --git a/vortex-array/src/arrays/varbin/compute/mod.rs b/vortex-array/src/arrays/varbin/compute/mod.rs
index ab2de942138..480c07a3031 100644
--- a/vortex-array/src/arrays/varbin/compute/mod.rs
+++ b/vortex-array/src/arrays/varbin/compute/mod.rs
@@ -15,6 +15,8 @@ mod tests {
     use rstest::rstest;
 
     use crate::IntoArray;
+    use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::VarBinArray;
     use crate::compute::conformance::consistency::test_array_consistency;
     use crate::dtype::DType;
@@ -60,6 +62,9 @@ mod tests {
         DType::Utf8(Nullability::NonNullable),
     ))]
     fn test_varbin_consistency(#[case] array: VarBinArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/vortex-array/src/arrays/varbin/vtable/canonical.rs b/vortex-array/src/arrays/varbin/vtable/canonical.rs
index 9a2256fe05a..4865df5e1a3 100644
--- a/vortex-array/src/arrays/varbin/vtable/canonical.rs
+++ b/vortex-array/src/arrays/varbin/vtable/canonical.rs
@@ -47,7 +47,6 @@ pub(crate) fn varbin_to_canonical(
 mod tests {
     use rstest::rstest;
 
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::VarBinArray;
@@ -80,7 +79,7 @@ mod tests {
 
         assert!(
             !canonical
-                .is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(0, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
 
diff --git a/vortex-array/src/arrays/varbinview/compact.rs b/vortex-array/src/arrays/varbinview/compact.rs
index 2f6d459113f..7dd29c4edeb 100644
--- a/vortex-array/src/arrays/varbinview/compact.rs
+++ b/vortex-array/src/arrays/varbinview/compact.rs
@@ -193,7 +193,6 @@ mod tests {
     use vortex_buffer::buffer;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::VarBinArray;
@@ -221,7 +220,7 @@ mod tests {
         let indices = buffer![0u32, 4u32].into_array();
         let taken = original.take(indices).unwrap();
         let taken = taken
-            .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<VarBinViewArray>(&mut array_session().create_execution_ctx())
             .unwrap();
         // The taken array should still have the same number of buffers
         assert_eq!(taken.data_buffers().len(), original_buffers);
@@ -262,7 +261,7 @@ mod tests {
         let indices = buffer![0u32, 2u32].into_array();
         let taken = original.take(indices).unwrap();
         let taken_array = taken
-            .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<VarBinViewArray>(&mut array_session().create_execution_ctx())
             .unwrap();
 
         // Optimize the taken array
@@ -332,7 +331,7 @@ mod tests {
         let indices = buffer![0u32].into_array();
         let taken = original.take(indices).unwrap();
         let taken = taken
-            .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<VarBinViewArray>(&mut array_session().create_execution_ctx())
             .unwrap();
         // Compact with threshold=0 (should not compact)
         let compacted = taken.compact_with_threshold(0.0).unwrap();
@@ -358,7 +357,7 @@ mod tests {
         let indices = buffer![0u32, 2u32].into_array();
         let taken = original.take(indices).unwrap();
         let taken = taken
-            .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<VarBinViewArray>(&mut array_session().create_execution_ctx())
             .unwrap();
 
         let original_buffers = taken.data_buffers().len();
@@ -415,7 +414,7 @@ mod tests {
         let indices_array = buffer![0u32, 2u32, 4u32, 6u32, 8u32].into_array();
         let taken = original.take(indices_array).unwrap();
         let taken = taken
-            .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<VarBinViewArray>(&mut array_session().create_execution_ctx())
             .unwrap();
 
         // Compact with moderate threshold
@@ -442,7 +441,7 @@ mod tests {
         let indices_array = buffer![0u32, 1u32, 2u32, 3u32, 4u32].into_array();
         let taken = original.take(indices_array).unwrap();
         let taken = taken
-            .execute::<VarBinViewArray>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<VarBinViewArray>(&mut array_session().create_execution_ctx())
             .unwrap();
         // Get buffer stats before compaction
         let utils_before = taken.buffer_utilizations().unwrap();
diff --git a/vortex-array/src/arrays/varbinview/compute/mod.rs b/vortex-array/src/arrays/varbinview/compute/mod.rs
index b69efad1e88..7a0d0b2d67f 100644
--- a/vortex-array/src/arrays/varbinview/compute/mod.rs
+++ b/vortex-array/src/arrays/varbinview/compute/mod.rs
@@ -41,6 +41,8 @@ mod tests {
     // Consistency tests
     use rstest::rstest;
 
+    use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::compute::conformance::consistency::test_array_consistency;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -79,6 +81,9 @@ mod tests {
         None::<&str>, None, None, None
     ]))]
     fn test_varbinview_consistency(#[case] array: VarBinViewArray) {
-        test_array_consistency(&array.into_array());
+        test_array_consistency(
+            &array.into_array(),
+            &mut array_session().create_execution_ctx(),
+        );
     }
 }
diff --git a/vortex-array/src/arrays/variant/mod.rs b/vortex-array/src/arrays/variant/mod.rs
index d159570f146..1a5157e9aa1 100644
--- a/vortex-array/src/arrays/variant/mod.rs
+++ b/vortex-array/src/arrays/variant/mod.rs
@@ -88,7 +88,6 @@ mod tests {
     use crate::ArrayRef;
     use crate::Canonical;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::BoolArray;
@@ -142,7 +141,7 @@ mod tests {
     }
 
     fn execute_variant(array: ArrayRef) -> VortexResult<VariantArray> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let Canonical::Variant(variant) = array.execute::<Canonical>(&mut ctx)? else {
             return Err(vortex_err!("expected canonical variant array"));
         };
@@ -160,7 +159,7 @@ mod tests {
         let shredded = array
             .shredded()
             .ok_or_else(|| vortex_err!("expected shredded child"))?;
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let shredded = shredded.clone().execute::<PrimitiveArray>(&mut ctx)?;
         let expected_shredded_array = if let Some(values) = expected_shredded
             .iter()
@@ -182,7 +181,7 @@ mod tests {
     ) -> VortexResult<()> {
         assert_eq!(array.len(), expected_core.len());
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         for (idx, expected) in expected_core.iter().enumerate() {
             let scalar = array.core_storage().execute_scalar(idx, &mut ctx)?;
             let variant = scalar.as_variant();
@@ -274,7 +273,7 @@ mod tests {
         let shredded = PrimitiveArray::from_option_iter([Some(10i32), Some(20), None]).into_array();
         let variant = VariantArray::try_new(core_storage, Some(shredded))?;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         for (idx, expected) in [Some(10i32), None, Some(3)].into_iter().enumerate() {
             let scalar = variant.execute_scalar(idx, &mut ctx)?;
             let variant = scalar.as_variant();
@@ -396,7 +395,7 @@ mod tests {
         let result = variant
             .into_array()
             .apply(&expr)?
-            .execute::<PrimitiveArray>(&mut LEGACY_SESSION.create_execution_ctx())?;
+            .execute::<PrimitiveArray>(&mut array_session().create_execution_ctx())?;
 
         assert_arrays_eq!(
             result,
@@ -431,7 +430,7 @@ mod tests {
             .clone()
             .into_array()
             .apply(&value_expr)?
-            .execute::<PrimitiveArray>(&mut LEGACY_SESSION.create_execution_ctx())?;
+            .execute::<PrimitiveArray>(&mut array_session().create_execution_ctx())?;
         assert_arrays_eq!(
             value_result,
             PrimitiveArray::from_option_iter([Some(10i32), Some(20), Some(30)]),
@@ -446,7 +445,7 @@ mod tests {
         let typed_value_result = variant
             .into_array()
             .apply(&typed_value_expr)?
-            .execute::<PrimitiveArray>(&mut LEGACY_SESSION.create_execution_ctx())?;
+            .execute::<PrimitiveArray>(&mut array_session().create_execution_ctx())?;
         assert_arrays_eq!(
             typed_value_result,
             PrimitiveArray::from_option_iter([Some(40i32), Some(50), Some(60)]),
diff --git a/vortex-array/src/arrow/executor/byte.rs b/vortex-array/src/arrow/executor/byte.rs
index bace6665bca..2be7afc29c3 100644
--- a/vortex-array/src/arrow/executor/byte.rs
+++ b/vortex-array/src/arrow/executor/byte.rs
@@ -82,8 +82,8 @@ mod tests {
     use rstest::rstest;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrow::ArrowArrayExecutor;
     use crate::arrow::executor::byte::VarBinViewArray;
     use crate::dtype::DType;
@@ -119,7 +119,7 @@ mod tests {
         #[case] vortex_array: VarBinViewArray,
         #[case] target_dtype: DataType,
     ) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let arrow = vortex_array
             .into_array()
             .execute_arrow(Some(&target_dtype), &mut ctx)
@@ -166,7 +166,7 @@ mod tests {
             vortex_dtype,
         );
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let arrow = vortex_array
             .into_array()
             .execute_arrow(Some(&target_dtype), &mut ctx)
diff --git a/vortex-array/src/arrow/executor/decimal.rs b/vortex-array/src/arrow/executor/decimal.rs
index 077495354cc..a9aa9fdd2f5 100644
--- a/vortex-array/src/arrow/executor/decimal.rs
+++ b/vortex-array/src/arrow/executor/decimal.rs
@@ -222,9 +222,9 @@ mod tests {
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
 
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array::IntoArray;
+    use crate::array_session;
     use crate::arrow::ArrowArrayExecutor;
     use crate::arrow::executor::decimal::DecimalArray;
     use crate::builders::ArrayBuilder;
@@ -235,7 +235,7 @@ mod tests {
 
     #[test]
     fn decimal_to_arrow() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // Make a very simple i128 and i256 array.
         let decimal_vortex = DecimalArray::new(
             buffer![1i128, 2i128, 3i128, 4i128, 5i128],
@@ -264,7 +264,7 @@ mod tests {
     fn test_to_arrow_decimal128<T: NativeDecimalType>(
         #[case] _decimal_type: T,
     ) -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut decimal = DecimalBuilder::new::<T>(DecimalDType::new(2, 1), false.into());
         decimal.append_value(10);
         decimal.append_value(11);
@@ -292,7 +292,7 @@ mod tests {
     fn test_to_arrow_decimal32<T: NativeDecimalType>(#[case] _decimal_type: T) -> VortexResult<()> {
         use arrow_array::Decimal32Array;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut decimal = DecimalBuilder::new::<T>(DecimalDType::new(2, 1), false.into());
         decimal.append_value(10);
         decimal.append_value(11);
@@ -320,7 +320,7 @@ mod tests {
     fn test_to_arrow_decimal64<T: NativeDecimalType>(#[case] _decimal_type: T) -> VortexResult<()> {
         use arrow_array::Decimal64Array;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut decimal = DecimalBuilder::new::<T>(DecimalDType::new(2, 1), false.into());
         decimal.append_value(10);
         decimal.append_value(11);
@@ -348,7 +348,7 @@ mod tests {
     fn test_to_arrow_decimal256<T: NativeDecimalType>(
         #[case] _decimal_type: T,
     ) -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut decimal = DecimalBuilder::new::<T>(DecimalDType::new(2, 1), false.into());
         decimal.append_value(10);
         decimal.append_value(11);
diff --git a/vortex-array/src/arrow/executor/dictionary.rs b/vortex-array/src/arrow/executor/dictionary.rs
index 99e315bd8f7..97d25c3f7cc 100644
--- a/vortex-array/src/arrow/executor/dictionary.rs
+++ b/vortex-array/src/arrow/executor/dictionary.rs
@@ -149,7 +149,7 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::VarBinViewArray;
     use crate::arrow::ArrowArrayExecutor;
@@ -165,7 +165,7 @@ mod tests {
     }
 
     fn execute(array: crate::ArrayRef, dt: &DataType) -> VortexResult<arrow_array::ArrayRef> {
-        array.execute_arrow(Some(dt), &mut LEGACY_SESSION.create_execution_ctx())
+        array.execute_arrow(Some(dt), &mut array_session().create_execution_ctx())
     }
 
     fn dict_basic_input() -> crate::ArrayRef {
diff --git a/vortex-array/src/arrow/executor/struct_.rs b/vortex-array/src/arrow/executor/struct_.rs
index ebea596e219..d3b7bcda2dc 100644
--- a/vortex-array/src/arrow/executor/struct_.rs
+++ b/vortex-array/src/arrow/executor/struct_.rs
@@ -208,9 +208,9 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array;
+    use crate::array_session;
     use crate::arrays;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
@@ -221,7 +221,7 @@ mod tests {
 
     #[test]
     fn struct_nullable_non_null_to_arrow() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let xs = PrimitiveArray::new(buffer![0i64, 1, 2, 3, 4], Validity::AllValid);
 
         let struct_a = StructArray::try_new(
@@ -242,7 +242,7 @@ mod tests {
 
     #[test]
     fn struct_nullable_with_nulls_to_arrow() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let xs =
             PrimitiveArray::from_option_iter(vec![Some(0_i64), Some(1), Some(2), None, Some(3)]);
 
@@ -267,7 +267,7 @@ mod tests {
 
     #[test]
     fn struct_to_arrow_with_schema_mismatch() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let xs = PrimitiveArray::new(buffer![0i64, 1, 2, 3, 4], Validity::AllValid);
 
         let struct_a = StructArray::try_new(
@@ -297,7 +297,7 @@ mod tests {
 
     #[test]
     fn test_to_arrow() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = StructArray::from_fields(
             vec![
                 (
@@ -340,7 +340,7 @@ mod tests {
 
     #[test]
     fn to_arrow_with_non_nullable_fields() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = StructArray::from_fields(
             vec![
                 (
diff --git a/vortex-array/src/arrow/session.rs b/vortex-array/src/arrow/session.rs
index e94d403c242..8279d7a1ca7 100644
--- a/vortex-array/src/arrow/session.rs
+++ b/vortex-array/src/arrow/session.rs
@@ -630,8 +630,8 @@ mod tests {
     use vortex_error::VortexResult;
 
     use super::*;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::dtype::DType;
     use crate::dtype::FieldName;
     use crate::dtype::Nullability;
@@ -764,8 +764,9 @@ mod tests {
 
     #[test]
     fn execute_arrow_target_none_preserves_top_level_uuid_metadata() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
-        let session = LEGACY_SESSION.arrow();
+        let vortex_session = array_session();
+        let mut ctx = vortex_session.create_execution_ctx();
+        let session = vortex_session.arrow();
 
         let mut field = Field::new("id", DataType::FixedSizeBinary(16), false);
         field.try_with_extension_type(ArrowUuid)?;
diff --git a/vortex-array/src/builders/bool.rs b/vortex-array/src/builders/bool.rs
index e7a64089940..f26cbf04b57 100644
--- a/vortex-array/src/builders/bool.rs
+++ b/vortex-array/src/builders/bool.rs
@@ -161,7 +161,6 @@ mod tests {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::ChunkedArray;
@@ -200,7 +199,7 @@ mod tests {
         let chunk_count = 10;
         let chunk = make_opt_bool_chunks(len, chunk_count);
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut builder = builder_with_capacity(chunk.dtype(), len * chunk_count);
         chunk
             .clone()
diff --git a/vortex-array/src/builders/decimal.rs b/vortex-array/src/builders/decimal.rs
index 2a6de9661e8..aa777051e39 100644
--- a/vortex-array/src/builders/decimal.rs
+++ b/vortex-array/src/builders/decimal.rs
@@ -309,7 +309,6 @@ impl Default for DecimalBuffer {
 
 #[cfg(test)]
 mod tests {
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::assert_arrays_eq;
@@ -334,10 +333,10 @@ mod tests {
 
         for i in 0..i8s.len() {
             assert_eq!(
-                i8s.execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                i8s.execute_scalar(i, &mut array_session().create_execution_ctx())
                     .unwrap(),
                 i128s
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .unwrap()
             );
         }
@@ -365,7 +364,7 @@ mod tests {
         let mut builder2 = DecimalBuilder::new::<i64>(DecimalDType::new(10, 2), true.into());
         for i in 0..array.len() {
             let scalar = array
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .unwrap();
             builder2.append_scalar(&scalar).unwrap();
         }
diff --git a/vortex-array/src/builders/fixed_size_list.rs b/vortex-array/src/builders/fixed_size_list.rs
index 2e7aced758b..9129d8cb644 100644
--- a/vortex-array/src/builders/fixed_size_list.rs
+++ b/vortex-array/src/builders/fixed_size_list.rs
@@ -287,10 +287,10 @@ mod tests {
 
     use super::FixedSizeListBuilder;
     use crate::IntoArray as _;
-    use crate::LEGACY_SESSION;
     #[expect(deprecated)]
     use crate::ToCanonical as _;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::fixed_size_list::FixedSizeListArrayExt;
     use crate::builders::ArrayBuilder;
@@ -448,7 +448,7 @@ mod tests {
 
     #[test]
     fn test_nullable_lists_non_nullable_elements() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, NonNullable));
         let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 0);
 
@@ -567,7 +567,7 @@ mod tests {
 
     #[test]
     fn test_append_nulls() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // Elements must be nullable if we're going to append null lists
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, Nullable));
         let mut builder = FixedSizeListBuilder::with_capacity(dtype, 2, Nullable, 0);
@@ -597,7 +597,7 @@ mod tests {
 
     #[test]
     fn test_append_scalar_nulls() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // Elements must be nullable if we're going to append null lists
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, Nullable));
         let mut builder = FixedSizeListBuilder::with_capacity(dtype, 2, Nullable, 0);
@@ -670,7 +670,7 @@ mod tests {
 
     #[test]
     fn test_extend_from_array() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
 
         // Create a source array.
@@ -741,7 +741,7 @@ mod tests {
 
     #[test]
     fn test_extend_degenerate_arrays() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
 
         // Create degenerate source arrays (size = 0).
@@ -846,7 +846,7 @@ mod tests {
 
     #[test]
     fn test_mixed_operations() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // Use nullable elements since we'll be appending nulls
         let dtype: Arc<DType> = Arc::new(DType::Primitive(I32, Nullable));
         let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 0);
@@ -932,7 +932,7 @@ mod tests {
 
     #[test]
     fn test_append_scalar() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
         let mut builder = FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 2, Nullable, 10);
 
@@ -1002,7 +1002,7 @@ mod tests {
     #[test]
     fn test_append_array_as_list() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut builder =
             FixedSizeListBuilder::with_capacity(Arc::clone(&dtype), 3, NonNullable, 10);
 
diff --git a/vortex-array/src/builders/list.rs b/vortex-array/src/builders/list.rs
index 663f191e605..12c74ba53a4 100644
--- a/vortex-array/src/builders/list.rs
+++ b/vortex-array/src/builders/list.rs
@@ -329,9 +329,9 @@ mod tests {
     use vortex_error::VortexExpect;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     #[expect(deprecated)]
     use crate::ToCanonical as _;
+    use crate::array_session;
     use crate::arrays::ChunkedArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::list::ListArrayExt;
@@ -456,7 +456,7 @@ mod tests {
         .unwrap();
         assert_eq!(list.len(), 3);
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         let mut builder = ListBuilder::<O>::with_capacity(Arc::new(I32.into()), Nullable, 18, 9);
         builder.extend_from_array(&list);
@@ -544,18 +544,18 @@ mod tests {
 
         assert_eq!(
             one_trailing_unused_element
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             canon_values
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
         assert_eq!(
             second_array
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             canon_values
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(1, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
     }
@@ -585,7 +585,7 @@ mod tests {
         let array = builder.finish_into_list();
         assert_eq!(array.len(), 3);
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         // Check actual values using scalar_at.
 
@@ -642,7 +642,7 @@ mod tests {
     #[test]
     fn test_append_array_as_list() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut builder =
             ListBuilder::<u32>::with_capacity(Arc::clone(&dtype), NonNullable, 20, 10);
 
diff --git a/vortex-array/src/builders/listview.rs b/vortex-array/src/builders/listview.rs
index 5f54c6f0256..cb131048339 100644
--- a/vortex-array/src/builders/listview.rs
+++ b/vortex-array/src/builders/listview.rs
@@ -439,7 +439,6 @@ mod tests {
 
     use super::ListViewBuilder;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::ListArray;
@@ -466,7 +465,7 @@ mod tests {
 
     #[test]
     fn test_basic_append_and_nulls() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
         let mut builder =
             ListViewBuilder::<u32, u32>::with_capacity(Arc::clone(&dtype), Nullable, 0, 0);
@@ -603,7 +602,7 @@ mod tests {
 
     #[test]
     fn test_builder_trait_methods() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
         let mut builder =
             ListViewBuilder::<u32, u32>::with_capacity(Arc::clone(&dtype), Nullable, 0, 0);
@@ -656,7 +655,7 @@ mod tests {
 
     #[test]
     fn test_extend_from_array() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
 
         // Create a source ListArray.
@@ -722,7 +721,7 @@ mod tests {
 
     #[test]
     fn test_extend_from_array_overlapping_listview() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let dtype: Arc<DType> = Arc::new(I32.into());
 
         // Non-ZCTL source:
@@ -791,7 +790,7 @@ mod tests {
     #[test]
     fn test_append_array_as_list() {
         let dtype: Arc<DType> = Arc::new(I32.into());
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut builder =
             ListViewBuilder::<u32, u32>::with_capacity(Arc::clone(&dtype), NonNullable, 20, 10);
 
diff --git a/vortex-array/src/builders/mod.rs b/vortex-array/src/builders/mod.rs
index e9f86fa4332..48a347aa3d5 100644
--- a/vortex-array/src/builders/mod.rs
+++ b/vortex-array/src/builders/mod.rs
@@ -11,7 +11,7 @@
 //! ```
 //! use vortex_array::builders::{builder_with_capacity, ArrayBuilder};
 //! use vortex_array::dtype::{DType, Nullability};
-//! use vortex_array::{LEGACY_SESSION, VortexSessionExecute};
+//! use vortex_array::{VortexSessionExecute, array_session};
 //!
 //! // Create a new builder for string data.
 //! let mut builder = builder_with_capacity(&DType::Utf8(Nullability::NonNullable), 4);
@@ -22,7 +22,7 @@
 //! builder.append_scalar(&"d".into()).unwrap();
 //!
 //! let strings = builder.finish();
-//! let mut ctx = LEGACY_SESSION.create_execution_ctx();
+//! let mut ctx = array_session().create_execution_ctx();
 //!
 //! assert_eq!(strings.execute_scalar(0, &mut ctx).unwrap(), "a".into());
 //! assert_eq!(strings.execute_scalar(1, &mut ctx).unwrap(), "b".into());
@@ -225,7 +225,7 @@ pub trait ArrayBuilder: Send {
 /// ```
 /// use vortex_array::builders::{builder_with_capacity, ArrayBuilder};
 /// use vortex_array::dtype::{DType, Nullability};
-/// use vortex_array::{LEGACY_SESSION, VortexSessionExecute};
+/// use vortex_array::{VortexSessionExecute, array_session};
 ///
 /// // Create a new builder for string data.
 /// let mut builder = builder_with_capacity(&DType::Utf8(Nullability::NonNullable), 4);
@@ -236,7 +236,7 @@ pub trait ArrayBuilder: Send {
 /// builder.append_scalar(&"d".into()).unwrap();
 ///
 /// let strings = builder.finish();
-/// let mut ctx = LEGACY_SESSION.create_execution_ctx();
+/// let mut ctx = array_session().create_execution_ctx();
 ///
 /// assert_eq!(strings.execute_scalar(0, &mut ctx).unwrap(), "a".into());
 /// assert_eq!(strings.execute_scalar(1, &mut ctx).unwrap(), "b".into());
diff --git a/vortex-array/src/builders/primitive.rs b/vortex-array/src/builders/primitive.rs
index 77dfb4342bc..e7e8d3d7512 100644
--- a/vortex-array/src/builders/primitive.rs
+++ b/vortex-array/src/builders/primitive.rs
@@ -454,19 +454,19 @@ mod tests {
         // Check validity using scalar_at - nulls will return is_null() = true.
         assert!(
             !array
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null()
         );
         assert!(
             array
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(1, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null()
         );
         assert!(
             !array
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(2, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null()
         );
@@ -564,13 +564,13 @@ mod tests {
         // Check validity - the first two should be valid (from append_value).
         assert!(
             !array
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null()
         ); // initial value 100
         assert!(
             !array
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(1, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null()
         ); // initial value 200
@@ -578,19 +578,19 @@ mod tests {
         // Check the range items with modified validity.
         assert!(
             !array
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(2, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null()
         ); // range index 0 - set to valid
         assert!(
             array
-                .execute_scalar(3, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(3, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null()
         ); // range index 1 - left as null
         assert!(
             !array
-                .execute_scalar(4, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(4, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .is_null()
         ); // range index 2 - set to valid
@@ -686,7 +686,7 @@ mod tests {
         // values[2] might be any value since it's null.
 
         // Check validity - first two should be valid, third should be null.
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert!(
             array
                 .validity()
diff --git a/vortex-array/src/builders/struct_.rs b/vortex-array/src/builders/struct_.rs
index 53c521b4b07..016d42508ee 100644
--- a/vortex-array/src/builders/struct_.rs
+++ b/vortex-array/src/builders/struct_.rs
@@ -211,7 +211,6 @@ impl ArrayBuilder for StructBuilder {
 #[cfg(test)]
 mod tests {
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::PrimitiveArray;
@@ -259,7 +258,7 @@ mod tests {
         assert_eq!(struct_.dtype(), &dtype);
         assert_eq!(
             struct_
-                .valid_count(&mut LEGACY_SESSION.create_execution_ctx())
+                .valid_count(&mut array_session().create_execution_ctx())
                 .unwrap(),
             1
         );
diff --git a/vortex-array/src/builders/tests.rs b/vortex-array/src/builders/tests.rs
index b725a4636b5..02babab4a7d 100644
--- a/vortex-array/src/builders/tests.rs
+++ b/vortex-array/src/builders/tests.rs
@@ -8,8 +8,8 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
+use crate::array_session;
 use crate::builders::ArrayBuilder;
 use crate::builders::builder_with_capacity;
 use crate::dtype::DType;
@@ -95,10 +95,10 @@ fn test_append_zeros_matches_default_value(#[case] dtype: DType) {
     // Compare each element.
     for i in 0..num_elements {
         let scalar_zeros = array_zeros
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut array_session().create_execution_ctx())
             .unwrap();
         let scalar_manual = array_manual
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut array_session().create_execution_ctx())
             .unwrap();
 
         assert_eq!(
@@ -197,7 +197,7 @@ fn test_append_defaults_behavior(#[case] dtype: DType, #[case] should_be_null: b
 
     for i in 0..3 {
         let scalar = array
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut array_session().create_execution_ctx())
             .unwrap();
         if should_be_null {
             assert!(scalar.is_null(), "Element at index {} should be null", i);
@@ -255,10 +255,10 @@ where
     // Compare each element.
     for i in 0..array_direct.len() {
         let scalar_direct = array_direct
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut array_session().create_execution_ctx())
             .unwrap();
         let scalar_indirect = array_indirect
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut array_session().create_execution_ctx())
             .unwrap();
 
         assert_eq!(
@@ -549,7 +549,7 @@ fn test_append_scalar_comprehensive(#[case] dtype: DType) {
     // Verify each scalar matches.
     for (i, expected_scalar) in scalars.iter().enumerate() {
         let actual_scalar = array
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut array_session().create_execution_ctx())
             .unwrap();
         assert_scalars_equal(&actual_scalar, expected_scalar, &dtype, i);
     }
@@ -557,7 +557,7 @@ fn test_append_scalar_comprehensive(#[case] dtype: DType) {
     // If nullable, verify the last element is null.
     if dtype.is_nullable() {
         let null_scalar = array
-            .execute_scalar(num_elements, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(num_elements, &mut array_session().create_execution_ctx())
             .unwrap();
         assert!(
             null_scalar.is_null(),
@@ -707,31 +707,31 @@ fn test_append_scalar_mixed_nulls(#[case] dtype: DType) {
     // Check the pattern.
     assert!(
         !array
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
     assert!(
         array
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
     assert!(
         !array
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(2, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
     assert!(
         array
-            .execute_scalar(3, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(3, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
     assert!(
         !array
-            .execute_scalar(4, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(4, &mut array_session().create_execution_ctx())
             .unwrap()
             .is_null()
     );
@@ -739,7 +739,7 @@ fn test_append_scalar_mixed_nulls(#[case] dtype: DType) {
     // Verify non-null values match.
     assert_scalars_equal(
         &array
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap(),
         &test_scalars[0],
         &dtype,
@@ -747,7 +747,7 @@ fn test_append_scalar_mixed_nulls(#[case] dtype: DType) {
     );
     assert_scalars_equal(
         &array
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(2, &mut array_session().create_execution_ctx())
             .unwrap(),
         &test_scalars[1],
         &dtype,
@@ -755,7 +755,7 @@ fn test_append_scalar_mixed_nulls(#[case] dtype: DType) {
     );
     assert_scalars_equal(
         &array
-            .execute_scalar(4, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(4, &mut array_session().create_execution_ctx())
             .unwrap(),
         &test_scalars[2],
         &dtype,
@@ -812,7 +812,7 @@ fn test_append_scalar_repeated_same_instance() {
     // All values should be 42.
     for i in 0..5 {
         let actual = array
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut array_session().create_execution_ctx())
             .unwrap();
         assert_eq!(
             actual.as_primitive().typed_value::<i32>(),
@@ -855,7 +855,7 @@ fn test_set_validity_overrides_validity(
     builder.set_validity(mask);
 
     let validity = builder.finish().validity()?;
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     for (i, &valid) in expected.iter().enumerate() {
         assert_eq!(
             validity.execute_is_valid(i, &mut ctx)?,
@@ -877,7 +877,7 @@ fn test_set_validity_noop_when_non_nullable() -> VortexResult<()> {
     builder.set_validity(Mask::new_false(4));
 
     let validity = builder.finish().validity()?;
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     for i in 0..4 {
         assert!(
             validity.execute_is_valid(i, &mut ctx)?,
diff --git a/vortex-array/src/builders/varbinview.rs b/vortex-array/src/builders/varbinview.rs
index f3ad1ffd355..3aabfd87c31 100644
--- a/vortex-array/src/builders/varbinview.rs
+++ b/vortex-array/src/builders/varbinview.rs
@@ -873,7 +873,6 @@ mod tests {
     use vortex_error::VortexResult;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::assert_arrays_eq;
@@ -954,7 +953,7 @@ mod tests {
         let mut builder =
             VarBinViewBuilder::with_buffer_deduplication(DType::Utf8(Nullability::Nullable), 10);
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         array.append_to_builder(&mut builder, &mut ctx)?;
         assert_eq!(builder.completed_block_count(), 1);
@@ -1082,7 +1081,7 @@ mod tests {
 
         // Verify the value was stored correctly
         let retrieved = array
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_binary()
             .value()
diff --git a/vortex-array/src/compute/conformance/binary_numeric.rs b/vortex-array/src/compute/conformance/binary_numeric.rs
index ce3eba940df..1fe409bf648 100644
--- a/vortex-array/src/compute/conformance/binary_numeric.rs
+++ b/vortex-array/src/compute/conformance/binary_numeric.rs
@@ -21,19 +21,22 @@
 //! - Multiplication (`*`)
 //! - Division (`/`)
 
+use std::fmt::Debug;
+
 use itertools::Itertools;
+use num_traits::Bounded;
+use num_traits::Float;
 use num_traits::Num;
+use num_traits::Signed;
 use vortex_error::VortexExpect;
 use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
 
 use crate::ArrayRef;
+use crate::Canonical;
+use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::RecursiveCanonical;
-#[expect(deprecated)]
-use crate::ToCanonical as _;
-use crate::VortexSessionExecute;
 use crate::arrays::ConstantArray;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
@@ -43,12 +46,12 @@ use crate::scalar::NumericOperator;
 use crate::scalar::PrimitiveScalar;
 use crate::scalar::Scalar;
 
-fn to_vec_of_scalar(array: &ArrayRef) -> Vec<Scalar> {
+fn to_vec_of_scalar(array: &ArrayRef, ctx: &mut ExecutionCtx) -> Vec<Scalar> {
     // Not fast, but obviously correct
     (0..array.len())
         .map(|index| {
             array
-                .execute_scalar(index, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(index, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test")
         })
         .collect_vec()
@@ -78,24 +81,31 @@ fn to_vec_of_scalar(array: &ArrayRef) -> Vec<Scalar> {
 /// Panics if:
 /// - The array cannot be converted to primitive form
 /// - Results don't match expected values (for operations that don't overflow)
-fn test_binary_numeric_conformance<T: NativePType + Num + Copy>(array: ArrayRef)
-where
+fn test_binary_numeric_conformance<T: NativePType + Num + Copy>(
+    array: &ArrayRef,
+    ctx: &mut ExecutionCtx,
+) where
     Scalar: From<T>,
 {
     // First test with the standard scalar value of 1
-    test_standard_binary_numeric::<T>(array.clone());
+    test_standard_binary_numeric::<T>(array, ctx);
 
     // Then test edge cases
-    test_binary_numeric_edge_cases(array);
+    test_binary_numeric_edge_cases(array, ctx);
 }
 
-fn test_standard_binary_numeric<T: NativePType + Num + Copy>(array: ArrayRef)
-where
+fn test_standard_binary_numeric<T: NativePType + Num + Copy>(
+    array: &ArrayRef,
+    ctx: &mut ExecutionCtx,
+) where
     Scalar: From<T>,
 {
-    #[expect(deprecated)]
-    let canonicalized_array = array.to_primitive();
-    let original_values = to_vec_of_scalar(&canonicalized_array.into_array());
+    let canonicalized_array = array
+        .clone()
+        .execute::<Canonical>(ctx)
+        .vortex_expect("Must be able to canonicalise")
+        .into_array();
+    let original_values = to_vec_of_scalar(&canonicalized_array, ctx);
 
     let one = T::from(1)
         .ok_or_else(|| vortex_err!("could not convert 1 into array native type"))
@@ -119,7 +129,7 @@ where
         let result = array
             .binary(rhs_const.clone(), op.into())
             .vortex_expect("apply shouldn't fail")
-            .execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<RecursiveCanonical>(ctx)
             .map(|c| c.0.into_array());
 
         // Skip this operator if the entire operation fails
@@ -128,7 +138,7 @@ where
             continue;
         };
 
-        let actual_values = to_vec_of_scalar(&result);
+        let actual_values = to_vec_of_scalar(&result, ctx);
 
         // Check each element for overflow/underflow
         let expected_results: Vec<Option<Scalar>> = original_values
@@ -157,7 +167,7 @@ where
 
         // Test scalar operator array (e.g., 1 + array)
         let result = rhs_const.binary(array.clone(), op.into()).and_then(|a| {
-            a.execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())
+            a.execute::<RecursiveCanonical>(ctx)
                 .map(|c| c.0.into_array())
         });
 
@@ -166,7 +176,7 @@ where
             continue;
         };
 
-        let actual_values = to_vec_of_scalar(&result);
+        let actual_values = to_vec_of_scalar(&result, ctx);
 
         // Check each element for overflow/underflow
         let expected_results: Vec<Option<Scalar>> = original_values
@@ -212,23 +222,23 @@ where
 ///     test_binary_numeric_array(array.into_array());
 /// }
 /// ```
-pub fn test_binary_numeric_array(array: ArrayRef) {
+pub fn test_binary_numeric_array(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     match array.dtype() {
         DType::Primitive(ptype, _) => match ptype {
-            PType::I8 => test_binary_numeric_conformance::<i8>(array),
-            PType::I16 => test_binary_numeric_conformance::<i16>(array),
-            PType::I32 => test_binary_numeric_conformance::<i32>(array),
-            PType::I64 => test_binary_numeric_conformance::<i64>(array),
-            PType::U8 => test_binary_numeric_conformance::<u8>(array),
-            PType::U16 => test_binary_numeric_conformance::<u16>(array),
-            PType::U32 => test_binary_numeric_conformance::<u32>(array),
-            PType::U64 => test_binary_numeric_conformance::<u64>(array),
+            PType::I8 => test_binary_numeric_conformance::<i8>(array, ctx),
+            PType::I16 => test_binary_numeric_conformance::<i16>(array, ctx),
+            PType::I32 => test_binary_numeric_conformance::<i32>(array, ctx),
+            PType::I64 => test_binary_numeric_conformance::<i64>(array, ctx),
+            PType::U8 => test_binary_numeric_conformance::<u8>(array, ctx),
+            PType::U16 => test_binary_numeric_conformance::<u16>(array, ctx),
+            PType::U32 => test_binary_numeric_conformance::<u32>(array, ctx),
+            PType::U64 => test_binary_numeric_conformance::<u64>(array, ctx),
             PType::F16 => {
                 // F16 not supported in num-traits, skip
                 eprintln!("Skipping f16 binary numeric tests (not supported)");
             }
-            PType::F32 => test_binary_numeric_conformance::<f32>(array),
-            PType::F64 => test_binary_numeric_conformance::<f64>(array),
+            PType::F32 => test_binary_numeric_conformance::<f32>(array, ctx),
+            PType::F64 => test_binary_numeric_conformance::<f64>(array, ctx),
         },
         dtype => vortex_panic!(
             "Binary numeric tests are only supported for primitive numeric types, got {dtype}",
@@ -243,22 +253,22 @@ pub fn test_binary_numeric_array(array: ArrayRef) {
 /// - Negative one (tests signed arithmetic)
 /// - Maximum value (tests overflow behavior)
 /// - Minimum value (tests underflow behavior)
-fn test_binary_numeric_edge_cases(array: ArrayRef) {
+fn test_binary_numeric_edge_cases(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     match array.dtype() {
         DType::Primitive(ptype, _) => match ptype {
-            PType::I8 => test_binary_numeric_edge_cases_signed::<i8>(array),
-            PType::I16 => test_binary_numeric_edge_cases_signed::<i16>(array),
-            PType::I32 => test_binary_numeric_edge_cases_signed::<i32>(array),
-            PType::I64 => test_binary_numeric_edge_cases_signed::<i64>(array),
-            PType::U8 => test_binary_numeric_edge_cases_unsigned::<u8>(array),
-            PType::U16 => test_binary_numeric_edge_cases_unsigned::<u16>(array),
-            PType::U32 => test_binary_numeric_edge_cases_unsigned::<u32>(array),
-            PType::U64 => test_binary_numeric_edge_cases_unsigned::<u64>(array),
+            PType::I8 => test_binary_numeric_edge_cases_signed::<i8>(array, ctx),
+            PType::I16 => test_binary_numeric_edge_cases_signed::<i16>(array, ctx),
+            PType::I32 => test_binary_numeric_edge_cases_signed::<i32>(array, ctx),
+            PType::I64 => test_binary_numeric_edge_cases_signed::<i64>(array, ctx),
+            PType::U8 => test_binary_numeric_edge_cases_unsigned::<u8>(array, ctx),
+            PType::U16 => test_binary_numeric_edge_cases_unsigned::<u16>(array, ctx),
+            PType::U32 => test_binary_numeric_edge_cases_unsigned::<u32>(array, ctx),
+            PType::U64 => test_binary_numeric_edge_cases_unsigned::<u64>(array, ctx),
             PType::F16 => {
                 eprintln!("Skipping f16 edge case tests (not supported)");
             }
-            PType::F32 => test_binary_numeric_edge_cases_float::<f32>(array),
-            PType::F64 => test_binary_numeric_edge_cases_float::<f64>(array),
+            PType::F32 => test_binary_numeric_edge_cases_float::<f32>(array, ctx),
+            PType::F64 => test_binary_numeric_edge_cases_float::<f64>(array, ctx),
         },
         dtype => vortex_panic!(
             "Binary numeric edge case tests are only supported for primitive numeric types, got {dtype}"
@@ -266,73 +276,76 @@ fn test_binary_numeric_edge_cases(array: ArrayRef) {
     }
 }
 
-fn test_binary_numeric_edge_cases_signed<T>(array: ArrayRef)
+fn test_binary_numeric_edge_cases_signed<T>(array: &ArrayRef, ctx: &mut ExecutionCtx)
 where
-    T: NativePType + Num + Copy + std::fmt::Debug + num_traits::Bounded + num_traits::Signed,
+    T: NativePType + Num + Copy + Debug + Bounded + Signed,
     Scalar: From<T>,
 {
     // Test with zero
-    test_binary_numeric_with_scalar(array.clone(), T::zero());
+    test_binary_numeric_with_scalar(array, T::zero(), ctx);
 
     // Test with -1
-    test_binary_numeric_with_scalar(array.clone(), -T::one());
+    test_binary_numeric_with_scalar(array, -T::one(), ctx);
 
     // Test with max value
-    test_binary_numeric_with_scalar(array.clone(), T::max_value());
+    test_binary_numeric_with_scalar(array, T::max_value(), ctx);
 
     // Test with min value
-    test_binary_numeric_with_scalar(array, T::min_value());
+    test_binary_numeric_with_scalar(array, T::min_value(), ctx);
 }
 
-fn test_binary_numeric_edge_cases_unsigned<T>(array: ArrayRef)
+fn test_binary_numeric_edge_cases_unsigned<T>(array: &ArrayRef, ctx: &mut ExecutionCtx)
 where
-    T: NativePType + Num + Copy + std::fmt::Debug + num_traits::Bounded,
+    T: NativePType + Num + Copy + Debug + Bounded,
     Scalar: From<T>,
 {
     // Test with zero
-    test_binary_numeric_with_scalar(array.clone(), T::zero());
+    test_binary_numeric_with_scalar(array, T::zero(), ctx);
 
     // Test with max value
-    test_binary_numeric_with_scalar(array, T::max_value());
+    test_binary_numeric_with_scalar(array, T::max_value(), ctx);
 }
 
-fn test_binary_numeric_edge_cases_float<T>(array: ArrayRef)
+fn test_binary_numeric_edge_cases_float<T>(array: &ArrayRef, ctx: &mut ExecutionCtx)
 where
-    T: NativePType + Num + Copy + std::fmt::Debug + num_traits::Float,
+    T: NativePType + Num + Copy + Debug + Float,
     Scalar: From<T>,
 {
     // Test with zero
-    test_binary_numeric_with_scalar(array.clone(), T::zero());
+    test_binary_numeric_with_scalar(array, T::zero(), ctx);
 
     // Test with -1
-    test_binary_numeric_with_scalar(array.clone(), -T::one());
+    test_binary_numeric_with_scalar(array, -T::one(), ctx);
 
     // Test with max value
-    test_binary_numeric_with_scalar(array.clone(), T::max_value());
+    test_binary_numeric_with_scalar(array, T::max_value(), ctx);
 
     // Test with min value
-    test_binary_numeric_with_scalar(array.clone(), T::min_value());
+    test_binary_numeric_with_scalar(array, T::min_value(), ctx);
 
     // Test with small positive value
-    test_binary_numeric_with_scalar(array.clone(), T::epsilon());
+    test_binary_numeric_with_scalar(array, T::epsilon(), ctx);
 
     // Test with min positive value (subnormal)
-    test_binary_numeric_with_scalar(array.clone(), T::min_positive_value());
+    test_binary_numeric_with_scalar(array, T::min_positive_value(), ctx);
 
     // Test with special float values (NaN, Infinity)
-    test_binary_numeric_with_scalar(array.clone(), T::nan());
-    test_binary_numeric_with_scalar(array.clone(), T::infinity());
-    test_binary_numeric_with_scalar(array, T::neg_infinity());
+    test_binary_numeric_with_scalar(array, T::nan(), ctx);
+    test_binary_numeric_with_scalar(array, T::infinity(), ctx);
+    test_binary_numeric_with_scalar(array, T::neg_infinity(), ctx);
 }
 
-fn test_binary_numeric_with_scalar<T>(array: ArrayRef, scalar_value: T)
+fn test_binary_numeric_with_scalar<T>(array: &ArrayRef, scalar_value: T, ctx: &mut ExecutionCtx)
 where
-    T: NativePType + Num + Copy + std::fmt::Debug,
+    T: NativePType + Num + Copy + Debug,
     Scalar: From<T>,
 {
-    #[expect(deprecated)]
-    let canonicalized_array = array.to_primitive();
-    let original_values = to_vec_of_scalar(&canonicalized_array.into_array());
+    let canonicalized_array = array
+        .clone()
+        .execute::<Canonical>(ctx)
+        .vortex_expect("Must be able to canonicalise")
+        .into_array();
+    let original_values = to_vec_of_scalar(&canonicalized_array, ctx);
 
     let scalar = Scalar::from(scalar_value)
         .cast(array.dtype())
@@ -363,7 +376,7 @@ where
         let result = array
             .binary(rhs_const, op.into())
             .vortex_expect("apply failed")
-            .execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<RecursiveCanonical>(ctx)
             .map(|x| x.0.into_array());
 
         // Skip if the entire operation fails
@@ -373,7 +386,7 @@ where
         }
 
         let result = result.vortex_expect("operation should succeed in conformance test");
-        let actual_values = to_vec_of_scalar(&result);
+        let actual_values = to_vec_of_scalar(&result, ctx);
 
         // Check each element for overflow/underflow
         let expected_results: Vec<Option<Scalar>> = original_values
diff --git a/vortex-array/src/compute/conformance/cast.rs b/vortex-array/src/compute/conformance/cast.rs
index 5401ceab7a3..c823b2a778a 100644
--- a/vortex-array/src/compute/conformance/cast.rs
+++ b/vortex-array/src/compute/conformance/cast.rs
@@ -7,12 +7,12 @@ use vortex_error::vortex_panic;
 
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::RecursiveCanonical;
 use crate::VortexSessionExecute;
 use crate::aggregate_fn::NumericalAggregateOpts;
 use crate::aggregate_fn::fns::min_max::MinMaxResult;
 use crate::aggregate_fn::fns::min_max::min_max;
+use crate::array_session;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::dtype::Nullability;
@@ -23,7 +23,7 @@ use crate::scalar::Scalar;
 fn cast_and_execute(array: &ArrayRef, dtype: DType) -> VortexResult<ArrayRef> {
     Ok(array
         .cast(dtype)?
-        .execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())?
+        .execute::<RecursiveCanonical>(&mut array_session().create_execution_ctx())?
         .0
         .into_array())
 }
@@ -75,10 +75,10 @@ fn test_cast_identity(array: &ArrayRef) {
     for i in 0..array.len().min(10) {
         assert_eq!(
             array
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             result
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -110,7 +110,7 @@ fn test_cast_from_null(array: &ArrayRef) {
         for i in 0..array.len().min(10) {
             assert!(
                 result
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test")
                     .is_null()
             );
@@ -130,7 +130,7 @@ fn test_cast_from_null(array: &ArrayRef) {
 
 fn test_cast_to_non_nullable(array: &ArrayRef) {
     if array
-        .invalid_count(&mut LEGACY_SESSION.create_execution_ctx())
+        .invalid_count(&mut array_session().create_execution_ctx())
         .vortex_expect("invalid_count should succeed in conformance test")
         == 0
     {
@@ -142,10 +142,10 @@ fn test_cast_to_non_nullable(array: &ArrayRef) {
         for i in 0..array.len().min(10) {
             assert_eq!(
                 array
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test"),
                 non_nullable
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test")
             );
         }
@@ -158,10 +158,10 @@ fn test_cast_to_non_nullable(array: &ArrayRef) {
         for i in 0..array.len().min(10) {
             assert_eq!(
                 array
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test"),
                 back_to_nullable
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test")
             );
         }
@@ -191,10 +191,10 @@ fn test_cast_to_nullable(array: &ArrayRef) {
     for i in 0..array.len().min(10) {
         assert_eq!(
             array
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             nullable
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -207,9 +207,9 @@ fn test_cast_to_nullable(array: &ArrayRef) {
     for i in 0..array.len().min(10) {
         assert_eq!(
             array
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
-            back.execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            back.execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -248,7 +248,7 @@ fn fits(value: &Scalar, ptype: PType) -> bool {
 }
 
 fn test_cast_to_primitive(array: &ArrayRef, target_ptype: PType, test_round_trip: bool) {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let maybe_min_max = min_max(array, &mut ctx, NumericalAggregateOpts::default())
         .vortex_expect("cast should succeed in conformance test");
 
@@ -289,20 +289,20 @@ fn test_cast_to_primitive(array: &ArrayRef, target_ptype: PType, test_round_trip
         array
             .validity()
             .vortex_expect("validity_mask should succeed in conformance test")
-            .execute_mask(array.len(), &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_mask(array.len(), &mut array_session().create_execution_ctx())
             .vortex_expect("Failed to compute validity mask"),
         casted
             .validity()
             .vortex_expect("validity_mask should succeed in conformance test")
-            .execute_mask(casted.len(), &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_mask(casted.len(), &mut array_session().create_execution_ctx())
             .vortex_expect("Failed to compute validity mask")
     );
     for i in 0..array.len().min(10) {
         let original = array
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut array_session().create_execution_ctx())
             .vortex_expect("scalar_at should succeed in conformance test");
         let casted = casted
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, &mut array_session().create_execution_ctx())
             .vortex_expect("scalar_at should succeed in conformance test");
         assert_eq!(
             original
diff --git a/vortex-array/src/compute/conformance/consistency.rs b/vortex-array/src/compute/conformance/consistency.rs
index 4ae9f02c55f..73f98cce4a7 100644
--- a/vortex-array/src/compute/conformance/consistency.rs
+++ b/vortex-array/src/compute/conformance/consistency.rs
@@ -27,10 +27,11 @@ use vortex_error::vortex_panic;
 use vortex_mask::Mask;
 
 use crate::ArrayRef;
+use crate::Canonical;
+use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
-use crate::VortexSessionExecute;
 use crate::arrays::BoolArray;
+use crate::arrays::ConstantArray;
 use crate::arrays::PrimitiveArray;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
@@ -49,7 +50,7 @@ use crate::scalar_fn::fns::operators::Operator;
 /// - Creates indices array containing positions where mask is true
 /// - Applies take with these indices
 /// - Verifies both results are identical
-fn test_filter_take_consistency(array: &ArrayRef) {
+fn test_filter_take_consistency(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len == 0 {
         return;
@@ -89,10 +90,10 @@ fn test_filter_take_consistency(array: &ArrayRef) {
 
     for i in 0..filtered.len() {
         let filtered_val = filtered
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, ctx)
             .vortex_expect("scalar_at should succeed in conformance test");
         let taken_val = taken
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, ctx)
             .vortex_expect("scalar_at should succeed in conformance test");
         assert_eq!(
             filtered_val, taken_val,
@@ -117,7 +118,7 @@ fn test_filter_take_consistency(array: &ArrayRef) {
 /// # Why This Matters
 /// This test ensures that mask operations compose correctly, which is critical for
 /// complex query operations that may apply multiple filters.
-fn test_double_mask_consistency(array: &ArrayRef) {
+fn test_double_mask_consistency(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len == 0 {
         return;
@@ -163,10 +164,10 @@ fn test_double_mask_consistency(array: &ArrayRef) {
 
     for i in 0..double_masked.len() {
         let double_val = double_masked
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, ctx)
             .vortex_expect("scalar_at should succeed in conformance test");
         let direct_val = directly_masked
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, ctx)
             .vortex_expect("scalar_at should succeed in conformance test");
         assert_eq!(
             double_val, direct_val,
@@ -190,7 +191,7 @@ fn test_double_mask_consistency(array: &ArrayRef) {
 /// # Why This Matters
 /// This is an identity operation that should be optimized in implementations
 /// to avoid unnecessary copying.
-fn test_filter_identity(array: &ArrayRef) {
+fn test_filter_identity(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len == 0 {
         return;
@@ -213,10 +214,10 @@ fn test_filter_identity(array: &ArrayRef) {
 
     for i in 0..len {
         let original_val = array
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, ctx)
             .vortex_expect("scalar_at should succeed in conformance test");
         let filtered_val = filtered
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, ctx)
             .vortex_expect("scalar_at should succeed in conformance test");
         assert_eq!(
             filtered_val, original_val,
@@ -239,7 +240,7 @@ fn test_filter_identity(array: &ArrayRef) {
 /// # Why This Matters
 /// Masking always produces a nullable array, even when no values are actually masked.
 /// This test ensures the type system handles this correctly.
-fn test_mask_identity(array: &ArrayRef) {
+fn test_mask_identity(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len == 0 {
         return;
@@ -269,10 +270,10 @@ fn test_mask_identity(array: &ArrayRef) {
 
     for i in 0..len {
         let original_val = array
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, ctx)
             .vortex_expect("scalar_at should succeed in conformance test");
         let masked_val = masked
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, ctx)
             .vortex_expect("scalar_at should succeed in conformance test");
         let expected_val = original_val.clone().into_nullable();
         assert_eq!(
@@ -297,7 +298,7 @@ fn test_mask_identity(array: &ArrayRef) {
 /// # Why This Matters
 /// When a filter mask represents a contiguous range, it should be equivalent to
 /// a slice operation. Some implementations may optimize this case.
-fn test_slice_filter_consistency(array: &ArrayRef) {
+fn test_slice_filter_consistency(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len < 4 {
         return; // Need at least 4 elements for meaningful test
@@ -328,10 +329,10 @@ fn test_slice_filter_consistency(array: &ArrayRef) {
 
     for i in 0..filtered.len() {
         let filtered_val = filtered
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, ctx)
             .vortex_expect("scalar_at should succeed in conformance test");
         let sliced_val = sliced
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, ctx)
             .vortex_expect("scalar_at should succeed in conformance test");
         assert_eq!(
             filtered_val, sliced_val,
@@ -354,7 +355,7 @@ fn test_slice_filter_consistency(array: &ArrayRef) {
 ///
 /// # Why This Matters
 /// Sequential takes are a common pattern that can be optimized to slice operations.
-fn test_take_slice_consistency(array: &ArrayRef) {
+fn test_take_slice_consistency(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len < 3 {
         return; // Need at least 3 elements
@@ -383,10 +384,10 @@ fn test_take_slice_consistency(array: &ArrayRef) {
 
     for i in 0..taken.len() {
         let taken_val = taken
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, ctx)
             .vortex_expect("scalar_at should succeed in conformance test");
         let sliced_val = sliced
-            .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(i, ctx)
             .vortex_expect("scalar_at should succeed in conformance test");
         assert_eq!(
             taken_val, sliced_val,
@@ -397,7 +398,7 @@ fn test_take_slice_consistency(array: &ArrayRef) {
 }
 
 /// Tests that filter preserves relative ordering
-fn test_filter_preserves_order(array: &ArrayRef) {
+fn test_filter_preserves_order(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len < 4 {
         return;
@@ -416,33 +417,33 @@ fn test_filter_preserves_order(array: &ArrayRef) {
     if len >= 4 {
         assert_eq!(
             filtered
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test"),
             array
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
         assert_eq!(
             filtered
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(1, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test"),
             array
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(2, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
         assert_eq!(
             filtered
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(2, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test"),
             array
-                .execute_scalar(3, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(3, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
 }
 
 /// Tests that take with repeated indices works correctly
-fn test_take_repeated_indices(array: &ArrayRef) {
+fn test_take_repeated_indices(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len == 0 {
         return;
@@ -458,17 +459,17 @@ fn test_take_repeated_indices(array: &ArrayRef) {
     for i in 0..3 {
         assert_eq!(
             taken
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test"),
             array
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
 }
 
 /// Tests mask and filter interaction with nulls
-fn test_mask_filter_null_consistency(array: &ArrayRef) {
+fn test_mask_filter_null_consistency(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len < 3 {
         return;
@@ -498,10 +499,10 @@ fn test_mask_filter_null_consistency(array: &ArrayRef) {
     for i in 0..filtered.len() {
         assert_eq!(
             filtered
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test"),
             direct_filtered
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -537,7 +538,7 @@ fn test_empty_operations_consistency(array: &ArrayRef) {
 }
 
 /// Tests that take preserves array properties
-fn test_take_preserves_properties(array: &ArrayRef) {
+fn test_take_preserves_properties(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len == 0 {
         return;
@@ -555,10 +556,10 @@ fn test_take_preserves_properties(array: &ArrayRef) {
     for i in 0..len {
         assert_eq!(
             taken
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test"),
             array
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -581,7 +582,7 @@ fn test_take_preserves_properties(array: &ArrayRef) {
 /// # Why This Matters
 /// Nullable indices are a powerful feature that allows introducing nulls during
 /// a take operation, which is useful for outer joins and similar operations.
-fn test_nullable_indices_consistency(array: &ArrayRef) {
+fn test_nullable_indices_consistency(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len < 3 {
         return; // Need at least 3 elements to test indices 0 and 2
@@ -610,11 +611,11 @@ fn test_nullable_indices_consistency(array: &ArrayRef) {
 
     // Check first element (from index 0)
     let expected_0 = array
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, ctx)
         .vortex_expect("scalar_at should succeed in conformance test")
         .into_nullable();
     let actual_0 = taken
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, ctx)
         .vortex_expect("scalar_at should succeed in conformance test");
     assert_eq!(
         actual_0, expected_0,
@@ -624,7 +625,7 @@ fn test_nullable_indices_consistency(array: &ArrayRef) {
 
     // Check second element (should be null)
     let actual_1 = taken
-        .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(1, ctx)
         .vortex_expect("scalar_at should succeed in conformance test");
     assert!(
         actual_1.is_null(),
@@ -633,11 +634,11 @@ fn test_nullable_indices_consistency(array: &ArrayRef) {
 
     // Check third element (from index 2)
     let expected_2 = array
-        .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(2, ctx)
         .vortex_expect("scalar_at should succeed in conformance test")
         .into_nullable();
     let actual_2 = taken
-        .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(2, ctx)
         .vortex_expect("scalar_at should succeed in conformance test");
     assert_eq!(
         actual_2, expected_2,
@@ -647,7 +648,7 @@ fn test_nullable_indices_consistency(array: &ArrayRef) {
 }
 
 /// Tests large array consistency
-fn test_large_array_consistency(array: &ArrayRef) {
+fn test_large_array_consistency(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len < 1000 {
         return;
@@ -672,10 +673,10 @@ fn test_large_array_consistency(array: &ArrayRef) {
     for i in 0..taken.len() {
         assert_eq!(
             taken
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test"),
             filtered
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -697,7 +698,7 @@ fn test_large_array_consistency(array: &ArrayRef) {
 /// Comparison operations must maintain logical consistency across encodings.
 /// This test catches bugs where an encoding might implement one comparison
 /// correctly but fail on its logical inverse.
-fn test_comparison_inverse_consistency(array: &ArrayRef) {
+fn test_comparison_inverse_consistency(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len == 0 {
         return;
@@ -718,19 +719,15 @@ fn test_comparison_inverse_consistency(array: &ArrayRef) {
         return;
     } else {
         array
-            .execute_scalar(len / 2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(len / 2, ctx)
             .vortex_expect("scalar_at should succeed in conformance test")
     };
 
     // Test Eq vs NotEq
-    let const_array = crate::arrays::ConstantArray::new(test_scalar, len);
+    let const_array = ConstantArray::new(test_scalar, len).into_array();
     if let (Ok(eq_result), Ok(neq_result)) = (
-        array
-            .clone()
-            .binary(const_array.clone().into_array(), Operator::Eq),
-        array
-            .clone()
-            .binary(const_array.clone().into_array(), Operator::NotEq),
+        array.binary(const_array.clone(), Operator::Eq),
+        array.binary(const_array.clone(), Operator::NotEq),
     ) {
         let inverted_eq = eq_result
             .not()
@@ -744,10 +741,10 @@ fn test_comparison_inverse_consistency(array: &ArrayRef) {
 
         for i in 0..inverted_eq.len() {
             let inv_val = inverted_eq
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             let neq_val = neq_result
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             assert_eq!(
                 inv_val, neq_val,
@@ -759,12 +756,8 @@ fn test_comparison_inverse_consistency(array: &ArrayRef) {
 
     // Test Gt vs Lte
     if let (Ok(gt_result), Ok(lte_result)) = (
-        array
-            .clone()
-            .binary(const_array.clone().into_array(), Operator::Gt),
-        array
-            .clone()
-            .binary(const_array.clone().into_array(), Operator::Lte),
+        array.binary(const_array.clone(), Operator::Gt),
+        array.binary(const_array.clone(), Operator::Lte),
     ) {
         let inverted_gt = gt_result
             .not()
@@ -772,10 +765,10 @@ fn test_comparison_inverse_consistency(array: &ArrayRef) {
 
         for i in 0..inverted_gt.len() {
             let inv_val = inverted_gt
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             let lte_val = lte_result
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             assert_eq!(
                 inv_val, lte_val,
@@ -787,12 +780,8 @@ fn test_comparison_inverse_consistency(array: &ArrayRef) {
 
     // Test Lt vs Gte
     if let (Ok(lt_result), Ok(gte_result)) = (
-        array
-            .clone()
-            .binary(const_array.clone().into_array(), Operator::Lt),
-        array
-            .clone()
-            .binary(const_array.into_array(), Operator::Gte),
+        array.binary(const_array.clone(), Operator::Lt),
+        array.binary(const_array, Operator::Gte),
     ) {
         let inverted_lt = lt_result
             .not()
@@ -800,10 +789,10 @@ fn test_comparison_inverse_consistency(array: &ArrayRef) {
 
         for i in 0..inverted_lt.len() {
             let inv_val = inverted_lt
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             let gte_val = gte_result
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             assert_eq!(
                 inv_val, gte_val,
@@ -829,7 +818,7 @@ fn test_comparison_inverse_consistency(array: &ArrayRef) {
 /// # Why This Matters
 /// Ensures that comparison operations maintain mathematical ordering properties
 /// regardless of operand order.
-fn test_comparison_symmetry_consistency(array: &ArrayRef) {
+fn test_comparison_symmetry_consistency(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len == 0 {
         return;
@@ -850,22 +839,17 @@ fn test_comparison_symmetry_consistency(array: &ArrayRef) {
         return;
     } else {
         array
-            .execute_scalar(len / 2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(len / 2, ctx)
             .vortex_expect("scalar_at should succeed in conformance test")
     };
 
     // Create a constant array with the test scalar for reverse comparison
-    let const_array = crate::arrays::ConstantArray::new(test_scalar, len);
+    let const_array = ConstantArray::new(test_scalar, len).into_array();
 
     // Test Gt vs Lt symmetry
     if let (Ok(arr_gt_scalar), Ok(scalar_lt_arr)) = (
-        array
-            .clone()
-            .binary(const_array.clone().into_array(), Operator::Gt),
-        const_array
-            .clone()
-            .into_array()
-            .binary(array.clone(), Operator::Lt),
+        array.binary(const_array.clone(), Operator::Gt),
+        const_array.binary(array.clone(), Operator::Lt),
     ) {
         assert_eq!(
             arr_gt_scalar.len(),
@@ -875,10 +859,10 @@ fn test_comparison_symmetry_consistency(array: &ArrayRef) {
 
         for i in 0..arr_gt_scalar.len() {
             let arr_gt = arr_gt_scalar
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             let scalar_lt = scalar_lt_arr
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             assert_eq!(
                 arr_gt, scalar_lt,
@@ -890,17 +874,15 @@ fn test_comparison_symmetry_consistency(array: &ArrayRef) {
 
     // Test Eq symmetry
     if let (Ok(arr_eq_scalar), Ok(scalar_eq_arr)) = (
-        array
-            .clone()
-            .binary(const_array.clone().into_array(), Operator::Eq),
-        const_array.into_array().binary(array.clone(), Operator::Eq),
+        array.binary(const_array.clone(), Operator::Eq),
+        const_array.binary(array.clone(), Operator::Eq),
     ) {
         for i in 0..arr_eq_scalar.len() {
             let arr_eq = arr_eq_scalar
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             let scalar_eq = scalar_eq_arr
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             assert_eq!(
                 arr_eq, scalar_eq,
@@ -927,7 +909,7 @@ fn test_comparison_symmetry_consistency(array: &ArrayRef) {
 /// Boolean operations must maintain logical consistency across encodings.
 /// This test catches bugs where encodings might optimize boolean operations
 /// incorrectly, breaking fundamental logical properties.
-fn test_boolean_demorgan_consistency(array: &ArrayRef) {
+fn test_boolean_demorgan_consistency(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     if !matches!(array.dtype(), DType::Bool(_)) {
         return;
     }
@@ -940,7 +922,7 @@ fn test_boolean_demorgan_consistency(array: &ArrayRef) {
 
     // Test first De Morgan's law: NOT(A AND B) = (NOT A) OR (NOT B)
     if let (Ok(a_and_b), Ok(not_a), Ok(not_b)) = (
-        array.clone().binary(bool_mask.clone(), Operator::And),
+        array.binary(bool_mask.clone(), Operator::And),
         array.not(),
         bool_mask.not(),
     ) {
@@ -959,10 +941,10 @@ fn test_boolean_demorgan_consistency(array: &ArrayRef) {
 
         for i in 0..not_a_and_b.len() {
             let left = not_a_and_b
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             let right = not_a_or_not_b
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             assert_eq!(
                 left, right,
@@ -974,7 +956,7 @@ fn test_boolean_demorgan_consistency(array: &ArrayRef) {
 
     // Test second De Morgan's law: NOT(A OR B) = (NOT A) AND (NOT B)
     if let (Ok(a_or_b), Ok(not_a), Ok(not_b)) = (
-        array.clone().binary(bool_mask.clone(), Operator::Or),
+        array.binary(bool_mask.clone(), Operator::Or),
         array.not(),
         bool_mask.not(),
     ) {
@@ -987,10 +969,10 @@ fn test_boolean_demorgan_consistency(array: &ArrayRef) {
 
         for i in 0..not_a_or_b.len() {
             let left = not_a_or_b
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             let right = not_a_and_not_b
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             assert_eq!(
                 left, right,
@@ -1016,15 +998,13 @@ fn test_boolean_demorgan_consistency(array: &ArrayRef) {
 /// # Why This Matters
 /// Aggregate operations on sliced arrays must produce correct results
 /// regardless of the underlying encoding's offset handling.
-fn test_slice_aggregate_consistency(array: &ArrayRef) {
+fn test_slice_aggregate_consistency(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     use crate::aggregate_fn::NumericalAggregateOpts;
     use crate::aggregate_fn::fns::min_max::min_max;
     use crate::aggregate_fn::fns::nan_count::nan_count;
     use crate::aggregate_fn::fns::sum::sum;
     use crate::dtype::DType;
 
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
-
     let len = array.len();
     if len < 5 {
         return; // Need enough elements for meaningful slice
@@ -1038,8 +1018,10 @@ fn test_slice_aggregate_consistency(array: &ArrayRef) {
     let sliced = array
         .slice(start..end)
         .vortex_expect("slice should succeed in conformance test");
-    #[expect(deprecated)]
-    let canonical = array.to_canonical().vortex_expect("to_canonical failed");
+    let canonical = array
+        .clone()
+        .execute::<Canonical>(ctx)
+        .vortex_expect("to_canonical failed");
     let canonical_sliced = canonical
         .into_array()
         .slice(start..end)
@@ -1047,10 +1029,10 @@ fn test_slice_aggregate_consistency(array: &ArrayRef) {
 
     // Test null count through invalid_count
     let sliced_invalid_count = sliced
-        .invalid_count(&mut ctx)
+        .invalid_count(ctx)
         .vortex_expect("invalid_count should succeed in conformance test");
     let canonical_invalid_count = canonical_sliced
-        .invalid_count(&mut ctx)
+        .invalid_count(ctx)
         .vortex_expect("invalid_count should succeed in conformance test");
     assert_eq!(
         sliced_invalid_count, canonical_invalid_count,
@@ -1063,9 +1045,7 @@ fn test_slice_aggregate_consistency(array: &ArrayRef) {
         return;
     }
 
-    if let (Ok(slice_sum), Ok(canonical_sum)) =
-        (sum(&sliced, &mut ctx), sum(&canonical_sliced, &mut ctx))
-    {
+    if let (Ok(slice_sum), Ok(canonical_sum)) = (sum(&sliced, ctx), sum(&canonical_sliced, ctx)) {
         // Compare sum scalars
         assert_eq!(
             slice_sum, canonical_sum,
@@ -1076,12 +1056,8 @@ fn test_slice_aggregate_consistency(array: &ArrayRef) {
 
     // Test min_max
     if let (Ok(slice_minmax), Ok(canonical_minmax)) = (
-        min_max(&sliced, &mut ctx, NumericalAggregateOpts::default()),
-        min_max(
-            &canonical_sliced,
-            &mut ctx,
-            NumericalAggregateOpts::default(),
-        ),
+        min_max(&sliced, ctx, NumericalAggregateOpts::default()),
+        min_max(&canonical_sliced, ctx, NumericalAggregateOpts::default()),
     ) {
         match (slice_minmax, canonical_minmax) {
             (Some(s_result), Some(c_result)) => {
@@ -1105,10 +1081,8 @@ fn test_slice_aggregate_consistency(array: &ArrayRef) {
 
     // Test nan_count for floating point types
     if array.dtype().is_float()
-        && let (Ok(slice_nan_count), Ok(canonical_nan_count)) = (
-            nan_count(&sliced, &mut ctx),
-            nan_count(&canonical_sliced, &mut ctx),
-        )
+        && let (Ok(slice_nan_count), Ok(canonical_nan_count)) =
+            (nan_count(&sliced, ctx), nan_count(&canonical_sliced, ctx))
     {
         assert_eq!(
             slice_nan_count, canonical_nan_count,
@@ -1133,7 +1107,7 @@ fn test_slice_aggregate_consistency(array: &ArrayRef) {
 /// This test specifically catches bugs where encodings (like RunEndArray) fail to preserve
 /// offset information during cast operations. Such bugs can lead to incorrect data being
 /// returned after casting a sliced array.
-fn test_cast_slice_consistency(array: &ArrayRef) {
+fn test_cast_slice_consistency(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     let len = array.len();
     if len < 5 {
         return; // Need at least 5 elements for meaningful slice
@@ -1144,8 +1118,11 @@ fn test_cast_slice_consistency(array: &ArrayRef) {
     let end = 7.min(len - 2).max(start + 1); // Ensure we have at least 1 element
 
     // Get canonical form of the original array
-    #[expect(deprecated)]
-    let canonical = array.to_canonical().vortex_expect("to_canonical failed");
+    let canonical = array
+        .clone()
+        .execute::<Canonical>(ctx)
+        .vortex_expect("to_canonical failed")
+        .into_array();
 
     // Choose appropriate target dtype based on the array's type
     let target_dtypes = match array.dtype() {
@@ -1270,10 +1247,10 @@ fn test_cast_slice_consistency(array: &ArrayRef) {
             .vortex_expect("slice should succeed in conformance test");
 
         // Try to cast the sliced array (force execution via to_canonical)
-        let slice_then_cast = match sliced.cast(target_dtype.clone()).and_then(|a| {
-            #[expect(deprecated)]
-            a.to_canonical().map(|c| c.into_array())
-        }) {
+        let slice_then_cast = match sliced
+            .cast(target_dtype.clone())
+            .and_then(|a| a.execute::<Canonical>(ctx).map(|c| c.into_array()))
+        {
             Ok(result) => result,
             Err(_) => continue, // Skip if cast fails
         };
@@ -1290,14 +1267,12 @@ fn test_cast_slice_consistency(array: &ArrayRef) {
         // Compare each value against the canonical form
         for i in 0..slice_then_cast.len() {
             let slice_cast_val = slice_then_cast
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
 
             // Get the corresponding value from the canonical array (adjusted for slice offset)
             let canonical_val = canonical
-                .clone()
-                .into_array()
-                .execute_scalar(start + i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(start + i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
 
             // Cast the canonical scalar to the target dtype
@@ -1322,10 +1297,10 @@ fn test_cast_slice_consistency(array: &ArrayRef) {
         }
 
         // Also test the other way: cast then slice
-        let casted = match array.clone().cast(target_dtype.clone()).and_then(|a| {
-            #[expect(deprecated)]
-            a.to_canonical().map(|c| c.into_array())
-        }) {
+        let casted = match array
+            .cast(target_dtype.clone())
+            .and_then(|a| a.execute::<Canonical>(ctx).map(|c| c.into_array()))
+        {
             Ok(result) => result,
             Err(_) => continue, // Skip if cast fails
         };
@@ -1342,10 +1317,10 @@ fn test_cast_slice_consistency(array: &ArrayRef) {
 
         for i in 0..slice_then_cast.len() {
             let slice_cast_val = slice_then_cast
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             let cast_slice_val = cast_then_slice
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, ctx)
                 .vortex_expect("scalar_at should succeed in conformance test");
             assert_eq!(
                 slice_cast_val, cast_slice_val,
@@ -1397,38 +1372,38 @@ fn test_cast_slice_consistency(array: &ArrayRef) {
 /// ## Large Arrays
 /// - **Performance**: Operations scale correctly to large arrays (1000+ elements)
 /// ```text
-pub fn test_array_consistency(array: &ArrayRef) {
+pub fn test_array_consistency(array: &ArrayRef, ctx: &mut ExecutionCtx) {
     // Core operation consistency
-    test_filter_take_consistency(array);
-    test_double_mask_consistency(array);
-    test_slice_filter_consistency(array);
-    test_take_slice_consistency(array);
-    test_cast_slice_consistency(array);
+    test_filter_take_consistency(array, ctx);
+    test_double_mask_consistency(array, ctx);
+    test_slice_filter_consistency(array, ctx);
+    test_take_slice_consistency(array, ctx);
+    test_cast_slice_consistency(array, ctx);
 
     // Boolean operations
-    test_boolean_demorgan_consistency(array);
+    test_boolean_demorgan_consistency(array, ctx);
 
     // Comparison operations
-    test_comparison_inverse_consistency(array);
-    test_comparison_symmetry_consistency(array);
+    test_comparison_inverse_consistency(array, ctx);
+    test_comparison_symmetry_consistency(array, ctx);
 
     // Aggregate operations
-    test_slice_aggregate_consistency(array);
+    test_slice_aggregate_consistency(array, ctx);
 
     // Identity operations
-    test_filter_identity(array);
-    test_mask_identity(array);
-    test_take_preserves_properties(array);
+    test_filter_identity(array, ctx);
+    test_mask_identity(array, ctx);
+    test_take_preserves_properties(array, ctx);
 
     // Ordering and correctness
-    test_filter_preserves_order(array);
-    test_take_repeated_indices(array);
+    test_filter_preserves_order(array, ctx);
+    test_take_repeated_indices(array, ctx);
 
     // Null handling
-    test_mask_filter_null_consistency(array);
-    test_nullable_indices_consistency(array);
+    test_mask_filter_null_consistency(array, ctx);
+    test_nullable_indices_consistency(array, ctx);
 
     // Edge cases
     test_empty_operations_consistency(array);
-    test_large_array_consistency(array);
+    test_large_array_consistency(array, ctx);
 }
diff --git a/vortex-array/src/compute/conformance/filter.rs b/vortex-array/src/compute/conformance/filter.rs
index dc87726e095..01bfb3bb2fa 100644
--- a/vortex-array/src/compute/conformance/filter.rs
+++ b/vortex-array/src/compute/conformance/filter.rs
@@ -6,7 +6,6 @@ use vortex_mask::Mask;
 
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
 use crate::array_session;
 use crate::assert_arrays_eq;
@@ -102,10 +101,10 @@ fn test_selective_filter(array: &ArrayRef) {
     for (filtered_idx, i) in (0..len).step_by(2).enumerate() {
         assert_eq!(
             filtered
-                .execute_scalar(filtered_idx, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(filtered_idx, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             array
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -122,18 +121,18 @@ fn test_selective_filter(array: &ArrayRef) {
         assert_eq!(filtered.len(), 2);
         assert_eq!(
             filtered
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             array
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
         assert_eq!(
             filtered
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(1, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             array
-                .execute_scalar(len - 1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(len - 1, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -155,10 +154,10 @@ fn test_single_element_filter(array: &ArrayRef) {
     assert_eq!(filtered.len(), 1);
     assert_eq!(
         filtered
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .vortex_expect("scalar_at should succeed in conformance test"),
         array
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .vortex_expect("scalar_at should succeed in conformance test")
     );
 
@@ -173,10 +172,10 @@ fn test_single_element_filter(array: &ArrayRef) {
         assert_eq!(filtered.len(), 1);
         assert_eq!(
             filtered
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             array
-                .execute_scalar(len - 1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(len - 1, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -239,10 +238,10 @@ fn test_alternating_pattern_filter(array: &ArrayRef) {
         if keep {
             assert_eq!(
                 filtered
-                    .execute_scalar(filtered_idx, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(filtered_idx, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test"),
                 array
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test")
             );
             filtered_idx += 1;
diff --git a/vortex-array/src/compute/conformance/mask.rs b/vortex-array/src/compute/conformance/mask.rs
index 42d7bb9c494..7a002662d38 100644
--- a/vortex-array/src/compute/conformance/mask.rs
+++ b/vortex-array/src/compute/conformance/mask.rs
@@ -6,8 +6,8 @@ use vortex_mask::Mask;
 
 use crate::ArrayRef;
 use crate::IntoArray;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
+use crate::array_session;
 use crate::arrays::BoolArray;
 use crate::arrays::bool::BoolArrayExt;
 use crate::builtins::ArrayBuiltins;
@@ -54,16 +54,16 @@ fn test_heterogenous_mask(array: &ArrayRef) {
         if masked_out {
             assert!(
                 !masked
-                    .is_valid(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .is_valid(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("is_valid should succeed in conformance test")
             );
         } else {
             assert_eq!(
                 masked
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test"),
                 array
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test")
                     .into_nullable()
             );
@@ -87,10 +87,10 @@ fn test_empty_mask(array: &ArrayRef) {
     for i in 0..len {
         assert_eq!(
             masked
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             array
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
                 .into_nullable()
         );
@@ -113,7 +113,7 @@ fn test_full_mask(array: &ArrayRef) {
     for i in 0..len {
         assert!(
             !masked
-                .is_valid(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("is_valid should succeed in conformance test")
         );
     }
@@ -135,16 +135,16 @@ fn test_alternating_mask(array: &ArrayRef) {
         if i % 2 == 0 {
             assert!(
                 !masked
-                    .is_valid(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .is_valid(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("is_valid should succeed in conformance test")
             );
         } else {
             assert_eq!(
                 masked
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test"),
                 array
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test")
                     .into_nullable()
             );
@@ -173,7 +173,7 @@ fn test_sparse_mask(array: &ArrayRef) {
     let valid_count = (0..len)
         .filter(|&i| {
             masked
-                .is_valid(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("is_valid should succeed in conformance test")
         })
         .count();
@@ -185,7 +185,7 @@ fn test_sparse_mask(array: &ArrayRef) {
         .filter(|&i| {
             pattern[i]
                 || !array
-                    .is_valid(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .is_valid(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("is_valid should succeed in conformance test")
         })
         .count();
@@ -208,17 +208,17 @@ fn test_single_element_mask(array: &ArrayRef) {
         .vortex_expect("mask should succeed in conformance test");
     assert!(
         !masked
-            .is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .is_valid(0, &mut array_session().create_execution_ctx())
             .vortex_expect("is_valid should succeed in conformance test")
     );
 
     for i in 1..len {
         assert_eq!(
             masked
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             array
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
                 .into_nullable()
         );
@@ -249,16 +249,16 @@ fn test_double_mask(array: &ArrayRef) {
         if mask1_pattern[i] || mask2_pattern[i] {
             assert!(
                 !double_masked
-                    .is_valid(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .is_valid(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("is_valid should succeed in conformance test")
             );
         } else {
             assert_eq!(
                 double_masked
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test"),
                 array
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test")
                     .into_nullable()
             );
@@ -282,7 +282,7 @@ fn test_nullable_mask_input(array: &ArrayRef) {
     let nullable_mask = BoolArray::new(bool_array.to_bit_buffer(), validity);
 
     let mask_array =
-        nullable_mask.to_mask_fill_null_false(&mut LEGACY_SESSION.create_execution_ctx());
+        nullable_mask.to_mask_fill_null_false(&mut array_session().create_execution_ctx());
     let masked = array
         .clone()
         .mask((!&mask_array).into_array())
@@ -293,16 +293,16 @@ fn test_nullable_mask_input(array: &ArrayRef) {
         if bool_values[i] && validity_values[i] {
             assert!(
                 !masked
-                    .is_valid(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .is_valid(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("is_valid should succeed in conformance test")
             );
         } else {
             assert_eq!(
                 masked
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test"),
                 array
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test")
                     .into_nullable()
             );
diff --git a/vortex-array/src/compute/conformance/search_sorted.rs b/vortex-array/src/compute/conformance/search_sorted.rs
index 472dfec9dc1..0d0cf9d8cc8 100644
--- a/vortex-array/src/compute/conformance/search_sorted.rs
+++ b/vortex-array/src/compute/conformance/search_sorted.rs
@@ -10,9 +10,9 @@ use vortex_buffer::Buffer;
 use vortex_buffer::buffer;
 
 use crate::ArrayRef;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
 use crate::array::IntoArray;
+use crate::array_session;
 use crate::arrays::PrimitiveArray;
 use crate::patches::Patches;
 use crate::validity::Validity;
@@ -32,7 +32,7 @@ pub fn sparse_high_null_fill() -> ArrayRef {
                 None,
             )
             .unwrap(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
         .into_array()
@@ -49,7 +49,7 @@ pub fn sparse_high_non_null_fill() -> ArrayRef {
                 None,
             )
             .unwrap(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
         .into_array()
@@ -66,7 +66,7 @@ pub fn sparse_low() -> ArrayRef {
                 None,
             )
             .unwrap(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
         .into_array()
@@ -83,7 +83,7 @@ pub fn sparse_low_high() -> ArrayRef {
                 None,
             )
             .unwrap(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
         .into_array()
@@ -100,7 +100,7 @@ pub fn sparse_edge_patch_high() -> ArrayRef {
                 None,
             )
             .unwrap(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
         .into_array()
@@ -117,7 +117,7 @@ pub fn sparse_edge_patch_low() -> ArrayRef {
                 None,
             )
             .unwrap(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )
         .unwrap()
         .into_array()
diff --git a/vortex-array/src/compute/conformance/take.rs b/vortex-array/src/compute/conformance/take.rs
index 911a2ae7295..babaf392eb9 100644
--- a/vortex-array/src/compute/conformance/take.rs
+++ b/vortex-array/src/compute/conformance/take.rs
@@ -7,8 +7,8 @@ use vortex_error::VortexExpect;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::IntoArray as _;
-use crate::LEGACY_SESSION;
 use crate::VortexSessionExecute;
+use crate::array_session;
 use crate::arrays::PrimitiveArray;
 use crate::dtype::Nullability;
 
@@ -84,10 +84,10 @@ fn test_take_all(array: &ArrayRef) {
             for i in 0..len {
                 assert_eq!(
                     array
-                        .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                        .execute_scalar(i, &mut array_session().create_execution_ctx())
                         .vortex_expect("scalar_at should succeed in conformance test"),
                     result
-                        .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                        .execute_scalar(i, &mut array_session().create_execution_ctx())
                         .vortex_expect("scalar_at should succeed in conformance test")
                 );
             }
@@ -125,11 +125,11 @@ fn test_take_selective(array: &ArrayRef) {
             array
                 .execute_scalar(
                     original_idx as usize,
-                    &mut LEGACY_SESSION.create_execution_ctx()
+                    &mut array_session().create_execution_ctx()
                 )
                 .vortex_expect("scalar_at should succeed in conformance test"),
             result
-                .execute_scalar(result_idx, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(result_idx, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -145,18 +145,18 @@ fn test_take_first_and_last(array: &ArrayRef) {
     assert_eq!(result.len(), 2);
     assert_eq!(
         array
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .vortex_expect("scalar_at should succeed in conformance test"),
         result
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .vortex_expect("scalar_at should succeed in conformance test")
     );
     assert_eq!(
         array
-            .execute_scalar(len - 1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(len - 1, &mut array_session().create_execution_ctx())
             .vortex_expect("scalar_at should succeed in conformance test"),
         result
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .vortex_expect("scalar_at should succeed in conformance test")
     );
 }
@@ -190,17 +190,17 @@ fn test_take_with_nullable_indices(array: &ArrayRef) {
         match idx_opt {
             Some(idx) => {
                 let expected = array
-                    .execute_scalar(*idx as usize, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(*idx as usize, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test");
                 let actual = result
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .vortex_expect("scalar_at should succeed in conformance test");
                 assert_eq!(expected, actual);
             }
             None => {
                 assert!(
                     result
-                        .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                        .execute_scalar(i, &mut array_session().create_execution_ctx())
                         .vortex_expect("scalar_at should succeed in conformance test")
                         .is_null()
                 );
@@ -222,12 +222,12 @@ fn test_take_repeated_indices(array: &ArrayRef) {
 
     assert_eq!(result.len(), 3);
     let first_elem = array
-        .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+        .execute_scalar(0, &mut array_session().create_execution_ctx())
         .vortex_expect("scalar_at should succeed in conformance test");
     for i in 0..3 {
         assert_eq!(
             result
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             first_elem
         );
@@ -258,10 +258,10 @@ fn test_take_reverse(array: &ArrayRef) {
     for i in 0..len {
         assert_eq!(
             array
-                .execute_scalar(len - 1 - i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(len - 1 - i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             result
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -279,10 +279,10 @@ fn test_take_single_middle(array: &ArrayRef) {
     assert_eq!(result.len(), 1);
     assert_eq!(
         array
-            .execute_scalar(middle_idx, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(middle_idx, &mut array_session().create_execution_ctx())
             .vortex_expect("scalar_at should succeed in conformance test"),
         result
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .vortex_expect("scalar_at should succeed in conformance test")
     );
 }
@@ -310,10 +310,10 @@ fn test_take_random_unsorted(array: &ArrayRef) {
     for (i, &idx) in indices.iter().enumerate() {
         assert_eq!(
             array
-                .execute_scalar(idx as usize, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(idx as usize, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             result
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -336,10 +336,10 @@ fn test_take_contiguous_range(array: &ArrayRef) {
     for i in 0..(end - start) {
         assert_eq!(
             array
-                .execute_scalar(start + i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(start + i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             result
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -372,10 +372,10 @@ fn test_take_mixed_repeated(array: &ArrayRef) {
     for (i, &idx) in indices.iter().enumerate() {
         assert_eq!(
             array
-                .execute_scalar(idx as usize, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(idx as usize, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             result
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
@@ -404,10 +404,10 @@ fn test_take_large_indices(array: &ArrayRef) {
         let expected_idx = indices[i] as usize;
         assert_eq!(
             array
-                .execute_scalar(expected_idx, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(expected_idx, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test"),
             result
-                .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(i, &mut array_session().create_execution_ctx())
                 .vortex_expect("scalar_at should succeed in conformance test")
         );
     }
diff --git a/vortex-array/src/expr/exprs.rs b/vortex-array/src/expr/exprs.rs
index ab3a115c652..303424f56c0 100644
--- a/vortex-array/src/expr/exprs.rs
+++ b/vortex-array/src/expr/exprs.rs
@@ -422,13 +422,13 @@ where
 /// ```
 /// # use vortex_array::IntoArray;
 /// # use vortex_array::arrow::ArrowArrayExecutor;
-/// # use vortex_array::{LEGACY_SESSION, VortexSessionExecute};
+/// # use vortex_array::{VortexSessionExecute, array_session};
 /// # use vortex_buffer::buffer;
 /// # use vortex_array::expr::{checked_add, lit, root};
 /// let xs = buffer![1, 2, 3].into_array();
 /// let result = xs.apply(&checked_add(root(), lit(5))).unwrap();
 ///
-/// let mut ctx = LEGACY_SESSION.create_execution_ctx();
+/// let mut ctx = array_session().create_execution_ctx();
 /// assert_eq!(
 ///     &result.execute_arrow(None, &mut ctx).unwrap(),
 ///     &buffer![6, 7, 8]
diff --git a/vortex-array/src/expr/proto.rs b/vortex-array/src/expr/proto.rs
index 27859235e88..ebf1f877f15 100644
--- a/vortex-array/src/expr/proto.rs
+++ b/vortex-array/src/expr/proto.rs
@@ -74,7 +74,7 @@ mod tests {
     use vortex_session::VortexSession;
 
     use super::ExprSerializeProtoExt;
-    use crate::LEGACY_SESSION;
+    use crate::array_session;
     use crate::expr::Expression;
     use crate::expr::and;
     use crate::expr::between;
@@ -108,7 +108,7 @@ mod tests {
         let s_expr = expr.serialize_proto().unwrap();
         let buf = s_expr.encode_to_vec();
         let s_expr = pb::Expr::decode(buf.as_slice()).unwrap();
-        let deser_expr = Expression::from_proto(&s_expr, &LEGACY_SESSION).unwrap();
+        let deser_expr = Expression::from_proto(&s_expr, &array_session()).unwrap();
 
         assert_eq!(&deser_expr, &expr);
     }
diff --git a/vortex-array/src/expr/stats/mod.rs b/vortex-array/src/expr/stats/mod.rs
index d0834555cea..57e11135ef3 100644
--- a/vortex-array/src/expr/stats/mod.rs
+++ b/vortex-array/src/expr/stats/mod.rs
@@ -268,8 +268,8 @@ impl Display for Stat {
 mod test {
     use enum_iterator::all;
 
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::expr::stats::Stat;
 
@@ -277,7 +277,7 @@ mod test {
     fn min_of_nulls_is_not_panic() {
         let min = PrimitiveArray::from_option_iter::<i32, _>([None, None, None, None])
             .statistics()
-            .compute_as::<i64>(Stat::Min, &mut LEGACY_SESSION.create_execution_ctx());
+            .compute_as::<i64>(Stat::Min, &mut array_session().create_execution_ctx());
 
         assert_eq!(min, None);
     }
diff --git a/vortex-array/src/mask.rs b/vortex-array/src/mask.rs
index d8ba622f347..ee55abc9875 100644
--- a/vortex-array/src/mask.rs
+++ b/vortex-array/src/mask.rs
@@ -103,8 +103,8 @@ mod tests {
 
     use crate::ExecutionCtx;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::arrays::ConstantArray;
     use crate::builtins::ArrayBuiltins;
@@ -113,7 +113,7 @@ mod tests {
     use crate::scalar::Scalar;
 
     fn ctx() -> ExecutionCtx {
-        LEGACY_SESSION.create_execution_ctx()
+        array_session().create_execution_ctx()
     }
 
     #[test]
diff --git a/vortex-array/src/scalar_fn/fns/between/mod.rs b/vortex-array/src/scalar_fn/fns/between/mod.rs
index 7d15b250a50..2151a310dde 100644
--- a/vortex-array/src/scalar_fn/fns/between/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/between/mod.rs
@@ -381,6 +381,7 @@ mod tests {
         let lower = buffer![0, 0, 0, 0, 2].into_array();
         let array = buffer![1, 0, 1, 0, 1].into_array();
         let upper = buffer![2, 1, 1, 0, 0].into_array();
+        let ctx = &mut SESSION.create_execution_ctx();
 
         let matches = between_canonical(
             &array,
@@ -390,13 +391,13 @@ mod tests {
                 lower_strict,
                 upper_strict,
             },
-            &mut SESSION.create_execution_ctx(),
+            ctx,
         )
         .unwrap()
-        .execute::<BoolArray>(&mut SESSION.create_execution_ctx())
+        .execute::<BoolArray>(ctx)
         .unwrap();
 
-        let indices = to_int_indices(matches).unwrap();
+        let indices = to_int_indices(matches, ctx).unwrap();
         assert_eq!(indices, expected);
     }
 
@@ -404,6 +405,7 @@ mod tests {
     fn test_constants() {
         let lower = buffer![0, 0, 2, 0, 2].into_array();
         let array = buffer![1, 0, 1, 0, 1].into_array();
+        let ctx = &mut SESSION.create_execution_ctx();
 
         // upper is null
         let upper = ConstantArray::new(
@@ -420,13 +422,13 @@ mod tests {
                 lower_strict: StrictComparison::NonStrict,
                 upper_strict: StrictComparison::NonStrict,
             },
-            &mut SESSION.create_execution_ctx(),
+            ctx,
         )
         .unwrap()
-        .execute::<BoolArray>(&mut SESSION.create_execution_ctx())
+        .execute::<BoolArray>(ctx)
         .unwrap();
 
-        let indices = to_int_indices(matches).unwrap();
+        let indices = to_int_indices(matches, ctx).unwrap();
         assert!(indices.is_empty());
 
         // upper is a fixed constant
@@ -439,12 +441,12 @@ mod tests {
                 lower_strict: StrictComparison::NonStrict,
                 upper_strict: StrictComparison::NonStrict,
             },
-            &mut SESSION.create_execution_ctx(),
+            ctx,
         )
         .unwrap()
-        .execute::<BoolArray>(&mut SESSION.create_execution_ctx())
+        .execute::<BoolArray>(ctx)
         .unwrap();
-        let indices = to_int_indices(matches).unwrap();
+        let indices = to_int_indices(matches, ctx).unwrap();
         assert_eq!(indices, vec![0, 1, 3]);
 
         // lower is also a constant
@@ -458,18 +460,18 @@ mod tests {
                 lower_strict: StrictComparison::NonStrict,
                 upper_strict: StrictComparison::NonStrict,
             },
-            &mut SESSION.create_execution_ctx(),
+            ctx,
         )
         .unwrap()
-        .execute::<BoolArray>(&mut SESSION.create_execution_ctx())
+        .execute::<BoolArray>(ctx)
         .unwrap();
-        let indices = to_int_indices(matches).unwrap();
+        let indices = to_int_indices(matches, ctx).unwrap();
         assert_eq!(indices, vec![0, 1, 2, 3, 4]);
     }
 
     #[test]
     fn test_between_decimal() {
-        let mut ctx = SESSION.create_execution_ctx();
+        let ctx = &mut SESSION.create_execution_ctx();
         let values = buffer![100i128, 200i128, 300i128, 400i128];
         let decimal_type = DecimalDType::new(3, 2);
         let array = DecimalArray::new(values, decimal_type, Validity::NonNullable).into_array();
@@ -502,13 +504,13 @@ mod tests {
                 lower_strict: StrictComparison::Strict,
                 upper_strict: StrictComparison::NonStrict,
             },
-            &mut SESSION.create_execution_ctx(),
+            ctx,
         )
         .unwrap();
         assert_arrays_eq!(
             between_strict,
             BoolArray::from_iter([false, true, true, true]),
-            &mut ctx
+            ctx
         );
 
         // Non-strict lower bound, strict upper bound
@@ -520,13 +522,13 @@ mod tests {
                 lower_strict: StrictComparison::NonStrict,
                 upper_strict: StrictComparison::Strict,
             },
-            &mut SESSION.create_execution_ctx(),
+            ctx,
         )
         .unwrap();
         assert_arrays_eq!(
             between_strict,
             BoolArray::from_iter([true, true, true, false]),
-            &mut ctx
+            ctx
         );
     }
 
@@ -549,6 +551,7 @@ mod tests {
         #[case] upper_val: DecimalValue,
         #[case] expected_indices: Vec<u64>,
     ) {
+        let ctx = &mut SESSION.create_execution_ctx();
         // Array uses I16 storage with precision=5 (values fit in i16 even though precision=5
         // nominally maps to I32 as the smallest storage type).
         let decimal_type = DecimalDType::new(5, -67);
@@ -578,12 +581,12 @@ mod tests {
                 lower_strict: StrictComparison::NonStrict,
                 upper_strict: StrictComparison::NonStrict,
             },
-            &mut SESSION.create_execution_ctx(),
+            ctx,
         )
         .unwrap()
-        .execute::<BoolArray>(&mut SESSION.create_execution_ctx())
+        .execute::<BoolArray>(ctx)
         .unwrap();
 
-        assert_eq!(to_int_indices(result).unwrap(), expected_indices);
+        assert_eq!(to_int_indices(result, ctx).unwrap(), expected_indices);
     }
 }
diff --git a/vortex-array/src/scalar_fn/fns/binary/boolean.rs b/vortex-array/src/scalar_fn/fns/binary/boolean.rs
index d109ba3d01b..b7f838c6d13 100644
--- a/vortex-array/src/scalar_fn/fns/binary/boolean.rs
+++ b/vortex-array/src/scalar_fn/fns/binary/boolean.rs
@@ -757,7 +757,6 @@ mod tests {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::BoolArray;
@@ -870,22 +869,22 @@ mod tests {
         let r = r.to_bool().into_array();
 
         let v0 = r
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_bool()
             .value();
         let v1 = r
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_bool()
             .value();
         let v2 = r
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(2, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_bool()
             .value();
         let v3 = r
-            .execute_scalar(3, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(3, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_bool()
             .value();
@@ -914,22 +913,22 @@ mod tests {
             .into_array();
 
         let v0 = r
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_bool()
             .value();
         let v1 = r
-            .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(1, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_bool()
             .value();
         let v2 = r
-            .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(2, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_bool()
             .value();
         let v3 = r
-            .execute_scalar(3, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(3, &mut array_session().create_execution_ctx())
             .unwrap()
             .as_bool()
             .value();
diff --git a/vortex-array/src/scalar_fn/fns/binary/compare.rs b/vortex-array/src/scalar_fn/fns/binary/compare.rs
index 67f34bbddd6..b7a53c21d62 100644
--- a/vortex-array/src/scalar_fn/fns/binary/compare.rs
+++ b/vortex-array/src/scalar_fn/fns/binary/compare.rs
@@ -245,13 +245,12 @@ mod tests {
     use std::sync::Arc;
 
     use rstest::rstest;
+    use vortex_buffer::BitBuffer;
     use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
-    #[expect(deprecated)]
-    use crate::ToCanonical as _;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::BoolArray;
@@ -281,71 +280,70 @@ mod tests {
 
     #[test]
     fn test_bool_basic_comparisons() {
-        use vortex_buffer::BitBuffer;
-
+        let ctx = &mut array_session().create_execution_ctx();
         let arr = BoolArray::new(
             BitBuffer::from_iter([true, true, false, true, false]),
             Validity::from_iter([false, true, true, true, true]),
         );
 
-        #[expect(deprecated)]
         let matches = arr
             .clone()
             .into_array()
             .binary(arr.clone().into_array(), Operator::Eq)
             .unwrap()
-            .to_bool();
-        assert_eq!(to_int_indices(matches).unwrap(), [1u64, 2, 3, 4]);
+            .execute::<BoolArray>(ctx)
+            .vortex_expect("must be a bool array");
+        assert_eq!(to_int_indices(matches, ctx).unwrap(), [1u64, 2, 3, 4]);
 
-        #[expect(deprecated)]
         let matches = arr
             .clone()
             .into_array()
             .binary(arr.clone().into_array(), Operator::NotEq)
             .unwrap()
-            .to_bool();
+            .execute::<BoolArray>(ctx)
+            .vortex_expect("must be a bool array");
         let empty: [u64; 0] = [];
-        assert_eq!(to_int_indices(matches).unwrap(), empty);
+        assert_eq!(to_int_indices(matches, ctx).unwrap(), empty);
 
         let other = BoolArray::new(
             BitBuffer::from_iter([false, false, false, true, true]),
             Validity::from_iter([false, true, true, true, true]),
         );
 
-        #[expect(deprecated)]
         let matches = arr
             .clone()
             .into_array()
             .binary(other.clone().into_array(), Operator::Lte)
             .unwrap()
-            .to_bool();
-        assert_eq!(to_int_indices(matches).unwrap(), [2u64, 3, 4]);
+            .execute::<BoolArray>(ctx)
+            .vortex_expect("must be a bool array");
+        assert_eq!(to_int_indices(matches, ctx).unwrap(), [2u64, 3, 4]);
 
-        #[expect(deprecated)]
         let matches = arr
             .clone()
             .into_array()
             .binary(other.clone().into_array(), Operator::Lt)
             .unwrap()
-            .to_bool();
-        assert_eq!(to_int_indices(matches).unwrap(), [4u64]);
+            .execute::<BoolArray>(ctx)
+            .vortex_expect("must be a bool array");
+        assert_eq!(to_int_indices(matches, ctx).unwrap(), [4u64]);
 
-        #[expect(deprecated)]
         let matches = other
             .clone()
             .into_array()
             .binary(arr.clone().into_array(), Operator::Gte)
             .unwrap()
-            .to_bool();
-        assert_eq!(to_int_indices(matches).unwrap(), [2u64, 3, 4]);
+            .execute::<BoolArray>(ctx)
+            .vortex_expect("must be a bool array");
+        assert_eq!(to_int_indices(matches, ctx).unwrap(), [2u64, 3, 4]);
 
-        #[expect(deprecated)]
         let matches = other
             .into_array()
             .binary(arr.into_array(), Operator::Gt)
             .unwrap()
-            .to_bool();
-        assert_eq!(to_int_indices(matches).unwrap(), [4u64]);
+            .execute::<BoolArray>(ctx)
+            .vortex_expect("must be a bool array");
+        assert_eq!(to_int_indices(matches, ctx).unwrap(), [4u64]);
     }
 
     #[test]
@@ -359,7 +357,7 @@ mod tests {
             .unwrap();
         assert_eq!(result.len(), 10);
         let scalar = result
-            .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            .execute_scalar(0, &mut array_session().create_execution_ctx())
             .unwrap();
         assert_eq!(scalar.as_bool().value(), Some(false));
     }
@@ -572,6 +570,7 @@ mod tests {
 
     #[test]
     fn test_empty_list() {
+        let ctx = &mut array_session().create_execution_ctx();
         let list = ListViewArray::new(
             BoolArray::from_iter(Vec::<bool>::new()).into_array(),
             buffer![0i32, 0i32, 0i32].into_array(),
@@ -584,23 +583,8 @@ mod tests {
             .into_array()
             .binary(list.into_array(), Operator::Eq)
             .unwrap();
-        assert!(
-            result
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap()
-                .is_valid()
-        );
-        assert!(
-            result
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap()
-                .is_valid()
-        );
-        assert!(
-            result
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
-                .unwrap()
-                .is_valid()
-        );
+        assert!(result.execute_scalar(0, ctx).unwrap().is_valid());
+        assert!(result.execute_scalar(1, ctx).unwrap().is_valid());
+        assert!(result.execute_scalar(2, ctx).unwrap().is_valid());
     }
 }
diff --git a/vortex-array/src/scalar_fn/fns/binary/mod.rs b/vortex-array/src/scalar_fn/fns/binary/mod.rs
index 9dc142eb892..156540a2820 100644
--- a/vortex-array/src/scalar_fn/fns/binary/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/binary/mod.rs
@@ -281,7 +281,6 @@ mod tests {
     use vortex_error::VortexResult;
 
     use super::*;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::assert_arrays_eq;
@@ -500,7 +499,7 @@ mod tests {
         let result_equal = lhs_struct.binary(rhs_struct_equal, Operator::Eq).unwrap();
         assert_eq!(
             result_equal
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .vortex_expect("value"),
             Scalar::bool(true, Nullability::NonNullable),
             "Equal structs should be equal"
@@ -511,7 +510,7 @@ mod tests {
             .unwrap();
         assert_eq!(
             result_different
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .vortex_expect("value"),
             Scalar::bool(false, Nullability::NonNullable),
             "Different structs should not be equal"
diff --git a/vortex-array/src/scalar_fn/fns/binary/numeric.rs b/vortex-array/src/scalar_fn/fns/binary/numeric.rs
index 0c824f59002..e95627155e9 100644
--- a/vortex-array/src/scalar_fn/fns/binary/numeric.rs
+++ b/vortex-array/src/scalar_fn/fns/binary/numeric.rs
@@ -926,7 +926,6 @@ mod test {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::RecursiveCanonical;
     use crate::VortexSessionExecute;
     use crate::array_session;
@@ -945,7 +944,7 @@ mod test {
                 Operator::Sub,
             )
             .and_then(|a| {
-                a.execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())
+                a.execute::<RecursiveCanonical>(&mut array_session().create_execution_ctx())
             })
             .map(|a| a.0.into_array())
     }
@@ -1006,7 +1005,7 @@ mod test {
                 ConstantArray::new(0.0f64, values.len()).into_array(),
                 Operator::Div,
             )
-            .and_then(|a| a.execute::<PrimitiveArray>(&mut LEGACY_SESSION.create_execution_ctx()))
+            .and_then(|a| a.execute::<PrimitiveArray>(&mut array_session().create_execution_ctx()))
             .unwrap();
 
         assert_arrays_eq!(
@@ -1024,7 +1023,7 @@ mod test {
                 ConstantArray::new(1u8, values.len()).into_array(),
                 Operator::Add,
             )
-            .and_then(|a| a.execute::<PrimitiveArray>(&mut LEGACY_SESSION.create_execution_ctx()));
+            .and_then(|a| a.execute::<PrimitiveArray>(&mut array_session().create_execution_ctx()));
 
         assert!(result.is_err());
     }
@@ -1037,7 +1036,7 @@ mod test {
                 ConstantArray::new(0i32, values.len()).into_array(),
                 Operator::Div,
             )
-            .and_then(|a| a.execute::<PrimitiveArray>(&mut LEGACY_SESSION.create_execution_ctx()));
+            .and_then(|a| a.execute::<PrimitiveArray>(&mut array_session().create_execution_ctx()));
 
         assert!(result.is_err());
     }
@@ -1050,7 +1049,7 @@ mod test {
                 ConstantArray::new(-1i64, values.len()).into_array(),
                 Operator::Div,
             )
-            .and_then(|a| a.execute::<PrimitiveArray>(&mut LEGACY_SESSION.create_execution_ctx()));
+            .and_then(|a| a.execute::<PrimitiveArray>(&mut array_session().create_execution_ctx()));
 
         assert!(result.is_err());
     }
@@ -1064,7 +1063,7 @@ mod test {
         let result = lhs
             .binary(rhs, Operator::Div)
             .and_then(|a| {
-                a.execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())
+                a.execute::<RecursiveCanonical>(&mut array_session().create_execution_ctx())
             })
             .map(|a| a.0.into_array())
             .unwrap();
@@ -1087,7 +1086,7 @@ mod test {
                 Operator::Add,
             )
             .and_then(|a| {
-                a.execute::<RecursiveCanonical>(&mut LEGACY_SESSION.create_execution_ctx())
+                a.execute::<RecursiveCanonical>(&mut array_session().create_execution_ctx())
             })
             .map(|a| a.0.into_array())
             .unwrap();
@@ -1109,7 +1108,7 @@ mod test {
         let rhs = buffer![1u8, 1, 1].into_array();
         let result = lhs
             .binary(rhs, Operator::Add)
-            .and_then(|a| a.execute::<PrimitiveArray>(&mut LEGACY_SESSION.create_execution_ctx()));
+            .and_then(|a| a.execute::<PrimitiveArray>(&mut array_session().create_execution_ctx()));
 
         assert!(result.is_err());
     }
@@ -1123,7 +1122,7 @@ mod test {
                 ConstantArray::new(Some(1u8), values.len()).into_array(),
                 Operator::Add,
             )
-            .and_then(|a| a.execute::<PrimitiveArray>(&mut LEGACY_SESSION.create_execution_ctx()))
+            .and_then(|a| a.execute::<PrimitiveArray>(&mut array_session().create_execution_ctx()))
             .unwrap();
 
         assert_arrays_eq!(
diff --git a/vortex-array/src/scalar_fn/fns/byte_length.rs b/vortex-array/src/scalar_fn/fns/byte_length.rs
index 064e3a95869..cfab5290a8f 100644
--- a/vortex-array/src/scalar_fn/fns/byte_length.rs
+++ b/vortex-array/src/scalar_fn/fns/byte_length.rs
@@ -180,7 +180,6 @@ mod tests {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::ConstantArray;
@@ -226,16 +225,16 @@ mod tests {
             .into_array();
         let result = array.apply(&byte_length(root()))?;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert!(result.is_valid(0, &mut ctx)?);
         assert!(!result.is_valid(1, &mut ctx)?);
         assert!(result.is_valid(2, &mut ctx)?);
         assert_eq!(
-            result.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())?,
+            result.execute_scalar(0, &mut array_session().create_execution_ctx())?,
             Scalar::primitive(5u64, Nullability::Nullable),
         );
         assert_eq!(
-            result.execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())?,
+            result.execute_scalar(2, &mut array_session().create_execution_ctx())?,
             Scalar::primitive(18u64, Nullability::Nullable),
         );
         Ok(())
@@ -246,7 +245,7 @@ mod tests {
         let null_scalar = Scalar::null(DType::Utf8(Nullability::Nullable));
         let array = ConstantArray::new(null_scalar, 2).into_array();
         let result = array.apply(&byte_length(root()))?;
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert!(!result.is_valid(0, &mut ctx)?);
         assert!(!result.is_valid(1, &mut ctx)?);
         Ok(())
diff --git a/vortex-array/src/scalar_fn/fns/case_when.rs b/vortex-array/src/scalar_fn/fns/case_when.rs
index 7ff2190ccee..d57026e00f5 100644
--- a/vortex-array/src/scalar_fn/fns/case_when.rs
+++ b/vortex-array/src/scalar_fn/fns/case_when.rs
@@ -450,7 +450,6 @@ mod tests {
     use super::*;
     use crate::Canonical;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::arrays::BoolArray;
     use crate::arrays::PrimitiveArray;
@@ -1237,19 +1236,19 @@ mod tests {
 
         let result = evaluate_expr(&expr, &test_array);
         assert_eq!(
-            result.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())?,
+            result.execute_scalar(0, &mut SESSION.create_execution_ctx())?,
             Scalar::utf8("low", Nullability::NonNullable)
         );
         assert_eq!(
-            result.execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())?,
+            result.execute_scalar(1, &mut SESSION.create_execution_ctx())?,
             Scalar::utf8("low", Nullability::NonNullable)
         );
         assert_eq!(
-            result.execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())?,
+            result.execute_scalar(2, &mut SESSION.create_execution_ctx())?,
             Scalar::utf8("high", Nullability::NonNullable)
         );
         assert_eq!(
-            result.execute_scalar(3, &mut LEGACY_SESSION.create_execution_ctx())?,
+            result.execute_scalar(3, &mut SESSION.create_execution_ctx())?,
             Scalar::utf8("high", Nullability::NonNullable)
         );
         Ok(())
diff --git a/vortex-array/src/scalar_fn/fns/is_not_null.rs b/vortex-array/src/scalar_fn/fns/is_not_null.rs
index f2849f53ccf..75d86db5ee8 100644
--- a/vortex-array/src/scalar_fn/fns/is_not_null.rs
+++ b/vortex-array/src/scalar_fn/fns/is_not_null.rs
@@ -107,8 +107,8 @@ mod tests {
     use vortex_session::VortexSession;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
     use crate::dtype::DType;
@@ -162,7 +162,7 @@ mod tests {
         for (i, expected_value) in expected.iter().enumerate() {
             assert_eq!(
                 result
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .unwrap(),
                 Scalar::bool(*expected_value, Nullability::NonNullable)
             );
@@ -179,7 +179,7 @@ mod tests {
         for i in 0..result.len() {
             assert_eq!(
                 result
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .unwrap(),
                 Scalar::bool(true, Nullability::NonNullable)
             );
@@ -198,7 +198,7 @@ mod tests {
         for i in 0..result.len() {
             assert_eq!(
                 result
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .unwrap(),
                 Scalar::bool(false, Nullability::NonNullable)
             );
@@ -227,7 +227,7 @@ mod tests {
         for (i, expected_value) in expected.iter().enumerate() {
             assert_eq!(
                 result
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .unwrap(),
                 Scalar::bool(*expected_value, Nullability::NonNullable)
             );
diff --git a/vortex-array/src/scalar_fn/fns/is_null.rs b/vortex-array/src/scalar_fn/fns/is_null.rs
index 8df263a4b22..5e605ca6ee0 100644
--- a/vortex-array/src/scalar_fn/fns/is_null.rs
+++ b/vortex-array/src/scalar_fn/fns/is_null.rs
@@ -98,8 +98,8 @@ mod tests {
     use vortex_session::VortexSession;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
     use crate::dtype::DType;
@@ -151,7 +151,7 @@ mod tests {
         for (i, expected_value) in expected.iter().enumerate() {
             assert_eq!(
                 result
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .unwrap(),
                 Scalar::bool(*expected_value, Nullability::NonNullable)
             );
@@ -169,7 +169,7 @@ mod tests {
         for i in 0..result.len() {
             assert_eq!(
                 result
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .unwrap(),
                 Scalar::bool(false, Nullability::NonNullable)
             );
@@ -189,7 +189,7 @@ mod tests {
         for i in 0..result.len() {
             assert_eq!(
                 result
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .unwrap(),
                 Scalar::bool(true, Nullability::NonNullable)
             );
@@ -218,7 +218,7 @@ mod tests {
         for (i, expected_value) in expected.iter().enumerate() {
             assert_eq!(
                 result
-                    .execute_scalar(i, &mut LEGACY_SESSION.create_execution_ctx())
+                    .execute_scalar(i, &mut array_session().create_execution_ctx())
                     .unwrap(),
                 Scalar::bool(*expected_value, Nullability::NonNullable)
             );
diff --git a/vortex-array/src/scalar_fn/fns/like/mod.rs b/vortex-array/src/scalar_fn/fns/like/mod.rs
index a2da7735c6b..63ced07c8e7 100644
--- a/vortex-array/src/scalar_fn/fns/like/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/like/mod.rs
@@ -244,8 +244,8 @@ mod tests {
     use std::borrow::Cow;
 
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::BoolArray;
     use crate::assert_arrays_eq;
     use crate::dtype::DType;
@@ -262,7 +262,7 @@ mod tests {
     fn invert_booleans() {
         let not_expr = not(root());
         let bools = BoolArray::from_iter([false, true, false, false, true, true]);
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_arrays_eq!(
             bools.into_array().apply(&not_expr).unwrap(),
             BoolArray::from_iter([true, false, true, true, false, false]),
diff --git a/vortex-array/src/scalar_fn/fns/list_contains/mod.rs b/vortex-array/src/scalar_fn/fns/list_contains/mod.rs
index cf0704b68f3..5185e513e70 100644
--- a/vortex-array/src/scalar_fn/fns/list_contains/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/list_contains/mod.rs
@@ -405,7 +405,6 @@ mod tests {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::ListArray;
@@ -462,12 +461,12 @@ mod tests {
         let item = arr.apply(&expr).unwrap();
 
         assert_eq!(
-            item.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            item.execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::bool(true, Nullability::Nullable)
         );
         assert_eq!(
-            item.execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            item.execute_scalar(1, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::bool(false, Nullability::Nullable)
         );
@@ -481,12 +480,12 @@ mod tests {
         let item = arr.apply(&expr).unwrap();
 
         assert_eq!(
-            item.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            item.execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::bool(true, Nullability::Nullable)
         );
         assert_eq!(
-            item.execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            item.execute_scalar(1, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::bool(true, Nullability::Nullable)
         );
@@ -500,12 +499,12 @@ mod tests {
         let item = arr.apply(&expr).unwrap();
 
         assert_eq!(
-            item.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            item.execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::bool(false, Nullability::Nullable)
         );
         assert_eq!(
-            item.execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            item.execute_scalar(1, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::bool(false, Nullability::Nullable)
         );
@@ -525,12 +524,12 @@ mod tests {
         let item = arr.apply(&expr).unwrap();
 
         assert_eq!(
-            item.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            item.execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::bool(true, Nullability::Nullable)
         );
         assert_eq!(
-            item.execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+            item.execute_scalar(1, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::bool(false, Nullability::Nullable)
         );
@@ -550,13 +549,13 @@ mod tests {
         let item = arr.apply(&expr).unwrap();
 
         assert_eq!(
-            item.execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+            item.execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::bool(true, Nullability::Nullable)
         );
         assert!(
             !item
-                .is_valid(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .is_valid(1, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
     }
@@ -648,7 +647,7 @@ mod tests {
         let result = arr.clone().apply(&expr).unwrap();
         assert_eq!(
             result
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::bool(true, Nullability::NonNullable)
         );
@@ -658,7 +657,7 @@ mod tests {
         let result = arr.apply(&expr).unwrap();
         assert_eq!(
             result
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::bool(false, Nullability::NonNullable)
         );
diff --git a/vortex-array/src/scalar_fn/fns/variant_get/mod.rs b/vortex-array/src/scalar_fn/fns/variant_get/mod.rs
index 179264ba033..432a28bb1ab 100644
--- a/vortex-array/src/scalar_fn/fns/variant_get/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/variant_get/mod.rs
@@ -395,8 +395,8 @@ mod tests {
     use crate::ArrayRef;
     use crate::Canonical;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::Chunked;
     use crate::arrays::ChunkedArray;
     use crate::arrays::ConstantArray;
@@ -539,7 +539,7 @@ mod tests {
         let expr = variant_get(root(), parse_path(path)?, dtype);
         array
             .apply(&expr)?
-            .execute::<ArrayRef>(&mut LEGACY_SESSION.create_execution_ctx())
+            .execute::<ArrayRef>(&mut array_session().create_execution_ctx())
     }
 
     #[test]
@@ -630,7 +630,7 @@ mod tests {
             Some(DType::Primitive(PType::I32, Nullability::NonNullable)),
         );
         let proto = expr.serialize_proto().unwrap();
-        let actual = Expression::from_proto(&proto, &LEGACY_SESSION).unwrap();
+        let actual = Expression::from_proto(&proto, &array_session()).unwrap();
 
         assert_eq!(actual, expr);
     }
@@ -672,7 +672,7 @@ mod tests {
             "$.items[1]",
             Some(DType::Primitive(PType::I32, Nullability::NonNullable)),
         )?;
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         assert_arrays_eq!(
             result,
@@ -706,7 +706,7 @@ mod tests {
             "$.a",
             Some(DType::Primitive(PType::I32, Nullability::NonNullable)),
         )?;
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         assert_arrays_eq!(
             result,
@@ -740,7 +740,7 @@ mod tests {
         )?;
 
         assert!(!result.is::<Chunked>());
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_arrays_eq!(
             result,
             PrimitiveArray::from_option_iter([Some(10i32), Some(20), None]),
@@ -766,7 +766,7 @@ mod tests {
 
         let result = execute_variant_get(array, "$.a", None)?;
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let row0 = result.execute_scalar(0, &mut ctx)?;
         assert_eq!(
             row0.as_variant()
@@ -803,8 +803,8 @@ mod tests {
         let result = execute_variant_get(array, "$.a", None)?;
         let variant = result
             .clone()
-            .execute::<VariantArray>(&mut LEGACY_SESSION.create_execution_ctx())?;
-        let canonical = result.execute::<Canonical>(&mut LEGACY_SESSION.create_execution_ctx())?;
+            .execute::<VariantArray>(&mut array_session().create_execution_ctx())?;
+        let canonical = result.execute::<Canonical>(&mut array_session().create_execution_ctx())?;
         let Canonical::Variant(canonical_variant) = canonical else {
             vortex_bail!("expected Variant canonical array");
         };
@@ -814,7 +814,7 @@ mod tests {
         assert_eq!(variant.core_storage().dtype(), variant.dtype());
         assert_eq!(variant.core_storage().len(), variant.len());
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         for (idx, expected) in [10i32, 20].into_iter().enumerate() {
             let scalar = variant.execute_scalar(idx, &mut ctx)?;
             let actual = scalar
diff --git a/vortex-array/src/scalar_fn/fns/zip/mod.rs b/vortex-array/src/scalar_fn/fns/zip/mod.rs
index 249d8bfcf49..48449bc8428 100644
--- a/vortex-array/src/scalar_fn/fns/zip/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/zip/mod.rs
@@ -276,7 +276,6 @@ mod tests {
     use super::zip_impl;
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
     use crate::array_session;
     use crate::arrays::ConstantArray;
@@ -368,7 +367,7 @@ mod tests {
         let if_false =
             PrimitiveArray::from_option_iter([Some(1), Some(2), Some(3), None]).into_array();
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = zip_impl(&if_true, &if_false, &mask, &mut ctx)?;
         assert_arrays_eq!(
             result,
@@ -387,7 +386,7 @@ mod tests {
             PrimitiveArray::from_option_iter([Some(10), Some(20), Some(30), None]).into_array();
         let if_false = buffer![1i32, 2, 3, 4].into_array();
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = zip_impl(&if_true, &if_false, &mask, &mut ctx)?;
         assert_arrays_eq!(
             result,
@@ -428,7 +427,7 @@ mod tests {
         let mask = Mask::from_indices(len, indices);
         let mask_array = mask.into_array();
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let result = mask_array
             .zip(const1.clone(), const2.clone())?
             .execute::<Columnar>(&mut ctx)?
@@ -488,7 +487,7 @@ mod tests {
         let mask = Mask::from_indices(200, (0..100).filter(|i| i % 3 != 0));
         let mask_array = mask.clone().into_array();
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let zipped = mask_array
             .zip(if_true.clone(), if_false.clone())
             .unwrap()
@@ -497,25 +496,25 @@ mod tests {
         let zipped = zipped.as_opt::<VarBinView>().unwrap();
         assert_eq!(zipped.data_buffers().len(), 2);
 
-        let mut arrow_ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut arrow_ctx = array_session().create_execution_ctx();
         let expected = arrow_zip(
-            LEGACY_SESSION
+            array_session()
                 .arrow()
                 .execute_arrow(mask.into_array(), None, &mut arrow_ctx)
                 .unwrap()
                 .as_boolean(),
-            &LEGACY_SESSION
+            &array_session()
                 .arrow()
                 .execute_arrow(if_true, None, &mut arrow_ctx)
                 .unwrap(),
-            &LEGACY_SESSION
+            &array_session()
                 .arrow()
                 .execute_arrow(if_false, None, &mut arrow_ctx)
                 .unwrap(),
         )
         .unwrap();
 
-        let actual = LEGACY_SESSION
+        let actual = array_session()
             .arrow()
             .execute_arrow(zipped.array().clone(), None, &mut arrow_ctx)
             .unwrap();
diff --git a/vortex-array/src/stats/stats_set.rs b/vortex-array/src/stats/stats_set.rs
index 7613b746a33..6025afed2c6 100644
--- a/vortex-array/src/stats/stats_set.rs
+++ b/vortex-array/src/stats/stats_set.rs
@@ -565,8 +565,8 @@ mod test {
     use itertools::Itertools;
     use smallvec::smallvec;
 
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::DType;
     use crate::dtype::Nullability;
@@ -877,7 +877,7 @@ mod test {
             .collect_vec();
         array
             .statistics()
-            .compute_all(&all_stats, &mut LEGACY_SESSION.create_execution_ctx())
+            .compute_all(&all_stats, &mut array_session().create_execution_ctx())
             .unwrap();
 
         let stats = array.statistics().to_owned();
diff --git a/vortex-array/src/test_harness.rs b/vortex-array/src/test_harness.rs
index dabeb8bdde4..98be3a85ce4 100644
--- a/vortex-array/src/test_harness.rs
+++ b/vortex-array/src/test_harness.rs
@@ -8,8 +8,7 @@ use goldenfile::differs::binary_diff;
 use itertools::Itertools;
 use vortex_error::VortexResult;
 
-use crate::LEGACY_SESSION;
-use crate::VortexSessionExecute;
+use crate::ExecutionCtx;
 use crate::arrays::BoolArray;
 use crate::arrays::bool::BoolArrayExt;
 
@@ -26,12 +25,12 @@ pub fn check_metadata(name: &str, metadata: &[u8]) {
 }
 
 /// Outputs the indices of the true values in a BoolArray
-pub fn to_int_indices(indices_bits: BoolArray) -> VortexResult<Vec<u64>> {
+pub fn to_int_indices(indices_bits: BoolArray, ctx: &mut ExecutionCtx) -> VortexResult<Vec<u64>> {
     let buffer = indices_bits.to_bit_buffer();
-    let mask = indices_bits.as_ref().validity()?.execute_mask(
-        indices_bits.as_ref().len(),
-        &mut LEGACY_SESSION.create_execution_ctx(),
-    )?;
+    let mask = indices_bits
+        .as_ref()
+        .validity()?
+        .execute_mask(indices_bits.as_ref().len(), ctx)?;
     Ok(buffer
         .iter()
         .enumerate()
diff --git a/vortex-array/src/validity.rs b/vortex-array/src/validity.rs
index c45c4cf3094..0911f8ae287 100644
--- a/vortex-array/src/validity.rs
+++ b/vortex-array/src/validity.rs
@@ -645,8 +645,8 @@ mod tests {
 
     use crate::ArrayRef;
     use crate::IntoArray;
-    use crate::LEGACY_SESSION;
     use crate::VortexSessionExecute;
+    use crate::array_session;
     use crate::arrays::PrimitiveArray;
     use crate::dtype::Nullability;
     use crate::validity::BoolArray;
@@ -715,7 +715,7 @@ mod tests {
         let indices =
             PrimitiveArray::new(Buffer::copy_from(positions), Validity::NonNullable).into_array();
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         assert!(
             validity
@@ -729,7 +729,7 @@ mod tests {
     #[test]
     #[should_panic]
     fn out_of_bounds_patch() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         Validity::NonNullable
             .patch(
                 2,
@@ -781,7 +781,7 @@ mod tests {
         #[case] indices: ArrayRef,
         #[case] expected: Validity,
     ) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert!(
             validity
                 .take(&indices)
@@ -828,7 +828,7 @@ mod tests {
         #[case] rhs: Validity,
         #[case] expected: bool,
     ) -> vortex_error::VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(lhs.mask_eq(&rhs, 3, &mut ctx)?, expected);
         Ok(())
     }
diff --git a/vortex-compressor/src/stats/bool.rs b/vortex-compressor/src/stats/bool.rs
index 8825ec8a7f6..fbbc4001b90 100644
--- a/vortex-compressor/src/stats/bool.rs
+++ b/vortex-compressor/src/stats/bool.rs
@@ -92,8 +92,8 @@ impl BoolStats {
 
 #[cfg(test)]
 mod tests {
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::BoolArray;
     use vortex_array::validity::Validity;
     use vortex_buffer::BitBuffer;
@@ -103,7 +103,7 @@ mod tests {
 
     #[test]
     fn test_all_true() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = BoolArray::new(
             BitBuffer::from(vec![true, true, true]),
             Validity::NonNullable,
@@ -118,7 +118,7 @@ mod tests {
 
     #[test]
     fn test_all_false() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = BoolArray::new(
             BitBuffer::from(vec![false, false, false]),
             Validity::NonNullable,
@@ -133,7 +133,7 @@ mod tests {
 
     #[test]
     fn test_mixed() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = BoolArray::new(
             BitBuffer::from(vec![true, false, true]),
             Validity::NonNullable,
@@ -148,7 +148,7 @@ mod tests {
 
     #[test]
     fn test_with_nulls() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = BoolArray::new(
             BitBuffer::from(vec![true, false, true]),
             Validity::from_iter([true, false, true]),
diff --git a/vortex-compressor/src/stats/float.rs b/vortex-compressor/src/stats/float.rs
index d968e8d368f..9d94038af18 100644
--- a/vortex-compressor/src/stats/float.rs
+++ b/vortex-compressor/src/stats/float.rs
@@ -276,8 +276,8 @@ where
 #[cfg(test)]
 mod tests {
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::validity::Validity;
     use vortex_buffer::buffer;
@@ -287,7 +287,7 @@ mod tests {
 
     #[test]
     fn test_float_stats() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let floats = buffer![0.0f32, 1.0f32, 2.0f32].into_array();
         let floats = floats.execute::<PrimitiveArray>(&mut ctx)?;
 
@@ -308,7 +308,7 @@ mod tests {
 
     #[test]
     fn test_float_stats_leading_nulls() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let floats = PrimitiveArray::new(
             buffer![0.0f32, 1.0f32, 2.0f32],
             Validity::from_iter([false, true, true]),
diff --git a/vortex-compressor/src/stats/integer.rs b/vortex-compressor/src/stats/integer.rs
index 64345ac5f06..a399c1060f9 100644
--- a/vortex-compressor/src/stats/integer.rs
+++ b/vortex-compressor/src/stats/integer.rs
@@ -561,8 +561,8 @@ fn inner_loop_naive<T: IntegerPType>(
 mod tests {
     use std::iter;
 
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::validity::Validity;
     use vortex_buffer::BitBuffer;
@@ -575,7 +575,7 @@ mod tests {
 
     #[test]
     fn test_naive_count_distinct_values() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::new(buffer![217u8, 0], Validity::NonNullable);
         let stats = typed_int_stats::<u8>(&array, true, &mut ctx)?;
         assert_eq!(stats.distinct_count().unwrap(), 2);
@@ -584,7 +584,7 @@ mod tests {
 
     #[test]
     fn test_naive_count_distinct_values_nullable() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::new(
             buffer![217u8, 0],
             Validity::from(BitBuffer::from(vec![true, false])),
@@ -596,7 +596,7 @@ mod tests {
 
     #[test]
     fn test_count_distinct_values() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::new((0..128u8).collect::<Buffer<u8>>(), Validity::NonNullable);
         let stats = typed_int_stats::<u8>(&array, true, &mut ctx)?;
         assert_eq!(stats.distinct_count().unwrap(), 128);
@@ -605,7 +605,7 @@ mod tests {
 
     #[test]
     fn test_count_distinct_values_nullable() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = PrimitiveArray::new(
             (0..128u8).collect::<Buffer<u8>>(),
             Validity::from(BitBuffer::from_iter(
@@ -619,7 +619,7 @@ mod tests {
 
     #[test]
     fn test_integer_stats_leading_nulls() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let ints = PrimitiveArray::new(buffer![0, 1, 2], Validity::from_iter([false, true, true]));
 
         let stats = IntegerStats::generate_opts(
diff --git a/vortex-cuda/src/kernel/encodings/alp.rs b/vortex-cuda/src/kernel/encodings/alp.rs
index 5c6f70498a3..d027aa0bbd6 100644
--- a/vortex-cuda/src/kernel/encodings/alp.rs
+++ b/vortex-cuda/src/kernel/encodings/alp.rs
@@ -141,7 +141,7 @@ mod tests {
     use std::f64;
 
     use vortex::array::IntoArray;
-    use vortex::array::LEGACY_SESSION;
+    use vortex::array::array_session;
     use vortex::array::arrays::PrimitiveArray;
     use vortex::array::assert_arrays_eq;
     use vortex::array::patches::Patches;
@@ -169,7 +169,7 @@ mod tests {
     /// Patches must carry `chunk_offsets` — the fused kernel requires them.
     #[crate::test]
     async fn test_cuda_alp_decompression_f32() -> VortexResult<()> {
-        let mut ctx = vortex_array::array_session().create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session())
             .vortex_expect("failed to create execution context");
 
@@ -215,7 +215,7 @@ mod tests {
     /// preserved through the standalone ALP GPU executor.
     #[crate::test]
     async fn test_cuda_alp_nullable_with_patches() -> VortexResult<()> {
-        let mut ctx = vortex_array::array_session().create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session())
             .vortex_expect("failed to create execution context");
 
@@ -236,7 +236,7 @@ mod tests {
         let alp_array = alp_encode(
             prim.as_view(),
             None,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
 
         let gpu_result = alp_array
@@ -256,7 +256,7 @@ mod tests {
     /// elements are actually null.
     #[crate::test]
     async fn test_cuda_alp_all_valid_nullable() -> VortexResult<()> {
-        let mut ctx = vortex_array::array_session().create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session())
             .vortex_expect("failed to create execution context");
 
@@ -267,7 +267,7 @@ mod tests {
         let alp_array = alp_encode(
             values.as_view(),
             None,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
 
         let gpu_result = alp_array
@@ -289,7 +289,7 @@ mod tests {
     /// (zero patches) via the offset math rather than the NULL sentinel.
     #[crate::test]
     async fn test_cuda_alp_multi_chunk_sparse_patches() -> VortexResult<()> {
-        let mut ctx = vortex_array::array_session().create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session())
             .vortex_expect("failed to create execution context");
 
@@ -309,7 +309,7 @@ mod tests {
         let alp_array = alp_encode(
             prim.as_view(),
             None,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         assert!(
             alp_array.patches().is_some(),
@@ -334,7 +334,7 @@ mod tests {
     /// so this guards the fast-path for the (i64, f64) kernel variant.
     #[crate::test]
     async fn test_cuda_alp_f64_multi_chunk_with_patches() -> VortexResult<()> {
-        let mut ctx = vortex_array::array_session().create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session())
             .vortex_expect("failed to create execution context");
 
@@ -352,7 +352,7 @@ mod tests {
         let alp_array = alp_encode(
             prim.as_view(),
             None,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         assert!(
             alp_array.patches().is_some(),
@@ -378,7 +378,7 @@ mod tests {
     /// (existing tests have ≤ 6 patches per chunk).
     #[crate::test]
     async fn test_cuda_alp_dense_patches_single_chunk() -> VortexResult<()> {
-        let mut ctx = vortex_array::array_session().create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session())
             .vortex_expect("failed to create execution context");
 
@@ -425,7 +425,7 @@ mod tests {
     /// loop. Includes a patch in the tail.
     #[crate::test]
     async fn test_cuda_alp_partial_tail_chunk() -> VortexResult<()> {
-        let mut ctx = vortex_array::array_session().create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session())
             .vortex_expect("failed to create execution context");
 
@@ -436,7 +436,7 @@ mod tests {
         let alp_array = alp_encode(
             prim.as_view(),
             None,
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         assert!(
             alp_array.patches().is_some(),
diff --git a/vortex-cuda/src/kernel/encodings/for_.rs b/vortex-cuda/src/kernel/encodings/for_.rs
index 424b358c937..6348f8479b7 100644
--- a/vortex-cuda/src/kernel/encodings/for_.rs
+++ b/vortex-cuda/src/kernel/encodings/for_.rs
@@ -138,8 +138,8 @@ mod tests {
     use vortex::encodings::fastlanes::FoRArray;
     use vortex::error::VortexExpect;
     use vortex::scalar::Scalar;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
 
     use super::*;
     use crate::CanonicalCudaExt;
@@ -160,7 +160,7 @@ mod tests {
     #[case::u64(make_for_array((0..2050).map(|i| (i % 2050) as u64).collect(), 1000000u64))]
     #[crate::test]
     async fn test_cuda_for_decompression(#[case] for_array: FoRArray) -> VortexResult<()> {
-        let mut ctx = vortex_array::array_session().create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session())
             .vortex_expect("failed to create execution context");
 
@@ -179,7 +179,7 @@ mod tests {
 
     #[crate::test]
     async fn test_signed_ffor() {
-        let mut ctx = vortex_array::array_session().create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session())
             .vortex_expect("failed to create execution context");
 
@@ -188,7 +188,7 @@ mod tests {
             .take(1024)
             .collect::<Buffer<_>>()
             .into_array();
-        let packed = BitPacked::encode(&values, 3, &mut LEGACY_SESSION.create_execution_ctx())
+        let packed = BitPacked::encode(&values, 3, &mut array_session().create_execution_ctx())
             .unwrap()
             .into_array();
         let for_array = FoR::try_new(packed, (-8i8).into()).unwrap();
diff --git a/vortex-cuda/src/kernel/patches/mod.rs b/vortex-cuda/src/kernel/patches/mod.rs
index 4408a3003f2..bd6d2b737db 100644
--- a/vortex-cuda/src/kernel/patches/mod.rs
+++ b/vortex-cuda/src/kernel/patches/mod.rs
@@ -175,8 +175,8 @@ mod tests {
     use cudarc::driver::DeviceRepr;
     use vortex::array::ExecutionCtx;
     use vortex::array::IntoArray;
-    use vortex::array::LEGACY_SESSION;
     use vortex::array::VortexSessionExecute;
+    use vortex::array::array_session;
     use vortex::array::arrays::PrimitiveArray;
     use vortex::array::arrays::primitive::PrimitiveDataParts;
     use vortex::array::assert_arrays_eq;
@@ -217,7 +217,7 @@ mod tests {
 
     async fn full_test_case<Values: NativePType + DeviceRepr, Indices: NativePType + DeviceRepr>() {
         let mut cuda_ctx = CudaSession::create_execution_ctx(&crate::cuda_session()).unwrap();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         let values = PrimitiveArray::from_iter(0..128);
         let values = force_cast::<Values>(values, &mut ctx);
diff --git a/vortex-duckdb/src/convert/vector.rs b/vortex-duckdb/src/convert/vector.rs
index 5ee6b1e2541..1d12dab9dbe 100644
--- a/vortex-duckdb/src/convert/vector.rs
+++ b/vortex-duckdb/src/convert/vector.rs
@@ -392,7 +392,6 @@ mod tests {
     use std::ffi::CString;
 
     use geo_types::point;
-    use vortex::array::LEGACY_SESSION;
     use vortex::array::VortexSessionExecute;
     use vortex::array::arrays::BoolArray;
     use vortex::array::arrays::Extension;
@@ -438,7 +437,7 @@ mod tests {
 
     #[test]
     fn test_timestamp_vector_conversion() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let values = vec![1_703_980_800_000_000_i64, 0i64, -86_400_000_000_i64]; // microseconds
         let len = values.len();
 
@@ -466,7 +465,7 @@ mod tests {
 
     #[test]
     fn test_timestamp_seconds_vector_conversion() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let values = vec![1_703_980_800_i64, 0i64, -86_400_i64]; // seconds
         let len = values.len();
 
@@ -494,7 +493,7 @@ mod tests {
 
     #[test]
     fn test_timestamp_milliseconds_vector_conversion() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let values = vec![1_703_980_800_000_i64, 0i64, -86_400_000_i64]; // milliseconds
         let len = values.len();
 
@@ -522,7 +521,7 @@ mod tests {
 
     #[test]
     fn test_timestamp_with_nulls_conversion() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let values = vec![1_703_980_800_000_000_i64, 0i64, -86_400_000_000_i64];
         let len = values.len();
 
@@ -586,7 +585,7 @@ mod tests {
         // Test conversion
         let result = flat_vector_to_vortex(&vector, len).unwrap();
         let vortex_array = TemporalArray::try_from(result).unwrap();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let vortex_values = vortex_array
             .temporal_values()
             .clone()
@@ -599,7 +598,7 @@ mod tests {
 
     #[test]
     fn test_timestamp_single_value() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let values = vec![1_703_980_800_000_000_i64]; // Single microsecond timestamp
         let len = values.len();
 
@@ -627,7 +626,7 @@ mod tests {
 
     #[test]
     fn test_boolean_vector_conversion() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let values = vec![true, false, true, false];
         let len = values.len();
 
@@ -649,7 +648,7 @@ mod tests {
 
     #[test]
     fn test_vector_with_nulls() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let values = vec![1i32, 2, 3];
         let len = values.len();
 
@@ -708,7 +707,7 @@ mod tests {
 
         // Test conversion
         let result = flat_vector_to_vortex(&vector, len).unwrap();
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let vortex_array = result.execute::<ListViewArray>(&mut ctx).unwrap();
 
         assert_eq!(vortex_array.len(), len);
@@ -721,7 +720,7 @@ mod tests {
 
     #[test]
     fn test_fixed_sized_list() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let values = vec![1i32, 2, 3, 4];
         let len = 1;
 
@@ -751,7 +750,7 @@ mod tests {
 
     #[test]
     fn test_empty_struct() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let len = 4;
         let logical_type = LogicalType::struct_type([], [])
             .vortex_expect("LogicalTypeRef creation should succeed for test data");
@@ -767,7 +766,7 @@ mod tests {
 
     #[test]
     fn test_struct() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let values1 = vec![1i32, 2, 3, 4];
         let values2 = vec![5i32, 6, 7, 8];
         let len = values1.len();
@@ -813,7 +812,7 @@ mod tests {
 
     #[test]
     fn test_list_with_trailing_null() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // Regression test: when the last list entry is null, its offset/length may be 0/0,
         // so we can't use the last entry to compute child vector length.
         let child_values = vec![1i32, 2, 3, 4];
@@ -868,7 +867,7 @@ mod tests {
 
     #[test]
     fn test_list_out_of_order() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // Regression test: list views can be out of order in DuckDB. The child vector length
         // must be computed as the maximum end offset, not just the last entry's end offset.
         let child_values = vec![1i32, 2, 3, 4];
@@ -916,7 +915,7 @@ mod tests {
 
     #[test]
     fn test_list_null_garbage_data() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         // Test that null list entries with garbage offset/size values don't cause issues.
         // DuckDB doesn't guarantee valid offset/size for null list views, so we must check
         // validity before reading the offset/size values.
@@ -1000,7 +999,7 @@ mod tests {
 
     #[test]
     fn test_geometry_vector_conversion() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         let mut wkb_a: Vec<u8> = Vec::new();
         write_point(
diff --git a/vortex-duckdb/src/duckdb/vector.rs b/vortex-duckdb/src/duckdb/vector.rs
index 3f0330657ae..697ce52da50 100644
--- a/vortex-duckdb/src/duckdb/vector.rs
+++ b/vortex-duckdb/src/duckdb/vector.rs
@@ -400,7 +400,7 @@ impl ValidityRef<'_> {
 
 #[cfg(test)]
 mod tests {
-    use vortex::array::LEGACY_SESSION;
+    use vortex::array::array_session;
     use vortex::mask::Mask;
     use vortex_array::VortexSessionExecute;
 
@@ -437,7 +437,7 @@ mod tests {
         let validity = validity.to_validity();
         assert_eq!(validity.maybe_len(), Some(len));
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         assert_eq!(
             validity.execute_mask(len, &mut ctx).unwrap(),
             Mask::from_indices(len, vec![0, 2, 4, 5, 6, 8, 9])
@@ -457,7 +457,7 @@ mod tests {
         let validity = validity.to_validity();
         assert!(
             validity
-                .execute_is_null(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_null(0, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
     }
@@ -474,7 +474,7 @@ mod tests {
         let validity = validity.to_validity();
         assert!(
             validity
-                .execute_is_valid(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_is_valid(0, &mut array_session().create_execution_ctx())
                 .unwrap()
         );
     }
diff --git a/vortex-duckdb/src/e2e_test/vortex_scan_test.rs b/vortex-duckdb/src/e2e_test/vortex_scan_test.rs
index 99bab3f71ce..bf757acff63 100644
--- a/vortex-duckdb/src/e2e_test/vortex_scan_test.rs
+++ b/vortex-duckdb/src/e2e_test/vortex_scan_test.rs
@@ -19,8 +19,8 @@ use jiff::tz::TimeZone;
 use num_traits::AsPrimitive;
 use tempfile::NamedTempFile;
 use vortex::array::IntoArray;
-use vortex::array::LEGACY_SESSION;
 use vortex::array::VortexSessionExecute;
+use vortex::array::array_session;
 use vortex::array::arrays::BoolArray;
 use vortex::array::arrays::ConstantArray;
 use vortex::array::arrays::DictArray;
@@ -778,7 +778,7 @@ async fn write_vortex_file_with_encodings() -> NamedTempFile {
     // 4. Run-End
     let run_ends = buffer![3u32, 5];
     let run_values = buffer![100i32, 200];
-    let mut rle_ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut rle_ctx = array_session().create_execution_ctx();
     let rle_array =
         RunEnd::try_new(run_ends.into_array(), run_values.into_array(), &mut rle_ctx).unwrap();
 
diff --git a/vortex-duckdb/src/exporter/decimal.rs b/vortex-duckdb/src/exporter/decimal.rs
index b0683190b3a..361f4477474 100644
--- a/vortex-duckdb/src/exporter/decimal.rs
+++ b/vortex-duckdb/src/exporter/decimal.rs
@@ -134,8 +134,8 @@ pub fn precision_to_duckdb_storage_size(decimal_dtype: &DecimalDType) -> VortexR
 
 #[cfg(test)]
 mod tests {
-    use vortex::array::LEGACY_SESSION;
     use vortex::array::VortexSessionExecute;
+    use vortex::array::array_session;
     use vortex::array::arrays::DecimalArray;
     use vortex::dtype::DecimalDType;
     use vortex::error::VortexExpect;
@@ -150,7 +150,7 @@ mod tests {
     ) -> VortexResult<Box<dyn ColumnExporter>> {
         let validity = array.as_ref().validity()?.execute_mask(
             array.as_ref().len(),
-            &mut LEGACY_SESSION.create_execution_ctx(),
+            &mut array_session().create_execution_ctx(),
         )?;
         let dest_values_type = precision_to_duckdb_storage_size(&array.decimal_dtype())?;
 
diff --git a/vortex-ffi/src/array.rs b/vortex-ffi/src/array.rs
index eacad4edb1e..a87178446de 100644
--- a/vortex-ffi/src/array.rs
+++ b/vortex-ffi/src/array.rs
@@ -496,8 +496,8 @@ mod tests {
     use std::ptr;
 
     use vortex::array::IntoArray;
-    use vortex::array::LEGACY_SESSION;
     use vortex::array::VortexSessionExecute;
+    use vortex::array::array_session;
     use vortex::array::arrays::BoolArray;
     use vortex::array::arrays::PrimitiveArray;
     use vortex::array::arrays::StructArray;
@@ -827,7 +827,7 @@ mod tests {
             assert!(!res.is_null());
             {
                 let res = vx_array::as_ref(res);
-                let mut ctx = LEGACY_SESSION.create_execution_ctx();
+                let mut ctx = array_session().create_execution_ctx();
                 let bool_array = res.clone().execute::<BoolArray>(&mut ctx).unwrap();
                 let buffer = bool_array.to_bit_buffer();
                 let expected = BoolArray::from_iter(vec![false, false, true, true]);
diff --git a/vortex-ffi/src/expression.rs b/vortex-ffi/src/expression.rs
index 10fecc4ad8e..269e1e5d941 100644
--- a/vortex-ffi/src/expression.rs
+++ b/vortex-ffi/src/expression.rs
@@ -336,8 +336,8 @@ mod tests {
     use std::sync::Arc;
 
     use vortex::array::IntoArray;
-    use vortex::array::LEGACY_SESSION;
     use vortex::array::VortexSessionExecute;
+    use vortex::array::array_session;
     use vortex::array::arrays::BoolArray;
     use vortex::array::arrays::ListArray;
     use vortex::array::arrays::PrimitiveArray;
@@ -393,7 +393,7 @@ mod tests {
     #[test]
     #[cfg_attr(miri, ignore)]
     fn test_get_item() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let (array, names_array, ages_array) = struct_array();
         unsafe {
             let root = vx_expression_root();
@@ -444,7 +444,7 @@ mod tests {
     #[test]
     #[cfg_attr(miri, ignore)]
     fn test_literal() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array =
             PrimitiveArray::new(buffer![1i32, 2i32, 3i32], Validity::NonNullable).into_array();
 
@@ -528,7 +528,7 @@ mod tests {
     #[test]
     #[cfg_attr(miri, ignore)]
     fn test_and_or() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let col1 = BoolArray::from_iter([true, false, true, true]);
         let col2 = BoolArray::from_iter([false, true, true, false]);
         let col3 = BoolArray::from_iter([false, true, true, true]);
@@ -620,7 +620,7 @@ mod tests {
     #[test]
     #[cfg_attr(miri, ignore)]
     fn test_list_contains() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let elements = buffer![1i32, 2, 3, 4, 5].into_array();
         let offsets = buffer![0u32, 2, 5, 5].into_array();
         let array = ListArray::try_new(elements, offsets, Validity::NonNullable).unwrap();
diff --git a/vortex-ffi/src/struct_array.rs b/vortex-ffi/src/struct_array.rs
index 99e10c29c34..765864a6176 100644
--- a/vortex-ffi/src/struct_array.rs
+++ b/vortex-ffi/src/struct_array.rs
@@ -132,8 +132,8 @@ mod tests {
     use std::sync::Arc;
 
     use vortex::array::IntoArray;
-    use vortex::array::LEGACY_SESSION;
     use vortex::array::VortexSessionExecute;
+    use vortex::array::array_session;
     use vortex::array::arrays::PrimitiveArray;
     use vortex::array::arrays::StructArray;
     use vortex::array::arrays::VarBinViewArray;
@@ -170,7 +170,7 @@ mod tests {
     #[test]
     #[cfg_attr(miri, ignore)]
     fn test_many() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let names = ["age", "name"];
         let age_field = PrimitiveArray::new(buffer![30u8, 25u8, 35u8], Validity::NonNullable);
         let name_field = VarBinViewArray::from_iter_str(["Alice", "Bob", "Charlie"]);
diff --git a/vortex-layout/src/layouts/file_stats.rs b/vortex-layout/src/layouts/file_stats.rs
index 4ae95de1a7d..983f9e59a58 100644
--- a/vortex-layout/src/layouts/file_stats.rs
+++ b/vortex-layout/src/layouts/file_stats.rs
@@ -498,6 +498,7 @@ impl FileStatsAccumulator {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_array::array_session;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::bool::BoolArrayExt;
     use vortex_array::builders::VarBinViewBuilder;
@@ -510,7 +511,7 @@ mod tests {
     #[case(DType::Utf8(Nullability::NonNullable))]
     #[case(DType::Binary(Nullability::NonNullable))]
     fn truncates_accumulated_stats(#[case] dtype: DType) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let mut builder = VarBinViewBuilder::with_capacity(dtype.clone(), 2);
         builder.append_value("Value to be truncated");
         builder.append_value("untruncated");
@@ -555,7 +556,7 @@ mod tests {
 
     #[test]
     fn always_adds_is_truncated_column() {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let array = buffer![0, 1, 2].into_array();
         let mut acc = StatsAccumulator::new(array.dtype(), &[Stat::Max, Stat::Min, Stat::Sum], 12);
         acc.push_chunk(&array, &mut ctx)
diff --git a/vortex-layout/src/layouts/flat/writer.rs b/vortex-layout/src/layouts/flat/writer.rs
index f390555a4e7..2f2415617b3 100644
--- a/vortex-layout/src/layouts/flat/writer.rs
+++ b/vortex-layout/src/layouts/flat/writer.rs
@@ -199,9 +199,9 @@ mod tests {
     use vortex_array::ArrayContext;
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::MaskFuture;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::Dict;
     use vortex_array::arrays::DictArray;
@@ -342,7 +342,7 @@ mod tests {
     #[test]
     fn struct_array_round_trip() {
         block_on(|handle| async {
-            let mut ctx_exec = LEGACY_SESSION.create_execution_ctx();
+            let mut ctx_exec = array_session().create_execution_ctx();
             let session = SESSION.clone().with_handle(handle);
             let mut validity_builder = BitBufferMut::with_capacity(2);
             validity_builder.append(true);
diff --git a/vortex-layout/src/layouts/repartition.rs b/vortex-layout/src/layouts/repartition.rs
index cba2046ebe8..89a1317d240 100644
--- a/vortex-layout/src/layouts/repartition.rs
+++ b/vortex-layout/src/layouts/repartition.rs
@@ -276,8 +276,8 @@ mod tests {
 
     use vortex_array::ArrayContext;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::ConstantArray;
     use vortex_array::arrays::FixedSizeListArray;
     use vortex_array::arrays::PrimitiveArray;
@@ -490,7 +490,7 @@ mod tests {
     /// `pop_front` subtracted the larger Cached-era values.
     #[test]
     fn chunks_buffer_pop_front_no_panic_after_shared_execution() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let n = 20_000usize;
         let block_len = 10_000usize;
 
diff --git a/vortex-layout/src/layouts/struct_/reader.rs b/vortex-layout/src/layouts/struct_/reader.rs
index f44c9178413..ab03a4624fa 100644
--- a/vortex-layout/src/layouts/struct_/reader.rs
+++ b/vortex-layout/src/layouts/struct_/reader.rs
@@ -394,9 +394,9 @@ mod tests {
     use rstest::rstest;
     use vortex_array::ArrayContext;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::MaskFuture;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::BoolArray;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::StructArray;
@@ -677,7 +677,7 @@ mod tests {
     fn test_struct_layout_select(
         #[from(struct_layout)] (segments, layout): (Arc<dyn SegmentSource>, LayoutRef),
     ) {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let reader = layout
             .new_reader("".into(), segments, &SESSION, &Default::default())
             .unwrap();
@@ -740,7 +740,7 @@ mod tests {
         // ...and the result is masked with the validity of the parent StructArray
         assert_eq!(
             result
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap(),
             Scalar::null(result.dtype().clone()),
         );
@@ -785,7 +785,7 @@ mod tests {
         // Row 0: struct is valid, field "c" is 4.
         assert_eq!(
             result
-                .execute_scalar(0, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(0, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .as_struct()
                 .field_by_idx(0)
@@ -796,7 +796,7 @@ mod tests {
         // Row 1: struct is null (because root.a.b was null at this row).
         assert!(
             result
-                .execute_scalar(1, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(1, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .as_struct()
                 .is_null()
@@ -805,7 +805,7 @@ mod tests {
         // Row 2: struct is valid, field "c" is 6.
         assert_eq!(
             result
-                .execute_scalar(2, &mut LEGACY_SESSION.create_execution_ctx())
+                .execute_scalar(2, &mut array_session().create_execution_ctx())
                 .unwrap()
                 .as_struct()
                 .field_by_idx(0)
diff --git a/vortex-layout/src/scan/scan_builder.rs b/vortex-layout/src/scan/scan_builder.rs
index d916003fc78..65bc494a7fc 100644
--- a/vortex-layout/src/scan/scan_builder.rs
+++ b/vortex-layout/src/scan/scan_builder.rs
@@ -440,9 +440,9 @@ mod test {
     use futures::task::noop_waker_ref;
     use parking_lot::Mutex;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::MaskFuture;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::FieldMask;
@@ -703,7 +703,7 @@ mod test {
 
     #[test]
     fn into_stream_executes_after_prepare() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let calls = Arc::new(AtomicUsize::new(0));
         let reader = Arc::new(SplittingLayoutReader::new(Arc::clone(&calls)));
 
@@ -847,7 +847,7 @@ mod test {
 
     #[test]
     fn into_stream_with_row_range() -> VortexResult<()> {
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
         let calls = Arc::new(AtomicUsize::new(0));
         let reader = Arc::new(SplittingLayoutReader::new(Arc::clone(&calls)));
 
diff --git a/vortex-row/src/tests.rs b/vortex-row/src/tests.rs
index 5c85c911154..c7f9e8a2b49 100644
--- a/vortex-row/src/tests.rs
+++ b/vortex-row/src/tests.rs
@@ -7,8 +7,8 @@ use std::f64::consts::PI;
 
 use rstest::rstest;
 use vortex_array::IntoArray;
-use vortex_array::LEGACY_SESSION;
 use vortex_array::VortexSessionExecute;
+use vortex_array::array_session;
 use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::ExtensionArray;
 use vortex_array::arrays::ListViewArray;
@@ -29,7 +29,7 @@ use crate::convert_columns;
 use crate::convert_columns_with_options;
 
 fn collect_row_bytes(array: &ListViewArray) -> Vec<Vec<u8>> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let nrows = array.len();
     (0..nrows)
         .map(|i| {
@@ -43,7 +43,7 @@ fn collect_row_bytes(array: &ListViewArray) -> Vec<Vec<u8>> {
 /// Encode each column independently, sort the resulting row bytes, and check the permutation
 /// matches the natural sort order of `values`.
 fn assert_sort_order_i64(values: Vec<i64>, descending: bool) -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let col = PrimitiveArray::from_iter(values.clone()).into_array();
     let field = RowSortField::new(descending, true);
     let encoded = convert_columns(&[col], &[field], &mut ctx)?;
@@ -77,7 +77,7 @@ fn primitive_i64_roundtrip(#[case] descending: bool) -> VortexResult<()> {
 
 #[test]
 fn primitive_u32_sort_order() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let values: Vec<u32> = vec![0, 1, 100, u32::MAX, 42, 17];
     let col = PrimitiveArray::from_iter(values.clone()).into_array();
     let encoded = convert_columns(&[col], &[RowSortField::default()], &mut ctx)?;
@@ -95,7 +95,7 @@ fn primitive_u32_sort_order() -> VortexResult<()> {
 
 #[test]
 fn reject_temporal_extension_dtype_early() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let storage = PrimitiveArray::from_iter([2i32, -1, 0, 7]).into_array();
     let ext_dtype = Date::new(TimeUnit::Days, Nullability::NonNullable).erased();
     let col = ExtensionArray::new(ext_dtype, storage).into_array();
@@ -111,7 +111,7 @@ fn reject_temporal_extension_dtype_early() -> VortexResult<()> {
 
 #[test]
 fn reject_nested_temporal_extension_dtype_early() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let storage = PrimitiveArray::from_iter([2i32, -1, 0, 7]).into_array();
     let ext_dtype = Date::new(TimeUnit::Days, Nullability::NonNullable).erased();
     let date_col = ExtensionArray::new(ext_dtype, storage).into_array();
@@ -130,7 +130,7 @@ fn reject_nested_temporal_extension_dtype_early() -> VortexResult<()> {
 
 #[test]
 fn primitive_f64_sort_order() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     // We use IEEE total-ordering semantics: -0.0 < +0.0 in the byte encoding (matches
     // `arrow-row`). Avoid -0.0 in the natural-order baseline since partial_cmp says
     // -0.0 == 0.0.
@@ -151,7 +151,7 @@ fn primitive_f64_sort_order() -> VortexResult<()> {
 
 #[test]
 fn bool_sort_order() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let col = BoolArray::from_iter([true, false, true, false]).into_array();
     let encoded = convert_columns(&[col], &[RowSortField::default()], &mut ctx)?;
     let rows = collect_row_bytes(&encoded);
@@ -168,7 +168,7 @@ fn bool_sort_order() -> VortexResult<()> {
 
 #[test]
 fn utf8_sort_order() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let values = vec![
         "banana",
         "apple",
@@ -193,7 +193,7 @@ fn utf8_sort_order() -> VortexResult<()> {
 
 #[test]
 fn multi_column_sort() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let ints: Vec<i32> = vec![1, 2, 1, 2, 1, 3];
     let strs = vec!["b", "a", "a", "b", "c", "z"];
     let col0 = PrimitiveArray::from_iter(ints.clone()).into_array();
@@ -216,7 +216,7 @@ fn multi_column_sort() -> VortexResult<()> {
 
 #[test]
 fn nulls_first_and_last() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let values: Vec<Option<i32>> = vec![Some(5), None, Some(1), None, Some(3)];
     let col = PrimitiveArray::from_option_iter(values.clone()).into_array();
 
@@ -250,7 +250,7 @@ fn nulls_first_and_last() -> VortexResult<()> {
 
 #[test]
 fn reusable_options_helpers() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let options = RowEncodingOptions::new([RowSortField::descending().nulls_last()]);
     assert_eq!(options.len(), 1);
     assert!(!options.is_empty());
@@ -282,7 +282,7 @@ fn reusable_options_helpers() -> VortexResult<()> {
 
 #[test]
 fn row_encoder_new_accepts_sort_fields() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let encoder = RowEncoder::new([RowSortField::ascending()]);
     let col = PrimitiveArray::from_iter([1i32, 2, 3]).into_array();
 
@@ -293,7 +293,7 @@ fn row_encoder_new_accepts_sort_fields() -> VortexResult<()> {
 
 #[test]
 fn default_row_encoder_uses_default_fields() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let col0 = PrimitiveArray::from_iter([1i32, 2, 3]).into_array();
     let col1 = PrimitiveArray::from_iter([4i32, 5, 6]).into_array();
 
@@ -305,7 +305,7 @@ fn default_row_encoder_uses_default_fields() -> VortexResult<()> {
 #[test]
 fn struct_sort_order() -> VortexResult<()> {
     use vortex_array::arrays::StructArray;
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let ids: Vec<i64> = vec![3, 1, 3, 1, 2];
     let names = vec!["b", "a", "a", "b", "z"];
     let id_arr = PrimitiveArray::from_iter(ids.clone()).into_array();
@@ -332,7 +332,7 @@ fn row_size_struct_shape() -> VortexResult<()> {
 
     use crate::compute_row_sizes;
 
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let ints: Vec<i32> = vec![1, 2, 3, 4, 5];
     let strs = vec!["a", "bb", "ccc", "", "eeeee"];
     let col0 = PrimitiveArray::from_iter(ints).into_array();
@@ -372,7 +372,7 @@ fn row_size_struct_shape() -> VortexResult<()> {
 
 #[test]
 fn single_buffer_invariant() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     // Encoded rows here are all > 12 bytes, forcing the Ref-view path that points back into
     // the shared data buffer.
     let nrows = 64usize;
@@ -411,7 +411,7 @@ fn single_buffer_invariant() -> VortexResult<()> {
 /// boundaries always align.
 #[test]
 fn multi_column_varlen_empty_vs_nul_byte_string() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     // col1: empty vs single 0-byte. col2: same int for all rows.
     let col1 = VarBinViewArray::from_iter_str(["", "\0", "a", "ab"]).into_array();
     let col2 = PrimitiveArray::from_iter([1i32, 1, 1, 1]).into_array();
@@ -442,7 +442,7 @@ fn multi_column_varlen_empty_vs_nul_byte_string() -> VortexResult<()> {
 /// the 3-sentinel scheme null=0x00, empty=0x01 differ at byte 0.
 #[test]
 fn multi_column_varlen_null_vs_empty() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let col1 = VarBinViewArray::from_iter_nullable_str([
         None::<&str>,
         Some(""),
@@ -505,7 +505,7 @@ fn multi_column_varlen_null_vs_empty() -> VortexResult<()> {
 /// non-empty's first byte is smaller than empty's first byte.
 #[test]
 fn varlen_descending_empty_vs_non_empty() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let col = VarBinViewArray::from_iter_str(["a", "", "abc"]).into_array();
     let encoded = convert_columns(&[col], &[RowSortField::descending()], &mut ctx)?;
     let rows = collect_row_bytes(&encoded);
@@ -531,7 +531,7 @@ fn null_struct_rows_with_varying_child_lengths_are_byte_equal() -> VortexResult<
     use vortex_array::validity::Validity;
     use vortex_buffer::BitBuffer;
 
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     // Build a nullable struct{name: utf8} where rows 0 and 2 are null but the underlying
     // child has different length data ("short" vs "much longer text data").
     let names =
@@ -556,7 +556,7 @@ fn null_struct_rows_with_varying_child_lengths_are_byte_equal() -> VortexResult<
 
 #[test]
 fn primitive_f32_sort_order() -> VortexResult<()> {
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let values: Vec<f32> = vec![-1.5, 0.0, 1.5, f32::INFINITY, f32::NEG_INFINITY];
     let col = PrimitiveArray::from_iter(values.clone()).into_array();
     let encoded = convert_columns(&[col], &[RowSortField::default()], &mut ctx)?;
@@ -573,7 +573,7 @@ fn primitive_f32_sort_order() -> VortexResult<()> {
 #[test]
 fn primitive_f16_sort_order() -> VortexResult<()> {
     use vortex_array::dtype::half::f16;
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let values: Vec<f16> = vec![
         f16::from_f32(-1.5),
         f16::from_f32(0.0),
@@ -600,7 +600,7 @@ fn reject_list_dtype_early() {
     use vortex_array::validity::Validity;
     use vortex_buffer::buffer;
 
-    let mut ctx = LEGACY_SESSION.create_execution_ctx();
+    let mut ctx = array_session().create_execution_ctx();
     let offsets = PrimitiveArray::new(buffer![0u32, 1, 2], Validity::NonNullable).into_array();
     let elements = PrimitiveArray::from_iter([10i32, 20]).into_array();
     let list: ArrayRef = ListArray::try_new(elements, offsets, Validity::NonNullable)
diff --git a/vortex/src/lib.rs b/vortex/src/lib.rs
index ff6bcd39572..34d15c74e94 100644
--- a/vortex/src/lib.rs
+++ b/vortex/src/lib.rs
@@ -197,8 +197,8 @@ mod test {
 
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::array_session;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::StructArray;
     use vortex_array::dtype::FieldNames;
@@ -348,7 +348,7 @@ mod test {
 
         assert_eq!(recovered_array.len(), array.len());
 
-        let mut ctx = LEGACY_SESSION.create_execution_ctx();
+        let mut ctx = array_session().create_execution_ctx();
 
         let recovered_primitive = recovered_array.execute::<PrimitiveArray>(&mut ctx)?;
         assert!(recovered_primitive.validity()?.mask_eq(