refactor(ir): rename summary_update to summary_input_data

It reads the producing SummaryAgg's update expression and reduction; it
does not update the summary.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: zzylol

crates/types/src/ir/asap.rs

@@ -489,8 +489,12 @@ impl ASAPOp {
                 }
                 // Equal schemas do not prove the states summarize the same
                 // expression with the same grouping; the producers do.
-                let update = first.summary_update();
-                if update.is_none() || children.iter().any(|c| c.summary_update() != update) {
+                let input_data = first.summary_input_data();
+                if input_data.is_none()
+                    || children
+                        .iter()
+                        .any(|c| c.summary_input_data() != input_data)
+                {
                     return Err(SchemaDerivationError::InvalidScalarSignature(
                         "summary merge inputs must share update expression and reduction".into(),
                     ));

crates/types/src/ir/node.rs

@@ -161,18 +161,20 @@ impl OperatorNode {
         Ok(self)
     }
 
-    /// What a summary state was built from: the update expression (`input`)
-    /// and grouping (`reduction`) of the `SummaryAgg` that produced it. For a
+    /// What a summary state summarizes from each row: the update expression
+    /// fed into the state (`input`, e.g. the `latency` column) and the
+    /// grouping (`reduction`, e.g. by `job`) of the `SummaryAgg` that produced
+    /// it. Which rows were included is `coverage`, not this. For a
     /// `SummaryMerge` these are its first input's, which merge validation
-    /// requires every input to share. `None` for any other node. Merging
-    /// compares it so that all inputs summarize the same expression with the
-    /// same grouping.
-    pub fn summary_update(&self) -> Option<(&SummaryUpdate, &Reduction)> {
+    /// requires every input to share. `None` for any other node. Equal schemas
+    /// cannot tell a KLL over `latency` from one over `size`; merging compares
+    /// this instead.
+    pub fn summary_input_data(&self) -> Option<(&SummaryUpdate, &Reduction)> {
         match self.asap()? {
             ASAPOp::SummaryAgg {
                 input, reduction, ..
             } => Some((input, reduction)),
-            ASAPOp::SummaryMerge { children } => children.first()?.summary_update(),
+            ASAPOp::SummaryMerge { children } => children.first()?.summary_input_data(),
             _ => None,
         }
     }