diff --git a/encodings/alp/public-api.lock b/encodings/alp/public-api.lock
index 55e908346d9..847521ab0b4 100644
--- a/encodings/alp/public-api.lock
+++ b/encodings/alp/public-api.lock
@@ -8,6 +8,10 @@ impl vortex_alp::ALP
 
 pub const vortex_alp::ALP::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_alp::ALP
+
+pub fn vortex_alp::ALP::clone(&self) -> vortex_alp::ALP
+
 impl core::fmt::Debug for vortex_alp::ALP
 
 pub fn vortex_alp::ALP::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -72,7 +76,7 @@ pub fn vortex_alp::ALP::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::
 
 pub fn vortex_alp::ALP::dtype(array: &vortex_alp::ALPArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_alp::ALP::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_alp::ALP::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_alp::ALP::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
 
@@ -178,6 +182,10 @@ impl vortex_alp::ALPRD
 
 pub const vortex_alp::ALPRD::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_alp::ALPRD
+
+pub fn vortex_alp::ALPRD::clone(&self) -> vortex_alp::ALPRD
+
 impl core::fmt::Debug for vortex_alp::ALPRD
 
 pub fn vortex_alp::ALPRD::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -230,7 +238,7 @@ pub fn vortex_alp::ALPRD::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype
 
 pub fn vortex_alp::ALPRD::dtype(array: &vortex_alp::ALPRDArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_alp::ALPRD::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_alp::ALPRD::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_alp::ALPRD::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
 
diff --git a/encodings/alp/src/alp/array.rs b/encodings/alp/src/alp/array.rs
index 5343ad15450..086b699bf54 100644
--- a/encodings/alp/src/alp/array.rs
+++ b/encodings/alp/src/alp/array.rs
@@ -3,6 +3,7 @@
 
 use std::fmt::Debug;
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
@@ -10,7 +11,7 @@ use vortex_array::ArrayRef;
 use vortex_array::DeserializeMetadata;
 use vortex_array::DynArray;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::ProstMetadata;
@@ -239,10 +240,10 @@ impl VTable for ALP {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        // TODO(joe): take by value
-        Ok(ExecutionStep::Done(
-            execute_decompress(array.clone(), ctx)?.into_array(),
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        let array = Arc::try_unwrap(array).unwrap_or_else(|arc| (*arc).clone());
+        Ok(ExecutionResult::done(
+            execute_decompress(array, ctx)?.into_array(),
         ))
     }
 
@@ -273,7 +274,7 @@ pub struct ALPArray {
     stats_set: ArrayStats,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct ALP;
 
 impl ALP {
diff --git a/encodings/alp/src/alp_rd/array.rs b/encodings/alp/src/alp_rd/array.rs
index cab37cad4a2..af8bd1b6ade 100644
--- a/encodings/alp/src/alp_rd/array.rs
+++ b/encodings/alp/src/alp_rd/array.rs
@@ -3,6 +3,7 @@
 
 use std::fmt::Debug;
 use std::hash::Hash;
+use std::sync::Arc;
 
 use itertools::Itertools;
 use vortex_array::ArrayEq;
@@ -11,7 +12,7 @@ use vortex_array::ArrayRef;
 use vortex_array::DeserializeMetadata;
 use vortex_array::DynArray;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::ProstMetadata;
@@ -300,7 +301,7 @@ impl VTable for ALPRD {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
         let left_parts = array.left_parts().clone().execute::<PrimitiveArray>(ctx)?;
         let right_parts = array.right_parts().clone().execute::<PrimitiveArray>(ctx)?;
 
@@ -339,7 +340,7 @@ impl VTable for ALPRD {
             )
         };
 
-        Ok(ExecutionStep::Done(decoded_array.into_array()))
+        Ok(ExecutionResult::done(decoded_array.into_array()))
     }
 
     fn reduce_parent(
@@ -371,7 +372,7 @@ pub struct ALPRDArray {
     stats_set: ArrayStats,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct ALPRD;
 
 impl ALPRD {
diff --git a/encodings/bytebool/public-api.lock b/encodings/bytebool/public-api.lock
index bb1e1a5e5ef..0471ced549a 100644
--- a/encodings/bytebool/public-api.lock
+++ b/encodings/bytebool/public-api.lock
@@ -6,6 +6,10 @@ impl vortex_bytebool::ByteBool
 
 pub const vortex_bytebool::ByteBool::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_bytebool::ByteBool
+
+pub fn vortex_bytebool::ByteBool::clone(&self) -> vortex_bytebool::ByteBool
+
 impl core::fmt::Debug for vortex_bytebool::ByteBool
 
 pub fn vortex_bytebool::ByteBool::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -54,7 +58,7 @@ pub fn vortex_bytebool::ByteBool::deserialize(_bytes: &[u8], _dtype: &vortex_arr
 
 pub fn vortex_bytebool::ByteBool::dtype(array: &vortex_bytebool::ByteBoolArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_bytebool::ByteBool::execute(array: &Self::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_bytebool::ByteBool::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_bytebool::ByteBool::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
 
diff --git a/encodings/bytebool/src/array.rs b/encodings/bytebool/src/array.rs
index b7cf88b3763..37cedf941b5 100644
--- a/encodings/bytebool/src/array.rs
+++ b/encodings/bytebool/src/array.rs
@@ -3,13 +3,14 @@
 
 use std::fmt::Debug;
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
 use vortex_array::ArrayRef;
 use vortex_array::EmptyMetadata;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::arrays::BoolArray;
@@ -187,10 +188,10 @@ impl VTable for ByteBool {
         crate::rules::RULES.evaluate(array, parent, child_idx)
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
         let boolean_buffer = BitBuffer::from(array.as_slice());
         let validity = array.validity().clone();
-        Ok(ExecutionStep::Done(
+        Ok(ExecutionResult::done(
             BoolArray::new(boolean_buffer, validity).into_array(),
         ))
     }
@@ -213,7 +214,7 @@ pub struct ByteBoolArray {
     stats_set: ArrayStats,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct ByteBool;
 
 impl ByteBool {
diff --git a/encodings/datetime-parts/public-api.lock b/encodings/datetime-parts/public-api.lock
index 7c5f76f597c..362d3e551c6 100644
--- a/encodings/datetime-parts/public-api.lock
+++ b/encodings/datetime-parts/public-api.lock
@@ -6,6 +6,10 @@ impl vortex_datetime_parts::DateTimeParts
 
 pub const vortex_datetime_parts::DateTimeParts::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_datetime_parts::DateTimeParts
+
+pub fn vortex_datetime_parts::DateTimeParts::clone(&self) -> vortex_datetime_parts::DateTimeParts
+
 impl core::fmt::Debug for vortex_datetime_parts::DateTimeParts
 
 pub fn vortex_datetime_parts::DateTimeParts::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -62,7 +66,7 @@ pub fn vortex_datetime_parts::DateTimeParts::deserialize(bytes: &[u8], _dtype: &
 
 pub fn vortex_datetime_parts::DateTimeParts::dtype(array: &vortex_datetime_parts::DateTimePartsArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_datetime_parts::DateTimeParts::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_datetime_parts::DateTimeParts::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_datetime_parts::DateTimeParts::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
 
diff --git a/encodings/datetime-parts/src/array.rs b/encodings/datetime-parts/src/array.rs
index 1cc9f920cad..58750254e9f 100644
--- a/encodings/datetime-parts/src/array.rs
+++ b/encodings/datetime-parts/src/array.rs
@@ -3,6 +3,7 @@
 
 use std::fmt::Debug;
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
@@ -10,7 +11,7 @@ use vortex_array::ArrayRef;
 use vortex_array::DeserializeMetadata;
 use vortex_array::DynArray;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::ProstMetadata;
@@ -226,9 +227,9 @@ impl VTable for DateTimeParts {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(
-            decode_to_temporal(array, ctx)?.into_array(),
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            decode_to_temporal(&array, ctx)?.into_array(),
         ))
     }
 
@@ -267,7 +268,7 @@ pub struct DateTimePartsArrayParts {
     pub subseconds: ArrayRef,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct DateTimeParts;
 
 impl DateTimeParts {
diff --git a/encodings/decimal-byte-parts/public-api.lock b/encodings/decimal-byte-parts/public-api.lock
index 6ce143d358c..b248730cf49 100644
--- a/encodings/decimal-byte-parts/public-api.lock
+++ b/encodings/decimal-byte-parts/public-api.lock
@@ -6,6 +6,10 @@ impl vortex_decimal_byte_parts::DecimalByteParts
 
 pub const vortex_decimal_byte_parts::DecimalByteParts::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_decimal_byte_parts::DecimalByteParts
+
+pub fn vortex_decimal_byte_parts::DecimalByteParts::clone(&self) -> vortex_decimal_byte_parts::DecimalByteParts
+
 impl core::fmt::Debug for vortex_decimal_byte_parts::DecimalByteParts
 
 pub fn vortex_decimal_byte_parts::DecimalByteParts::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -62,7 +66,7 @@ pub fn vortex_decimal_byte_parts::DecimalByteParts::deserialize(bytes: &[u8], _d
 
 pub fn vortex_decimal_byte_parts::DecimalByteParts::dtype(array: &vortex_decimal_byte_parts::DecimalBytePartsArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_decimal_byte_parts::DecimalByteParts::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_decimal_byte_parts::DecimalByteParts::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_decimal_byte_parts::DecimalByteParts::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
 
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 c3a35c4cf97..0d41fe2bb22 100644
--- a/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs
+++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs
@@ -6,6 +6,7 @@ mod rules;
 mod slice;
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use prost::Message as _;
 use vortex_array::ArrayEq;
@@ -13,7 +14,7 @@ use vortex_array::ArrayHash;
 use vortex_array::ArrayRef;
 use vortex_array::DynArray;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::ProstMetadata;
@@ -194,8 +195,8 @@ impl VTable for DecimalByteParts {
         PARENT_RULES.evaluate(array, parent, child_idx)
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        to_canonical_decimal(array, ctx).map(ExecutionStep::Done)
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        to_canonical_decimal(&array, ctx).map(ExecutionResult::done)
     }
 
     fn execute_parent(
@@ -274,7 +275,7 @@ impl DecimalBytePartsArray {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct DecimalByteParts;
 
 impl DecimalByteParts {
diff --git a/encodings/fastlanes/public-api.lock b/encodings/fastlanes/public-api.lock
index 59fc2d85f1b..f9b45d5c213 100644
--- a/encodings/fastlanes/public-api.lock
+++ b/encodings/fastlanes/public-api.lock
@@ -126,6 +126,10 @@ impl vortex_fastlanes::BitPacked
 
 pub const vortex_fastlanes::BitPacked::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_fastlanes::BitPacked
+
+pub fn vortex_fastlanes::BitPacked::clone(&self) -> vortex_fastlanes::BitPacked
+
 impl core::fmt::Debug for vortex_fastlanes::BitPacked
 
 pub fn vortex_fastlanes::BitPacked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -176,7 +180,7 @@ pub fn vortex_fastlanes::BitPacked::deserialize(bytes: &[u8], _dtype: &vortex_ar
 
 pub fn vortex_fastlanes::BitPacked::dtype(array: &vortex_fastlanes::BitPackedArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_fastlanes::BitPacked::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_fastlanes::BitPacked::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_fastlanes::BitPacked::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
 
@@ -286,6 +290,10 @@ impl vortex_fastlanes::Delta
 
 pub const vortex_fastlanes::Delta::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_fastlanes::Delta
+
+pub fn vortex_fastlanes::Delta::clone(&self) -> vortex_fastlanes::Delta
+
 impl core::fmt::Debug for vortex_fastlanes::Delta
 
 pub fn vortex_fastlanes::Delta::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -326,7 +334,7 @@ pub fn vortex_fastlanes::Delta::deserialize(bytes: &[u8], _dtype: &vortex_array:
 
 pub fn vortex_fastlanes::Delta::dtype(array: &vortex_fastlanes::DeltaArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_fastlanes::Delta::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_fastlanes::Delta::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_fastlanes::Delta::id(&self) -> vortex_array::vtable::dyn_::ArrayId
 
@@ -414,6 +422,10 @@ impl vortex_fastlanes::FoR
 
 pub const vortex_fastlanes::FoR::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_fastlanes::FoR
+
+pub fn vortex_fastlanes::FoR::clone(&self) -> vortex_fastlanes::FoR
+
 impl core::fmt::Debug for vortex_fastlanes::FoR
 
 pub fn vortex_fastlanes::FoR::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -466,7 +478,7 @@ pub fn vortex_fastlanes::FoR::deserialize(bytes: &[u8], dtype: &vortex_array::dt
 
 pub fn vortex_fastlanes::FoR::dtype(array: &vortex_fastlanes::FoRArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_fastlanes::FoR::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_fastlanes::FoR::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_fastlanes::FoR::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
 
@@ -550,6 +562,10 @@ impl vortex_fastlanes::RLE
 
 pub const vortex_fastlanes::RLE::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_fastlanes::RLE
+
+pub fn vortex_fastlanes::RLE::clone(&self) -> vortex_fastlanes::RLE
+
 impl core::fmt::Debug for vortex_fastlanes::RLE
 
 pub fn vortex_fastlanes::RLE::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -590,7 +606,7 @@ pub fn vortex_fastlanes::RLE::deserialize(bytes: &[u8], _dtype: &vortex_array::d
 
 pub fn vortex_fastlanes::RLE::dtype(array: &vortex_fastlanes::RLEArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_fastlanes::RLE::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_fastlanes::RLE::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_fastlanes::RLE::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
 
diff --git a/encodings/fastlanes/src/bitpacking/vtable/mod.rs b/encodings/fastlanes/src/bitpacking/vtable/mod.rs
index 25a3e11b959..dd286a4e43d 100644
--- a/encodings/fastlanes/src/bitpacking/vtable/mod.rs
+++ b/encodings/fastlanes/src/bitpacking/vtable/mod.rs
@@ -2,13 +2,14 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
 use vortex_array::ArrayRef;
 use vortex_array::DeserializeMetadata;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::ProstMetadata;
@@ -358,8 +359,10 @@ impl VTable for BitPacked {
         })
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(unpack_array(array, ctx)?.into_array()))
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            unpack_array(&array, ctx)?.into_array(),
+        ))
     }
 
     fn execute_parent(
@@ -372,7 +375,7 @@ impl VTable for BitPacked {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct BitPacked;
 
 impl BitPacked {
diff --git a/encodings/fastlanes/src/delta/vtable/mod.rs b/encodings/fastlanes/src/delta/vtable/mod.rs
index 8f302aac4f9..fc4dc9b9b20 100644
--- a/encodings/fastlanes/src/delta/vtable/mod.rs
+++ b/encodings/fastlanes/src/delta/vtable/mod.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use fastlanes::FastLanes;
 use prost::Message;
@@ -9,7 +10,7 @@ use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
 use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::ProstMetadata;
@@ -193,14 +194,14 @@ impl VTable for Delta {
         DeltaArray::try_new(bases, deltas, metadata.0.offset as usize, len)
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(
-            delta_decompress(array, ctx)?.into_array(),
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            delta_decompress(&array, ctx)?.into_array(),
         ))
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Delta;
 
 impl Delta {
diff --git a/encodings/fastlanes/src/for/vtable/mod.rs b/encodings/fastlanes/src/for/vtable/mod.rs
index 9ebc0dee089..fb40d6d93da 100644
--- a/encodings/fastlanes/src/for/vtable/mod.rs
+++ b/encodings/fastlanes/src/for/vtable/mod.rs
@@ -3,12 +3,13 @@
 
 use std::fmt::Debug;
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
 use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::buffer::BufferHandle;
@@ -170,8 +171,8 @@ impl VTable for FoR {
         PARENT_RULES.evaluate(array, parent, child_idx)
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(decompress(array, ctx)?.into_array()))
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(decompress(&array, ctx)?.into_array()))
     }
 
     fn execute_parent(
@@ -184,7 +185,7 @@ impl VTable for FoR {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct FoR;
 
 impl FoR {
diff --git a/encodings/fastlanes/src/rle/vtable/mod.rs b/encodings/fastlanes/src/rle/vtable/mod.rs
index 5fb9cc0173e..b4f3eaa0c93 100644
--- a/encodings/fastlanes/src/rle/vtable/mod.rs
+++ b/encodings/fastlanes/src/rle/vtable/mod.rs
@@ -2,13 +2,14 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use prost::Message;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
 use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::ProstMetadata;
@@ -235,14 +236,14 @@ impl VTable for RLE {
         PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(
-            rle_decompress(array, ctx)?.into_array(),
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            rle_decompress(&array, ctx)?.into_array(),
         ))
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct RLE;
 
 impl RLE {
diff --git a/encodings/fsst/public-api.lock b/encodings/fsst/public-api.lock
index 8df42025d72..a6c7dbc4cf4 100644
--- a/encodings/fsst/public-api.lock
+++ b/encodings/fsst/public-api.lock
@@ -6,6 +6,10 @@ impl vortex_fsst::FSST
 
 pub const vortex_fsst::FSST::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_fsst::FSST
+
+pub fn vortex_fsst::FSST::clone(&self) -> vortex_fsst::FSST
+
 impl core::fmt::Debug for vortex_fsst::FSST
 
 pub fn vortex_fsst::FSST::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -64,7 +68,7 @@ pub fn vortex_fsst::FSST::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype
 
 pub fn vortex_fsst::FSST::dtype(array: &vortex_fsst::FSSTArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_fsst::FSST::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_fsst::FSST::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_fsst::FSST::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
 
diff --git a/encodings/fsst/src/array.rs b/encodings/fsst/src/array.rs
index f7452ae5a33..c7685665c66 100644
--- a/encodings/fsst/src/array.rs
+++ b/encodings/fsst/src/array.rs
@@ -17,7 +17,7 @@ use vortex_array::Canonical;
 use vortex_array::DeserializeMetadata;
 use vortex_array::DynArray;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::ProstMetadata;
@@ -343,8 +343,8 @@ impl VTable for FSST {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        canonicalize_fsst(array, ctx).map(ExecutionStep::Done)
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        canonicalize_fsst(&array, ctx).map(ExecutionResult::done)
     }
 
     fn execute_parent(
@@ -393,7 +393,7 @@ impl Debug for FSSTArray {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct FSST;
 
 impl FSST {
diff --git a/encodings/pco/public-api.lock b/encodings/pco/public-api.lock
index b67721840bf..10dc3f56b82 100644
--- a/encodings/pco/public-api.lock
+++ b/encodings/pco/public-api.lock
@@ -6,6 +6,10 @@ impl vortex_pco::Pco
 
 pub const vortex_pco::Pco::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_pco::Pco
+
+pub fn vortex_pco::Pco::clone(&self) -> vortex_pco::Pco
+
 impl core::fmt::Debug for vortex_pco::Pco
 
 pub fn vortex_pco::Pco::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -46,7 +50,7 @@ pub fn vortex_pco::Pco::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype::
 
 pub fn vortex_pco::Pco::dtype(array: &vortex_pco::PcoArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_pco::Pco::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_pco::Pco::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_pco::Pco::id(&self) -> vortex_array::vtable::dyn_::ArrayId
 
diff --git a/encodings/pco/src/array.rs b/encodings/pco/src/array.rs
index 36048990944..ad3ef76b60a 100644
--- a/encodings/pco/src/array.rs
+++ b/encodings/pco/src/array.rs
@@ -4,6 +4,7 @@
 use std::cmp;
 use std::fmt::Debug;
 use std::hash::Hash;
+use std::sync::Arc;
 
 use pco::ChunkConfig;
 use pco::PagingSpec;
@@ -20,7 +21,7 @@ use vortex_array::ArrayHash;
 use vortex_array::ArrayRef;
 use vortex_array::DynArray;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::LEGACY_SESSION;
 use vortex_array::Precision;
@@ -269,8 +270,8 @@ impl VTable for Pco {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(array.decompress(ctx)?.into_array()))
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(array.decompress(ctx)?.into_array()))
     }
 
     fn reduce_parent(
@@ -312,7 +313,7 @@ pub(crate) fn vortex_err_from_pco(err: PcoError) -> VortexError {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Pco;
 
 impl Pco {
diff --git a/encodings/runend/public-api.lock b/encodings/runend/public-api.lock
index 946a8dacdee..0bc5f77ab7d 100644
--- a/encodings/runend/public-api.lock
+++ b/encodings/runend/public-api.lock
@@ -22,6 +22,10 @@ impl vortex_runend::RunEnd
 
 pub const vortex_runend::RunEnd::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_runend::RunEnd
+
+pub fn vortex_runend::RunEnd::clone(&self) -> vortex_runend::RunEnd
+
 impl core::fmt::Debug for vortex_runend::RunEnd
 
 pub fn vortex_runend::RunEnd::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -74,7 +78,7 @@ pub fn vortex_runend::RunEnd::deserialize(bytes: &[u8], _dtype: &vortex_array::d
 
 pub fn vortex_runend::RunEnd::dtype(array: &vortex_runend::RunEndArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_runend::RunEnd::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_runend::RunEnd::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_runend::RunEnd::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
 
diff --git a/encodings/runend/src/array.rs b/encodings/runend/src/array.rs
index ecb6a696f3c..58fe7ee5476 100644
--- a/encodings/runend/src/array.rs
+++ b/encodings/runend/src/array.rs
@@ -3,6 +3,7 @@
 
 use std::fmt::Debug;
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
@@ -10,7 +11,7 @@ use vortex_array::ArrayRef;
 use vortex_array::DeserializeMetadata;
 use vortex_array::DynArray;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::ProstMetadata;
@@ -207,8 +208,8 @@ impl VTable for RunEnd {
         PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        run_end_canonicalize(array, ctx).map(ExecutionStep::Done)
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        run_end_canonicalize(&array, ctx).map(ExecutionResult::done)
     }
 }
 
@@ -226,7 +227,7 @@ pub struct RunEndArrayParts {
     pub values: ArrayRef,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct RunEnd;
 
 impl RunEnd {
diff --git a/encodings/sequence/public-api.lock b/encodings/sequence/public-api.lock
index 41e01a8aa18..5b0f17988c0 100644
--- a/encodings/sequence/public-api.lock
+++ b/encodings/sequence/public-api.lock
@@ -6,6 +6,10 @@ impl vortex_sequence::Sequence
 
 pub const vortex_sequence::Sequence::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_sequence::Sequence
+
+pub fn vortex_sequence::Sequence::clone(&self) -> vortex_sequence::Sequence
+
 impl core::fmt::Debug for vortex_sequence::Sequence
 
 pub fn vortex_sequence::Sequence::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -62,7 +66,7 @@ pub fn vortex_sequence::Sequence::deserialize(bytes: &[u8], dtype: &vortex_array
 
 pub fn vortex_sequence::Sequence::dtype(array: &vortex_sequence::SequenceArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_sequence::Sequence::execute(array: &Self::Array, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_sequence::Sequence::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_sequence::Sequence::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
 
diff --git a/encodings/sequence/src/array.rs b/encodings/sequence/src/array.rs
index 7a4dd6078b8..9171f05e6ca 100644
--- a/encodings/sequence/src/array.rs
+++ b/encodings/sequence/src/array.rs
@@ -2,12 +2,13 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use num_traits::cast::FromPrimitive;
 use vortex_array::ArrayRef;
 use vortex_array::DeserializeMetadata;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::Precision;
 use vortex_array::ProstMetadata;
 use vortex_array::SerializeMetadata;
@@ -385,8 +386,8 @@ impl VTable for Sequence {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        sequence_decompress(array).map(ExecutionStep::Done)
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        sequence_decompress(&array).map(ExecutionResult::done)
     }
 
     fn execute_parent(
@@ -422,7 +423,7 @@ impl ValidityVTable<Sequence> for Sequence {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Sequence;
 
 impl Sequence {
diff --git a/encodings/sparse/public-api.lock b/encodings/sparse/public-api.lock
index 67c8d9bfb7b..87ef7c664bd 100644
--- a/encodings/sparse/public-api.lock
+++ b/encodings/sparse/public-api.lock
@@ -26,6 +26,10 @@ impl vortex_sparse::Sparse
 
 pub const vortex_sparse::Sparse::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_sparse::Sparse
+
+pub fn vortex_sparse::Sparse::clone(&self) -> vortex_sparse::Sparse
+
 impl core::fmt::Debug for vortex_sparse::Sparse
 
 pub fn vortex_sparse::Sparse::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -78,7 +82,7 @@ pub fn vortex_sparse::Sparse::deserialize(bytes: &[u8], dtype: &vortex_array::dt
 
 pub fn vortex_sparse::Sparse::dtype(array: &vortex_sparse::SparseArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_sparse::Sparse::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_sparse::Sparse::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_sparse::Sparse::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
 
diff --git a/encodings/sparse/src/lib.rs b/encodings/sparse/src/lib.rs
index 06138c0c814..2e7a0a24bd7 100644
--- a/encodings/sparse/src/lib.rs
+++ b/encodings/sparse/src/lib.rs
@@ -3,6 +3,7 @@
 
 use std::fmt::Debug;
 use std::hash::Hash;
+use std::sync::Arc;
 
 use kernel::PARENT_KERNELS;
 use prost::Message as _;
@@ -11,7 +12,7 @@ use vortex_array::ArrayHash;
 use vortex_array::ArrayRef;
 use vortex_array::DynArray;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::ToCanonical;
@@ -260,8 +261,8 @@ impl VTable for Sparse {
         PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        execute_sparse(array, ctx).map(ExecutionStep::Done)
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        execute_sparse(&array, ctx).map(ExecutionResult::done)
     }
 }
 
@@ -272,7 +273,7 @@ pub struct SparseArray {
     stats_set: ArrayStats,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Sparse;
 
 impl Sparse {
diff --git a/encodings/zigzag/public-api.lock b/encodings/zigzag/public-api.lock
index 369864404d7..e34a3ebde15 100644
--- a/encodings/zigzag/public-api.lock
+++ b/encodings/zigzag/public-api.lock
@@ -6,6 +6,10 @@ impl vortex_zigzag::ZigZag
 
 pub const vortex_zigzag::ZigZag::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_zigzag::ZigZag
+
+pub fn vortex_zigzag::ZigZag::clone(&self) -> vortex_zigzag::ZigZag
+
 impl core::fmt::Debug for vortex_zigzag::ZigZag
 
 pub fn vortex_zigzag::ZigZag::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -58,7 +62,7 @@ pub fn vortex_zigzag::ZigZag::deserialize(_bytes: &[u8], _dtype: &vortex_array::
 
 pub fn vortex_zigzag::ZigZag::dtype(array: &vortex_zigzag::ZigZagArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_zigzag::ZigZag::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_zigzag::ZigZag::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_zigzag::ZigZag::execute_parent(array: &Self::Array, parent: &vortex_array::array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::array::ArrayRef>>
 
diff --git a/encodings/zigzag/src/array.rs b/encodings/zigzag/src/array.rs
index 7c916707169..e0fdc2203b7 100644
--- a/encodings/zigzag/src/array.rs
+++ b/encodings/zigzag/src/array.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
@@ -9,7 +10,7 @@ use vortex_array::ArrayRef;
 use vortex_array::DynArray;
 use vortex_array::EmptyMetadata;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::buffer::BufferHandle;
@@ -153,8 +154,8 @@ impl VTable for ZigZag {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
             zigzag_decode(array.encoded().clone().execute(ctx)?).into_array(),
         ))
     }
@@ -184,7 +185,7 @@ pub struct ZigZagArray {
     stats_set: ArrayStats,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct ZigZag;
 
 impl ZigZag {
diff --git a/encodings/zstd/public-api.lock b/encodings/zstd/public-api.lock
index d3c6fdb812f..d6d8ab5cb34 100644
--- a/encodings/zstd/public-api.lock
+++ b/encodings/zstd/public-api.lock
@@ -6,6 +6,10 @@ impl vortex_zstd::Zstd
 
 pub const vortex_zstd::Zstd::ID: vortex_array::vtable::dyn_::ArrayId
 
+impl core::clone::Clone for vortex_zstd::Zstd
+
+pub fn vortex_zstd::Zstd::clone(&self) -> vortex_zstd::Zstd
+
 impl core::fmt::Debug for vortex_zstd::Zstd
 
 pub fn vortex_zstd::Zstd::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -46,7 +50,7 @@ pub fn vortex_zstd::Zstd::deserialize(bytes: &[u8], _dtype: &vortex_array::dtype
 
 pub fn vortex_zstd::Zstd::dtype(array: &vortex_zstd::ZstdArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_zstd::Zstd::execute(array: &Self::Array, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionStep>
+pub fn vortex_zstd::Zstd::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::executor::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::executor::ExecutionResult>
 
 pub fn vortex_zstd::Zstd::id(&self) -> vortex_array::vtable::dyn_::ArrayId
 
diff --git a/encodings/zstd/src/array.rs b/encodings/zstd/src/array.rs
index 06c8dd2bf22..bd9950cbc04 100644
--- a/encodings/zstd/src/array.rs
+++ b/encodings/zstd/src/array.rs
@@ -13,7 +13,7 @@ use vortex_array::ArrayRef;
 use vortex_array::Canonical;
 use vortex_array::DynArray;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::IntoArray;
 use vortex_array::LEGACY_SESSION;
 use vortex_array::Precision;
@@ -279,11 +279,11 @@ impl VTable for Zstd {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
         array
             .decompress(ctx)?
             .execute::<ArrayRef>(ctx)
-            .map(ExecutionStep::Done)
+            .map(ExecutionResult::done)
     }
 
     fn reduce_parent(
@@ -295,7 +295,7 @@ impl VTable for Zstd {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Zstd;
 
 impl Zstd {
diff --git a/encodings/zstd/src/zstd_buffers.rs b/encodings/zstd/src/zstd_buffers.rs
index 9b3c398b553..0f9dee83e66 100644
--- a/encodings/zstd/src/zstd_buffers.rs
+++ b/encodings/zstd/src/zstd_buffers.rs
@@ -10,7 +10,7 @@ use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
 use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
-use vortex_array::ExecutionStep;
+use vortex_array::ExecutionResult;
 use vortex_array::Precision;
 use vortex_array::ProstMetadata;
 use vortex_array::buffer::BufferHandle;
@@ -37,7 +37,7 @@ use crate::ZstdBuffersMetadata;
 
 vtable!(ZstdBuffers);
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct ZstdBuffers;
 
 impl ZstdBuffers {
@@ -471,12 +471,12 @@ impl VTable for ZstdBuffers {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
         let session = ctx.session();
         let inner_array = array.decompress_and_build_inner(session)?;
         inner_array
             .execute::<ArrayRef>(ctx)
-            .map(ExecutionStep::Done)
+            .map(ExecutionResult::done)
     }
 }
 
diff --git a/fuzz/src/array/mod.rs b/fuzz/src/array/mod.rs
index 0b101b91d8f..cd6e197a596 100644
--- a/fuzz/src/array/mod.rs
+++ b/fuzz/src/array/mod.rs
@@ -398,7 +398,7 @@ impl<'a> Arbitrary<'a> for FuzzArrayAction {
                         current_array
                             .to_canonical()
                             .vortex_expect("to_canonical should succeed in fuzz test"),
-                        &Mask::from_iter(mask.clone()),
+                        &!Mask::from_iter(mask.clone()),
                     )
                     .vortex_expect("mask_canonical_array should succeed in fuzz test");
                     // Update current_array to the result for chaining
diff --git a/vortex-array/public-api.lock b/vortex-array/public-api.lock
index 15cc3e5936e..a1ec6334ba5 100644
--- a/vortex-array/public-api.lock
+++ b/vortex-array/public-api.lock
@@ -848,6 +848,10 @@ impl vortex_array::arrays::Bool
 
 pub const vortex_array::arrays::Bool::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Bool
+
+pub fn vortex_array::arrays::Bool::clone(&self) -> vortex_array::arrays::Bool
+
 impl core::fmt::Debug for vortex_array::arrays::Bool
 
 pub fn vortex_array::arrays::Bool::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -916,7 +920,7 @@ pub fn vortex_array::arrays::Bool::deserialize(bytes: &[u8], _dtype: &vortex_arr
 
 pub fn vortex_array::arrays::Bool::dtype(array: &vortex_array::arrays::BoolArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Bool::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Bool::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Bool::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -1060,6 +1064,10 @@ impl vortex_array::arrays::Chunked
 
 pub const vortex_array::arrays::Chunked::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Chunked
+
+pub fn vortex_array::arrays::Chunked::clone(&self) -> vortex_array::arrays::Chunked
+
 impl core::fmt::Debug for vortex_array::arrays::Chunked
 
 pub fn vortex_array::arrays::Chunked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -1126,7 +1134,7 @@ pub fn vortex_array::arrays::Chunked::deserialize(_bytes: &[u8], _dtype: &vortex
 
 pub fn vortex_array::arrays::Chunked::dtype(array: &vortex_array::arrays::ChunkedArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Chunked::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Chunked::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Chunked::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -1228,6 +1236,10 @@ impl vortex_array::arrays::Constant
 
 pub const vortex_array::arrays::Constant::TAKE_RULES: vortex_array::optimizer::rules::ParentRuleSet<Self>
 
+impl core::clone::Clone for vortex_array::arrays::Constant
+
+pub fn vortex_array::arrays::Constant::clone(&self) -> vortex_array::arrays::Constant
+
 impl core::fmt::Debug for vortex_array::arrays::Constant
 
 pub fn vortex_array::arrays::Constant::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -1294,7 +1306,7 @@ pub fn vortex_array::arrays::Constant::deserialize(_bytes: &[u8], dtype: &vortex
 
 pub fn vortex_array::arrays::Constant::dtype(array: &vortex_array::arrays::ConstantArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Constant::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Constant::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Constant::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -1434,6 +1446,10 @@ impl vortex_array::arrays::Decimal
 
 pub const vortex_array::arrays::Decimal::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Decimal
+
+pub fn vortex_array::arrays::Decimal::clone(&self) -> vortex_array::arrays::Decimal
+
 impl core::fmt::Debug for vortex_array::arrays::Decimal
 
 pub fn vortex_array::arrays::Decimal::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -1502,7 +1518,7 @@ pub fn vortex_array::arrays::Decimal::deserialize(bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Decimal::dtype(array: &vortex_array::arrays::DecimalArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Decimal::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Decimal::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Decimal::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -1642,6 +1658,10 @@ impl vortex_array::arrays::dict::Dict
 
 pub const vortex_array::arrays::dict::Dict::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::dict::Dict
+
+pub fn vortex_array::arrays::dict::Dict::clone(&self) -> vortex_array::arrays::dict::Dict
+
 impl core::fmt::Debug for vortex_array::arrays::dict::Dict
 
 pub fn vortex_array::arrays::dict::Dict::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -1712,7 +1732,7 @@ pub fn vortex_array::arrays::dict::Dict::deserialize(bytes: &[u8], _dtype: &vort
 
 pub fn vortex_array::arrays::dict::Dict::dtype(array: &vortex_array::arrays::dict::DictArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::dict::Dict::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::dict::Dict::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::dict::Dict::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -1748,6 +1768,10 @@ impl vortex_array::arrays::dict::Dict
 
 pub const vortex_array::arrays::dict::Dict::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::dict::Dict
+
+pub fn vortex_array::arrays::dict::Dict::clone(&self) -> vortex_array::arrays::dict::Dict
+
 impl core::fmt::Debug for vortex_array::arrays::dict::Dict
 
 pub fn vortex_array::arrays::dict::Dict::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -1818,7 +1842,7 @@ pub fn vortex_array::arrays::dict::Dict::deserialize(bytes: &[u8], _dtype: &vort
 
 pub fn vortex_array::arrays::dict::Dict::dtype(array: &vortex_array::arrays::dict::DictArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::dict::Dict::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::dict::Dict::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::dict::Dict::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -2054,6 +2078,10 @@ impl vortex_array::arrays::Extension
 
 pub const vortex_array::arrays::Extension::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Extension
+
+pub fn vortex_array::arrays::Extension::clone(&self) -> vortex_array::arrays::Extension
+
 impl core::fmt::Debug for vortex_array::arrays::Extension
 
 pub fn vortex_array::arrays::Extension::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -2116,7 +2144,7 @@ pub fn vortex_array::arrays::Extension::deserialize(_bytes: &[u8], _dtype: &vort
 
 pub fn vortex_array::arrays::Extension::dtype(array: &vortex_array::arrays::ExtensionArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Extension::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Extension::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Extension::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -2216,6 +2244,10 @@ impl vortex_array::arrays::Filter
 
 pub const vortex_array::arrays::Filter::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Filter
+
+pub fn vortex_array::arrays::Filter::clone(&self) -> vortex_array::arrays::Filter
+
 impl core::fmt::Debug for vortex_array::arrays::Filter
 
 pub fn vortex_array::arrays::Filter::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -2254,7 +2286,7 @@ pub fn vortex_array::arrays::Filter::deserialize(_bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Filter::dtype(array: &vortex_array::arrays::FilterArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Filter::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Filter::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Filter::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -2418,6 +2450,10 @@ impl vortex_array::arrays::FixedSizeList
 
 pub const vortex_array::arrays::FixedSizeList::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::FixedSizeList
+
+pub fn vortex_array::arrays::FixedSizeList::clone(&self) -> vortex_array::arrays::FixedSizeList
+
 impl core::fmt::Debug for vortex_array::arrays::FixedSizeList
 
 pub fn vortex_array::arrays::FixedSizeList::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -2472,7 +2508,7 @@ pub fn vortex_array::arrays::FixedSizeList::deserialize(_bytes: &[u8], _dtype: &
 
 pub fn vortex_array::arrays::FixedSizeList::dtype(array: &vortex_array::arrays::FixedSizeListArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::FixedSizeList::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::FixedSizeList::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::FixedSizeList::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -2564,6 +2600,10 @@ impl vortex_array::arrays::List
 
 pub const vortex_array::arrays::List::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::List
+
+pub fn vortex_array::arrays::List::clone(&self) -> vortex_array::arrays::List
+
 impl core::fmt::Debug for vortex_array::arrays::List
 
 pub fn vortex_array::arrays::List::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -2622,7 +2662,7 @@ pub fn vortex_array::arrays::List::deserialize(bytes: &[u8], _dtype: &vortex_arr
 
 pub fn vortex_array::arrays::List::dtype(array: &vortex_array::arrays::ListArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::List::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::List::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::List::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -2738,6 +2778,10 @@ impl vortex_array::arrays::ListView
 
 pub const vortex_array::arrays::ListView::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::ListView
+
+pub fn vortex_array::arrays::ListView::clone(&self) -> vortex_array::arrays::ListView
+
 impl core::fmt::Debug for vortex_array::arrays::ListView
 
 pub fn vortex_array::arrays::ListView::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -2792,7 +2836,7 @@ pub fn vortex_array::arrays::ListView::deserialize(bytes: &[u8], _dtype: &vortex
 
 pub fn vortex_array::arrays::ListView::dtype(array: &vortex_array::arrays::ListViewArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::ListView::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::ListView::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::ListView::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -2918,6 +2962,10 @@ impl vortex_array::arrays::Masked
 
 pub const vortex_array::arrays::Masked::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Masked
+
+pub fn vortex_array::arrays::Masked::clone(&self) -> vortex_array::arrays::Masked
+
 impl core::fmt::Debug for vortex_array::arrays::Masked
 
 pub fn vortex_array::arrays::Masked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -2972,7 +3020,7 @@ pub fn vortex_array::arrays::Masked::deserialize(_bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Masked::dtype(array: &vortex_array::arrays::MaskedArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Masked::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Masked::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Masked::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -3054,6 +3102,10 @@ impl vortex_array::arrays::null::Null
 
 pub const vortex_array::arrays::null::Null::TAKE_RULES: vortex_array::optimizer::rules::ParentRuleSet<Self>
 
+impl core::clone::Clone for vortex_array::arrays::null::Null
+
+pub fn vortex_array::arrays::null::Null::clone(&self) -> vortex_array::arrays::null::Null
+
 impl core::fmt::Debug for vortex_array::arrays::null::Null
 
 pub fn vortex_array::arrays::null::Null::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -3112,7 +3164,7 @@ pub fn vortex_array::arrays::null::Null::deserialize(_bytes: &[u8], _dtype: &vor
 
 pub fn vortex_array::arrays::null::Null::dtype(_array: &vortex_array::arrays::null::NullArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::null::Null::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::null::Null::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::null::Null::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -3256,6 +3308,10 @@ impl vortex_array::arrays::Primitive
 
 pub const vortex_array::arrays::Primitive::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Primitive
+
+pub fn vortex_array::arrays::Primitive::clone(&self) -> vortex_array::arrays::Primitive
+
 impl core::fmt::Debug for vortex_array::arrays::Primitive
 
 pub fn vortex_array::arrays::Primitive::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -3324,7 +3380,7 @@ pub fn vortex_array::arrays::Primitive::deserialize(_bytes: &[u8], _dtype: &vort
 
 pub fn vortex_array::arrays::Primitive::dtype(array: &vortex_array::arrays::PrimitiveArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Primitive::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Primitive::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Primitive::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -3630,7 +3686,7 @@ pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::deserialize(_bytes: &[u8
 
 pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::dtype(array: &vortex_array::arrays::scalar_fn::ScalarFnArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -3676,6 +3732,10 @@ impl vortex_array::arrays::Shared
 
 pub const vortex_array::arrays::Shared::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Shared
+
+pub fn vortex_array::arrays::Shared::clone(&self) -> vortex_array::arrays::Shared
+
 impl core::fmt::Debug for vortex_array::arrays::Shared
 
 pub fn vortex_array::arrays::Shared::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -3714,7 +3774,7 @@ pub fn vortex_array::arrays::Shared::deserialize(_bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Shared::dtype(array: &vortex_array::arrays::SharedArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Shared::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Shared::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Shared::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -3792,6 +3852,10 @@ impl vortex_array::arrays::slice::Slice
 
 pub const vortex_array::arrays::slice::Slice::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::slice::Slice
+
+pub fn vortex_array::arrays::slice::Slice::clone(&self) -> vortex_array::arrays::slice::Slice
+
 impl core::fmt::Debug for vortex_array::arrays::slice::Slice
 
 pub fn vortex_array::arrays::slice::Slice::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -3834,7 +3898,7 @@ pub fn vortex_array::arrays::slice::Slice::deserialize(_bytes: &[u8], _dtype: &v
 
 pub fn vortex_array::arrays::slice::Slice::dtype(array: &vortex_array::arrays::slice::SliceArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::slice::Slice::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::slice::Slice::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::slice::Slice::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -4032,6 +4096,10 @@ impl vortex_array::arrays::Struct
 
 pub const vortex_array::arrays::Struct::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Struct
+
+pub fn vortex_array::arrays::Struct::clone(&self) -> vortex_array::arrays::Struct
+
 impl core::fmt::Debug for vortex_array::arrays::Struct
 
 pub fn vortex_array::arrays::Struct::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -4090,7 +4158,7 @@ pub fn vortex_array::arrays::Struct::deserialize(_bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Struct::dtype(array: &vortex_array::arrays::StructArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Struct::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Struct::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Struct::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -4246,6 +4314,10 @@ impl vortex_array::arrays::VarBin
 
 pub fn vortex_array::arrays::VarBin::_slice(array: &vortex_array::arrays::VarBinArray, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
+impl core::clone::Clone for vortex_array::arrays::VarBin
+
+pub fn vortex_array::arrays::VarBin::clone(&self) -> vortex_array::arrays::VarBin
+
 impl core::fmt::Debug for vortex_array::arrays::VarBin
 
 pub fn vortex_array::arrays::VarBin::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -4308,7 +4380,7 @@ pub fn vortex_array::arrays::VarBin::deserialize(bytes: &[u8], _dtype: &vortex_a
 
 pub fn vortex_array::arrays::VarBin::dtype(array: &vortex_array::arrays::VarBinArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::VarBin::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::VarBin::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::VarBin::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -4654,6 +4726,10 @@ impl vortex_array::arrays::VarBinView
 
 pub const vortex_array::arrays::VarBinView::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::VarBinView
+
+pub fn vortex_array::arrays::VarBinView::clone(&self) -> vortex_array::arrays::VarBinView
+
 impl core::fmt::Debug for vortex_array::arrays::VarBinView
 
 pub fn vortex_array::arrays::VarBinView::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -4712,7 +4788,7 @@ pub fn vortex_array::arrays::VarBinView::deserialize(_bytes: &[u8], _dtype: &vor
 
 pub fn vortex_array::arrays::VarBinView::dtype(array: &vortex_array::arrays::VarBinViewArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::VarBinView::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::VarBinView::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::VarBinView::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -4866,6 +4942,10 @@ impl vortex_array::arrays::Variant
 
 pub const vortex_array::arrays::Variant::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Variant
+
+pub fn vortex_array::arrays::Variant::clone(&self) -> vortex_array::arrays::Variant
+
 impl core::fmt::Debug for vortex_array::arrays::Variant
 
 pub fn vortex_array::arrays::Variant::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -4904,7 +4984,7 @@ pub fn vortex_array::arrays::Variant::deserialize(_bytes: &[u8], _dtype: &vortex
 
 pub fn vortex_array::arrays::Variant::dtype(array: &Self::Array) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Variant::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Variant::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Variant::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -4978,6 +5058,10 @@ impl vortex_array::arrays::Bool
 
 pub const vortex_array::arrays::Bool::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Bool
+
+pub fn vortex_array::arrays::Bool::clone(&self) -> vortex_array::arrays::Bool
+
 impl core::fmt::Debug for vortex_array::arrays::Bool
 
 pub fn vortex_array::arrays::Bool::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -5046,7 +5130,7 @@ pub fn vortex_array::arrays::Bool::deserialize(bytes: &[u8], _dtype: &vortex_arr
 
 pub fn vortex_array::arrays::Bool::dtype(array: &vortex_array::arrays::BoolArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Bool::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Bool::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Bool::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -5162,6 +5246,10 @@ impl vortex_array::arrays::Chunked
 
 pub const vortex_array::arrays::Chunked::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Chunked
+
+pub fn vortex_array::arrays::Chunked::clone(&self) -> vortex_array::arrays::Chunked
+
 impl core::fmt::Debug for vortex_array::arrays::Chunked
 
 pub fn vortex_array::arrays::Chunked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -5228,7 +5316,7 @@ pub fn vortex_array::arrays::Chunked::deserialize(_bytes: &[u8], _dtype: &vortex
 
 pub fn vortex_array::arrays::Chunked::dtype(array: &vortex_array::arrays::ChunkedArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Chunked::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Chunked::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Chunked::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -5328,6 +5416,10 @@ impl vortex_array::arrays::Constant
 
 pub const vortex_array::arrays::Constant::TAKE_RULES: vortex_array::optimizer::rules::ParentRuleSet<Self>
 
+impl core::clone::Clone for vortex_array::arrays::Constant
+
+pub fn vortex_array::arrays::Constant::clone(&self) -> vortex_array::arrays::Constant
+
 impl core::fmt::Debug for vortex_array::arrays::Constant
 
 pub fn vortex_array::arrays::Constant::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -5394,7 +5486,7 @@ pub fn vortex_array::arrays::Constant::deserialize(_bytes: &[u8], dtype: &vortex
 
 pub fn vortex_array::arrays::Constant::dtype(array: &vortex_array::arrays::ConstantArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Constant::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Constant::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Constant::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -5470,6 +5562,10 @@ impl vortex_array::arrays::Decimal
 
 pub const vortex_array::arrays::Decimal::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Decimal
+
+pub fn vortex_array::arrays::Decimal::clone(&self) -> vortex_array::arrays::Decimal
+
 impl core::fmt::Debug for vortex_array::arrays::Decimal
 
 pub fn vortex_array::arrays::Decimal::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -5538,7 +5634,7 @@ pub fn vortex_array::arrays::Decimal::deserialize(bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Decimal::dtype(array: &vortex_array::arrays::DecimalArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Decimal::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Decimal::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Decimal::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -5646,6 +5742,10 @@ impl vortex_array::arrays::dict::Dict
 
 pub const vortex_array::arrays::dict::Dict::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::dict::Dict
+
+pub fn vortex_array::arrays::dict::Dict::clone(&self) -> vortex_array::arrays::dict::Dict
+
 impl core::fmt::Debug for vortex_array::arrays::dict::Dict
 
 pub fn vortex_array::arrays::dict::Dict::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -5716,7 +5816,7 @@ pub fn vortex_array::arrays::dict::Dict::deserialize(bytes: &[u8], _dtype: &vort
 
 pub fn vortex_array::arrays::dict::Dict::dtype(array: &vortex_array::arrays::dict::DictArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::dict::Dict::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::dict::Dict::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::dict::Dict::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -5810,6 +5910,10 @@ impl vortex_array::arrays::Extension
 
 pub const vortex_array::arrays::Extension::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Extension
+
+pub fn vortex_array::arrays::Extension::clone(&self) -> vortex_array::arrays::Extension
+
 impl core::fmt::Debug for vortex_array::arrays::Extension
 
 pub fn vortex_array::arrays::Extension::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -5872,7 +5976,7 @@ pub fn vortex_array::arrays::Extension::deserialize(_bytes: &[u8], _dtype: &vort
 
 pub fn vortex_array::arrays::Extension::dtype(array: &vortex_array::arrays::ExtensionArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Extension::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Extension::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Extension::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -5970,6 +6074,10 @@ impl vortex_array::arrays::Filter
 
 pub const vortex_array::arrays::Filter::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Filter
+
+pub fn vortex_array::arrays::Filter::clone(&self) -> vortex_array::arrays::Filter
+
 impl core::fmt::Debug for vortex_array::arrays::Filter
 
 pub fn vortex_array::arrays::Filter::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -6008,7 +6116,7 @@ pub fn vortex_array::arrays::Filter::deserialize(_bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Filter::dtype(array: &vortex_array::arrays::FilterArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Filter::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Filter::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Filter::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -6088,6 +6196,10 @@ impl vortex_array::arrays::FixedSizeList
 
 pub const vortex_array::arrays::FixedSizeList::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::FixedSizeList
+
+pub fn vortex_array::arrays::FixedSizeList::clone(&self) -> vortex_array::arrays::FixedSizeList
+
 impl core::fmt::Debug for vortex_array::arrays::FixedSizeList
 
 pub fn vortex_array::arrays::FixedSizeList::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -6142,7 +6254,7 @@ pub fn vortex_array::arrays::FixedSizeList::deserialize(_bytes: &[u8], _dtype: &
 
 pub fn vortex_array::arrays::FixedSizeList::dtype(array: &vortex_array::arrays::FixedSizeListArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::FixedSizeList::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::FixedSizeList::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::FixedSizeList::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -6232,6 +6344,10 @@ impl vortex_array::arrays::List
 
 pub const vortex_array::arrays::List::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::List
+
+pub fn vortex_array::arrays::List::clone(&self) -> vortex_array::arrays::List
+
 impl core::fmt::Debug for vortex_array::arrays::List
 
 pub fn vortex_array::arrays::List::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -6290,7 +6406,7 @@ pub fn vortex_array::arrays::List::deserialize(bytes: &[u8], _dtype: &vortex_arr
 
 pub fn vortex_array::arrays::List::dtype(array: &vortex_array::arrays::ListArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::List::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::List::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::List::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -6384,6 +6500,10 @@ impl vortex_array::arrays::ListView
 
 pub const vortex_array::arrays::ListView::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::ListView
+
+pub fn vortex_array::arrays::ListView::clone(&self) -> vortex_array::arrays::ListView
+
 impl core::fmt::Debug for vortex_array::arrays::ListView
 
 pub fn vortex_array::arrays::ListView::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -6438,7 +6558,7 @@ pub fn vortex_array::arrays::ListView::deserialize(bytes: &[u8], _dtype: &vortex
 
 pub fn vortex_array::arrays::ListView::dtype(array: &vortex_array::arrays::ListViewArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::ListView::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::ListView::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::ListView::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -6544,6 +6664,10 @@ impl vortex_array::arrays::Masked
 
 pub const vortex_array::arrays::Masked::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Masked
+
+pub fn vortex_array::arrays::Masked::clone(&self) -> vortex_array::arrays::Masked
+
 impl core::fmt::Debug for vortex_array::arrays::Masked
 
 pub fn vortex_array::arrays::Masked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -6598,7 +6722,7 @@ pub fn vortex_array::arrays::Masked::deserialize(_bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Masked::dtype(array: &vortex_array::arrays::MaskedArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Masked::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Masked::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Masked::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -6676,6 +6800,10 @@ impl vortex_array::arrays::null::Null
 
 pub const vortex_array::arrays::null::Null::TAKE_RULES: vortex_array::optimizer::rules::ParentRuleSet<Self>
 
+impl core::clone::Clone for vortex_array::arrays::null::Null
+
+pub fn vortex_array::arrays::null::Null::clone(&self) -> vortex_array::arrays::null::Null
+
 impl core::fmt::Debug for vortex_array::arrays::null::Null
 
 pub fn vortex_array::arrays::null::Null::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -6734,7 +6862,7 @@ pub fn vortex_array::arrays::null::Null::deserialize(_bytes: &[u8], _dtype: &vor
 
 pub fn vortex_array::arrays::null::Null::dtype(_array: &vortex_array::arrays::null::NullArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::null::Null::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::null::Null::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::null::Null::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -6810,6 +6938,10 @@ impl vortex_array::arrays::Primitive
 
 pub const vortex_array::arrays::Primitive::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Primitive
+
+pub fn vortex_array::arrays::Primitive::clone(&self) -> vortex_array::arrays::Primitive
+
 impl core::fmt::Debug for vortex_array::arrays::Primitive
 
 pub fn vortex_array::arrays::Primitive::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -6878,7 +7010,7 @@ pub fn vortex_array::arrays::Primitive::deserialize(_bytes: &[u8], _dtype: &vort
 
 pub fn vortex_array::arrays::Primitive::dtype(array: &vortex_array::arrays::PrimitiveArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Primitive::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Primitive::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Primitive::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -7110,7 +7242,7 @@ pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::deserialize(_bytes: &[u8
 
 pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::dtype(array: &vortex_array::arrays::scalar_fn::ScalarFnArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -7146,6 +7278,10 @@ impl vortex_array::arrays::Shared
 
 pub const vortex_array::arrays::Shared::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Shared
+
+pub fn vortex_array::arrays::Shared::clone(&self) -> vortex_array::arrays::Shared
+
 impl core::fmt::Debug for vortex_array::arrays::Shared
 
 pub fn vortex_array::arrays::Shared::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -7184,7 +7320,7 @@ pub fn vortex_array::arrays::Shared::deserialize(_bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Shared::dtype(array: &vortex_array::arrays::SharedArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Shared::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Shared::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Shared::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -7260,6 +7396,10 @@ impl vortex_array::arrays::slice::Slice
 
 pub const vortex_array::arrays::slice::Slice::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::slice::Slice
+
+pub fn vortex_array::arrays::slice::Slice::clone(&self) -> vortex_array::arrays::slice::Slice
+
 impl core::fmt::Debug for vortex_array::arrays::slice::Slice
 
 pub fn vortex_array::arrays::slice::Slice::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -7302,7 +7442,7 @@ pub fn vortex_array::arrays::slice::Slice::deserialize(_bytes: &[u8], _dtype: &v
 
 pub fn vortex_array::arrays::slice::Slice::dtype(array: &vortex_array::arrays::slice::SliceArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::slice::Slice::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::slice::Slice::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::slice::Slice::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -7382,6 +7522,10 @@ impl vortex_array::arrays::Struct
 
 pub const vortex_array::arrays::Struct::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Struct
+
+pub fn vortex_array::arrays::Struct::clone(&self) -> vortex_array::arrays::Struct
+
 impl core::fmt::Debug for vortex_array::arrays::Struct
 
 pub fn vortex_array::arrays::Struct::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -7440,7 +7584,7 @@ pub fn vortex_array::arrays::Struct::deserialize(_bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Struct::dtype(array: &vortex_array::arrays::StructArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Struct::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Struct::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Struct::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -7620,6 +7764,10 @@ impl vortex_array::arrays::VarBin
 
 pub fn vortex_array::arrays::VarBin::_slice(array: &vortex_array::arrays::VarBinArray, range: core::ops::range::Range<usize>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
+impl core::clone::Clone for vortex_array::arrays::VarBin
+
+pub fn vortex_array::arrays::VarBin::clone(&self) -> vortex_array::arrays::VarBin
+
 impl core::fmt::Debug for vortex_array::arrays::VarBin
 
 pub fn vortex_array::arrays::VarBin::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -7682,7 +7830,7 @@ pub fn vortex_array::arrays::VarBin::deserialize(bytes: &[u8], _dtype: &vortex_a
 
 pub fn vortex_array::arrays::VarBin::dtype(array: &vortex_array::arrays::VarBinArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::VarBin::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::VarBin::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::VarBin::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -7842,6 +7990,10 @@ impl vortex_array::arrays::VarBinView
 
 pub const vortex_array::arrays::VarBinView::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::VarBinView
+
+pub fn vortex_array::arrays::VarBinView::clone(&self) -> vortex_array::arrays::VarBinView
+
 impl core::fmt::Debug for vortex_array::arrays::VarBinView
 
 pub fn vortex_array::arrays::VarBinView::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -7900,7 +8052,7 @@ pub fn vortex_array::arrays::VarBinView::deserialize(_bytes: &[u8], _dtype: &vor
 
 pub fn vortex_array::arrays::VarBinView::dtype(array: &vortex_array::arrays::VarBinViewArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::VarBinView::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::VarBinView::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::VarBinView::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -8042,6 +8194,10 @@ impl vortex_array::arrays::Variant
 
 pub const vortex_array::arrays::Variant::ID: vortex_array::vtable::ArrayId
 
+impl core::clone::Clone for vortex_array::arrays::Variant
+
+pub fn vortex_array::arrays::Variant::clone(&self) -> vortex_array::arrays::Variant
+
 impl core::fmt::Debug for vortex_array::arrays::Variant
 
 pub fn vortex_array::arrays::Variant::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -8080,7 +8236,7 @@ pub fn vortex_array::arrays::Variant::deserialize(_bytes: &[u8], _dtype: &vortex
 
 pub fn vortex_array::arrays::Variant::dtype(array: &Self::Array) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Variant::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Variant::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Variant::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -20456,7 +20612,9 @@ pub trait vortex_array::vtable::DynVTable: 'static + core::marker::Send + core::
 
 pub fn vortex_array::vtable::DynVTable::build(&self, id: vortex_array::vtable::ArrayId, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::vtable::DynVTable::execute(&self, array: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::vtable::DynVTable::clone_boxed(&self) -> alloc::boxed::Box<dyn vortex_array::vtable::DynVTable>
+
+pub fn vortex_array::vtable::DynVTable::execute(&self, array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::vtable::DynVTable::execute_parent(&self, array: &vortex_array::ArrayRef, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -20470,7 +20628,9 @@ impl<V: vortex_array::vtable::VTable> vortex_array::vtable::DynVTable for V
 
 pub fn V::build(&self, _id: vortex_array::vtable::ArrayId, dtype: &vortex_array::dtype::DType, len: usize, metadata: &[u8], buffers: &[vortex_array::buffer::BufferHandle], children: &dyn vortex_array::serde::ArrayChildren, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn V::execute(&self, array: &vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn V::clone_boxed(&self) -> alloc::boxed::Box<dyn vortex_array::vtable::DynVTable>
+
+pub fn V::execute(&self, array: vortex_array::ArrayRef, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn V::execute_parent(&self, array: &vortex_array::ArrayRef, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -20568,7 +20728,7 @@ impl<V: vortex_array::vtable::VTable> vortex_array::vtable::OperationsVTable<V>
 
 pub fn vortex_array::vtable::NotSupported::scalar_at(array: &<V as vortex_array::vtable::VTable>::Array, _index: usize) -> vortex_error::VortexResult<vortex_array::scalar::Scalar>
 
-pub trait vortex_array::vtable::VTable: 'static + core::marker::Sized + core::marker::Send + core::marker::Sync + core::fmt::Debug
+pub trait vortex_array::vtable::VTable: 'static + core::clone::Clone + core::marker::Sized + core::marker::Send + core::marker::Sync + core::fmt::Debug
 
 pub type vortex_array::vtable::VTable::Array: 'static + core::marker::Send + core::marker::Sync + core::clone::Clone + core::fmt::Debug + core::ops::deref::Deref<Target = dyn vortex_array::DynArray> + vortex_array::IntoArray
 
@@ -20598,7 +20758,7 @@ pub fn vortex_array::vtable::VTable::deserialize(bytes: &[u8], _dtype: &vortex_a
 
 pub fn vortex_array::vtable::VTable::dtype(array: &Self::Array) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::vtable::VTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::vtable::VTable::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::vtable::VTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -20654,7 +20814,7 @@ pub fn vortex_array::arrays::Bool::deserialize(bytes: &[u8], _dtype: &vortex_arr
 
 pub fn vortex_array::arrays::Bool::dtype(array: &vortex_array::arrays::BoolArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Bool::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Bool::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Bool::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -20710,7 +20870,7 @@ pub fn vortex_array::arrays::Chunked::deserialize(_bytes: &[u8], _dtype: &vortex
 
 pub fn vortex_array::arrays::Chunked::dtype(array: &vortex_array::arrays::ChunkedArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Chunked::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Chunked::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Chunked::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -20766,7 +20926,7 @@ pub fn vortex_array::arrays::Constant::deserialize(_bytes: &[u8], dtype: &vortex
 
 pub fn vortex_array::arrays::Constant::dtype(array: &vortex_array::arrays::ConstantArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Constant::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Constant::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Constant::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -20822,7 +20982,7 @@ pub fn vortex_array::arrays::Decimal::deserialize(bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Decimal::dtype(array: &vortex_array::arrays::DecimalArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Decimal::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Decimal::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Decimal::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -20878,7 +21038,7 @@ pub fn vortex_array::arrays::Extension::deserialize(_bytes: &[u8], _dtype: &vort
 
 pub fn vortex_array::arrays::Extension::dtype(array: &vortex_array::arrays::ExtensionArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Extension::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Extension::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Extension::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -20934,7 +21094,7 @@ pub fn vortex_array::arrays::Filter::deserialize(_bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Filter::dtype(array: &vortex_array::arrays::FilterArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Filter::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Filter::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Filter::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -20990,7 +21150,7 @@ pub fn vortex_array::arrays::FixedSizeList::deserialize(_bytes: &[u8], _dtype: &
 
 pub fn vortex_array::arrays::FixedSizeList::dtype(array: &vortex_array::arrays::FixedSizeListArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::FixedSizeList::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::FixedSizeList::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::FixedSizeList::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -21046,7 +21206,7 @@ pub fn vortex_array::arrays::List::deserialize(bytes: &[u8], _dtype: &vortex_arr
 
 pub fn vortex_array::arrays::List::dtype(array: &vortex_array::arrays::ListArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::List::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::List::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::List::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -21102,7 +21262,7 @@ pub fn vortex_array::arrays::ListView::deserialize(bytes: &[u8], _dtype: &vortex
 
 pub fn vortex_array::arrays::ListView::dtype(array: &vortex_array::arrays::ListViewArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::ListView::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::ListView::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::ListView::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -21158,7 +21318,7 @@ pub fn vortex_array::arrays::Masked::deserialize(_bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Masked::dtype(array: &vortex_array::arrays::MaskedArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Masked::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Masked::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Masked::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -21214,7 +21374,7 @@ pub fn vortex_array::arrays::Primitive::deserialize(_bytes: &[u8], _dtype: &vort
 
 pub fn vortex_array::arrays::Primitive::dtype(array: &vortex_array::arrays::PrimitiveArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Primitive::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Primitive::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Primitive::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -21270,7 +21430,7 @@ pub fn vortex_array::arrays::Shared::deserialize(_bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Shared::dtype(array: &vortex_array::arrays::SharedArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Shared::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Shared::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Shared::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -21326,7 +21486,7 @@ pub fn vortex_array::arrays::Struct::deserialize(_bytes: &[u8], _dtype: &vortex_
 
 pub fn vortex_array::arrays::Struct::dtype(array: &vortex_array::arrays::StructArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Struct::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Struct::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Struct::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -21382,7 +21542,7 @@ pub fn vortex_array::arrays::VarBin::deserialize(bytes: &[u8], _dtype: &vortex_a
 
 pub fn vortex_array::arrays::VarBin::dtype(array: &vortex_array::arrays::VarBinArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::VarBin::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::VarBin::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::VarBin::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -21438,7 +21598,7 @@ pub fn vortex_array::arrays::VarBinView::deserialize(_bytes: &[u8], _dtype: &vor
 
 pub fn vortex_array::arrays::VarBinView::dtype(array: &vortex_array::arrays::VarBinViewArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::VarBinView::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::VarBinView::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::VarBinView::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -21494,7 +21654,7 @@ pub fn vortex_array::arrays::Variant::deserialize(_bytes: &[u8], _dtype: &vortex
 
 pub fn vortex_array::arrays::Variant::dtype(array: &Self::Array) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::Variant::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::Variant::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::Variant::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -21550,7 +21710,7 @@ pub fn vortex_array::arrays::dict::Dict::deserialize(bytes: &[u8], _dtype: &vort
 
 pub fn vortex_array::arrays::dict::Dict::dtype(array: &vortex_array::arrays::dict::DictArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::dict::Dict::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::dict::Dict::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::dict::Dict::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -21606,7 +21766,7 @@ pub fn vortex_array::arrays::null::Null::deserialize(_bytes: &[u8], _dtype: &vor
 
 pub fn vortex_array::arrays::null::Null::dtype(_array: &vortex_array::arrays::null::NullArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::null::Null::execute(array: &Self::Array, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::null::Null::execute(array: alloc::sync::Arc<Self::Array>, _ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::null::Null::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -21662,7 +21822,7 @@ pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::deserialize(_bytes: &[u8
 
 pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::dtype(array: &vortex_array::arrays::scalar_fn::ScalarFnArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::scalar_fn::ScalarFnVTable::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -21718,7 +21878,7 @@ pub fn vortex_array::arrays::slice::Slice::deserialize(_bytes: &[u8], _dtype: &v
 
 pub fn vortex_array::arrays::slice::Slice::dtype(array: &vortex_array::arrays::slice::SliceArray) -> &vortex_array::dtype::DType
 
-pub fn vortex_array::arrays::slice::Slice::execute(array: &Self::Array, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionStep>
+pub fn vortex_array::arrays::slice::Slice::execute(array: alloc::sync::Arc<Self::Array>, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<vortex_array::ExecutionResult>
 
 pub fn vortex_array::arrays::slice::Slice::execute_parent(array: &Self::Array, parent: &vortex_array::ArrayRef, child_idx: usize, ctx: &mut vortex_array::ExecutionCtx) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
@@ -22076,16 +22236,10 @@ pub fn vortex_array::ColumnarView<'a>::as_ref(&self) -> &dyn vortex_array::DynAr
 
 pub enum vortex_array::ExecutionStep
 
-pub vortex_array::ExecutionStep::Done(vortex_array::ArrayRef)
+pub vortex_array::ExecutionStep::Done
 
 pub vortex_array::ExecutionStep::ExecuteChild(usize, vortex_array::DonePredicate)
 
-impl vortex_array::ExecutionStep
-
-pub fn vortex_array::ExecutionStep::done(result: vortex_array::ArrayRef) -> Self
-
-pub fn vortex_array::ExecutionStep::execute_child<M: vortex_array::matcher::Matcher>(child_idx: usize) -> Self
-
 impl core::fmt::Debug for vortex_array::ExecutionStep
 
 pub fn vortex_array::ExecutionStep::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -22132,6 +22286,8 @@ impl<V: vortex_array::vtable::VTable> vortex_array::ArrayAdapter<V>
 
 pub fn vortex_array::ArrayAdapter<V>::as_inner(&self) -> &<V as vortex_array::vtable::VTable>::Array
 
+pub fn vortex_array::ArrayAdapter<V>::into_inner(self) -> <V as vortex_array::vtable::VTable>::Array
+
 impl<V: vortex_array::vtable::VTable> core::fmt::Debug for vortex_array::ArrayAdapter<V>
 
 pub fn vortex_array::ArrayAdapter<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -22274,6 +22430,26 @@ impl core::ops::drop::Drop for vortex_array::ExecutionCtx
 
 pub fn vortex_array::ExecutionCtx::drop(&mut self)
 
+pub struct vortex_array::ExecutionResult
+
+impl vortex_array::ExecutionResult
+
+pub fn vortex_array::ExecutionResult::array(&self) -> &vortex_array::ArrayRef
+
+pub fn vortex_array::ExecutionResult::done(result: impl vortex_array::IntoArray) -> Self
+
+pub fn vortex_array::ExecutionResult::done_upcast<V: vortex_array::vtable::VTable>(arr: alloc::sync::Arc<<V as vortex_array::vtable::VTable>::Array>) -> Self
+
+pub fn vortex_array::ExecutionResult::execute_child<M: vortex_array::matcher::Matcher>(array: impl vortex_array::IntoArray, child_idx: usize) -> Self
+
+pub fn vortex_array::ExecutionResult::into_parts(self) -> (vortex_array::ArrayRef, vortex_array::ExecutionStep)
+
+pub fn vortex_array::ExecutionResult::step(&self) -> &vortex_array::ExecutionStep
+
+impl core::fmt::Debug for vortex_array::ExecutionResult
+
+pub fn vortex_array::ExecutionResult::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
 pub struct vortex_array::MaskFuture
 
 impl vortex_array::MaskFuture
diff --git a/vortex-array/src/array/mod.rs b/vortex-array/src/array/mod.rs
index 5436ec2250b..3d5fba1a16a 100644
--- a/vortex-array/src/array/mod.rs
+++ b/vortex-array/src/array/mod.rs
@@ -401,6 +401,11 @@ impl<V: VTable> ArrayAdapter<V> {
     pub fn as_inner(&self) -> &V::Array {
         &self.0
     }
+
+    /// Consume the adapter and return the underlying array.
+    pub fn into_inner(self) -> V::Array {
+        self.0
+    }
 }
 
 impl<V: VTable> Debug for ArrayAdapter<V> {
@@ -454,7 +459,7 @@ impl<V: VTable> DynArray for ArrayAdapter<V> {
     }
 
     fn vtable(&self) -> &dyn DynVTable {
-        V::vtable(&self.0)
+        V::vtable(self.as_inner())
     }
 
     fn encoding_id(&self) -> ArrayId {
diff --git a/vortex-array/src/arrays/bool/vtable/mod.rs b/vortex-array/src/arrays/bool/vtable/mod.rs
index 2519c1895e7..5442ba3b3f7 100644
--- a/vortex-array/src/arrays/bool/vtable/mod.rs
+++ b/vortex-array/src/arrays/bool/vtable/mod.rs
@@ -12,8 +12,7 @@ use vortex_session::VortexSession;
 use crate::ArrayRef;
 use crate::DeserializeMetadata;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
-use crate::IntoArray;
+use crate::ExecutionResult;
 use crate::ProstMetadata;
 use crate::SerializeMetadata;
 use crate::arrays::BoolArray;
@@ -32,6 +31,7 @@ mod operations;
 mod validity;
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use crate::Precision;
 use crate::arrays::bool::compute::rules::RULES;
@@ -189,8 +189,8 @@ impl VTable for Bool {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(array.clone().into_array()))
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done_upcast::<Self>(array))
     }
 
     fn execute_parent(
@@ -211,7 +211,7 @@ impl VTable for Bool {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Bool;
 
 impl Bool {
diff --git a/vortex-array/src/arrays/chunked/vtable/mod.rs b/vortex-array/src/arrays/chunked/vtable/mod.rs
index bb04800cdd5..c7b4a9e22fc 100644
--- a/vortex-array/src/arrays/chunked/vtable/mod.rs
+++ b/vortex-array/src/arrays/chunked/vtable/mod.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use itertools::Itertools;
 use vortex_error::VortexResult;
@@ -15,7 +16,7 @@ use crate::ArrayRef;
 use crate::Canonical;
 use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
+use crate::ExecutionResult;
 use crate::IntoArray;
 use crate::Precision;
 use crate::ToCanonical;
@@ -42,7 +43,7 @@ mod operations;
 mod validity;
 vtable!(Chunked);
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Chunked;
 
 impl Chunked {
@@ -244,8 +245,10 @@ impl VTable for Chunked {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(_canonicalize(array, ctx)?.into_array()))
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            _canonicalize(&array, ctx)?.into_array(),
+        ))
     }
 
     fn reduce(array: &Self::Array) -> VortexResult<Option<ArrayRef>> {
diff --git a/vortex-array/src/arrays/constant/vtable/mod.rs b/vortex-array/src/arrays/constant/vtable/mod.rs
index 9f6fb377fad..a5a6d80f53c 100644
--- a/vortex-array/src/arrays/constant/vtable/mod.rs
+++ b/vortex-array/src/arrays/constant/vtable/mod.rs
@@ -3,6 +3,7 @@
 
 use std::fmt::Debug;
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_buffer::ByteBufferMut;
 use vortex_error::VortexExpect;
@@ -13,7 +14,7 @@ use vortex_session::VortexSession;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
+use crate::ExecutionResult;
 use crate::IntoArray;
 use crate::Precision;
 use crate::arrays::ConstantArray;
@@ -44,7 +45,7 @@ mod validity;
 
 vtable!(Constant);
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Constant;
 
 impl Constant {
@@ -182,9 +183,9 @@ impl VTable for Constant {
         PARENT_RULES.evaluate(array, parent, child_idx)
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(
-            constant_canonicalize(array)?.into_array(),
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            constant_canonicalize(&array)?.into_array(),
         ))
     }
 
diff --git a/vortex-array/src/arrays/decimal/vtable/mod.rs b/vortex-array/src/arrays/decimal/vtable/mod.rs
index 49efe6e97c1..4c9451cd97b 100644
--- a/vortex-array/src/arrays/decimal/vtable/mod.rs
+++ b/vortex-array/src/arrays/decimal/vtable/mod.rs
@@ -13,8 +13,7 @@ use vortex_session::VortexSession;
 use crate::ArrayRef;
 use crate::DeserializeMetadata;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
-use crate::IntoArray;
+use crate::ExecutionResult;
 use crate::ProstMetadata;
 use crate::SerializeMetadata;
 use crate::arrays::DecimalArray;
@@ -35,6 +34,7 @@ mod operations;
 mod validity;
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use crate::Precision;
 use crate::arrays::decimal::compute::rules::RULES;
@@ -211,8 +211,8 @@ impl VTable for Decimal {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(array.clone().into_array()))
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done_upcast::<Self>(array))
     }
 
     fn reduce_parent(
@@ -233,7 +233,7 @@ impl VTable for Decimal {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Decimal;
 
 impl Decimal {
diff --git a/vortex-array/src/arrays/dict/vtable/mod.rs b/vortex-array/src/arrays/dict/vtable/mod.rs
index 91c3c45ede4..40c35ffbbd3 100644
--- a/vortex-array/src/arrays/dict/vtable/mod.rs
+++ b/vortex-array/src/arrays/dict/vtable/mod.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use kernel::PARENT_KERNELS;
 use vortex_error::VortexResult;
@@ -29,7 +30,7 @@ use crate::dtype::DType;
 use crate::dtype::Nullability;
 use crate::dtype::PType;
 use crate::executor::ExecutionCtx;
-use crate::executor::ExecutionStep;
+use crate::executor::ExecutionResult;
 use crate::hash::ArrayEq;
 use crate::hash::ArrayHash;
 use crate::scalar::Scalar;
@@ -44,7 +45,7 @@ mod validity;
 
 vtable!(Dict);
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Dict;
 
 impl Dict {
@@ -195,9 +196,9 @@ impl VTable for Dict {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        if let Some(canonical) = execute_fast_path(array, ctx)? {
-            return Ok(ExecutionStep::Done(canonical));
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        if let Some(canonical) = execute_fast_path(&array, ctx)? {
+            return Ok(ExecutionResult::done(canonical));
         }
 
         // TODO(joe): if the values are constant return a constant
@@ -213,7 +214,7 @@ impl VTable for Dict {
         // TODO(ngates): if indices min is quite high, we could slice self and offset the indices
         //  such that canonicalize does less work.
 
-        Ok(ExecutionStep::Done(
+        Ok(ExecutionResult::done(
             take_canonical(values, &codes, ctx)?.into_array(),
         ))
     }
diff --git a/vortex-array/src/arrays/extension/vtable/mod.rs b/vortex-array/src/arrays/extension/vtable/mod.rs
index cd630ce11b9..13a4bc1e093 100644
--- a/vortex-array/src/arrays/extension/vtable/mod.rs
+++ b/vortex-array/src/arrays/extension/vtable/mod.rs
@@ -6,6 +6,7 @@ mod operations;
 mod validity;
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use kernel::PARENT_KERNELS;
 use vortex_error::VortexExpect;
@@ -18,8 +19,7 @@ use vortex_session::VortexSession;
 use crate::ArrayRef;
 use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
-use crate::IntoArray;
+use crate::ExecutionResult;
 use crate::Precision;
 use crate::arrays::ExtensionArray;
 use crate::arrays::extension::compute::rules::PARENT_RULES;
@@ -157,8 +157,8 @@ impl VTable for Extension {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(array.clone().into_array()))
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done_upcast::<Self>(array))
     }
 
     fn reduce_parent(
@@ -179,7 +179,7 @@ impl VTable for Extension {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Extension;
 
 impl Extension {
diff --git a/vortex-array/src/arrays/filter/vtable.rs b/vortex-array/src/arrays/filter/vtable.rs
index 4287b788863..02f2cce0a1d 100644
--- a/vortex-array/src/arrays/filter/vtable.rs
+++ b/vortex-array/src/arrays/filter/vtable.rs
@@ -4,6 +4,7 @@
 use std::fmt::Debug;
 use std::fmt::Formatter;
 use std::hash::Hasher;
+use std::sync::Arc;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -27,7 +28,7 @@ use crate::arrays::filter::rules::RULES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::executor::ExecutionCtx;
-use crate::executor::ExecutionStep;
+use crate::executor::ExecutionResult;
 use crate::scalar::Scalar;
 use crate::serde::ArrayChildren;
 use crate::stats::StatsSetRef;
@@ -40,7 +41,7 @@ use crate::vtable::ValidityVTable;
 
 vtable!(Filter);
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Filter;
 
 impl Filter {
@@ -159,9 +160,9 @@ impl VTable for Filter {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        if let Some(canonical) = execute_filter_fast_paths(array, ctx)? {
-            return Ok(ExecutionStep::Done(canonical));
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        if let Some(canonical) = execute_filter_fast_paths(&array, ctx)? {
+            return Ok(ExecutionResult::done(canonical));
         }
         let Mask::Values(mask_values) = &array.mask else {
             unreachable!("`execute_filter_fast_paths` handles AllTrue and AllFalse")
@@ -169,7 +170,7 @@ impl VTable for Filter {
 
         // We rely on the optimization pass that runs prior to this execution for filter pushdown,
         // so now we can just execute the filter without worrying.
-        Ok(ExecutionStep::Done(
+        Ok(ExecutionResult::done(
             execute_filter(array.child.clone().execute(ctx)?, mask_values).into_array(),
         ))
     }
diff --git a/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs b/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs
index 3b6438773d4..2b0e3544872 100644
--- a/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs
+++ b/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -13,8 +14,7 @@ use vortex_session::VortexSession;
 use crate::ArrayRef;
 use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
-use crate::IntoArray;
+use crate::ExecutionResult;
 use crate::Precision;
 use crate::arrays::FixedSizeListArray;
 use crate::arrays::fixed_size_list::compute::rules::PARENT_RULES;
@@ -34,9 +34,10 @@ use crate::vtable::validity_to_child;
 mod kernel;
 mod operations;
 mod validity;
+
 vtable!(FixedSizeList);
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct FixedSizeList;
 
 impl FixedSizeList {
@@ -223,7 +224,7 @@ impl VTable for FixedSizeList {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(array.clone().into_array()))
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done_upcast::<Self>(array))
     }
 }
diff --git a/vortex-array/src/arrays/list/vtable/mod.rs b/vortex-array/src/arrays/list/vtable/mod.rs
index 0a7325d9998..33cf835c596 100644
--- a/vortex-array/src/arrays/list/vtable/mod.rs
+++ b/vortex-array/src/arrays/list/vtable/mod.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -13,7 +14,7 @@ use vortex_session::VortexSession;
 use crate::ArrayRef;
 use crate::DynArray;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
+use crate::ExecutionResult;
 use crate::IntoArray;
 use crate::Precision;
 use crate::ProstMetadata;
@@ -215,9 +216,9 @@ impl VTable for List {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(
-            list_view_from_list(array.clone(), ctx)?.into_array(),
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            list_view_from_list(ListArray::clone(&array), ctx)?.into_array(),
         ))
     }
 
@@ -231,7 +232,7 @@ impl VTable for List {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct List;
 
 impl List {
diff --git a/vortex-array/src/arrays/listview/vtable/mod.rs b/vortex-array/src/arrays/listview/vtable/mod.rs
index 21398950931..84e50ff072c 100644
--- a/vortex-array/src/arrays/listview/vtable/mod.rs
+++ b/vortex-array/src/arrays/listview/vtable/mod.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -13,8 +14,7 @@ use vortex_session::VortexSession;
 use crate::ArrayRef;
 use crate::DeserializeMetadata;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
-use crate::IntoArray;
+use crate::ExecutionResult;
 use crate::Precision;
 use crate::ProstMetadata;
 use crate::SerializeMetadata;
@@ -39,7 +39,7 @@ mod operations;
 mod validity;
 vtable!(ListView);
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct ListView;
 
 impl ListView {
@@ -243,8 +243,8 @@ impl VTable for ListView {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(array.clone().into_array()))
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done_upcast::<Self>(array))
     }
 
     fn reduce_parent(
diff --git a/vortex-array/src/arrays/masked/vtable/mod.rs b/vortex-array/src/arrays/masked/vtable/mod.rs
index e1d1b7e23b5..263c73cd4c5 100644
--- a/vortex-array/src/arrays/masked/vtable/mod.rs
+++ b/vortex-array/src/arrays/masked/vtable/mod.rs
@@ -5,6 +5,7 @@ mod operations;
 mod validity;
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -25,7 +26,7 @@ use crate::arrays::masked::mask_validity_canonical;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::executor::ExecutionCtx;
-use crate::executor::ExecutionStep;
+use crate::executor::ExecutionResult;
 use crate::hash::ArrayEq;
 use crate::hash::ArrayHash;
 use crate::scalar::Scalar;
@@ -40,7 +41,7 @@ use crate::vtable::validity_nchildren;
 use crate::vtable::validity_to_child;
 vtable!(Masked);
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Masked;
 
 impl Masked {
@@ -165,12 +166,12 @@ impl VTable for Masked {
         MaskedArray::try_new(child, validity)
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
         let validity_mask = array.validity_mask()?;
 
         // Fast path: all masked means result is all nulls.
         if validity_mask.all_false() {
-            return Ok(ExecutionStep::Done(
+            return Ok(ExecutionResult::done(
                 ConstantArray::new(Scalar::null(array.dtype().as_nullable()), array.len())
                     .into_array(),
             ));
@@ -183,7 +184,7 @@ impl VTable for Masked {
         // `AllTrue` masks (no data copying), so there's no benefit.
 
         let child = array.child().clone().execute::<Canonical>(ctx)?;
-        Ok(ExecutionStep::Done(
+        Ok(ExecutionResult::done(
             mask_validity_canonical(child, &validity_mask, ctx)?.into_array(),
         ))
     }
diff --git a/vortex-array/src/arrays/null/mod.rs b/vortex-array/src/arrays/null/mod.rs
index 673f153f031..38dd3665f5e 100644
--- a/vortex-array/src/arrays/null/mod.rs
+++ b/vortex-array/src/arrays/null/mod.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
@@ -11,8 +12,7 @@ use vortex_session::VortexSession;
 use crate::ArrayRef;
 use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
-use crate::IntoArray;
+use crate::ExecutionResult;
 use crate::Precision;
 use crate::arrays::null::compute::rules::PARENT_RULES;
 use crate::buffer::BufferHandle;
@@ -136,8 +136,8 @@ impl VTable for Null {
         PARENT_RULES.evaluate(array, parent, child_idx)
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(array.clone().into_array()))
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done_upcast::<Self>(array))
     }
 }
 
@@ -174,7 +174,7 @@ pub struct NullArray {
     stats_set: ArrayStats,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Null;
 
 impl Null {
diff --git a/vortex-array/src/arrays/primitive/vtable/mod.rs b/vortex-array/src/arrays/primitive/vtable/mod.rs
index 6343f48e014..0eab4f5dece 100644
--- a/vortex-array/src/arrays/primitive/vtable/mod.rs
+++ b/vortex-array/src/arrays/primitive/vtable/mod.rs
@@ -11,8 +11,7 @@ use vortex_error::vortex_panic;
 use crate::ArrayRef;
 use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
-use crate::IntoArray;
+use crate::ExecutionResult;
 use crate::arrays::PrimitiveArray;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
@@ -30,6 +29,7 @@ mod validity;
 
 use std::hash::Hash;
 use std::hash::Hasher;
+use std::sync::Arc;
 
 use vortex_buffer::Alignment;
 use vortex_session::VortexSession;
@@ -203,8 +203,8 @@ impl VTable for Primitive {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(array.clone().into_array()))
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done_upcast::<Self>(array))
     }
 
     fn reduce_parent(
@@ -225,7 +225,7 @@ impl VTable for Primitive {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Primitive;
 
 impl Primitive {
diff --git a/vortex-array/src/arrays/scalar_fn/vtable/mod.rs b/vortex-array/src/arrays/scalar_fn/vtable/mod.rs
index e2d5c396630..28619eb778d 100644
--- a/vortex-array/src/arrays/scalar_fn/vtable/mod.rs
+++ b/vortex-array/src/arrays/scalar_fn/vtable/mod.rs
@@ -8,6 +8,7 @@ use std::hash::Hash;
 use std::hash::Hasher;
 use std::marker::PhantomData;
 use std::ops::Deref;
+use std::sync::Arc;
 
 use itertools::Itertools;
 use vortex_error::VortexResult;
@@ -29,7 +30,7 @@ use crate::arrays::scalar_fn::rules::RULES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::executor::ExecutionCtx;
-use crate::executor::ExecutionStep;
+use crate::executor::ExecutionResult;
 use crate::expr::Expression;
 use crate::matcher::Matcher;
 use crate::scalar_fn;
@@ -203,13 +204,13 @@ impl VTable for ScalarFnVTable {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
         ctx.log(format_args!("scalar_fn({}): executing", array.scalar_fn()));
         let args = VecExecutionArgs::new(array.children.clone(), array.len);
         array
             .scalar_fn()
             .execute(&args, ctx)
-            .map(ExecutionStep::Done)
+            .map(ExecutionResult::done)
     }
 
     fn reduce(array: &Self::Array) -> VortexResult<Option<ArrayRef>> {
diff --git a/vortex-array/src/arrays/shared/vtable.rs b/vortex-array/src/arrays/shared/vtable.rs
index 675ac56abce..ba5ea8f5e3f 100644
--- a/vortex-array/src/arrays/shared/vtable.rs
+++ b/vortex-array/src/arrays/shared/vtable.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::hash::Hash;
+use std::sync::Arc;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -12,7 +13,7 @@ use crate::ArrayRef;
 use crate::Canonical;
 use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
+use crate::ExecutionResult;
 use crate::Precision;
 use crate::arrays::SharedArray;
 use crate::buffer::BufferHandle;
@@ -32,7 +33,7 @@ vtable!(Shared);
 
 // TODO(ngates): consider hooking Shared into the iterative execution model. Cache either the
 //  most executed, or after each iteration, and return a shared cache for each execution.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Shared;
 
 impl Shared {
@@ -149,10 +150,10 @@ impl VTable for Shared {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
         array
             .get_or_compute(|source| source.clone().execute::<Canonical>(ctx))
-            .map(ExecutionStep::Done)
+            .map(ExecutionResult::done)
     }
 }
 impl OperationsVTable<Shared> for Shared {
diff --git a/vortex-array/src/arrays/slice/vtable.rs b/vortex-array/src/arrays/slice/vtable.rs
index 535affae3e0..74d31023f50 100644
--- a/vortex-array/src/arrays/slice/vtable.rs
+++ b/vortex-array/src/arrays/slice/vtable.rs
@@ -6,6 +6,7 @@ use std::fmt::Formatter;
 use std::hash::Hash;
 use std::hash::Hasher;
 use std::ops::Range;
+use std::sync::Arc;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -26,7 +27,7 @@ use crate::arrays::slice::rules::PARENT_RULES;
 use crate::buffer::BufferHandle;
 use crate::dtype::DType;
 use crate::executor::ExecutionCtx;
-use crate::executor::ExecutionStep;
+use crate::executor::ExecutionResult;
 use crate::scalar::Scalar;
 use crate::serde::ArrayChildren;
 use crate::stats::StatsSetRef;
@@ -39,7 +40,7 @@ use crate::vtable::ValidityVTable;
 
 vtable!(Slice);
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Slice;
 
 impl Slice {
@@ -159,7 +160,7 @@ impl VTable for Slice {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
         // Execute the child to get canonical form, then slice it
         let Some(canonical) = array.child.as_opt::<AnyCanonical>() else {
             // If the child is not canonical, recurse.
@@ -168,14 +169,14 @@ impl VTable for Slice {
                 .clone()
                 .execute::<ArrayRef>(ctx)?
                 .slice(array.slice_range().clone())
-                .map(ExecutionStep::Done);
+                .map(ExecutionResult::done);
         };
 
         // TODO(ngates): we should inline canonical slice logic here.
         Canonical::from(canonical)
             .as_ref()
             .slice(array.range.clone())
-            .map(ExecutionStep::Done)
+            .map(ExecutionResult::done)
     }
 
     fn reduce_parent(
diff --git a/vortex-array/src/arrays/struct_/vtable/mod.rs b/vortex-array/src/arrays/struct_/vtable/mod.rs
index 8868b7cc8c3..cb0b089d650 100644
--- a/vortex-array/src/arrays/struct_/vtable/mod.rs
+++ b/vortex-array/src/arrays/struct_/vtable/mod.rs
@@ -15,8 +15,7 @@ use vortex_session::VortexSession;
 use crate::ArrayRef;
 use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
-use crate::IntoArray;
+use crate::ExecutionResult;
 use crate::arrays::StructArray;
 use crate::arrays::struct_::compute::rules::PARENT_RULES;
 use crate::buffer::BufferHandle;
@@ -211,8 +210,8 @@ impl VTable for Struct {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(array.clone().into_array()))
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done_upcast::<Self>(array))
     }
 
     fn reduce_parent(
@@ -233,7 +232,7 @@ impl VTable for Struct {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Struct;
 
 impl Struct {
diff --git a/vortex-array/src/arrays/varbin/vtable/mod.rs b/vortex-array/src/arrays/varbin/vtable/mod.rs
index def655047b8..8adf733a34a 100644
--- a/vortex-array/src/arrays/varbin/vtable/mod.rs
+++ b/vortex-array/src/arrays/varbin/vtable/mod.rs
@@ -10,7 +10,7 @@ use vortex_error::vortex_panic;
 use crate::ArrayRef;
 use crate::DeserializeMetadata;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
+use crate::ExecutionResult;
 use crate::IntoArray;
 use crate::ProstMetadata;
 use crate::SerializeMetadata;
@@ -32,6 +32,7 @@ mod kernel;
 mod operations;
 mod validity;
 use std::hash::Hash;
+use std::sync::Arc;
 
 use canonical::varbin_to_canonical;
 use kernel::PARENT_KERNELS;
@@ -223,14 +224,14 @@ impl VTable for VarBin {
         PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(
-            varbin_to_canonical(array, ctx)?.into_array(),
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done(
+            varbin_to_canonical(&array, ctx)?.into_array(),
         ))
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct VarBin;
 
 impl VarBin {
diff --git a/vortex-array/src/arrays/varbinview/vtable/mod.rs b/vortex-array/src/arrays/varbinview/vtable/mod.rs
index 5e927a89a2d..9794c733009 100644
--- a/vortex-array/src/arrays/varbinview/vtable/mod.rs
+++ b/vortex-array/src/arrays/varbinview/vtable/mod.rs
@@ -17,8 +17,7 @@ use vortex_session::VortexSession;
 use crate::ArrayRef;
 use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
-use crate::IntoArray;
+use crate::ExecutionResult;
 use crate::Precision;
 use crate::arrays::VarBinViewArray;
 use crate::arrays::varbinview::BinaryView;
@@ -41,7 +40,7 @@ mod operations;
 mod validity;
 vtable!(VarBinView);
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct VarBinView;
 
 impl VarBinView {
@@ -247,7 +246,7 @@ impl VTable for VarBinView {
         PARENT_KERNELS.execute(array, parent, child_idx, ctx)
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        Ok(ExecutionStep::Done(array.clone().into_array()))
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        Ok(ExecutionResult::done_upcast::<Self>(array))
     }
 }
diff --git a/vortex-array/src/arrays/variant/vtable/mod.rs b/vortex-array/src/arrays/variant/vtable/mod.rs
index 8cdfb123ea0..24fb0f51577 100644
--- a/vortex-array/src/arrays/variant/vtable/mod.rs
+++ b/vortex-array/src/arrays/variant/vtable/mod.rs
@@ -5,6 +5,7 @@ mod operations;
 mod validity;
 
 use std::hash::Hasher;
+use std::sync::Arc;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -16,7 +17,7 @@ use crate::ArrayHash;
 use crate::ArrayRef;
 use crate::EmptyMetadata;
 use crate::ExecutionCtx;
-use crate::ExecutionStep;
+use crate::ExecutionResult;
 use crate::IntoArray;
 use crate::Precision;
 use crate::arrays::VariantArray;
@@ -30,7 +31,7 @@ use crate::vtable::VTable;
 
 vtable!(Variant);
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Variant;
 
 impl Variant {
@@ -154,8 +155,8 @@ impl VTable for Variant {
         Ok(())
     }
 
-    fn execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
+    fn execute(array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
         // VariantArray is the canonical variant representation.
-        Ok(ExecutionStep::done(array.clone().into_array()))
+        Ok(ExecutionResult::done(array.as_ref().clone().into_array()))
     }
 }
diff --git a/vortex-array/src/executor.rs b/vortex-array/src/executor.rs
index da05450f8de..52bfcf79b77 100644
--- a/vortex-array/src/executor.rs
+++ b/vortex-array/src/executor.rs
@@ -21,6 +21,8 @@ use crate::DynArray;
 use crate::IntoArray;
 use crate::matcher::Matcher;
 use crate::optimizer::ArrayOptimizer;
+use crate::vtable::VTable;
+use crate::vtable::upcast_array;
 
 /// Maximum number of iterations to attempt when executing an array before giving up and returning
 /// an error.
@@ -141,22 +143,24 @@ impl dyn DynArray + '_ {
                 continue;
             }
 
-            // Execute the array itself
-            match current.vtable().execute(&current, ctx)? {
+            // Execute the array itself.
+            let result = execute_step(current, ctx)?;
+            let (array, step) = result.into_parts();
+            match step {
                 ExecutionStep::ExecuteChild(i, done) => {
-                    let child = current
+                    let child = array
                         .nth_child(i)
                         .vortex_expect("ExecuteChild index in bounds");
                     ctx.log(format_args!(
                         "ExecuteChild({i}): pushing {}, focusing on {}",
-                        current, child
+                        array, child
                     ));
-                    stack.push((current, i, done));
+                    stack.push((array, i, done));
                     current = child.optimize()?;
                 }
-                ExecutionStep::Done(result) => {
-                    ctx.log(format_args!("Done: {} -> {}", current, result));
-                    current = result;
+                ExecutionStep::Done => {
+                    ctx.log(format_args!("Done: {}", array));
+                    current = array;
                 }
             }
         }
@@ -286,6 +290,7 @@ impl Executable for ArrayRef {
 
         // 3. execute_parent (child-driven optimized execution)
         for child_idx in 0..array.nchildren() {
+            // TODO(joe): remove internal copy in nth_child.
             let child = array.nth_child(child_idx).vortex_expect("checked length");
             if let Some(executed_parent) = child
                 .vtable()
@@ -305,12 +310,14 @@ impl Executable for ArrayRef {
             }
         }
 
-        // 4. execute (returns an ExecutionStep)
+        // 4. execute (returns an ExecutionResult)
         ctx.log(format_args!("executing {}", array));
-        match array.vtable().execute(&array, ctx)? {
-            ExecutionStep::Done(result) => {
-                ctx.log(format_args!("-> {}", result.as_ref()));
-                Ok(result)
+        let result = execute_step(array, ctx)?;
+        let (array, step) = result.into_parts();
+        match step {
+            ExecutionStep::Done => {
+                ctx.log(format_args!("-> {}", array.as_ref()));
+                Ok(array)
             }
             ExecutionStep::ExecuteChild(i, _) => {
                 // For single-step execution, handle ExecuteChild by executing the child,
@@ -323,6 +330,14 @@ impl Executable for ArrayRef {
     }
 }
 
+/// Execute a single step on an array, consuming it.
+///
+/// Extracts the vtable before consuming the array to avoid borrow conflicts.
+fn execute_step(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+    let vtable = array.vtable().clone_boxed();
+    vtable.execute(array, ctx)
+}
+
 /// Try execute_parent on each child of the array.
 fn try_execute_parent(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Option<ArrayRef>> {
     for child_idx in 0..array.nchildren() {
@@ -343,7 +358,7 @@ fn try_execute_parent(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<
 /// A predicate that determines when an array has reached a desired form during execution.
 pub type DonePredicate = fn(&dyn DynArray) -> bool;
 
-/// The result of a single execution step on an array encoding.
+/// Metadata-only step indicator returned alongside an array in [`ExecutionResult`].
 ///
 /// Instead of recursively executing children, encodings return an `ExecutionStep` that tells the
 /// scheduler what to do next. This enables the scheduler to manage execution iteratively using
@@ -355,25 +370,11 @@ pub enum ExecutionStep {
     ///
     /// Between steps, the scheduler runs reduce/reduce_parent rules to fixpoint, enabling
     /// cross-step optimization (e.g., pushing scalar functions through newly-decoded children).
-    ///
-    /// Use [`ExecutionStep::execute_child`] instead of constructing this variant directly.
     ExecuteChild(usize, DonePredicate),
 
-    /// Execution is complete. The result may be in any encoding — not necessarily canonical.
-    /// The scheduler will continue executing the result if it has not yet reached the target form.
-    Done(ArrayRef),
-}
-
-impl ExecutionStep {
-    /// Request execution of child at `child_idx` until it matches the given [`Matcher`].
-    pub fn execute_child<M: Matcher>(child_idx: usize) -> Self {
-        ExecutionStep::ExecuteChild(child_idx, M::matches)
-    }
-
-    /// Signal that execution is complete with the given result.
-    pub fn done(result: ArrayRef) -> Self {
-        ExecutionStep::Done(result)
-    }
+    /// Execution is complete. The array in the accompanying [`ExecutionResult`] is the result.
+    /// The scheduler will continue executing if it has not yet reached the target form.
+    Done,
 }
 
 impl fmt::Debug for ExecutionStep {
@@ -382,9 +383,69 @@ impl fmt::Debug for ExecutionStep {
             ExecutionStep::ExecuteChild(idx, _) => {
                 f.debug_tuple("ExecuteChild").field(idx).finish()
             }
-            ExecutionStep::Done(result) => f.debug_tuple("Done").field(result).finish(),
+            ExecutionStep::Done => write!(f, "Done"),
+        }
+    }
+}
+
+/// The result of a single execution step on an array encoding.
+///
+/// Combines an [`ArrayRef`] with an [`ExecutionStep`] to tell the scheduler both what to do next
+/// and what array to work with.
+pub struct ExecutionResult {
+    array: ArrayRef,
+    step: ExecutionStep,
+}
+
+impl ExecutionResult {
+    /// Signal that execution is complete with the given result array.
+    pub fn done(result: impl IntoArray) -> Self {
+        Self {
+            array: result.into_array(),
+            step: ExecutionStep::Done,
         }
     }
+
+    pub fn done_upcast<V: VTable>(arr: Arc<V::Array>) -> Self {
+        Self {
+            array: upcast_array::<V>(arr),
+            step: ExecutionStep::Done,
+        }
+    }
+
+    /// Request execution of child at `child_idx` until it matches the given [`Matcher`].
+    ///
+    /// The provided array is the (possibly modified) parent that still needs its child executed.
+    pub fn execute_child<M: Matcher>(array: impl IntoArray, child_idx: usize) -> Self {
+        Self {
+            array: array.into_array(),
+            step: ExecutionStep::ExecuteChild(child_idx, M::matches),
+        }
+    }
+
+    /// Returns a reference to the array.
+    pub fn array(&self) -> &ArrayRef {
+        &self.array
+    }
+
+    /// Returns a reference to the step.
+    pub fn step(&self) -> &ExecutionStep {
+        &self.step
+    }
+
+    /// Decompose into parts.
+    pub fn into_parts(self) -> (ArrayRef, ExecutionStep) {
+        (self.array, self.step)
+    }
+}
+
+impl fmt::Debug for ExecutionResult {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ExecutionResult")
+            .field("array", &self.array)
+            .field("step", &self.step)
+            .finish()
+    }
 }
 
 /// Extension trait for creating an execution context from a session.
diff --git a/vortex-array/src/vtable/dyn_.rs b/vortex-array/src/vtable/dyn_.rs
index 0520ad9aaa1..9d53a60938c 100644
--- a/vortex-array/src/vtable/dyn_.rs
+++ b/vortex-array/src/vtable/dyn_.rs
@@ -13,6 +13,7 @@ use vortex_session::VortexSession;
 use crate::ArrayAdapter;
 use crate::ArrayRef;
 use crate::DynArray;
+use crate::ExecutionResult;
 use crate::ExecutionStep;
 use crate::IntoArray;
 use crate::buffer::BufferHandle;
@@ -32,6 +33,9 @@ pub type DynVTableRef = Arc<dyn DynVTable>;
 /// This trait contains the implementation API for Vortex arrays, allowing us to keep the public
 /// [`DynArray`] trait API to a minimum.
 pub trait DynVTable: 'static + Send + Sync + Debug {
+    /// Clone this vtable into a `Box<dyn DynVTable>`.
+    fn clone_boxed(&self) -> Box<dyn DynVTable>;
+
     #[allow(clippy::too_many_arguments)]
     fn build(
         &self,
@@ -57,7 +61,7 @@ pub trait DynVTable: 'static + Send + Sync + Debug {
     ) -> VortexResult<Option<ArrayRef>>;
 
     /// See [`VTable::execute`]
-    fn execute(&self, array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep>;
+    fn execute(&self, array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult>;
 
     /// See [`VTable::execute_parent`]
     fn execute_parent(
@@ -70,6 +74,10 @@ pub trait DynVTable: 'static + Send + Sync + Debug {
 }
 
 impl<V: VTable> DynVTable for V {
+    fn clone_boxed(&self) -> Box<dyn DynVTable> {
+        Box::new(self.clone())
+    }
+
     fn build(
         &self,
         _id: ArrayId,
@@ -138,31 +146,34 @@ impl<V: VTable> DynVTable for V {
         Ok(Some(reduced))
     }
 
-    fn execute(&self, array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
-        let step = V::execute(downcast::<V>(array), ctx)?;
+    fn execute(&self, array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
+        // Capture metadata before the move for post-validation and stats inheritance.
+        let len = array.len();
+        let dtype = array.dtype().clone();
+        let stats = array.statistics().to_owned();
 
-        if let ExecutionStep::Done(ref result) = step {
+        let owned = downcast_owned::<V>(array);
+        let result = V::execute(owned, ctx)?;
+
+        if matches!(result.step(), ExecutionStep::Done) {
             if cfg!(debug_assertions) {
                 vortex_ensure!(
-                    result.as_ref().len() == array.len(),
+                    result.array().len() == len,
                     "Result length mismatch for {:?}",
                     self
                 );
                 vortex_ensure!(
-                    result.as_ref().dtype() == array.dtype(),
+                    result.array().dtype() == &dtype,
                     "Executed canonical dtype mismatch for {:?}",
                     self
                 );
             }
 
             // TODO(ngates): do we want to do this on every execution? We used to in to_canonical.
-            result
-                .as_ref()
-                .statistics()
-                .inherit_from(array.statistics());
+            result.array().statistics().set_iter(stats.into_iter());
         }
 
-        Ok(step)
+        Ok(result)
     }
 
     fn execute_parent(
@@ -198,3 +209,30 @@ fn downcast<V: VTable>(array: &ArrayRef) -> &V::Array {
         .vortex_expect("Failed to downcast array to expected encoding type")
         .as_inner()
 }
+
+/// Downcast an `ArrayRef` into an `Arc<V::Array>` without cloning.
+///
+/// This is a zero-cost pointer cast leveraging the `#[repr(transparent)]` layout of
+/// [`ArrayAdapter`].
+fn downcast_owned<V: VTable>(array: ArrayRef) -> Arc<V::Array> {
+    let adapter: Arc<ArrayAdapter<V>> = array
+        .as_any_arc()
+        .downcast::<ArrayAdapter<V>>()
+        .ok()
+        .vortex_expect("Failed to downcast array to expected encoding type");
+    // SAFETY: ArrayAdapter<V> is #[repr(transparent)] over V::Array,
+    // so Arc<ArrayAdapter<V>> and Arc<V::Array> have identical layout.
+    let raw = Arc::into_raw(adapter) as *const V::Array;
+    unsafe { Arc::from_raw(raw) }
+}
+
+/// Upcast an `Arc<V::Array>` into an `ArrayRef` without cloning.
+///
+/// This is a zero-cost pointer cast leveraging the `#[repr(transparent)]` layout of
+/// [`ArrayAdapter`]. It is the reverse of `downcast_owned`.
+pub(crate) fn upcast_array<V: VTable>(array: Arc<V::Array>) -> ArrayRef {
+    // SAFETY: ArrayAdapter<V> is #[repr(transparent)] over V::Array,
+    // so Arc<V::Array> and Arc<ArrayAdapter<V>> have identical layout.
+    let raw = Arc::into_raw(array) as *const ArrayAdapter<V>;
+    unsafe { Arc::from_raw(raw) }
+}
diff --git a/vortex-array/src/vtable/mod.rs b/vortex-array/src/vtable/mod.rs
index 4018c8b9ead..c6ef0af88b8 100644
--- a/vortex-array/src/vtable/mod.rs
+++ b/vortex-array/src/vtable/mod.rs
@@ -10,6 +10,7 @@ mod validity;
 use std::fmt::Debug;
 use std::hash::Hasher;
 use std::ops::Deref;
+use std::sync::Arc;
 
 pub use dyn_::*;
 pub use operations::*;
@@ -22,7 +23,7 @@ use vortex_session::VortexSession;
 use crate::ArrayRef;
 use crate::Canonical;
 use crate::DynArray;
-use crate::ExecutionStep;
+use crate::ExecutionResult;
 use crate::IntoArray;
 use crate::Precision;
 use crate::arrays::ConstantArray;
@@ -48,7 +49,7 @@ use crate::validity::Validity;
 /// implementations so do not need to be checked in the vtable implementations (for example, index
 /// out of bounds). Post-conditions are validated after invocation of the vtable function and will
 /// panic if violated.
-pub trait VTable: 'static + Sized + Send + Sync + Debug {
+pub trait VTable: 'static + Clone + Sized + Send + Sync + Debug {
     type Array: 'static + Send + Sync + Clone + Debug + Deref<Target = dyn DynArray> + IntoArray;
     type Metadata: Debug;
 
@@ -186,13 +187,12 @@ pub trait VTable: 'static + Sized + Send + Sync + Debug {
     /// of children must be expected.
     fn with_children(array: &mut Self::Array, children: Vec<ArrayRef>) -> VortexResult<()>;
 
-    /// Execute this array by returning an [`ExecutionStep`] that tells the scheduler what to
+    /// Execute this array by returning an [`ExecutionResult`] that tells the scheduler what to
     /// do next.
     ///
     /// Instead of recursively executing children, implementations should return
-    /// [`ExecutionStep::ExecuteChild`] to request that the scheduler execute a child first,
-    /// or [`ExecutionStep::Done`] when the
-    /// encoding can produce a result directly.
+    /// [`ExecutionResult::execute_child`] to request that the scheduler execute a child first,
+    /// or [`ExecutionResult::done`] when the encoding can produce a result directly.
     ///
     /// Array execution is designed such that repeated execution of an array will eventually
     /// converge to a canonical representation. Implementations of this function should therefore
@@ -203,7 +203,7 @@ pub trait VTable: 'static + Sized + Send + Sync + Debug {
     ///
     /// Debug builds will panic if the returned array is of the wrong type, wrong length, or
     /// incorrectly contains null values.
-    fn execute(array: &Self::Array, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep>;
+    fn execute(array: Arc<Self::Array>, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult>;
 
     /// Attempt to execute the parent of this array.
     ///
diff --git a/vortex-python/src/arrays/py/vtable.rs b/vortex-python/src/arrays/py/vtable.rs
index c677c66d645..d25d2510c62 100644
--- a/vortex-python/src/arrays/py/vtable.rs
+++ b/vortex-python/src/arrays/py/vtable.rs
@@ -9,7 +9,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyBytes;
 use vortex::array::ArrayRef;
 use vortex::array::ExecutionCtx;
-use vortex::array::ExecutionStep;
+use vortex::array::ExecutionResult;
 use vortex::array::Precision;
 use vortex::array::RawMetadata;
 use vortex::array::SerializeMetadata;
@@ -161,7 +161,7 @@ impl VTable for PythonVTable {
         Ok(())
     }
 
-    fn execute(_array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
+    fn execute(_array: Arc<Self::Array>, _ctx: &mut ExecutionCtx) -> VortexResult<ExecutionResult> {
         todo!()
     }
 }