@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! `Widen` operations over a `BitPacked` child.
+//!
+//! Selection and comparison keep the stored width of the child, aggregates read the child, and
+//! canonical execution widens the values to the logical dtype of the `Widen`.
+
+#![cfg(test)]
+
+use std::sync::LazyLock;
+
+use rstest::rstest;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::aggregate_fn::NumericalAggregateOpts;
+use vortex_array::aggregate_fn::fns::is_constant::is_constant;
+use vortex_array::aggregate_fn::fns::is_sorted::is_sorted;
+use vortex_array::aggregate_fn::fns::is_sorted::is_strict_sorted;
+use vortex_array::aggregate_fn::fns::min_max::min_max;
+use vortex_array::aggregate_fn::fns::sum::sum;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::arrays::Widen;
+use vortex_array::arrays::WidenArray;
+use vortex_array::arrays::widen::WidenArraySlotsExt;
+use vortex_array::assert_arrays_eq;
+use vortex_array::builtins::ArrayBuiltins;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::PType;
+use vortex_array::scalar::Scalar;
+use vortex_array::scalar_fn::fns::operators::Operator;
+use vortex_buffer::buffer;
+use vortex_error::VortexResult;
+use vortex_fastlanes::BitPacked;
+use vortex_mask::Mask;
+use vortex_session::VortexSession;
+
+static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+    let session = VortexSession::empty();
+    vortex_fastlanes::initialize(&session);
+    session
+});
+
+/// Returns a `u64` `Widen` over `values` packed at `bit_width` bits.
+fn widen_bitpacked(values: PrimitiveArray, bit_width: u8) -> VortexResult<ArrayRef> {
+    let mut ctx = SESSION.create_execution_ctx();
+    let packed = BitPacked::encode(&values.into_array(), bit_width, &mut ctx)?.into_array();
+    let dtype = DType::Primitive(PType::U64, packed.dtype().nullability());
+
+    Ok(WidenArray::try_new(packed, dtype)?.into_array())
+}
+
+#[test]
+fn test_operations() -> VortexResult<()> {
+    let mut ctx = SESSION.create_execution_ctx();
+    let array = widen_bitpacked(PrimitiveArray::from_iter([0u8, 1, 3, 7]), 3)?;
+
+    let selected = array.filter(Mask::from_iter([true, false, true, true]))?;
+    assert!(selected.is::<Widen>());
+    assert_eq!(selected.as_::<Widen>().values().dtype(), &PType::U8.into());
+    assert_arrays_eq!(selected, buffer![0u64, 3, 7].into_array(), &mut ctx);
+
+    assert_arrays_eq!(
+        array.take(buffer![3u32, 1].into_array())?,
+        buffer![7u64, 1].into_array(),
+        &mut ctx
+    );
+    assert_arrays_eq!(
+        array.binary(
+            ConstantArray::new(Scalar::from(3u64), 4).into_array(),
+            Operator::Lt
+        )?,
+        BoolArray::from_iter([true, true, false, false]),
+        &mut ctx
+    );
+    assert_eq!(
+        array.execute::<PrimitiveArray>(&mut ctx)?.as_slice::<u64>(),
+        &[0, 1, 3, 7]
+    );
+
+    Ok(())
+}
+
+#[rstest]
+#[case::sorted(PrimitiveArray::from_iter([0u8, 1, 3, 7]))]
+#[case::constant(PrimitiveArray::from_iter([5u8, 5, 5, 5]))]
+#[case::partially_valid(PrimitiveArray::from_option_iter([None, Some(6u8), Some(2), None]))]
+fn test_aggregates_match_canonical(#[case] values: PrimitiveArray) -> VortexResult<()> {
+    let mut ctx = SESSION.create_execution_ctx();
+    let canonical = widen_bitpacked(values.clone(), 3)?
+        .execute::<PrimitiveArray>(&mut ctx)?
+        .into_array();
+    let options = NumericalAggregateOpts::default();
+
+    // Each aggregate gets a fresh `Widen`. A statistic cached by an earlier aggregate, such as the
+    // min and max that `min_max` caches, would otherwise answer a later one before its kernel runs.
+    let widen = || widen_bitpacked(values.clone(), 3);
+
+    assert_eq!(
+        min_max(&widen()?, &mut ctx, options)?,
+        min_max(&canonical, &mut ctx, options)?
+    );
+    assert_eq!(
+        is_constant(&widen()?, &mut ctx)?,
+        is_constant(&canonical, &mut ctx)?
+    );
+    assert_eq!(
+        is_sorted(&widen()?, &mut ctx)?,
+        is_sorted(&canonical, &mut ctx)?
+    );
+    assert_eq!(
+        is_strict_sorted(&widen()?, &mut ctx)?,
+        is_strict_sorted(&canonical, &mut ctx)?
+    );
+    assert_eq!(sum(&widen()?, &mut ctx)?, sum(&canonical, &mut ctx)?);
+
+    Ok(())
+}
@@ -46,6 +46,7 @@ use crate::arrays::Chunked;
 use crate::arrays::Dict;
 use crate::arrays::Primitive;
 use crate::arrays::RunEnd;
