@@ -4,10 +4,9 @@
 //! target, not ranked plans or accuracy certificates. Workload composition and
 //! physical planning consume this inventory later; empirical models belong to
 //! selection. The legacy search API remains until planner cutover.
-use std::collections::{BTreeMap, HashMap, HashSet};
+use std::collections::{HashMap, HashSet};
 use std::rc::Rc;
 
-use asap_types::ir::summary_coverage::{CoverageRegion, SummaryCoverage};
 use asap_types::ir::{ASAPOp, NonASAPOp, Operator, OperatorNode, QueryRoot, SchemaDerivationError};
 use asap_types::post_asap::{
     EntityIdentity, ExactKind, ExactParams, FieldDataType, GroupingStrategy,
@@ -197,7 +196,7 @@ fn rewrite(
         Some(realization) if **realization != Realization::PassThrough => {
             realize(node, realization, memo)?
         }
-        _ if changed => Rc::new(node.map_children(|child| memo[&Rc::as_ptr(child)].clone())?),
+        _ if changed => Rc::new(node.with_new_children(|child| memo[&Rc::as_ptr(child)].clone())?),
         _ => node.clone(),
     };
     memo.insert(Rc::as_ptr(node), rebuilt.clone());
@@ -253,16 +252,7 @@ fn realize(
         grouping: GroupingStrategy::default(),
         filter: None,
     }))?;
-    // Whole-source coverage is declared, not proven: Pass 1 trusts that the
-    // state holds every observation of its source that reaches it (#570).
-    let coverage = SummaryCoverage {
-        source: single_source(&child)?,
-        regions: vec![CoverageRegion {
-            time_ms: None,
-            population: BTreeMap::new(),
-        }],
-    };
-    let state = Rc::new(state.with_coverage(coverage)?);
+    let state = Rc::new(state);
     let evaluation = match query {
         Some(query) => ASAPOp::SummaryEstimate {
             summary_input: state,
@@ -273,25 +263,6 @@ fn realize(
     Ok(OperatorNode::new_shared(Operator::ASAP(evaluation))?)
 }
 
-fn single_source(
-    node: &Rc<OperatorNode>,
-) -> Result<asap_types::pre_asap::Source, LogicalCandidateError> {
-    let mut sources = Vec::new();
-    for node in OperatorNode::reachable(node) {
-        if let Some(NonASAPOp::Scan { source, .. }) = node.non_asap() {
-            if !sources.contains(source) {
-                sources.push(source.clone());
-            }
-        }
-    }
-    match <[_; 1]>::try_from(sources) {
-        Ok([source]) => Ok(source),
-        Err(_) => Err(LogicalCandidateError::Unsupported(
-            "summary coverage needs exactly one source",
-        )),
-    }
-}
-
 /// What each input row contributes, following the legacy realization rules:
 /// heap sketches rank series identities, frequency sketches count values, and
 /// every other family reads the measure's input column.
 
@@ -259,17 +259,16 @@ fn composed_candidate_replaces_chosen_target_with_summary_evaluation() {
     let Some(ASAPOp::SummaryEstimate { summary_input, .. }) = estimate.asap() else {
         panic!("summary evaluation expected")
     };
-    let coverage = summary_input.coverage.as_ref().unwrap();
-    assert_eq!(
-        coverage.source,
-        Source::Table {
-            table_ref: "flows".into()
-        }
+    // The state takes every row of its source: one unrestricted selection box.
+    let coverage = summary_input.coverage().unwrap();
+    assert!(OperatorNode::reachable(&coverage.definition).iter().any(|node| matches!(
+        node.non_asap(),
+        Some(NonASAPOp::Scan { source: Source::Table { table_ref }, .. }) if table_ref == "flows"
+    )));
+    assert_eq!(coverage.selection.len(), 1);
+    assert!(
+        coverage.selection[0].columns.is_empty() && coverage.selection[0].relative_time.is_none()
     );
-    assert!(coverage.regions[0].time_ms.is_none() && coverage.regions[0].population.is_empty());
-    asap_types::ir::export::compile_logical_asap_workload(&[hll[0].1.clone()])
-        .unwrap()
-        .validate()
-        .unwrap();
+    hll[0].1.validate_structure().unwrap();
     assert!(compose_logical_candidate(&inventory, &[99]).is_err());
 }
@@ -21,9 +21,7 @@ use asap_aware_mapping::logical_candidates::{
     compose_logical_candidate, enumerate_local_logical_candidates, LocalLogicalCandidates,
 };
 use asap_aware_mapping::Realization;
-use asap_types::ir::export::{
-    compile_logical_asap_workload, LogicalASAPDAG, LogicalASAPDAGDocument,
-};
+use asap_types::ir::flat::{flatten, FlatDag};
 use asap_types::ir::{OperatorNode, QueryRoot};
 use asap_types::post_asap::SketchAlgorithm;
 use asap_types::types::AccuracyTarget;
@@ -130,12 +128,14 @@ fn stage_pipeline(workload: &PlanningWorkload, max_candidates: usize) -> Result<
     }))
 }
 
-fn export(roots: &[QueryRoot]) -> Result<LogicalASAPDAG, String> {
-    let dag = compile_logical_asap_workload(roots).map_err(|e| format!("export: {e}"))?;
-    LogicalASAPDAGDocument::new(dag.clone())
-        .validate()
-        .map_err(|e| format!("export validation: {e}"))?;
-    Ok(dag)
+/// A logical DAG as a flat node list: node `i` is `nodes[i]`, and children are
+/// node indices inside each operator.
+fn export(roots: &[QueryRoot]) -> Result<FlatDag, String> {
+    for root in roots {
+        root.validate_structure()
+            .map_err(|e| format!("validation: {e}"))?;
+    }
+    Ok(flatten(roots).0)
 }
 
 /// The first query whose plan reaches each target (enumeration order).
 
@@ -3,7 +3,8 @@ use std::collections::HashSet;
 use std::path::PathBuf;
 use std::process::Command;
 
-use asap_types::ir::export::{LogicalASAPDAG, LogicalASAPDAGDocument};
+use asap_types::ir::flat::FlatDag;
+use asap_types::ir::QueryRoot;
 use serde_json::Value;
 
 const COMMITTED: &str = "../../tools/dag-viewer/examples/planner-layering-example1.json";
@@ -27,12 +28,24 @@ fn generate(extra: &[&str]) -> Value {
 }
 
 fn validated_dag(value: &Value, queries: usize) {
-    let dag: LogicalASAPDAG = serde_json::from_value(value.clone()).unwrap();
+    let dag: FlatDag = serde_json::from_value(value.clone()).unwrap();
     assert_eq!(dag.roots.len(), queries);
-    LogicalASAPDAGDocument::new(dag).validate().unwrap();
+    // Children come before their parents.
+    for (id, node) in dag.nodes.iter().enumerate() {
+        assert!(node
+            .operator
+            .children()
+            .into_iter()
+            .all(|child| *child < id));
+    }
+    for root in &dag.roots {
+        if let QueryRoot::Operator(id) = root {
+            assert!(*id < dag.nodes.len());
+        }
+    }
 }
 
-/// Every exported DAG validates and has one root per query; ids are unique;
+/// Every DAG is a well-formed flat DAG with one root per query; ids are unique;
 /// only Stages 0 and 1 are present; the committed fixture is current.
 #[test]
 fn example1_document_is_valid_and_committed_fixture_is_current() {