diff --git a/vortex-array/src/arrays/scalar_fn/vtable/validity.rs b/vortex-array/src/arrays/scalar_fn/vtable/validity.rs
index 39ab8c2c466..4e8ab0c95c0 100644
--- a/vortex-array/src/arrays/scalar_fn/vtable/validity.rs
+++ b/vortex-array/src/arrays/scalar_fn/vtable/validity.rs
@@ -21,7 +21,6 @@ use crate::legacy_session;
 use crate::scalar_fn::TypedScalarFnInstance;
 use crate::scalar_fn::VecExecutionArgs;
 use crate::scalar_fn::fns::literal::Literal;
-use crate::scalar_fn::fns::root::Root;
 use crate::validity::Validity;
 
 /// Execute an expression tree recursively.
@@ -32,10 +31,10 @@ fn execute_expr(
     row_count: usize,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrayRef> {
-    // Handle Root expression - this should not happen in validity expressions
-    if expr.is::<Root>() {
-        vortex_bail!("Root expression cannot be executed in validity context");
-    }
+    // Only Expression::Scalar is executable
+    let Some(scalar_fn) = expr.as_scalar() else {
+        vortex_bail!("Only Expression::Scalar is executable");
+    };
 
     // Handle Literal expression - create a constant array
     if expr.is::<Literal>() {
@@ -52,7 +51,7 @@ fn execute_expr(
 
     let args = VecExecutionArgs::new(inputs, row_count);
 
-    Ok(expr.scalar_fn().execute(&args, ctx)?.into_array())
+    Ok(scalar_fn.execute(&args, ctx)?.into_array())
 }
 
 impl ValidityVTable<ScalarFn> for ScalarFn {
diff --git a/vortex-array/src/expr/analysis/fallible.rs b/vortex-array/src/expr/analysis/fallible.rs
index b6d45bd5483..ff43d51603b 100644
--- a/vortex-array/src/expr/analysis/fallible.rs
+++ b/vortex-array/src/expr/analysis/fallible.rs
@@ -8,7 +8,11 @@ use crate::expr::label_tree;
 pub fn label_is_fallible(expr: &Expression) -> BooleanLabels<'_> {
     label_tree(
         expr,
-        |expr| expr.signature().is_fallible(),
+        |expr| match expr {
+            Expression::Scalar { scalar_fn, .. } => scalar_fn.signature().is_fallible(),
+            // The scope itself cannot fail.
+            Expression::Root => false,
+        },
         |acc, &child| acc | child,
     )
 }
diff --git a/vortex-array/src/expr/analysis/immediate_access.rs b/vortex-array/src/expr/analysis/immediate_access.rs
index fd720607284..6c2e4975a92 100644
--- a/vortex-array/src/expr/analysis/immediate_access.rs
+++ b/vortex-array/src/expr/analysis/immediate_access.rs
@@ -9,7 +9,6 @@ use crate::expr::BoundExpression;
 use crate::expr::Expression;
 use crate::expr::analysis::AnnotationFn;
 use crate::scalar_fn::fns::get_item::GetItem;
-use crate::scalar_fn::fns::root::Root;
 use crate::scalar_fn::fns::select::Select;
 
 /// Returns the "free fields" for this expression node.
@@ -26,9 +25,10 @@ use crate::scalar_fn::fns::select::Select;
 ///
 /// # Annotation Rules
 ///
-/// - **[`Select`]**: Returns the included field names if the child is [`Root`].
-/// - **[`GetItem`] on [`Root`]**: Returns `[field_name]` if the child is [`Root`].
-/// - **[`Root`]**: Returns all field names from `scope` (conservative over-approximation).
+/// - **[`Select`]**: Returns the included field names if the child is [`Expression::Root`].
+/// - **[`GetItem`] on the root**: Returns `[field_name]` if the child is [`Expression::Root`].
+/// - **[`Expression::Root`]**: Returns all field names from `scope` (conservative
+///   over-approximation).
 /// - **Everything else**: Returns empty (annotations aggregate from children automatically).
 ///
 /// # Example
@@ -42,7 +42,7 @@ pub fn make_free_field_annotator(
 ) -> impl AnnotationFn<Expression, Annotation = FieldName> {
     move |expr: &Expression| {
         if let Some(selection) = expr.as_opt::<Select>() {
-            if expr.child(0).is::<Root>() {
+            if expr.child(0).is_root() {
                 return selection
                     .normalize_to_included_fields(scope.names())
                     .vortex_expect("Select fields must be valid for scope")
@@ -50,10 +50,10 @@ pub fn make_free_field_annotator(
                     .collect();
             }
         } else if let Some(field_name) = expr.as_opt::<GetItem>() {
-            if expr.child(0).is::<Root>() {
+            if expr.child(0).is_root() {
                 return vec![field_name.clone()];
             }
-        } else if expr.is::<Root>() {
+        } else if expr.is_root() {
             return scope.names().iter().cloned().collect();
         }
 
diff --git a/vortex-array/src/expr/analysis/strict.rs b/vortex-array/src/expr/analysis/strict.rs
index df2147df60a..01cc71d91c3 100644
--- a/vortex-array/src/expr/analysis/strict.rs
+++ b/vortex-array/src/expr/analysis/strict.rs
@@ -12,7 +12,11 @@ use crate::expr::Expression;
 pub fn label_strict(expr: &Expression) -> BooleanLabels<'_> {
     label_tree(
         expr,
-        |expr| expr.signature().is_strict(),
+        |expr| match expr {
+            Expression::Scalar { scalar_fn, .. } => scalar_fn.signature().is_strict(),
+            // Vacuously strict.
+            Expression::Root => true,
+        },
         |acc, &child| acc & child,
     )
 }
diff --git a/vortex-array/src/expr/bound_expression.rs b/vortex-array/src/expr/bound_expression.rs
index 26173171d91..d93da7d2580 100644
--- a/vortex-array/src/expr/bound_expression.rs
+++ b/vortex-array/src/expr/bound_expression.rs
@@ -18,7 +18,6 @@ use crate::expr::Expression;
 use crate::expr::display::DisplayTreeExpr;
 use crate::expr::scope::Scope;
 use crate::scalar_fn::ScalarFnRef;
-use crate::scalar_fn::fns::root::Root;
 
 /// An [`Expression`] that has been type-checked against a [`Scope`].
 ///
@@ -247,7 +246,7 @@ impl Expression {
 
     /// Bind this expression against an explicit [`Scope`].
     pub fn bind_scope(&self, scope: &Scope) -> VortexResult<BoundExpression> {
-        if self.is::<Root>() {
+        if self.is_root() {
             return Ok(BoundExpression::new_root(scope.root().clone()));
         }
 
@@ -256,7 +255,10 @@ impl Expression {
             .iter()
             .map(|child| child.bind_scope(scope))
             .try_collect()?;
-        BoundExpression::try_new(self.scalar_fn().clone(), children)
+        let scalar_fn = self
+            .as_scalar()
+            .vortex_expect("root was handled above, so this is a scalar node");
+        BoundExpression::try_new(scalar_fn.clone(), children)
     }
 }
 
diff --git a/vortex-array/src/expr/display.rs b/vortex-array/src/expr/display.rs
index d542f7d35b3..202ec857bd0 100644
--- a/vortex-array/src/expr/display.rs
+++ b/vortex-array/src/expr/display.rs
@@ -8,7 +8,6 @@ use std::fmt::Formatter;
 use crate::expr::BoundExpression;
 use crate::expr::BoundKind;
 use crate::expr::Expression;
-use crate::expr::root;
 use crate::scalar_fn::ChildName;
 
 pub enum DisplayFormat {
@@ -56,17 +55,26 @@ trait DisplayTreeNode: Sized {
     fn fmt_tree_node(&self, f: &mut Formatter<'_>) -> fmt::Result;
 }
 
+/// Tree-display label for the scope root.
+const ROOT_DISPLAY: &str = "vortex.root()";
+
 impl DisplayTreeNode for Expression {
     fn tree_children(&self) -> &[Self] {
-        Expression::children(self).as_slice()
+        Expression::children(self)
     }
 
     fn tree_child_name(&self, index: usize) -> ChildName {
-        self.scalar_fn().signature().child_name(index)
+        match self {
+            Expression::Scalar { scalar_fn, .. } => scalar_fn.signature().child_name(index),
+            Expression::Root => unreachable!("the scope root has no children"),
+        }
     }
 
     fn fmt_tree_node(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        Display::fmt(self.scalar_fn(), f)
+        match self {
+            Expression::Scalar { scalar_fn, .. } => Display::fmt(scalar_fn, f),
+            Expression::Root => write!(f, "{ROOT_DISPLAY}"),
+        }
     }
 }
 
@@ -85,7 +93,7 @@ impl DisplayTreeNode for BoundExpression {
     fn fmt_tree_node(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self.kind() {
             BoundKind::Scalar { scalar_fn, .. } => Display::fmt(scalar_fn, f),
-            BoundKind::Root => Display::fmt(root().scalar_fn(), f),
+            BoundKind::Root => write!(f, "{ROOT_DISPLAY}"),
         }
     }
 }
diff --git a/vortex-array/src/expr/expression.rs b/vortex-array/src/expr/expression.rs
index e53474ad040..44e2381b29b 100644
--- a/vortex-array/src/expr/expression.rs
+++ b/vortex-array/src/expr/expression.rs
@@ -6,10 +6,10 @@ use std::fmt::Debug;
 use std::fmt::Display;
 use std::fmt::Formatter;
 use std::hash::Hash;
-use std::ops::Deref;
 use std::sync::Arc;
 
 use itertools::Itertools;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_session::VortexSession;
@@ -20,27 +20,28 @@ use crate::expr::traversal::TraversalOrder;
 use crate::expr::traversal::pre_order_visit_down;
 use crate::scalar_fn::ScalarFnRef;
 use crate::scalar_fn::ScalarFnVTable;
-use crate::scalar_fn::fns::root::Root;
 use crate::stats::rewrite::StatsRewriteCtx;
 
+/// An empty child slice, returned by [`Expression::children`] for childless variants.
+const NO_CHILDREN: &[Expression] = &[];
+
 /// A node in a Vortex expression tree.
 ///
-/// Expressions represent scalar computations that can be performed on data. Each
-/// expression consists of an encoding (vtable), heap-allocated metadata, and child expressions.
+/// Most nodes are a scalar function applied to child expressions. [`Expression::Root`] is the scope
+/// itself: a language primitive rather than a registered function, because its dtype comes from the
+/// scope rather than from children and it is not executable. A [`ScalarFnVTable`] can answer neither
+/// of those, so `Root` is a variant instead.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct Expression {
-    /// The scalar fn for this node.
-    scalar_fn: ScalarFnRef,
-    /// Any children of this expression.
-    children: Arc<Vec<Expression>>,
-}
-
-impl Deref for Expression {
-    type Target = ScalarFnRef;
-
-    fn deref(&self) -> &Self::Target {
-        &self.scalar_fn
-    }
+pub enum Expression {
+    /// A scalar function applied to child expressions.
+    Scalar {
+        /// The scalar fn for this node.
+        scalar_fn: ScalarFnRef,
+        /// Any children of this expression.
+        children: Arc<Vec<Expression>>,
+    },
+    /// The full scope of the expression evaluation.
+    Root,
 }
 
 impl Expression {
@@ -58,62 +59,114 @@ impl Expression {
             children.len()
         );
 
-        Ok(Self {
+        Ok(Self::Scalar {
             scalar_fn,
             children: children.into(),
         })
     }
 
-    /// Returns the scalar fn vtable for this expression.
-    pub fn scalar_fn(&self) -> &ScalarFnRef {
-        &self.scalar_fn
+    /// Whether this expression is the scope root.
+    pub fn is_root(&self) -> bool {
+        matches!(self, Self::Root)
+    }
+
+    /// Returns the scalar fn for this expression, or `None` if it is not a scalar node.
+    pub fn as_scalar(&self) -> Option<&ScalarFnRef> {
+        match self {
+            Self::Scalar { scalar_fn, .. } => Some(scalar_fn),
+            Self::Root => None,
+        }
+    }
+
+    /// Whether this expression's scalar fn is of the given vtable type.
+    pub fn is<V: ScalarFnVTable>(&self) -> bool {
+        self.as_scalar().is_some_and(|sf| sf.is::<V>())
+    }
+
+    /// The typed options for this expression if its scalar fn matches the given vtable type.
+    pub fn as_opt<V: ScalarFnVTable>(&self) -> Option<&V::Options> {
+        self.as_scalar().and_then(|sf| sf.as_opt::<V>())
+    }
+
+    /// The typed options for this expression.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the vtable type does not match.
+    pub fn as_<V: ScalarFnVTable>(&self) -> &V::Options {
+        self.as_opt::<V>()
+            .vortex_expect("Expression options type mismatch")
     }
 
     /// Returns the children of this expression.
-    pub fn children(&self) -> &Arc<Vec<Expression>> {
-        &self.children
+    pub fn children(&self) -> &[Expression] {
+        match self {
+            Self::Scalar { children, .. } => children.as_slice(),
+            Self::Root => NO_CHILDREN,
+        }
     }
 
     /// Returns the n'th child of this expression.
     pub fn child(&self, n: usize) -> &Expression {
-        &self.children[n]
+        &self.children()[n]
     }
 
     /// Replace the children of this expression with the provided new children.
     pub fn with_children(
-        mut self,
+        self,
         children: impl IntoIterator<Item = Expression>,
     ) -> VortexResult<Self> {
         let children = Vec::from_iter(children);
-        vortex_ensure!(
-            self.signature().arity().matches(children.len()),
-            "Expression arity mismatch: expected {} children but got {}",
-            self.signature().arity(),
-            children.len()
-        );
-        self.children = Arc::new(children);
-        Ok(self)
+        match &self {
+            Self::Root => {
+                vortex_ensure!(
+                    children.is_empty(),
+                    "Expression arity mismatch: root expects 0 children but got {}",
+                    children.len()
+                );
+                Ok(Self::Root)
+            }
+            Self::Scalar { scalar_fn, .. } => {
+                vortex_ensure!(
+                    scalar_fn.signature().arity().matches(children.len()),
+                    "Expression arity mismatch: expected {} children but got {}",
+                    scalar_fn.signature().arity(),
+                    children.len()
+                );
+                Ok(Self::Scalar {
+                    scalar_fn: scalar_fn.clone(),
+                    children: children.into(),
+                })
+            }
+        }
     }
 
     /// Computes the return dtype of this expression given the input dtype.
     pub fn return_dtype(&self, scope: &DType) -> VortexResult<DType> {
-        if self.is::<Root>() {
-            return Ok(scope.clone());
+        match self {
+            Self::Root => Ok(scope.clone()),
+            Self::Scalar {
+                scalar_fn,
+                children,
+            } => {
+                let dtypes: Vec<_> = children
+                    .iter()
+                    .map(|c| c.return_dtype(scope))
+                    .try_collect()?;
+                scalar_fn.return_dtype(&dtypes)
+            }
         }
-
-        let dtypes: Vec<_> = self
-            .children
-            .iter()
-            .map(|c| c.return_dtype(scope))
-            .try_collect()?;
-        self.scalar_fn.return_dtype(&dtypes)
     }
 
     /// Returns a new expression representing the validity mask output of this expression.
     ///
     /// The returned expression evaluates to a non-nullable boolean array.
     pub fn validity(&self) -> VortexResult<Expression> {
-        self.scalar_fn.validity(self)
+        match self {
+            // The scope is exactly as valid as itself.
+            Self::Root => Ok(Self::Root),
+            Self::Scalar { scalar_fn, .. } => scalar_fn.validity(self),
+        }
     }
 
     /// Returns an expression that proves this predicate is definitely false from stats.
@@ -149,7 +202,10 @@ impl Expression {
     /// Since this is a recursive formatter, it is exposed on the public Expression type.
     /// See fmt_data that is only implemented on the vtable trait.
     pub fn fmt_sql(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        self.scalar_fn().fmt_sql(self, f)
+        match self {
+            Self::Root => write!(f, "$"),
+            Self::Scalar { scalar_fn, .. } => scalar_fn.fmt_sql(self, f),
+        }
     }
 
     /// Display the expression as a formatted tree structure.
@@ -243,13 +299,19 @@ impl Display for Expression {
 /// Iterative drop for expression to avoid stack overflows.
 impl Drop for Expression {
     fn drop(&mut self) {
-        if let Some(children) = Arc::get_mut(&mut self.children) {
-            let mut children_to_drop = std::mem::take(children);
+        let Self::Scalar { children, .. } = self else {
+            return;
+        };
+        let Some(children) = Arc::get_mut(children) else {
+            return;
+        };
 
-            while let Some(mut child) = children_to_drop.pop() {
-                if let Some(expr_children) = Arc::get_mut(&mut child.children) {
-                    children_to_drop.append(expr_children);
-                }
+        let mut children_to_drop = std::mem::take(children);
+        while let Some(mut child) = children_to_drop.pop() {
+            if let Self::Scalar { children, .. } = &mut child
+                && let Some(expr_children) = Arc::get_mut(children)
+            {
+                children_to_drop.append(expr_children);
             }
         }
     }
diff --git a/vortex-array/src/expr/exprs.rs b/vortex-array/src/expr/exprs.rs
index 9843277ede7..d603ec3b52c 100644
--- a/vortex-array/src/expr/exprs.rs
+++ b/vortex-array/src/expr/exprs.rs
@@ -4,7 +4,6 @@
 //! Factory functions for creating [`Expression`]s from scalar function vtables.
 
 use std::sync::Arc;
-use std::sync::LazyLock;
 
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -50,7 +49,6 @@ use crate::scalar_fn::fns::operators::CompareOperator;
 use crate::scalar_fn::fns::operators::Operator;
 use crate::scalar_fn::fns::pack::Pack;
 use crate::scalar_fn::fns::pack::PackOptions;
-use crate::scalar_fn::fns::root::Root;
 use crate::scalar_fn::fns::select::FieldSelection;
 use crate::scalar_fn::fns::select::Select;
 use crate::scalar_fn::fns::variant_get::VariantGet;
@@ -58,24 +56,17 @@ use crate::scalar_fn::fns::variant_get::VariantGetOptions;
 use crate::scalar_fn::fns::variant_get::VariantPath;
 use crate::scalar_fn::fns::zip::Zip;
 
-static ROOT: LazyLock<Expression> = LazyLock::new(|| {
-    Root.try_new_expr(EmptyOptions, vec![])
-        .vortex_expect("Creating root() shouldn't fail")
-});
-
 /// Creates an expression that references the root scope.
 ///
 /// Returns the entire input array as passed to the expression evaluator.
 /// This is commonly used as the starting point for field access and other operations.
 pub fn root() -> Expression {
-    ROOT.clone()
+    Expression::Root
 }
 
 /// Return whether the expression is a root expression.
 pub fn is_root(expr: &Expression) -> bool {
-    // root doesn't have any children, and scalar_fns have distinct ids
-    // so we should almost always hit this eq check
-    (expr.scalar_fn().id() == ROOT.scalar_fn().id()) || expr.is::<Root>()
+    expr.is_root()
 }
 
 // ---- Literal ----
diff --git a/vortex-array/src/expr/mod.rs b/vortex-array/src/expr/mod.rs
index 2ae61509ceb..5cb0cf12168 100644
--- a/vortex-array/src/expr/mod.rs
+++ b/vortex-array/src/expr/mod.rs
@@ -114,16 +114,37 @@ fn split_inner(expr: &Expression, exprs: &mut Vec<Expression>) {
 pub struct ExactExpr(pub Expression);
 impl PartialEq for ExactExpr {
     fn eq(&self, other: &Self) -> bool {
-        self.0.scalar_fn() == other.0.scalar_fn()
-            && Arc::ptr_eq(self.0.children(), other.0.children())
+        match (&self.0, &other.0) {
+            (Expression::Root, Expression::Root) => true,
+            (
+                Expression::Scalar {
+                    scalar_fn: lhs_fn,
+                    children: lhs_children,
+                },
+                Expression::Scalar {
+                    scalar_fn: rhs_fn,
+                    children: rhs_children,
+                },
+            ) => lhs_fn == rhs_fn && Arc::ptr_eq(lhs_children, rhs_children),
+            _ => false,
+        }
     }
 }
 impl Eq for ExactExpr {}
 
 impl Hash for ExactExpr {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.0.scalar_fn().hash(state);
-        Arc::as_ptr(self.0.children()).hash(state);
+        match &self.0 {
+            Expression::Root => state.write_u8(0),
+            Expression::Scalar {
+                scalar_fn,
+                children,
+            } => {
+                state.write_u8(1);
+                scalar_fn.hash(state);
+                Arc::as_ptr(children).hash(state);
+            }
+        }
     }
 }
 
diff --git a/vortex-array/src/expr/optimize.rs b/vortex-array/src/expr/optimize.rs
index ea1fc796d2e..82579ac564c 100644
--- a/vortex-array/src/expr/optimize.rs
+++ b/vortex-array/src/expr/optimize.rs
@@ -3,12 +3,12 @@
 
 use std::any::Any;
 use std::cell::RefCell;
-use std::ops::Deref;
 use std::sync::Arc;
 
 use itertools::Itertools;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
+use vortex_error::vortex_err;
 use vortex_utils::aliases::hash_map::HashMap;
 
 use crate::dtype::DType;
@@ -19,7 +19,6 @@ use crate::scalar_fn::ReduceNode;
 use crate::scalar_fn::ReduceNodeRef;
 use crate::scalar_fn::ScalarFnRef;
 use crate::scalar_fn::SimplifyCtx;
-use crate::scalar_fn::fns::root::Root;
 
 impl Expression {
     /// Optimize the root expression node only, iterating to convergence.
@@ -39,6 +38,36 @@ impl Expression {
             .unwrap_or_else(|| self.clone()))
     }
 
+    /// Apply this node's own untyped simplification rule, if it has one.
+    ///
+    /// Non-scalar nodes carry no rules, so they never simplify.
+    fn simplify_untyped_node(&self) -> VortexResult<Option<Expression>> {
+        match self {
+            Expression::Scalar { scalar_fn, .. } => scalar_fn.simplify_untyped(self),
+            Expression::Root => Ok(None),
+        }
+    }
+
+    /// Apply this node's own type-aware simplification rule, if it has one.
+    fn simplify_node(&self, ctx: &dyn SimplifyCtx) -> VortexResult<Option<Expression>> {
+        match self {
+            Expression::Scalar { scalar_fn, .. } => scalar_fn.simplify(self, ctx),
+            Expression::Root => Ok(None),
+        }
+    }
+
+    /// Apply this node's own abstract reduction rule, if it has one.
+    fn reduce_node(
+        &self,
+        node: &dyn ReduceNode,
+        ctx: &dyn ReduceCtx,
+    ) -> VortexResult<Option<ReduceNodeRef>> {
+        match self {
+            Expression::Scalar { scalar_fn, .. } => scalar_fn.reduce(node, ctx),
+            Expression::Root => Ok(None),
+        }
+    }
+
     /// Try to optimize the root expression node only, returning None if no optimizations applied.
     fn try_optimize(
         &self,
@@ -64,14 +93,14 @@ impl Expression {
             let mut changed = false;
 
             // Try simplify_untyped
-            if let Some(simplified) = current.scalar_fn().simplify_untyped(&current)? {
+            if let Some(simplified) = current.simplify_untyped_node()? {
                 current = simplified;
                 changed = true;
                 any_optimizations = true;
             }
 
             // Try simplify (typed)
-            if let Some(simplified) = current.scalar_fn().simplify(&current, cache)? {
+            if let Some(simplified) = current.simplify_node(cache)? {
                 current = simplified;
                 changed = true;
                 any_optimizations = true;
@@ -82,7 +111,7 @@ impl Expression {
                 expression: current.clone(),
                 scope: scope.clone(),
             };
-            if let Some(reduced) = current.scalar_fn().reduce(&reduce_node, &reduce_ctx)? {
+            if let Some(reduced) = current.reduce_node(&reduce_node, &reduce_ctx)? {
                 let reduced_expr = reduced
                     .as_any()
                     .downcast_ref::<ExpressionReduceNode>()
@@ -198,20 +227,15 @@ impl Expression {
                     .collect();
 
                 let new_expr = expr.clone().with_children(new_children)?;
-                Ok(Some(
-                    new_expr
-                        .scalar_fn()
-                        .simplify_untyped(&new_expr)?
-                        .unwrap_or(new_expr),
-                ))
+                let simplified = new_expr.simplify_untyped_node()?;
+                Ok(Some(simplified.unwrap_or(new_expr)))
             } else {
-                expr.scalar_fn().simplify_untyped(expr)
+                expr.simplify_untyped_node()
             }
         }
 
         let simplified = self
-            .scalar_fn()
-            .simplify_untyped(self)?
+            .simplify_untyped_node()?
             .unwrap_or_else(|| self.clone());
 
         let simplified = inner(&simplified)?.unwrap_or(simplified);
@@ -229,7 +253,7 @@ struct SimplifyCache<'a> {
 impl SimplifyCtx for SimplifyCache<'_> {
     fn return_dtype(&self, expr: &Expression) -> VortexResult<DType> {
         // If the expression is "root", return the scope dtype
-        if expr.is::<Root>() {
+        if expr.is_root() {
             return Ok(self.scope.clone());
         }
 
@@ -243,7 +267,10 @@ impl SimplifyCtx for SimplifyCache<'_> {
             .iter()
             .map(|c| self.return_dtype(c))
             .try_collect()?;
-        let dtype = expr.deref().return_dtype(&input_dtypes)?;
+        let dtype = expr
+            .as_scalar()
+            .ok_or_else(|| vortex_err!("cannot type a non-scalar expression: {expr}"))?
+            .return_dtype(&input_dtypes)?;
         self.dtype_cache
             .borrow_mut()
             .insert(expr.clone(), dtype.clone());
@@ -267,7 +294,7 @@ impl ReduceNode for ExpressionReduceNode {
     }
 
     fn scalar_fn(&self) -> Option<&ScalarFnRef> {
-        Some(self.expression.scalar_fn())
+        self.expression.as_scalar()
     }
 
     fn child(&self, idx: usize) -> ReduceNodeRef {
diff --git a/vortex-array/src/expr/proto.rs b/vortex-array/src/expr/proto.rs
index 8febdb389a0..4f544fecafb 100644
--- a/vortex-array/src/expr/proto.rs
+++ b/vortex-array/src/expr/proto.rs
@@ -3,6 +3,7 @@
 
 use itertools::Itertools;
 use vortex_error::VortexResult;
+use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
 use vortex_proto::expr as pb;
 use vortex_session::VortexSession;
@@ -17,20 +18,36 @@ pub trait ExprSerializeProtoExt {
     fn serialize_proto(&self) -> VortexResult<pb::Expr>;
 }
 
+/// The wire id for [`Expression::Root`], retained from when `Root` was a scalar function so that
+/// already-serialized expressions keep round-tripping.
+pub(crate) const ROOT_ID: &str = "vortex.root";
+
 impl ExprSerializeProtoExt for Expression {
     fn serialize_proto(&self) -> VortexResult<pb::Expr> {
+        let Some(scalar_fn) = self.as_scalar() else {
+            return Ok(pb::Expr {
+                id: ROOT_ID.to_string(),
+                children: vec![],
+                metadata: Some(vec![]),
+            });
+        };
+
         let children = self
             .children()
             .iter()
             .map(|child| child.serialize_proto())
             .try_collect()?;
 
-        let metadata = self.options().serialize()?.ok_or_else(|| {
-            vortex_err!("Expression '{}' is not serializable: {}", self.id(), self)
+        let metadata = scalar_fn.options().serialize()?.ok_or_else(|| {
+            vortex_err!(
+                "Expression '{}' is not serializable: {}",
+                scalar_fn.id(),
+                self
+            )
         })?;
 
         Ok(pb::Expr {
-            id: self.id().to_string(),
+            id: scalar_fn.id().to_string(),
             children,
             metadata: Some(metadata),
         })
@@ -39,6 +56,16 @@ impl ExprSerializeProtoExt for Expression {
 
 impl Expression {
     pub fn from_proto(expr: &pb::Expr, session: &VortexSession) -> VortexResult<Expression> {
+        // Root is not a registered scalar fn, so it must be resolved before the registry lookup.
+        if expr.id == ROOT_ID {
+            vortex_ensure!(
+                expr.children.is_empty(),
+                "root expression must have no children, got {}",
+                expr.children.len()
+            );
+            return Ok(Expression::Root);
+        }
+
         #[expect(clippy::disallowed_methods, reason = "interning a dynamic id")]
         let expr_id = ScalarFnId::new(expr.id.as_str());
         let children = expr
@@ -126,7 +153,10 @@ mod tests {
         };
 
         let expr = Expression::from_proto(&expr_proto, &session).unwrap();
-        assert_eq!(expr.id().as_ref(), "vortex.test.foreign_scalar_fn");
+        assert_eq!(
+            expr.as_scalar().map(|f| f.id().as_ref().to_string()),
+            Some("vortex.test.foreign_scalar_fn".to_string())
+        );
 
         let roundtrip = expr.serialize_proto().unwrap();
         assert_eq!(roundtrip.id, expr_proto.id);
diff --git a/vortex-array/src/expr/transform/coerce.rs b/vortex-array/src/expr/transform/coerce.rs
index 781045d652b..48e52b1b4a9 100644
--- a/vortex-array/src/expr/transform/coerce.rs
+++ b/vortex-array/src/expr/transform/coerce.rs
@@ -11,7 +11,6 @@ use crate::expr::cast;
 use crate::expr::traversal::NodeExt;
 use crate::expr::traversal::Transformed;
 use crate::scalar_fn::fns::literal::Literal;
-use crate::scalar_fn::fns::root::Root;
 
 /// Rewrite an expression tree to insert casts where a scalar function's `coerce_args` demands
 /// a different type than what the child currently produces.
@@ -23,7 +22,7 @@ pub fn coerce_expression(expr: Expression, scope: &DType) -> VortexResult<Expres
     let scope = scope.clone();
     expr.transform_up(|node| {
         // Leaf nodes (Root, Literal) have no children to coerce.
-        if node.is::<Root>() || node.is::<Literal>() || node.children().is_empty() {
+        if node.is_root() || node.is::<Literal>() || node.children().is_empty() {
             return Ok(Transformed::no(node));
         }
 
@@ -35,7 +34,10 @@ pub fn coerce_expression(expr: Expression, scope: &DType) -> VortexResult<Expres
             .collect::<VortexResult<_>>()?;
 
         // Ask the scalar function what types it wants.
-        let coerced_dtypes = node.scalar_fn().coerce_args(&child_dtypes)?;
+        let Some(scalar_fn) = node.as_scalar() else {
+            return Ok(Transformed::no(node));
+        };
+        let coerced_dtypes = scalar_fn.coerce_args(&child_dtypes)?;
 
         // If nothing changed, skip.
         if child_dtypes == coerced_dtypes {
diff --git a/vortex-array/src/expr/traversal/mod.rs b/vortex-array/src/expr/traversal/mod.rs
index c6000bfdcd4..b97ae2536f7 100644
--- a/vortex-array/src/expr/traversal/mod.rs
+++ b/vortex-array/src/expr/traversal/mod.rs
@@ -17,7 +17,6 @@ pub use fold::FoldDownContext;
 pub use fold::FoldUp;
 pub use fold::NodeFolder;
 pub use fold::NodeFolderContext;
-use itertools::Itertools;
 pub use references::ReferenceCollector;
 pub use visitor::pre_order_visit_down;
 pub use visitor::pre_order_visit_up;
@@ -501,19 +500,14 @@ impl Node for Expression {
         &'a self,
         mut f: F,
     ) -> VortexResult<TraversalOrder> {
-        self.children().as_ref().apply_elements(&mut f)
+        self.children().apply_ref_elements(&mut f)
     }
 
     fn map_children<F: FnMut(Self) -> VortexResult<Transformed<Self>>>(
         self,
         f: F,
     ) -> VortexResult<Transformed<Self>> {
-        let transformed = self
-            .children()
-            .iter()
-            .cloned()
-            .collect_vec()
-            .map_elements(f)?;
+        let transformed = self.children().to_vec().map_elements(f)?;
 
         if transformed.changed {
             Ok(Transformed {
diff --git a/vortex-array/src/expression.rs b/vortex-array/src/expression.rs
index 5e5f8d7ba41..a1a46196766 100644
--- a/vortex-array/src/expression.rs
+++ b/vortex-array/src/expression.rs
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use itertools::Itertools;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 
 use crate::ArrayRef;
@@ -13,7 +14,6 @@ use crate::expr::BoundKind;
 use crate::expr::Expression;
 use crate::optimizer::ArrayOptimizer;
 use crate::scalar_fn::fns::literal::Literal;
-use crate::scalar_fn::fns::root::Root;
 
 impl ArrayRef {
     /// Apply a bound expression to this array, producing a new array in constant time.
@@ -44,7 +44,7 @@ impl ArrayRef {
     /// Apply the expression to this array, producing a new array in constant time.
     pub fn apply(self, expr: &Expression) -> VortexResult<ArrayRef> {
         // If the expression is a root, return self.
-        if expr.is::<Root>() {
+        if expr.is_root() {
             return Ok(self);
         }
 
@@ -61,9 +61,11 @@ impl ArrayRef {
             .try_collect()?;
 
         // And wrap the scalar function up in an array.
+        let scalar_fn = expr
+            .as_scalar()
+            .vortex_expect("root and literal were handled above, so this is a scalar node");
         let array =
-            ScalarFnArray::try_new_with_len(expr.scalar_fn().clone(), children, self.len())?
-                .into_array();
+            ScalarFnArray::try_new_with_len(scalar_fn.clone(), children, self.len())?.into_array();
 
         // Optimize the resulting array's root.
         array.optimize()
diff --git a/vortex-array/src/scalar_fn/fns/between/mod.rs b/vortex-array/src/scalar_fn/fns/between/mod.rs
index c3131dbd342..9e8c4649b5d 100644
--- a/vortex-array/src/scalar_fn/fns/between/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/between/mod.rs
@@ -356,7 +356,7 @@ mod tests {
             },
         );
 
-        assert!(!expr.signature().is_strict());
+        assert!(!expr.as_scalar().is_some_and(|f| f.signature().is_strict()));
     }
 
     #[test]
diff --git a/vortex-array/src/scalar_fn/fns/dynamic.rs b/vortex-array/src/scalar_fn/fns/dynamic.rs
index 00e59796e05..7f4d5a96943 100644
--- a/vortex-array/src/scalar_fn/fns/dynamic.rs
+++ b/vortex-array/src/scalar_fn/fns/dynamic.rs
@@ -297,7 +297,7 @@ mod tests {
             root(),
         );
 
-        assert!(!expr.signature().is_strict());
+        assert!(!expr.as_scalar().is_some_and(|f| f.signature().is_strict()));
     }
 
     #[test]
diff --git a/vortex-array/src/scalar_fn/fns/get_item.rs b/vortex-array/src/scalar_fn/fns/get_item.rs
index bbbc15de479..f9aece952c7 100644
--- a/vortex-array/src/scalar_fn/fns/get_item.rs
+++ b/vortex-array/src/scalar_fn/fns/get_item.rs
@@ -229,7 +229,11 @@ mod tests {
     fn get_item_by_name() {
         let st = test_array();
         let get_item = get_item("a", root());
-        assert!(get_item.signature().is_strict());
+        assert!(
+            get_item
+                .as_scalar()
+                .is_some_and(|f| f.signature().is_strict())
+        );
         let item = st.into_array().apply(&get_item).unwrap();
         assert_eq!(item.dtype(), &DType::from(PType::I32))
     }
diff --git a/vortex-array/src/scalar_fn/fns/is_not_null.rs b/vortex-array/src/scalar_fn/fns/is_not_null.rs
index dcf00f62c08..e6d7cd2f479 100644
--- a/vortex-array/src/scalar_fn/fns/is_not_null.rs
+++ b/vortex-array/src/scalar_fn/fns/is_not_null.rs
@@ -247,7 +247,11 @@ mod tests {
 
     #[test]
     fn test_is_not_null_is_not_strict() {
-        assert!(!is_not_null(col("a")).signature().is_strict());
+        assert!(
+            !is_not_null(col("a"))
+                .as_scalar()
+                .is_some_and(|f| f.signature().is_strict())
+        );
     }
 
     #[test]
diff --git a/vortex-array/src/scalar_fn/fns/is_null.rs b/vortex-array/src/scalar_fn/fns/is_null.rs
index 118c00ab987..7e7d3f14c7c 100644
--- a/vortex-array/src/scalar_fn/fns/is_null.rs
+++ b/vortex-array/src/scalar_fn/fns/is_null.rs
@@ -251,6 +251,10 @@ mod tests {
 
     #[test]
     fn test_is_null_is_not_strict() {
-        assert!(!is_null(col("a")).signature().is_strict());
+        assert!(
+            !is_null(col("a"))
+                .as_scalar()
+                .is_some_and(|f| f.signature().is_strict())
+        );
     }
 }
diff --git a/vortex-array/src/scalar_fn/fns/like/mod.rs b/vortex-array/src/scalar_fn/fns/like/mod.rs
index c947ce461b2..de2efb7d903 100644
--- a/vortex-array/src/scalar_fn/fns/like/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/like/mod.rs
@@ -724,8 +724,16 @@ mod tests {
     #[test]
     fn signature() {
         let like_expr = like(root(), lit("%test%"));
-        assert!(like_expr.signature().is_strict());
-        assert!(!like_expr.signature().is_fallible());
+        assert!(
+            like_expr
+                .as_scalar()
+                .is_some_and(|f| f.signature().is_strict())
+        );
+        assert!(
+            !like_expr
+                .as_scalar()
+                .is_some_and(|f| f.signature().is_fallible())
+        );
     }
 
     #[test]
diff --git a/vortex-array/src/scalar_fn/fns/mod.rs b/vortex-array/src/scalar_fn/fns/mod.rs
index f4618154329..087f540ce7b 100644
--- a/vortex-array/src/scalar_fn/fns/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/mod.rs
@@ -22,7 +22,6 @@ pub mod merge;
 pub mod not;
 pub mod operators;
 pub mod pack;
-pub mod root;
 pub mod select;
 pub mod stat;
 pub mod variant_get;
diff --git a/vortex-array/src/scalar_fn/fns/not/mod.rs b/vortex-array/src/scalar_fn/fns/not/mod.rs
index 21b1c53112d..bfd0b665686 100644
--- a/vortex-array/src/scalar_fn/fns/not/mod.rs
+++ b/vortex-array/src/scalar_fn/fns/not/mod.rs
@@ -127,7 +127,11 @@ mod tests {
 
     #[test]
     fn is_strict() {
-        assert!(not(root()).signature().is_strict());
+        assert!(
+            not(root())
+                .as_scalar()
+                .is_some_and(|f| f.signature().is_strict())
+        );
     }
 
     #[test]
diff --git a/vortex-array/src/scalar_fn/fns/root.rs b/vortex-array/src/scalar_fn/fns/root.rs
deleted file mode 100644
index 0831e5b8585..00000000000
--- a/vortex-array/src/scalar_fn/fns/root.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright the Vortex contributors
-
-use std::fmt::Formatter;
-
-use vortex_error::VortexResult;
-use vortex_error::vortex_bail;
-use vortex_session::VortexSession;
-use vortex_session::registry::CachedId;
-
-use crate::ArrayRef;
-use crate::ExecutionCtx;
-use crate::dtype::DType;
-use crate::expr::display::ExprDisplay;
-use crate::scalar_fn::Arity;
-use crate::scalar_fn::ChildName;
-use crate::scalar_fn::EmptyOptions;
-use crate::scalar_fn::ExecutionArgs;
-use crate::scalar_fn::ScalarFnId;
-use crate::scalar_fn::ScalarFnVTable;
-
-/// An expression that returns the full scope of the expression evaluation.
-// TODO(ngates): rename to "Scope"
-#[derive(Clone)]
-pub struct Root;
-
-impl ScalarFnVTable for Root {
-    type Options = EmptyOptions;
-
-    fn id(&self) -> ScalarFnId {
-        static ID: CachedId = CachedId::new("vortex.root");
-        *ID
-    }
-
-    fn serialize(&self, _instance: &Self::Options) -> VortexResult<Option<Vec<u8>>> {
-        Ok(Some(vec![]))
-    }
-
-    fn deserialize(
-        &self,
-        _metadata: &[u8],
-        _session: &VortexSession,
-    ) -> VortexResult<Self::Options> {
-        Ok(EmptyOptions)
-    }
-
-    fn arity(&self, _options: &Self::Options) -> Arity {
-        Arity::Exact(0)
-    }
-
-    fn child_name(&self, _instance: &Self::Options, child_idx: usize) -> ChildName {
-        unreachable!(
-            "Root expression does not have children, got index {}",
-            child_idx
-        )
-    }
-
-    fn fmt_sql(
-        &self,
-        _options: &Self::Options,
-        _expr: &dyn ExprDisplay,
-        f: &mut Formatter<'_>,
-    ) -> std::fmt::Result {
-        write!(f, "$")
-    }
-
-    fn return_dtype(&self, _options: &Self::Options, _arg_dtypes: &[DType]) -> VortexResult<DType> {
-        vortex_bail!("Root expression does not support return_dtype")
-    }
-
-    fn execute(
-        &self,
-        _data: &Self::Options,
-        _args: &dyn ExecutionArgs,
-        _ctx: &mut ExecutionCtx,
-    ) -> VortexResult<ArrayRef> {
-        vortex_bail!("Root expression is not executable")
-    }
-
-    fn is_strict(&self, _options: &Self::Options) -> bool {
-        true
-    }
-
-    fn is_fallible(&self, _options: &Self::Options) -> bool {
-        false
-    }
-}
diff --git a/vortex-array/src/scalar_fn/session.rs b/vortex-array/src/scalar_fn/session.rs
index d05b2b0db6e..612ded7a5c8 100644
--- a/vortex-array/src/scalar_fn/session.rs
+++ b/vortex-array/src/scalar_fn/session.rs
@@ -28,7 +28,6 @@ use crate::scalar_fn::fns::literal::Literal;
 use crate::scalar_fn::fns::merge::Merge;
 use crate::scalar_fn::fns::not::Not;
 use crate::scalar_fn::fns::pack::Pack;
-use crate::scalar_fn::fns::root::Root;
 use crate::scalar_fn::fns::select::Select;
 use crate::scalar_fn::fns::stat::StatFn;
 use crate::scalar_fn::fns::variant_get::VariantGet;
@@ -77,7 +76,6 @@ impl Default for ScalarFnSession {
         this.register(Merge);
         this.register(Not);
         this.register(Pack);
-        this.register(Root);
         this.register(Select);
         this.register(StatFn);
         this.register(VariantGet);
diff --git a/vortex-array/src/stats/rewrite.rs b/vortex-array/src/stats/rewrite.rs
index 2bbeeb00022..cb63112bb83 100644
--- a/vortex-array/src/stats/rewrite.rs
+++ b/vortex-array/src/stats/rewrite.rs
@@ -135,10 +135,11 @@ fn rewrite(
         &StatsRewriteCtx<'_>,
     ) -> VortexResult<Option<Expression>>,
 ) -> VortexResult<Option<Expression>> {
-    let rules = ctx
-        .session()
-        .stats()
-        .rewrite_rules_for(expr.scalar_fn().id());
+    // The scope alone proves nothing about the rows it contains.
+    let Some(scalar_fn) = expr.as_scalar() else {
+        return Ok(None);
+    };
+    let rules = ctx.session().stats().rewrite_rules_for(scalar_fn.id());
     let Some(rules) = rules else {
         return Ok(None);
     };