+use crate::arrays::Widen;
 use crate::arrays::chunked::compute::aggregate::ChunkedArrayAggregate;
 use crate::arrays::dict::compute::is_constant::DictIsConstantKernel;
 use crate::arrays::dict::compute::is_sorted::DictIsSortedKernel;
@@ -54,6 +55,7 @@ use crate::arrays::runend::compute::is_constant::RunEndIsConstantKernel;
 use crate::arrays::runend::compute::is_sorted::RunEndIsSortedKernel;
 use crate::arrays::runend::compute::min_max::RunEndMinMaxKernel;
 use crate::arrays::runend::compute::sum::RunEndSumKernel;
+use crate::arrays::widen::compute::aggregate::WidenArrayAggregate;
 use crate::dtype::DType;
 use crate::dtype::extension::ExtVTable;
 use crate::extension::datetime::Date;
@@ -143,6 +145,12 @@ impl Default for AggregateFnSession {
         this.register_aggregate_kernel(RunEnd.id(), Some(IsSorted.id()), &RunEndIsSortedKernel);
         this.register_aggregate_kernel(RunEnd.id(), Some(Sum.id()), &RunEndSumKernel);
         this.register_aggregate_kernel(RunEnd.id(), Some(SumV2.id()), &RunEndSumKernel);
+        this.register_aggregate_kernel(Widen.id(), Some(MinMax.id()), &WidenArrayAggregate);
+        this.register_aggregate_kernel(Widen.id(), Some(Min.id()), &WidenArrayAggregate);
+        this.register_aggregate_kernel(Widen.id(), Some(Max.id()), &WidenArrayAggregate);
+        this.register_aggregate_kernel(Widen.id(), Some(IsConstant.id()), &WidenArrayAggregate);
+        this.register_aggregate_kernel(Widen.id(), Some(IsSorted.id()), &WidenArrayAggregate);
+        this.register_aggregate_kernel(Widen.id(), Some(Sum.id()), &WidenArrayAggregate);
 
         // Register the built-in grouped aggregate kernels.
         this.register_grouped_kernel(Count.id(), &CountGroupedKernel);
 
@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_error::VortexExpect;
+use vortex_error::VortexResult;
+
+use crate::ArrayRef;
+use crate::ExecutionCtx;
+use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::fns::sum::Sum;
+use crate::aggregate_fn::kernels::DynAggregateKernel;
+use crate::arrays::Widen;
+use crate::arrays::widen::WidenArraySlotsExt;
+use crate::dtype::DType;
+use crate::expr::stats::Stat;
+use crate::scalar::Scalar;
+
+/// Runs an aggregate of a [`Widen`] on its values and widens the partial to the logical dtype.
+///
+/// The values run the same accumulator code as the canonical array, so edge cases such as an empty
+/// batch or a single null match by construction, and the values keep their own cached statistics
+/// and kernels. [`Sum`] is served only when [`is_exact_sum`] holds.
+#[derive(Debug)]
+pub(crate) struct WidenArrayAggregate;
+
+impl DynAggregateKernel for WidenArrayAggregate {
+    fn aggregate(
+        &self,
+        aggregate_fn: &AggregateFnRef,
+        batch: &ArrayRef,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<Option<Scalar>> {
+        let Some(widen) = batch.as_opt::<Widen>() else {
+            return Ok(None);
+        };
+
+        // NB: Exactness rests on integer decoding. A decimal `Widen` (CD4 in #10733) needs its own
+        // argument, because `Sum` checks a decimal for overflow against the precision of its input.
+        if !batch.dtype().is_int() {
+            return Ok(None);
+        }
+
+        let values = widen.values();
+        if aggregate_fn.is::<Sum>() && !is_exact_sum(aggregate_fn, batch, values) {
+            return Ok(None);
+        }
+
+        let mut accumulator = aggregate_fn.accumulator(values.dtype())?;
+        accumulator.accumulate(values, ctx)?;
+
+        let partial_dtype = aggregate_fn.state_dtype(batch.dtype()).vortex_expect(
+            "an aggregate that accepts the values accepts the logical dtype, which is a wider \
+             integer of the same signedness",
+        );
+
+        Ok(Some(accumulator.flush()?.cast(&partial_dtype)?))
+    }
+}
+
+/// Returns whether the [`Sum`] of the values of `batch` equals the sum of the canonical batch.
+///
+/// - The accumulator **must** sum each batch from zero and then add the total to the running sum.
+///   It does so for an aggregate with the legacy [`Stat::Sum`] slot. Otherwise it adds each value
+///   to the running sum, which a batch total cannot match near the 64-bit bounds: from a running
+///   sum of `i64::MAX - 5`, the values `[10, -10]` overflow, but their total of zero does not.
+/// - The sum of the batch **must not** be able to overflow. `Sum` adds every integer type into a
+///   64-bit sum, but checks for overflow at different points for different widths: once per block
+///   for types narrower than 64 bits, and after every value for 64-bit types. A signed value of
+///   `b` bits lies in `[-2^(b-1), 2^(b-1))` and an unsigned one in `[0, 2^b)`, so no sum of at
+///   most `2^(64 - b)` of them leaves the range of `i64` or `u64`, and no check fires on either
+///   path.
+///
+/// Only `Sum` with `skip_nans` has the slot. Integers have no NaNs, so `skip_nans` matters here
+/// only because it selects the slot.
+fn is_exact_sum(aggregate_fn: &AggregateFnRef, batch: &ArrayRef, values: &ArrayRef) -> bool {
+    let DType::Primitive(values_ptype, _) = values.dtype() else {
+        return false;
+    };
+    let max_len = 1u64 << (64 - values_ptype.bit_width());
+
+    Stat::from_aggregate_fn(aggregate_fn) == Some(Stat::Sum) && batch.len() as u64 <= max_len
+}
@@ -1,8 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-//! Operations that run on the values of a [`Widen`](crate::arrays::Widen).
+//! Operations that run on the values of a [`Widen`](crate::arrays::Widen) instead of on a
+//! widened copy.
+//!
+//! An operation runs on the values only where it gives the canonical result. Decoding a value is a
+//! strictly increasing, one-to-one map that keeps validity, so comparisons, sortedness, constancy
+//! and extrema carry over from the values, and every value in a result widens exactly to the
+//! logical dtype.
+//!
+//! [`AggregateFnSession::default`] registers the aggregate kernel, not
+//! [`initialize`](super::initialize), because the kernel session runs `initialize` on a temporary
+//! session and drops its aggregate registry.
+//!
+//! [`AggregateFnSession::default`]: crate::aggregate_fn::session::AggregateFnSession::default
 
+pub(crate) mod aggregate;
 mod cast;
 mod compare;
 mod fill_null;
 
@@ -30,7 +30,7 @@ pub use array::WidenSlots;
 pub use array::WidenSlotsView;
 pub use vtable::WidenArray;
 
-mod compute;
+pub(crate) mod compute;
 mod encode;
 
 mod vtable;