refactor(ir): use SummaryCoverage names in summary merges

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

Author: zzylol

crates/types/src/ir/asap.rs

@@ -6,6 +6,7 @@ use std::rc::Rc;
 use serde::{Deserialize, Serialize};
 
 use super::node::{OperatorNode, OperatorResultKind};
+use super::summary_coverage::{CoverageError, SummaryCoverage};
 use crate::ir::operator_properties::Reduction;
 use crate::ir::SchemaDerivationError;
 use crate::post_asap::maintained_population::{MaintainedPopulation, PopulationStatistic};
@@ -213,27 +214,18 @@ impl ASAPOp {
         }
     }
 
-    /// Derive joint observation coverage; unknown or overlapping inputs fail closed.
-    pub fn merged_extent(
-        &self,
-    ) -> Result<super::observation_extent::ObservationExtent, SchemaDerivationError> {
+    /// Derive the merged node's coverage; unknown or overlapping inputs fail closed.
+    pub fn merged_coverage(&self) -> Result<SummaryCoverage, SchemaDerivationError> {
         let ASAPOp::SummaryMerge { children } = self else {
             return Err(SchemaDerivationError::InvalidScalarSignature(
                 "coverage merge requires SummaryMerge".into(),
             ));
         };
         let inputs = children
             .iter()
-            .map(|child| {
-                child.observation_extent.clone().ok_or_else(|| {
-                    SchemaDerivationError::InvalidScalarSignature(
-                        "summary merge requires known observation coverage".into(),
-                    )
-                })
-            })
+            .map(|child| child.coverage.clone().ok_or(CoverageError::UnknownInput))
             .collect::<Result<Vec<_>, _>>()?;
-        super::observation_extent::ObservationExtent::merge_disjoint(&inputs)
-            .map_err(|error| SchemaDerivationError::InvalidScalarSignature(error.to_string()))
+        Ok(SummaryCoverage::merge_disjoint(&inputs)?)
     }
 
     /// Output schema derived from the operator and its children. Summary
@@ -506,7 +498,7 @@ impl ASAPOp {
                         ));
                     }
                 }
-                self.merged_extent()?;
+                self.merged_coverage()?;
                 Ok(())
             }
             SummaryEstimate {

crates/types/src/ir/node.rs

@@ -112,7 +112,7 @@ impl OperatorNode {
         let schema = operator.output_schema()?;
         let mut node = Self::with_schema(operator, schema);
         if let Some(op @ ASAPOp::SummaryMerge { .. }) = node.asap() {
-            node.observation_extent = Some(op.merged_extent()?);
+            node.coverage = Some(op.merged_coverage()?);
         }
         Ok(node)
     }
@@ -165,7 +165,10 @@ impl OperatorNode {
 
     /// Summary nodes whose state can be composed must declare coverage.
     pub fn requires_coverage(&self) -> bool {
-        matches!(self.asap(), Some(ASAPOp::SummaryAgg { .. }))
+        matches!(
+            self.asap(),
+            Some(ASAPOp::SummaryAgg { .. } | ASAPOp::SummaryMerge { .. })
+        )
     }
 
     pub fn non_asap(&self) -> Option<&NonASAPOp> {
@@ -325,10 +328,8 @@ impl OperatorNode {
                 None => {}
             }
             if let Some(op @ ASAPOp::SummaryMerge { .. }) = node.asap() {
-                if node.observation_extent.as_ref() != Some(&op.merged_extent()?) {
-                    return Err(SchemaDerivationError::InvalidScalarSignature(
-                        "retained merge coverage disagrees with input union".into(),
-                    ));
+                if node.coverage.as_ref() != Some(&op.merged_coverage()?) {
+                    return Err(CoverageError::MergeOutputMismatch.into());
                 }
             }
             node.operator.validate_inputs()?;

crates/types/src/ir/summary_coverage.rs

@@ -48,6 +48,10 @@ pub enum CoverageError {
     NotState,
     #[error("summary node requires coverage")]
     Missing,
+    #[error("summary merge requires known coverage on every input")]
+    UnknownInput,
+    #[error("retained merge coverage disagrees with input union")]
+    MergeOutputMismatch,
 }
 
 impl SummaryCoverage {

crates/types/tests/summary_merge_structure.rs

@@ -29,16 +29,12 @@ fn state(k: u32) -> Rc<OperatorNode> {
     .unwrap();
     std::rc::Rc::new(
         summary
-            .with_observation_extent(asap_types::ir::observation_extent::ObservationExtent {
+            .with_coverage(asap_types::ir::summary_coverage::SummaryCoverage {
                 source: "latencies:timestamp".into(),
-                revision: "fixture-1".into(),
                 input: SummaryUpdate::column(ColumnRef::SampleValue),
-                grouping: Reduction::by(vec![]),
-                multiplicity:
-                    asap_types::ir::observation_extent::ObservationMultiplicity::OncePerObservation,
-                regions: vec![asap_types::ir::observation_extent::ExtentRegion {
-                    start_ms: 0,
-                    end_ms: 1,
+                reduction: Reduction::by(vec![]),
+                regions: vec![asap_types::ir::summary_coverage::CoverageRegion {
+                    time_ms: Some(0..1),
                     population: Default::default(),
                 }],
             })
@@ -55,8 +51,8 @@ fn compatible_panes_merge_structurally() {
     root.validate_structure().unwrap();
     assert_eq!(root.schema.fields.len(), 1);
     assert_eq!(
-        root.observation_extent.as_ref().unwrap().regions[0].end_ms,
-        2
+        root.coverage.as_ref().unwrap().regions[0].time_ms,
+        Some(0..2)
     );
 }
 /// An empty merge, raw rows and differently sized state cannot masquerade as compatible panes.
@@ -75,16 +71,15 @@ fn incompatible_merge_inputs_fail() {
 
 fn shifted_state(k: u32, start: i64, end: i64) -> Rc<OperatorNode> {
     let mut node = (*state(k)).clone();
-    let region = &mut node.observation_extent.as_mut().unwrap().regions[0];
-    region.start_ms = start;
-    region.end_ms = end;
+    let region = &mut node.coverage.as_mut().unwrap().regions[0];
+    region.time_ms = Some(start..end);
     Rc::new(node)
 }
 /// Schema equality cannot authorize overlapping or unknown observation coverage.
 #[test]
 fn unsafe_coverage_merge_is_rejected() {
     let mut unknown = (*state(200)).clone();
-    unknown.observation_extent = None;
+    unknown.coverage = None;
     for children in [
         vec![state(200), state(200)],
         vec![state(200), Rc::new(unknown)],
@@ -102,8 +97,8 @@ fn merge_derives_coverage_and_validates_retained_metadata() {
         children: vec![state(200), shifted_state(200, 2, 3)],
     }))
     .unwrap();
-    assert_eq!(root.observation_extent.as_ref().unwrap().regions.len(), 2);
+    assert_eq!(root.coverage.as_ref().unwrap().regions.len(), 2);
     let mut forged = (*root).clone();
-    forged.observation_extent.as_mut().unwrap().regions[0].end_ms = 2;
+    forged.coverage.as_mut().unwrap().regions[0].time_ms = Some(0..2);
     assert!(Rc::new(forged).validate_structure().is_err());
 }