diff --git a/crates/accuracy/src/estimators/hll.rs b/crates/accuracy/src/estimators/hll.rs
index 864475aba..18d45db02 100644
--- a/crates/accuracy/src/estimators/hll.rs
+++ b/crates/accuracy/src/estimators/hll.rs
@@ -2,7 +2,7 @@
 //!
 //! This is conditional on independent uniform bucket hashes and an enforced
 //! upper bound on distinct items in the complete evaluation population (including
-//! all merged panes). It is not an RSE-to-normal conversion or an ERP fit.
+//! all merged tumbling windows). It is not an RSE-to-normal conversion or an ERP fit.
 
 use super::*;
 
@@ -106,7 +106,7 @@ pub(crate) fn classic_guarantee(
                 "max_distinct": format!("{MAX_DISTINCT}[{source}]"),
                 "relative_error": relative_error,
                 "hash_assumption": "independent_uniform_buckets",
-                "population_scope": "complete_evaluation_including_merged_panes"}),
+                "population_scope": "complete_evaluation_including_merged_tumbling_windows"}),
             query: "Cardinality".into(),
         }],
     ))
@@ -170,7 +170,7 @@ impl ClassicHllConfidence {
                 params: serde_json::json!({"precision": precision,
                     "max_distinct": self.max_distinct, "relative_error": self.relative_error,
                     "hash_assumption": "independent_uniform_buckets",
-                    "population_scope": "complete_evaluation_including_merged_panes"}),
+                    "population_scope": "complete_evaluation_including_merged_tumbling_windows"}),
                 query: "Cardinality".into(),
             }],
         ))
diff --git a/crates/accuracy/src/estimators/univmon.rs b/crates/accuracy/src/estimators/univmon.rs
index be109b3c0..c9378c1d0 100644
--- a/crates/accuracy/src/estimators/univmon.rs
+++ b/crates/accuracy/src/estimators/univmon.rs
@@ -300,7 +300,7 @@ pub(crate) fn distinct_guarantee(params: &SketchParams, source: &str) -> Option<
                 "variance": "1.35 F0^2 / k",
                 "hash_assumption": "independent_uniform_layer_hashes",
                 "mode": "standard",
-                "population_scope": "complete_evaluation_including_merged_panes"}),
+                "population_scope": "complete_evaluation_including_merged_tumbling_windows"}),
             query: "Cardinality".into(),
         }],
     ))
diff --git a/crates/accuracy/src/propagation.rs b/crates/accuracy/src/propagation.rs
index 9ab658229..ed33978df 100644
--- a/crates/accuracy/src/propagation.rs
+++ b/crates/accuracy/src/propagation.rs
@@ -7,7 +7,7 @@ use std::collections::{HashMap, HashSet};
 use std::rc::Rc;
 
 use asap_types::ir::operator::operator_properties::{BinaryOpKind, JoinKind, Reduction, Source};
-use asap_types::ir::operator::pane_chain::{merged_chain, merged_window_build};
+use asap_types::ir::operator::tumbling_window_chain::{merged_chain, merged_window_build};
 use asap_types::ir::operator::AggIntent;
 use asap_types::ir::properties::guarantee::{
     AccuracyGuarantee, AccuracyMetric, BoundExpr, CompositionOperator, GuaranteeSource,
@@ -406,7 +406,7 @@ pub fn composed_guarantee(node: &OperatorNode) -> Option<AccuracyGuarantee> {
     if let Some(guarantee) = rolled_up_guarantee(node) {
         return guarantee;
     }
-    if let Some(guarantee) = merged_panes_guarantee(node) {
+    if let Some(guarantee) = merged_tumbling_windows_guarantee(node) {
         return guarantee;
     }
     let exact = |node: &OperatorNode| {
@@ -610,14 +610,14 @@ fn rolled_up_guarantee(node: &OperatorNode) -> Option<Option<AccuracyGuarantee>>
 }
 
 /// The guarantee of an estimate or finalized value read from merged
-/// tumbling panes ([`merged_chain`]): the guarantee of the same read of one
-/// build over the merged panes' window ([`merged_window_build`]: the whole
-/// chain's, or its newest panes') when the
+/// tumbling windows ([`merged_chain`]): the guarantee of the same read of one
+/// build over the merged tumbling windows' time range ([`merged_window_build`]: the whole
+/// chain's, or its newest tumbling windows') when the
 /// family's merged error for that read is exact or the same as that build's
 /// (the family-capability table); none when it is approximate (evidence
 /// only, for plan selection to judge) or the family has no merge. `None` for
-/// any node that does not read merged panes.
-fn merged_panes_guarantee(node: &OperatorNode) -> Option<Option<AccuracyGuarantee>> {
+/// any node that does not read merged tumbling windows.
+fn merged_tumbling_windows_guarantee(node: &OperatorNode) -> Option<Option<AccuracyGuarantee>> {
     let (state, merged) = match node.asap()? {
         ASAPOp::SummaryEstimate {
             summary_input,
@@ -647,7 +647,7 @@ fn merged_panes_guarantee(node: &OperatorNode) -> Option<Option<AccuracyGuarante
     let Ok(mut window_build) = merged_window_build(state) else {
         return Some(None);
     };
-    // The merged panes' window range over the chain's input carries the
+    // The merged tumbling windows' time range over the chain's input carries the
     // guarantee composed over that input.
     let ASAPOp::SummaryTumblingWindowChain { child: input, .. } = chain.asap()? else {
         return Some(None);
@@ -750,7 +750,7 @@ pub(crate) fn fold_stats(
 /// heap estimate whose update weights carry the
 /// [`WeightDomain::RawDataSamplesOfMetric`] requirement keep it, and so does a
 /// quantile estimate of those values, built over the raw window or merged
-/// from its tumbling panes: it is one of them, or between two of them, so it
+/// from its tumbling windows: it is one of them, or between two of them, so it
 /// shares their sign. Anything else (rate, arithmetic, other
 /// functions) ends it. Only the sign of the values is read from it.
 pub(crate) fn estimates_raw_data_samples_of(node: &OperatorNode) -> Option<String> {
@@ -771,9 +771,9 @@ pub(crate) fn estimates_raw_data_samples_of(node: &OperatorNode) -> Option<Strin
             _ => None,
         },
         // Only a φ in [0, 1] picks one of the values; outside it the answer
-        // is -Inf or +Inf, whatever their sign. Merged tumbling panes of one
+        // is -Inf or +Inf, whatever their sign. Merged tumbling windows of one
         // definition ([`merged_chain`]) are read through their `SummaryTumblingWindowChain`:
-        // a quantile of the merged state is still one of the panes'
+        // a quantile of the merged state is still one of the tumbling windows'
         // samples, or between two of them.
         Operator::ASAP(ASAPOp::SummaryEstimate {
             summary_input,
diff --git a/crates/cost/src/execution_demand.rs b/crates/cost/src/execution_demand.rs
index 252a53811..6a7e380bd 100644
--- a/crates/cost/src/execution_demand.rs
+++ b/crates/cost/src/execution_demand.rs
@@ -338,7 +338,7 @@ pub fn consumers(dag: &PhysicalASAPDAG) -> HashMap<PhysicalASAPNodeId, Vec<Consu
 /// its readers: once per second at ingestion time (`MatAtIngestion`), at
 /// the combined rate of the queries reaching it (`MatAtQuery`,
 /// [`evaluation_rate`]), or once per request of those queries for a chain
-/// kept across evaluations, whose request builds only its newest pane
+/// kept across evaluations, whose request builds only its newest tumbling window
 /// however many range steps it evaluates. `range_evaluations[q]` is query
 /// `q`'s range evaluation (none when missing). A `NotMaterialized` node is computed once per
 /// consumer that reaches it ([`consumers`]), at that consumer's rate. A consumer is a query
diff --git a/crates/cost/src/lib.rs b/crates/cost/src/lib.rs
index 95e8949f2..06878f0b0 100644
--- a/crates/cost/src/lib.rs
+++ b/crates/cost/src/lib.rs
@@ -41,9 +41,9 @@ pub use measured::{
 pub use operator_statistics::EdgeStatistics;
 pub use ranking::{cheaper, worst_latency_ms, PlanRanking};
 pub use usage::{
-    family_name, kept_pane_chains, node_map, node_usage, panes_of, plan_cost, query_reach,
-    trailing_window, tumbling_window_retention_ms, tumbling_window_retention_ms_of_plan, NodeMap,
-    NodeUsage, ProducerOutput,
+    family_name, kept_tumbling_window_chains, node_map, node_usage, plan_cost, query_reach,
+    trailing_window, tumbling_window_retention_ms, tumbling_window_retention_ms_of_plan,
+    tumbling_windows_of, NodeMap, NodeUsage, ProducerOutput,
 };
 
 /// Cost per second of wall time; one unit is one CPU-millisecond under
diff --git a/crates/cost/src/measured.rs b/crates/cost/src/measured.rs
index 70c2690cd..1fabd322c 100644
--- a/crates/cost/src/measured.rs
+++ b/crates/cost/src/measured.rs
@@ -151,9 +151,9 @@ pub enum OperatorKind {
     FinalizeExactAccumulator,
     MaintainPopulation,
     EvaluatePopulation,
-    /// Per input state merged (each pane of a chain is a state).
+    /// Per input state merged (each tumbling window of a chain is a state).
     SummaryMerge,
-    /// Per input row placed in its pane and inserted into that pane's state.
+    /// Per input row placed in its tumbling window and inserted into that tumbling window's state.
     // Named `PaneChain` before #1163.
     #[serde(alias = "PaneChain")]
     SummaryTumblingWindowChain,
diff --git a/crates/cost/src/ranking.rs b/crates/cost/src/ranking.rs
index 5f569f3e9..05adcb630 100644
--- a/crates/cost/src/ranking.rs
+++ b/crates/cost/src/ranking.rs
@@ -1,5 +1,5 @@
 //! How a cost model orders valid plans ([`PlanRanking`]): Stage 3 ranks its
-//! candidates with it, and the facade picks the best of its pane-width
+//! candidates with it, and the facade picks the best of its tumbling-window-width
 //! rounds' selections with it (#1047).
 use std::cmp::Ordering;
 
diff --git a/crates/cost/src/state_bytes.rs b/crates/cost/src/state_bytes.rs
index 1b4a2eacb..a8d4c8fba 100644
--- a/crates/cost/src/state_bytes.rs
+++ b/crates/cost/src/state_bytes.rs
@@ -274,7 +274,7 @@ mod tests {
 
     /// An exact accumulator's state is priced at the executor's per-group
     /// state, 56 bytes for every kind (a counter's state alone is 48), so a
-    /// pane chain of exact sums keeps 56 bytes per pane and group.
+    /// tumbling-window chain of exact sums keeps 56 bytes per tumbling window and group.
     #[test]
     fn exact_state_is_priced_at_the_executors_state_size() {
         use asap_types::ir::schema::{ExactKind, ExactParams};
@@ -320,7 +320,7 @@ mod tests {
             )
             .1
         };
-        // Ten Pareto(2) samples (scale 1), one 1 s pane of a 10 Hz series.
+        // Ten Pareto(2) samples (scale 1), one 1 s tumbling window of a 10 Hz series.
         let pareto: Vec<f64> = (0..10)
             .map(|i| (1.0 - (f64::from(i) + 0.5) / 10.0).powf(-0.5))
             .collect();
@@ -472,7 +472,7 @@ mod tests {
     /// samples it sees, not its full capacity: its fixed struct and level
     /// array, plus the item array the library starts empty and doubles from
     /// 16 items as samples arrive, up to `compute_max_capacity(k, 8)`. E.g.
-    /// a 10 s pane of a series sampled every 15 s sees one sample: 744 + 128
+    /// a 10 s tumbling window of a series sampled every 15 s sees one sample: 744 + 128
     /// = 872 bytes, where the full capacity at `k` = 269 is 1,206 items.
     #[test]
     fn kll_state_bytes_grow_with_the_samples_it_sees() {
diff --git a/crates/cost/src/usage.rs b/crates/cost/src/usage.rs
index 3ad96b178..fe4ee9f11 100644
--- a/crates/cost/src/usage.rs
+++ b/crates/cost/src/usage.rs
@@ -1,5 +1,5 @@
 //! Costing a physical plan DAG node by node: each node's resource usage
-//! ([`node_usage`]), then the plan's usage, latency, retention, kept pane
+//! ([`node_usage`]), then the plan's usage, latency, retention, kept tumbling window
 //! chains and cost ([`plan_cost`]). Moved from Stage 3 (`asap-plan-selection`,
 //! whose module doc, "Cost model", describes the model), so Stage 3 computes
 //! no cost of its own.
@@ -45,9 +45,9 @@ use asap_types::workload::bounds::{
 /// time ranges keep, times how often it is computed per second
 /// ([`computations`]); an ingestion-time node over one second of arriving
 /// rows. A materialized node's kept state is counted in byte-seconds per
-/// second; a pane chain kept beyond one evaluation keeps the panes its
+/// second; a tumbling-window chain kept beyond one evaluation keeps the tumbling windows its
 /// retention covers ([`tumbling_window_retention_ms`]). `nodes` and `kept_chains` are
-/// `dag`'s ([`node_map`], [`kept_pane_chains`]); `recurrence[q]` and
+/// `dag`'s ([`node_map`], [`kept_tumbling_window_chains`]); `recurrence[q]` and
 /// `range_evaluations[q]` say how often query `q` runs and how many steps
 /// each run evaluates (one when missing).
 #[allow(clippy::too_many_arguments)]
@@ -440,7 +440,7 @@ fn each_node_usage<'a>(
             &views,
             multipliers[&node.id],
             scan_window,
-            retained_panes(node, &retention_ms),
+            retained_tumbling_windows(node, &retention_ms),
             (node.output_state.timing == ExecutionTiming::IngestionTime)
                 .then(|| maintained_window_ms(node.id, nodes, &producers_of))
                 .flatten(),
@@ -545,8 +545,8 @@ pub struct NodeUsage<'a> {
 /// `rate` its `(multiplier, per_second)` ([`computations`]), `scan_window`
 /// the raw rows a query-time scan reads ([`PhysicalASAPDAG::scan_window`];
 /// read only for scans: it reads `width_ms` of rows and keeps them back to
-/// [`ScanWindow::lookback_ms`]), `retained_pane_count` the panes a pane chain keeps
-/// completed (`retained_panes`), and `ingestion_window_ms` the window an
+/// [`ScanWindow::lookback_ms`]), `retained_tumbling_window_count` the tumbling windows a tumbling-window chain keeps
+/// completed (`retained_tumbling_windows`), and `ingestion_window_ms` the window an
 /// ingestion-time node maintains (`maintained_window_ms`).
 #[allow(clippy::too_many_arguments)]
 pub fn node_usage<'a>(
@@ -554,7 +554,7 @@ pub fn node_usage<'a>(
     producers: &[ProducerOutput<'a>],
     rate: (u64, f64),
     scan_window: ScanWindow,
-    retained_pane_count: u64,
+    retained_tumbling_window_count: u64,
     ingestion_window_ms: Option<u64>,
     data: &DataWorkload,
     settings: &'a CostInputs,
@@ -945,19 +945,19 @@ pub fn node_usage<'a>(
             tumbling_window_count,
             ..
         }) => {
-            // Each input row is kept by the one pane its time falls in,
+            // Each input row is kept by the one tumbling window its time falls in,
             // as a time range keeps it (one operation), and updates
-            // that pane.
+            // that tumbling window.
             let group_count = groups(reduction)?;
             let states = group_count
                 .checked_mul(u64::from(*tumbling_window_count))
                 .ok_or(AnalyticalCostError::Overflow)?;
-            // Each pane's state sees its group's rows in one pane: of
+            // Each tumbling window's state sees its group's rows in one tumbling window: of
             // one second's rows at ingestion time, of the rows read at
             // query time (all of them for a chain kept across
-            // evaluations, whose scan Stage 2 bounds to its newest pane,
+            // evaluations, whose scan Stage 2 bounds to its newest tumbling window,
             // the only one it builds).
-            let rows_per_pane = match (ingestion, node.materialization) {
+            let rows_per_tumbling_window = match (ingestion, node.materialization) {
                 (true, _) => u64::try_from(
                     (u128::from(input.rows) * u128::from(*tumbling_window_width_ms))
                         .div_ceil(1_000),
@@ -969,7 +969,7 @@ pub fn node_usage<'a>(
                     .div_ceil(u64::from(*tumbling_window_count).max(1)),
             };
             let input_rows = StateInputRows {
-                rows_per_state: Some(rows_per_pane.div_ceil(group_count.max(1))),
+                rows_per_state: Some(rows_per_tumbling_window.div_ceil(group_count.max(1))),
                 non_negative: raw_data_samples_non_negative(),
             };
             let (depth, state_bytes) = summary_shape(family, input_rows);
@@ -988,7 +988,7 @@ pub fn node_usage<'a>(
                     0,
                 )),
                 format!(
-                    "build {} in {tumbling_window_count} panes of {tumbling_window_width_ms} ms for \
+                    "build {} in {tumbling_window_count} tumbling windows of {tumbling_window_width_ms} ms for \
                      {group_count} groups: {} rows x (1 + depth {depth})",
                     family_name(family),
                     input.rows
@@ -1001,20 +1001,20 @@ pub fn node_usage<'a>(
             ..
         }) => {
             // One operation per input state read; one state per group
-            // out, each pane of a chain being a state of its group. A
-            // merge of a chain's newest `n` panes reads `n` per group. A
+            // out, each tumbling window of a chain being a state of its group. A
+            // merge of a chain's newest `n` tumbling windows reads `n` per group. A
             // rollup's groups are those of its keys, at most its input
             // groups.
             let mut group_count = 0;
             for producer in producers {
-                let panes = match producer.payload {
+                let tumbling_windows = match producer.payload {
                     Payload::ASAP(ASAPOp::SummaryTumblingWindowChain {
                         tumbling_window_count,
                         ..
                     }) => u64::from(*tumbling_window_count),
                     _ => 1,
                 };
-                group_count = group_count.max(producer.output.rows / panes.max(1));
+                group_count = group_count.max(producer.output.rows / tumbling_windows.max(1));
             }
             let states = merged_states(*newest_tumbling_windows, producers)?;
             if let Some(keys) = group_by {
@@ -1119,7 +1119,7 @@ pub fn node_usage<'a>(
     let mut detail = format!("{detail}; x {per_second:.4}/s");
     // State kept between computations: at ingestion time, the window
     // being built and the completed ones queries read (a chain of N
-    // panes keeps N + 1), every second. At query time the output is
+    // tumbling windows keeps N + 1), every second. At query time the output is
     // reused only within one evaluation, so it is held only while that
     // evaluation runs (counted below, once latencies are known). The
     // state is what the node holds: its output, or the values an exact
@@ -1139,14 +1139,14 @@ pub fn node_usage<'a>(
             }
             (0, Medium::Memory)
         }
-        // A pane chain kept across evaluations holds the panes its
-        // retention covers ([`tumbling_window_retention_ms`]: N, plus one per pane
+        // A tumbling-window chain kept across evaluations holds the tumbling windows its
+        // retention covers ([`tumbling_window_retention_ms`]: N, plus one per tumbling window
         // width of the readers' range-evaluation span), all but the
         // newest between evaluations and all while one runs.
         (Materialization::MatAtQueryKeptAcrossEvaluations(medium), _) => {
-            let panes = panes_of(node);
-            let retained = retained_pane_count;
-            let between = (state / panes)
+            let tumbling_windows = tumbling_windows_of(node);
+            let retained = retained_tumbling_window_count;
+            let between = (state / tumbling_windows)
                 .checked_mul(
                     retained
                         .checked_sub(1)
@@ -1156,9 +1156,9 @@ pub fn node_usage<'a>(
             match medium {
                 Medium::Memory => {
                     average_memory_bytes = between as f64;
-                    peak_memory_bytes = match retained == panes {
+                    peak_memory_bytes = match retained == tumbling_windows {
                         true => state,
-                        false => (state / panes)
+                        false => (state / tumbling_windows)
                             .checked_mul(retained)
                             .ok_or(AnalyticalCostError::Overflow)?,
                     };
@@ -1178,16 +1178,16 @@ pub fn node_usage<'a>(
             }
             (0, medium)
         }
-        // The retained panes and the one being built.
+        // The retained tumbling windows and the one being built.
         (
             Materialization::MatAtIngestion(medium),
             Payload::ASAP(ASAPOp::SummaryTumblingWindowChain { .. }),
         ) => {
-            let panes = panes_of(node);
+            let tumbling_windows = tumbling_windows_of(node);
             (
-                (state / panes)
+                (state / tumbling_windows)
                     .checked_mul(
-                        retained_pane_count
+                        retained_tumbling_window_count
                             .checked_add(1)
                             .ok_or(AnalyticalCostError::Overflow)?,
                     )
@@ -1201,7 +1201,7 @@ pub fn node_usage<'a>(
         ),
     };
     if node.materialization == Materialization::MatAtIngestion(Medium::Memory) {
-        maintained = Some(state / panes_of(node));
+        maintained = Some(state / tumbling_windows_of(node));
     }
     if kept > 0 {
         match medium {
@@ -1328,7 +1328,7 @@ fn query_latencies(
         |id: PhysicalASAPNodeId| nodes[&id].output_state.timing == ExecutionTiming::IngestionTime;
     let compaction_ms = |state: PhysicalASAPNodeId| {
         let workers = ingest_workers(dag, work_ms, state) as f64;
-        let states = (output[&state].rows / panes_of(nodes[&state])) as f64;
+        let states = (output[&state].rows / tumbling_windows_of(nodes[&state])) as f64;
         let per_merge_ms = merge_ms.get(&state).copied().unwrap_or(formula_merge_ms);
         (workers - 1.0) * states * per_merge_ms
     };
@@ -1381,10 +1381,10 @@ fn ingest_workers(
     (ingest_ms_per_s / 1_000.0).ceil().max(1.0) as u64
 }
 
-/// For each tumbling-pane chain of `dag` kept beyond one evaluation (at
+/// For each tumbling-window chain of `dag` kept beyond one evaluation (at
 /// ingestion time, or at query time across evaluations), how far back
-/// from the newest evaluation its completed panes must be kept, in
-/// milliseconds: how long before the evaluation its newest pane ends (the
+/// from the newest evaluation its completed tumbling windows must be kept, in
+/// milliseconds: how long before the evaluation its newest tumbling window ends (the
 /// offset of its input, `chain_input_offset_ms`), plus its window
 /// `tumbling_window_count · tumbling_window_width_ms`, plus the longest
 /// `span_ms` ([`RangeEvaluation`]) among the queries reaching it,
@@ -1431,7 +1431,7 @@ pub fn tumbling_window_retention_ms(
         .collect()
 }
 
-/// How long before the evaluation a chain's newest pane ends: the offsets
+/// How long before the evaluation a chain's newest tumbling window ends: the offsets
 /// of the `TimeShift`s (without an `@` anchor) directly below the chain,
 /// added up; 0 for a negative total.
 fn chain_input_offset_ms(
@@ -1452,7 +1452,7 @@ fn chain_input_offset_ms(
     u64::try_from(offset_ms).unwrap_or(0)
 }
 
-/// The pane retention of every kept pane chain of `dag`
+/// The tumbling-window retention of every kept tumbling-window chain of `dag`
 /// ([`tumbling_window_retention_ms`] over [`query_reach`]), for a plan whose query
 /// `q` has range evaluation `range_evaluations[q]` (none when missing):
 /// what Stage 2's realizer records for a realized plan.
@@ -1464,8 +1464,8 @@ pub fn tumbling_window_retention_ms_of_plan(
 }
 
 /// The input states a `SummaryMerge` over `producers` reads: every row of
-/// each, or of the one pane chain whose newest `newest_tumbling_windows` it merges,
-/// that many panes' states per group.
+/// each, or of the one tumbling-window chain whose newest `newest_tumbling_windows` it merges,
+/// that many tumbling windows' states per group.
 fn merged_states(
     newest_tumbling_windows: Option<u32>,
     producers: &[ProducerOutput<'_>],
@@ -1487,9 +1487,9 @@ fn merged_states(
     })
 }
 
-/// The panes a chain in `retention_ms` ([`tumbling_window_retention_ms`]) keeps
-/// completed: its retention over its pane width, at least its pane count.
-fn retained_panes(
+/// The tumbling windows a chain in `retention_ms` ([`tumbling_window_retention_ms`]) keeps
+/// completed: its retention over its tumbling-window width, at least its tumbling-window count.
+fn retained_tumbling_windows(
     node: &asap_types::ir::physical_export::PhysicalASAPDAGNode,
     retention_ms: &BTreeMap<PhysicalASAPNodeId, u64>,
 ) -> u64 {
@@ -1500,13 +1500,13 @@ fn retained_panes(
                 ..
             }),
             Some(&retention),
-        ) => (retention / tumbling_window_width_ms.max(&1)).max(panes_of(node)),
-        _ => panes_of(node),
+        ) => (retention / tumbling_window_width_ms.max(&1)).max(tumbling_windows_of(node)),
+        _ => tumbling_windows_of(node),
     }
 }
 
-/// A node's panes: a pane chain's count, 1 for any other node.
-pub fn panes_of(node: &asap_types::ir::physical_export::PhysicalASAPDAGNode) -> u64 {
+/// A node's tumbling windows: a tumbling-window chain's count, 1 for any other node.
+pub fn tumbling_windows_of(node: &asap_types::ir::physical_export::PhysicalASAPDAGNode) -> u64 {
     match &node.payload {
         Payload::ASAP(ASAPOp::SummaryTumblingWindowChain {
             tumbling_window_count,
@@ -1543,8 +1543,8 @@ pub fn query_reach(
         .collect()
 }
 
-/// The window an ingestion-time grouping `node` maintains: a pane chain's
-/// panes, or the time range below it (through filters, projections and
+/// The window an ingestion-time grouping `node` maintains: a tumbling-window chain's
+/// tumbling windows, or the time range below it (through filters, projections and
 /// time shifts). `None` when there is none.
 fn maintained_window_ms(
     node: PhysicalASAPNodeId,
@@ -1594,13 +1594,13 @@ pub fn node_map(dag: &PhysicalASAPDAG) -> NodeMap<'_> {
 pub type NodeMap<'a> =
     HashMap<PhysicalASAPNodeId, &'a asap_types::ir::physical_export::PhysicalASAPDAGNode>;
 
-/// The tumbling-pane chains of `dag` kept across evaluations
+/// The tumbling-window chains of `dag` kept across evaluations
 /// (`MatAtQueryKeptAcrossEvaluations`, which Stage 2 offers only when the
 /// deployment keeps query-time results and every reader builds one new
-/// pane per evaluation). Each evaluation builds the newest pane, and the
+/// tumbling window per evaluation). Each evaluation builds the newest tumbling window, and the
 /// older ones, which complete the readers' look-back, are kept from
 /// earlier evaluations.
-pub fn kept_pane_chains(dag: &PhysicalASAPDAG) -> HashSet<PhysicalASAPNodeId> {
+pub fn kept_tumbling_window_chains(dag: &PhysicalASAPDAG) -> HashSet<PhysicalASAPNodeId> {
     dag.nodes
         .iter()
         .filter(|node| {
@@ -1619,7 +1619,7 @@ pub fn kept_pane_chains(dag: &PhysicalASAPDAG) -> HashSet<PhysicalASAPNodeId> {
 /// The widest window, in milliseconds, read above the scan `scan` at query
 /// time, ignoring readers that read it outside a window and the anchors of
 /// shifts: each range `TimeRange` and `SummaryTumblingWindowChain` (its whole window, or
-/// one pane for a chain in `kept_chains`) reached through time shifts.
+/// one tumbling window for a chain in `kept_chains`) reached through time shifts.
 /// Prices a scan whose [`PhysicalASAPDAG::scan_window`] is unbounded as
 /// Stage 3 did before; #955 decides `@` anchors.
 fn widest_window_read_ms(
diff --git a/crates/cost/tests/held_memory.rs b/crates/cost/tests/held_memory.rs
index 6f467f544..8bc3978c0 100644
--- a/crates/cost/tests/held_memory.rs
+++ b/crates/cost/tests/held_memory.rs
@@ -4,7 +4,9 @@
 
 use asap_cost::execution_demand::evaluation_rate;
 use asap_cost::ResourceUnitCost;
-use asap_cost::{kept_pane_chains, node_map, plan_cost, CostInputs, CostModel, PlanCost};
+use asap_cost::{
+    kept_tumbling_window_chains, node_map, plan_cost, CostInputs, CostModel, PlanCost,
+};
 use asap_logical_asap_optimization::test_support::lower_promql;
 use asap_physical_asap_optimization::optimize_physical_asap;
 use asap_types::ir::physical_export::PhysicalASAPDAG;
@@ -54,7 +56,7 @@ fn cost(dag: &PhysicalASAPDAG, cost_per_memory_byte_second: f64) -> PlanCost {
     plan_cost(
         dag,
         &nodes,
-        &kept_pane_chains(dag),
+        &kept_tumbling_window_chains(dag),
         &recurrence(),
         &[],
         &data(),
diff --git a/crates/cost/tests/ingestion_refresh_runs.rs b/crates/cost/tests/ingestion_refresh_runs.rs
index bdc09b2f8..ebd33bab5 100644
--- a/crates/cost/tests/ingestion_refresh_runs.rs
+++ b/crates/cost/tests/ingestion_refresh_runs.rs
@@ -51,7 +51,7 @@ fn quantile_sketch(algorithm: SketchAlgorithm) -> FieldDataType {
     FieldDataType::Sketch(SketchKind::new(algorithm, params), Default::default())
 }
 
-/// `tumbling_window_count` panes of `tumbling_window_width_ms` of a quantile sketch of
+/// `tumbling_window_count` tumbling windows of `tumbling_window_width_ms` of a quantile sketch of
 /// `algorithm` per `job` over `input`.
 fn chain(
     input: &Rc<OperatorNode>,
@@ -134,11 +134,11 @@ fn shifted(child: &Rc<OperatorNode>, offset_ms: i64) -> Rc<OperatorNode> {
 
 const AT_INGESTION: Materialization = Materialization::MatAtIngestion(Medium::Memory);
 
-/// A KLL chain and a DDSketch chain of 10 s panes over one `Scan`, both
-/// kept at ingestion, are refreshed in one ingestion run per pane: the
+/// A KLL chain and a DDSketch chain of 10 s tumbling windows over one `Scan`, both
+/// kept at ingestion, are refreshed in one ingestion run per tumbling window: the
 /// `Scan` is computed once per second of arriving data, not twice.
 #[test]
-fn a_scan_under_two_chains_of_one_pane_width_is_computed_once() {
+fn a_scan_under_two_chains_of_one_tumbling_window_width_is_computed_once() {
     let scan = scan();
     let dag = dag_of(
         &[
@@ -150,11 +150,11 @@ fn a_scan_under_two_chains_of_one_pane_width_is_computed_once() {
     assert_eq!(scan_computations(&dag), (1, 1.0));
 }
 
-/// With 10 s and 60 s panes the chains need different runs (the 10 s chain
-/// needs five pane ends the 60 s chain does not): the `Scan` is computed
+/// With 10 s and 60 s tumbling windows the chains need different runs (the 10 s chain
+/// needs five tumbling window ends the 60 s chain does not): the `Scan` is computed
 /// once for each.
 #[test]
-fn a_scan_under_chains_of_two_pane_widths_is_computed_for_each() {
+fn a_scan_under_chains_of_two_tumbling_window_widths_is_computed_for_each() {
     let scan = scan();
     let dag = dag_of(
         &[
@@ -217,7 +217,7 @@ fn a_scan_under_chains_of_10_10_and_60_s_is_computed_for_each_width() {
 }
 
 /// A 10 s chain over the `Scan` and a 10 s chain over the `Scan` shifted by
-/// 5 s end their panes on different grids (phases 0 and 5 s): two runs.
+/// 5 s end their tumbling windows on different grids (phases 0 and 5 s): two runs.
 #[test]
 fn chains_of_one_width_and_two_phases_are_computed_apart() {
     let scan = scan();
diff --git a/crates/devtools/src/bin/stage_pipeline.rs b/crates/devtools/src/bin/stage_pipeline.rs
index 8d235cc47..6889a6e3f 100644
--- a/crates/devtools/src/bin/stage_pipeline.rs
+++ b/crates/devtools/src/bin/stage_pipeline.rs
@@ -73,16 +73,16 @@
 //     `guarantee_check_rejection`, the sketches read and a one-line summary),
 //     `pruned_candidates` and `search_report` (`SearchReport`: `status`,
 //     `cost_lower_bound_per_second`, MILP size and timings); `error` when no
-//     plan was selected. `tumbling_window_retention_ms` maps each pane chain the
+//     plan was selected. `tumbling_window_retention_ms` maps each tumbling-window chain the
 //     selected plan keeps beyond one evaluation (by node id in `P1`) to how
-//     far back the runtime must keep its panes (`RealizedPlan::tumbling_window_retention_ms`).
+//     far back the runtime must keep its tumbling windows (`RealizedPlan::tumbling_window_retention_ms`).
 //     `materialized_views` are the selected plan's materialized views as
 //     `plan_installable`'s plan derives them (`installable_plan_of`, then
 //     `InstallablePlan::materialized_views`: each view's installed node id,
 //     `refresh`, `coverage` with its `definition_id` and `selection`,
 //     `inputs` and `retention_ms`), each with the node of `P1` it is
 //     installed from (`stage2_node_id`), its position among that node's
-//     installed nodes (`installed_position`, a pane chain's panes newest
+//     installed nodes (`installed_position`, a tumbling-window chain's tumbling windows newest
 //     first) and their number (`installed_count`); empty without a
 //     selection, with `materialized_views_error` when the plan is not
 //     installable. `warnings` are one-line warnings about the workload and
@@ -94,7 +94,7 @@
 //     declares no memory capacity (`large_peak_memory_warning`); absent when
 //     there are none;
 //   - planning_report: the facade's `PlanningReport`: Pass 1's time and, per
-//     pane-width round, Pass 2's and Stage 2's counts and each stage's time,
+//     tumbling-window-width round, Pass 2's and Stage 2's counts and each stage's time,
 //     with Stage 3's search report or error;
 //   - reference_pricing (with `--exhaustive`): the reference pricer's
 //     selection among the enumerated plans, named as Stage 3's `Selection`
@@ -115,7 +115,7 @@
 // their parents); `steps`, one per
 // memo step in pipeline order (`stage0`: the frontends' DAG hash-consed,
 // groups without candidates; `pass1`: Pass 1's candidates, with the
-// accuracy-scoped sizes; `pass2`: local window composition's pane
+// accuracy-scoped sizes; `pass2`: local window composition's tumbling window
 // candidates; `concrete_states`: the Pass 2 memo rules (scan labels,
 // summary inputs, top-k reuse, finer aggregates, rollups, summary results,
 // state configurations) and the concrete summary-state groups, the memo the
@@ -214,7 +214,7 @@
 // does not generate a query-time scan of raw data (its `pruned_candidates`
 // lists each with `RawDataNotRetained`), and stored data (at rest or
 // mixed) is refused as a contradiction; with `query_time_results_retained`,
-// a tumbling-pane chain whose readers evaluate together at its pane width is
+// a tumbling-window chain whose readers evaluate together at its tumbling-window width is
 // also offered built at query time and kept across evaluations, beside being
 // shared within one evaluation. The document's top-level
 // `deployment_capabilities` shows the capabilities used, with the
@@ -1173,7 +1173,7 @@ fn round_robin<'a, C: PartialEq>(
 /// plus the node of the selected Stage 2 candidate it is installed from
 /// (`stage2_node_id`, null when Stage 3 recorded no cost to map it by), its
 /// position among that node's installed nodes (`installed_position`: a
-/// pane chain's panes, newest first) and their number (`installed_count`).
+/// tumbling-window chain's tumbling windows, newest first) and their number (`installed_count`).
 fn materialized_views_json(
     roots: &[QueryRoot],
     selection: &Selection,
diff --git a/crates/devtools/src/candidate_labels.rs b/crates/devtools/src/candidate_labels.rs
index 56fe294b0..772fa3b30 100644
--- a/crates/devtools/src/candidate_labels.rs
+++ b/crates/devtools/src/candidate_labels.rs
@@ -136,7 +136,7 @@ fn duration_name(ms: u64) -> String {
 }
 
 /// `logical` followed by what the candidate materializes, e.g.
-/// "… · ingestion time: Kll for Q1, 5 × 1m panes · query time, shared:
+/// "… · ingestion time: Kll for Q1, 5 × 1m tumbling windows · query time, shared:
 /// DDSketch";
 /// just `logical` when nothing is.
 pub fn physical_label(logical: &str, candidate: &PhysicalWorkloadPlan) -> String {
@@ -155,14 +155,14 @@ pub fn physical_label(logical: &str, candidate: &PhysicalWorkloadPlan) -> String
             .find(|n| n.id == *id)
             .expect("an assigned node is in the DAG");
         let label = match &node.payload {
-            // Name the chain: chains of one family and pane count differ by
-            // their readers and pane width.
+            // Name the chain: chains of one family and tumbling-window count differ by
+            // their readers and tumbling-window width.
             Operator::ASAP(ASAPOp::SummaryTumblingWindowChain {
                 tumbling_window_width_ms,
                 tumbling_window_count,
                 ..
             }) => format!(
-                "{}, {tumbling_window_count} × {} panes",
+                "{}, {tumbling_window_count} × {} tumbling windows",
                 for_queries(
                     state_label(&node.payload),
                     &dag_readers(&candidate.dag, *id)
@@ -186,20 +186,23 @@ pub fn physical_label(logical: &str, candidate: &PhysicalWorkloadPlan) -> String
         .join(" · ")
 }
 
-/// A summary build, e.g. "Kll ×5 panes" or "Sum acc".
+/// A summary build, e.g. "Kll ×5 tumbling windows" or "Sum acc".
 fn build_label<C>(payload: &Operator<C>) -> String {
     match payload {
         Operator::ASAP(ASAPOp::SummaryTumblingWindowChain {
             tumbling_window_count,
             ..
         }) => {
-            format!("{} ×{tumbling_window_count} panes", state_label(payload))
+            format!(
+                "{} ×{tumbling_window_count} tumbling windows",
+                state_label(payload)
+            )
         }
         _ => state_label(payload),
     }
 }
 
-/// The state a summary build or pane chain keeps, e.g. "Kll" or "Sum acc";
+/// The state a summary build or tumbling-window chain keeps, e.g. "Kll" or "Sum acc";
 /// any other operator's kind.
 fn state_label<C>(payload: &Operator<C>) -> String {
     match payload {
@@ -309,13 +312,13 @@ mod tests {
         assert_eq!(label.matches("shared Sum acc").count(), 1);
     }
 
-    /// Two physical candidates that each maintain a different query's pane
+    /// Two physical candidates that each maintain a different query's tumbling window
     /// chain at ingestion time get different labels, even when both chains
-    /// have the same family and pane count (6 × 10s for Q1, 6 × 30s for Q2).
+    /// have the same family and tumbling-window count (6 × 10s for Q1, 6 × 30s for Q2).
     #[test]
-    fn physical_labels_name_the_pane_chain_maintained_at_ingestion() {
+    fn physical_labels_name_the_tumbling_window_chain_maintained_at_ingestion() {
         use asap_logical_asap_optimization::test_support::{
-            pane_candidates, window_composition_pass2_candidates,
+            tumbling_window_candidates, window_composition_pass2_candidates,
         };
         use asap_physical_asap_optimization::optimize_physical_asap;
         use asap_types::workload::PlanningWorkload;
@@ -354,12 +357,12 @@ mod tests {
         let summary: Vec<_> = compose_logical_candidate(&inventory, &choice).unwrap();
         let entries: Vec<_> = workload.query_workload.entries().collect();
         let grids: Vec<_> = entries.iter().map(|e| e.evaluation_grid_ms()).collect();
-        let panes = pane_candidates(&summary, &grids);
-        let roots = window_composition_pass2_candidates(&summary, &panes)
+        let tumbling_windows = tumbling_window_candidates(&summary, &grids);
+        let roots = window_composition_pass2_candidates(&summary, &tumbling_windows)
             .unwrap()
             .into_iter()
-            .find(|c| c.pane_candidates.len() == 2 && c.shared_chains.is_empty())
-            .expect("each query's DDSketch in its own pane chain")
+            .find(|c| c.tumbling_window_candidates.len() == 2 && c.shared_chains.is_empty())
+            .expect("each query's DDSketch in its own tumbling-window chain")
             .roots
             .unwrap();
         let plans = optimize_physical_asap(
@@ -370,7 +373,7 @@ mod tests {
             false,
         )
         .unwrap();
-        // The plans that maintain exactly one pane chain at ingestion time.
+        // The plans that maintain exactly one tumbling-window chain at ingestion time.
         let one_chain_at_ingestion: Vec<String> = plans
             .iter()
             .filter(|plan| {
@@ -403,14 +406,14 @@ mod tests {
             one_chain_at_ingestion
                 .iter()
                 .any(|l| ingestion(l).as_deref()
-                    == Some("ingestion time: DDSketch for Q1, 6 × 10s panes")),
+                    == Some("ingestion time: DDSketch for Q1, 6 × 10s tumbling windows")),
             "{one_chain_at_ingestion:#?}"
         );
         assert!(
             one_chain_at_ingestion
                 .iter()
                 .any(|l| ingestion(l).as_deref()
-                    == Some("ingestion time: DDSketch for Q2, 6 × 30s panes")),
+                    == Some("ingestion time: DDSketch for Q2, 6 × 30s tumbling windows")),
             "{one_chain_at_ingestion:#?}"
         );
         let mut distinct = one_chain_at_ingestion.clone();
diff --git a/crates/devtools/src/planner_fuzz/README.md b/crates/devtools/src/planner_fuzz/README.md
index 9e21316a9..d6adb0c47 100644
--- a/crates/devtools/src/planner_fuzz/README.md
+++ b/crates/devtools/src/planner_fuzz/README.md
@@ -91,7 +91,7 @@ For a query `q` of workload `W` and a query `q'` derivable from `q`, the tester
 builds a **witness**. The witness is `W`'s selected logical plan (its Stage 1
 candidate) plus one more root that derives `q'` from `q`'s node in that plan,
 by the operator the relation names. Three witnesses change that plan too: m
-and n lengthen the pane chain `q` reads (so `q` merges its newest panes of
+and n lengthen the tumbling-window chain `q` reads (so `q` merges its newest tumbling windows of
 the longer chain); l's `q'` also reads a sibling query, so `W` is planned
 with the sibling added; and h's second witness is `W ∪ {q'}` planned with
 UnivMon as the only sketch family. Each is a plan for `W ∪ {q'}`. The tester
@@ -133,7 +133,7 @@ Two rules decide whether a check counts:
 | `a-looser-accuracy` | `q` at the next looser target | reading `q`'s node |
 | `b-filter-on-group-key` | grouped `q` plus `label = 'value'` on a group key | `Filter` over `q`'s result |
 | `c-coarser-grouping` | `q` grouped by one key fewer | exact `Aggregate` (sum / max / min) over `q`'s result, or a sketch `SummaryMerge{group_by}` over `q`'s state |
-| `d-nested-shorter-window` | `q` over a shorter window that divides it | `SummaryMerge{newest_tumbling_windows}` over `q`'s pane chain |
+| `d-nested-shorter-window` | `q` over a shorter window that divides it | `SummaryMerge{newest_tumbling_windows}` over `q`'s tumbling-window chain |
 | `e-other-quantile-rank` | `q` at another rank | `q`'s estimate (or exact quantile aggregate) at the other rank, same input |
 | `f-exact-duplicate` | `q` | reading `q`'s node |
 | `g-outer-over-result` | an operator over `q`, by `q`'s outer operator: `topk(3, q)` (sum), `bottomk(3, q)` (count), `max(q)` (max), `quantile(0.5, q)` (avg), `q > 0` (min, quantile) | the operator's lowering grafted onto `q`'s node |
@@ -142,7 +142,7 @@ Two rules decide whether a check counts:
 | `j-smaller-topk` | `q`'s top-k at k = 3 | `q`'s `Limit` / `TopK` at 3 over the same input |
 | `k-union-of-selections` | `q` over `label =~ "v1\|v2"`, with `q`'s `v2` twin added to `W` | `SummaryMerge` of the two states, then `q`'s estimate |
 | `l-binary-over-result` | PromQL: `q{label="v"} / q` on a label `q` does not group by, or `q / q_count` for a `sum_over_time` `q` with no outer operator or `sum` (avg as sum/count) | the division's lowering grafted onto `q`'s node |
-| `m-longer-window` | `q` over the shortest longer window (up to 1 h) that is a multiple of `q`'s; not for `rate` or `increase` | `q`'s pane chain lengthened: every merge of it in `W`'s plan reads its old newest panes, and `q'` merges the whole chain |
+| `m-longer-window` | `q` over the shortest longer window (up to 1 h) that is a multiple of `q`'s; not for `rate` or `increase` | `q`'s tumbling-window chain lengthened: every merge of it in `W`'s plan reads its old newest tumbling windows, and `q'` merges the whole chain |
 | `n-longer-window-rollup` | `q` over a longer window, as in m, grouped by one key fewer | m's derivation, then c's rollup |
 | `o-equivalent-range-function` | `q` with `rate` and `increase` swapped (not under `count`) | `q`'s result times (or divided by) the window in seconds, grafted onto `q`'s node |
 
@@ -200,21 +200,21 @@ status column, "conclusive" means the check either held or was violated.
 | Slice: a filter on a group key over a grouped result or summary (planned) | asap-primitive-schema.md "Other uses of coverage" L846–848, L118 | `b-filter-on-group-key` | VIOLATED (995 of 1,003): #891, #902 (#689 for approximate inputs) |
 | Rollup to a coarser grouping: exact, or sketch `SummaryMerge{group_by}` | planner-layering.md rule table L588; asap-primitive-schema.md §5.6 L670, L754–794, L830–844; joint-planning-search.md L324 | `c-coarser-grouping` | VIOLATED (167 of 389): new drafts (exact rollup; sketch rollup over an inner range function) |
 | Scan widening: scans of one metric with different labels share one scan | planner-layering.md Pass 2 L597–607 | `c-coarser-grouping` (sketch rollup witness) | covered by c; no separate violation |
-| Nested window: a shorter window merges the newest panes of a longer window's chain | planner-layering.md L790–807; asap-primitive-schema.md §5.6 L669 | `d-nested-shorter-window` | VIOLATED (73 of 250): new draft (exact sums); compare #873 (rate/increase) |
+| Nested window: a shorter window merges the newest tumbling windows of a longer window's chain | planner-layering.md L790–807; asap-primitive-schema.md §5.6 L669 | `d-nested-shorter-window` | VIOLATED (73 of 250): new draft (exact sums); compare #873 (rate/increase) |
 | Another quantile rank from the same sketch | planner-layering.md L631–634, L804–817 | `e-other-quantile-rank` | VIOLATED (39 of 465), exact percentiles only: new draft (unshared exact aggregates) |
 | Identical expressions (common-subexpression elimination) | planner-layering.md rule table L583–585, Algorithm 2 L655–658 | `f-exact-duplicate` | VIOLATED (92 of 2,915), exact query-time aggregates: new draft |
 | A query over another query's result (top-k over a shared sum) | joint-planning-search.md L177–187; planner-layering.md L583–585 | `g-outer-over-result` | holds (552 conclusive checks). With the operator following q's (ASAPWorkloads #4, #12, #17, #18): VIOLATED (6 of 49), `topk(3, …)` over an exact instant sum and `… > 0` over an approximate quantile |
 | Summary capability: another statistic the family answers (`FamilyCapability::answers`) | planner-layering.md rule table L586, L611–617, Example 2 L1306–1370 | `h-other-statistic` | KLL and KMV answer one statistic, so h now checks SQL frequency statistics of a high-cardinality column (planner-layering Example 2; ASAPWorkloads #57, #107–#108): holds (5 conclusive checks) |
-| gcd pane grid across repeat intervals | planner-layering.md L791–809 | `i-other-repeat-interval` | VIOLATED (49 of 2,717): new draft; compare #731 |
+| gcd tumbling-window grid across repeat intervals | planner-layering.md L791–809 | `i-other-repeat-interval` | VIOLATED (49 of 2,717): new draft; compare #731 |
 | Exact top-k reuse (smaller k) | planner-layering.md rule table L589; joint-planning-search.md L325 | `j-smaller-topk` | holds (62 conclusive checks) |
 | Merge of disjoint selections | asap-primitive-schema.md §4.2 L194–232, §5.6 Example B L721–752 | `k-union-of-selections` | never conclusive: Stage 1 composes no guarantee for the merged estimate |
-| Panes kept across evaluations when query-time results are retained | planner-layering.md Materialization L889–893 | `results-retained` | holds (1,442 conclusive checks) |
-| Window = interval: the whole window as a one-pane tumbling chain | planner-layering.md Materialization L895–905 | — | not checked: a Stage 2 choice within one query |
-| Rollup over newest panes (windowed rollup) | planner-layering.md L809–823 | — | not checked: a composition of c and d |
+| Tumbling windows kept across evaluations when query-time results are retained | planner-layering.md Materialization L889–893 | `results-retained` | holds (1,442 conclusive checks) |
+| Window = interval: the whole window as a one-tumbling-window chain | planner-layering.md Materialization L895–905 | — | not checked: a Stage 2 choice within one query |
+| Rollup over newest tumbling windows (windowed rollup) | planner-layering.md L809–823 | — | not checked: a composition of c and d |
 | avg as sum/count: shared exact accumulators | planner-layering.md L372–383, L502–503; ASAPWorkloads #8 | `l-binary-over-result` | holds (15 conclusive checks, with the ratio row below); checks that the sum is shared, not one accumulator for both |
 | A ratio with a shared operand: a filtered share of a rate (5xx share), one rate over another | ASAPWorkloads #11, #12, #30, #126 | `l-binary-over-result` | holds (see above) |
-| Longer window over the same panes: one chain serves 5m and 1h windows | planner-layering.md L790–807; ASAPWorkloads #1–#2, #19, #122 | `m-longer-window` | VIOLATED (2 of 7): SQL count and percentile at a longer window build new state |
-| Longer window rolled up to a coarser grouping | ASAPWorkloads #1–#2, #61–#62, #65 | `n-longer-window-rollup` | never conclusive yet: needs a grouped q planned with a pane chain |
+| Longer window over the same tumbling windows: one chain serves 5m and 1h windows | planner-layering.md L790–807; ASAPWorkloads #1–#2, #19, #122 | `m-longer-window` | VIOLATED (2 of 7): SQL count and percentile at a longer window build new state |
+| Longer window rolled up to a coarser grouping | ASAPWorkloads #1–#2, #61–#62, #65 | `n-longer-window-rollup` | never conclusive yet: needs a grouped q planned with a tumbling-window chain |
 | `rate` and `increase` of one counter read one state | ASAPWorkloads #1–#2 | `o-equivalent-range-function` | VIOLATED (6 of 6): the second function builds its own state; compare #873 |
 | Stored-state reuse; sliding windows, exponential histograms, SummarySubtract | asap-primitive-schema.md L849, L851–869; planner-layering.md L618–630, L827 | — | not checked: planned or not implemented |
 
diff --git a/crates/devtools/src/planner_fuzz/relations.rs b/crates/devtools/src/planner_fuzz/relations.rs
index a35706a20..1b72e8cc9 100644
--- a/crates/devtools/src/planner_fuzz/relations.rs
+++ b/crates/devtools/src/planner_fuzz/relations.rs
@@ -44,8 +44,8 @@ pub enum Relation {
     /// (`Aggregate` over `q`'s result) or a sketch rollup (`SummaryMerge`
     /// with `group_by` over `q`'s state).
     CoarserGrouping,
-    /// (d) `q'` = `q` over a shorter window on the same pane grid: derived
-    /// by merging the newest panes of `q`'s pane chain.
+    /// (d) `q'` = `q` over a shorter window on the same tumbling-window grid: derived
+    /// by merging the newest tumbling windows of `q`'s tumbling-window chain.
     NestedShorterWindow,
     /// (e) `q'` = `q` at another quantile rank: derived by one more
     /// estimate from `q`'s sketch.
@@ -75,8 +75,8 @@ pub enum Relation {
     /// the division with `q` read from `q`'s result.
     BinaryOverResult,
     /// (m) `q'` = `q` over a longer window that is a multiple of it:
-    /// derived by lengthening `q`'s pane chain, which `q` reads the newest
-    /// panes of.
+    /// derived by lengthening `q`'s tumbling-window chain, which `q` reads the newest
+    /// tumbling windows of.
     LongerWindow,
     /// (n) `q'` = `q` over a longer window and grouped by one key fewer:
     /// derived by a rollup over (m)'s derivation.
@@ -245,9 +245,9 @@ pub enum Witness {
     /// `q`'s root estimate reading a `SummaryMerge` with `group_by` the
     /// `labels` columns over its state, when the family merges groups.
     SketchRollup { labels: Vec<String> },
-    /// `q`'s `SummaryMerge` over a pane chain merging only the newest panes
+    /// `q`'s `SummaryMerge` over a tumbling-window chain merging only the newest tumbling windows
     /// covering `window_ms`.
-    NewestPanes { window_ms: u64 },
+    NewestTumblingWindows { window_ms: u64 },
     /// `q`'s topmost quantile estimate (or exact quantile aggregate) at rank
     /// `to` instead of `from`.
     QuantileRank { from: f64, to: f64 },
@@ -257,8 +257,8 @@ pub enum Witness {
     /// `q`'s root estimate over a `SummaryMerge` of its state and the state
     /// of `W`'s last query (the other selection, added to `W`).
     UnionWithLast,
-    /// `q`'s pane chain lengthened to cover `window_ms`: every reader of
-    /// the chain in `W`'s plan merges its old newest panes of the longer
+    /// `q`'s tumbling-window chain lengthened to cover `window_ms`: every reader of
+    /// the chain in `W`'s plan merges its old newest tumbling windows of the longer
     /// chain, and `q'` merges all of them, then applies `rollup` when set.
     LongerWindow {
         window_ms: u64,
@@ -447,7 +447,7 @@ pub fn derive(relation: Relation, workload: &FuzzWorkload, target: usize) -> Opt
             let spec = match q.spec.as_ref()? {
                 QuerySpec::Promql(spec) => {
                     // A counter's rate and increase read the window length
-                    // and its boundary samples, not only merged pane state.
+                    // and its boundary samples, not only merged tumbling-window state.
                     if matches!(spec.range?, RangeFunction::Rate | RangeFunction::Increase) {
                         return None;
                     }
@@ -465,7 +465,10 @@ pub fn derive(relation: Relation, workload: &FuzzWorkload, target: usize) -> Opt
                 QuerySpec::Promql(s) => s.window_ms,
                 QuerySpec::Sql(s) => s.window_ms,
             };
-            derived(q.with_spec(spec), vec![Witness::NewestPanes { window_ms }])
+            derived(
+                q.with_spec(spec),
+                vec![Witness::NewestTumblingWindows { window_ms }],
+            )
         }
         Relation::OtherQuantileRank => {
             let (spec, from) = match q.spec.as_ref()? {
@@ -684,7 +687,7 @@ pub fn derive(relation: Relation, workload: &FuzzWorkload, target: usize) -> Opt
             let (longer, window_ms) = match q.spec.as_ref()? {
                 QuerySpec::Promql(spec) => {
                     // As for (d): rate and increase read more than merged
-                    // pane state.
+                    // tumbling-window state.
                     if matches!(spec.range?, RangeFunction::Rate | RangeFunction::Increase) {
                         return None;
                     }
@@ -1150,8 +1153,10 @@ pub fn witness_root(
             .map_err(|e| format!("rollup estimate: {e}"))?;
             with_root_estimate(q_root, estimate, &dropped)
         }
-        Witness::NewestPanes { window_ms } => {
-            rewrite_root(q_root, "summary merge over a pane chain", |node| {
+        Witness::NewestTumblingWindows { window_ms } => rewrite_root(
+            q_root,
+            "summary merge over a tumbling-window chain",
+            |node| {
                 let Some(ASAPOp::SummaryMerge {
                     children,
                     newest_tumbling_windows: None,
@@ -1171,22 +1176,22 @@ pub fn witness_root(
                 else {
                     return None;
                 };
-                let panes = window_ms / tumbling_window_width_ms;
+                let tumbling_windows = window_ms / tumbling_window_width_ms;
                 (window_ms % tumbling_window_width_ms == 0
-                    && panes >= 1
-                    && (panes as u32) < *tumbling_window_count)
+                    && tumbling_windows >= 1
+                    && (tumbling_windows as u32) < *tumbling_window_count)
                     .then(|| {
                         with_operator(
                             node,
                             Operator::ASAP(ASAPOp::SummaryMerge {
                                 children: children.clone(),
-                                newest_tumbling_windows: Some(panes as u32),
+                                newest_tumbling_windows: Some(tumbling_windows as u32),
                                 group_by: group_by.clone(),
                             }),
                         )
                     })
-            })
-        }
+            },
+        ),
         Witness::QuantileRank { from, to } => {
             let mut done = false;
             rewrite_root(q_root, "quantile estimate", |node| {
@@ -1448,8 +1453,8 @@ fn collect(
     }
 }
 
-/// `W`'s roots with the pane chain `q` merges whole lengthened to cover
-/// `window_ms`, every merge of it reading its old newest panes of the
+/// `W`'s roots with the tumbling-window chain `q` merges whole lengthened to cover
+/// `window_ms`, every merge of it reading its old newest tumbling windows of the
 /// longer chain; and `q`'s root merging the whole longer chain.
 fn longer_chain_roots(
     base_roots: &[QueryRoot],
@@ -1467,14 +1472,14 @@ fn longer_chain_roots(
         )
     };
     let merge = find_first(q_root, &whole_chain_merge)
-        .ok_or("q's plan has no summary merge over a pane chain")?;
+        .ok_or("q's plan has no summary merge over a tumbling-window chain")?;
     // Lengthening one of several chains (say, an SQL idiom's exact row
     // count beside its statistic) would leave the others at q's window.
     let mut merges = Vec::new();
     collect(q_root, &whole_chain_merge, &mut merges);
     if merges.len() > 1 {
         return Err(format!(
-            "q's plan merges {} pane chains whole",
+            "q's plan merges {} tumbling-window chains whole",
             merges.len()
         ));
     }
@@ -1489,14 +1494,14 @@ fn longer_chain_roots(
         ..
     }) = &mut operator
     else {
-        unreachable!("found a pane chain");
+        unreachable!("found a tumbling-window chain");
     };
     let old_count = *tumbling_window_count;
     if !window_ms.is_multiple_of(*tumbling_window_width_ms)
         || window_ms / *tumbling_window_width_ms <= old_count as u64
     {
         return Err(format!(
-            "q's chain of {old_count} panes of {tumbling_window_width_ms} ms does not extend to {window_ms} ms"
+            "q's chain of {old_count} tumbling windows of {tumbling_window_width_ms} ms does not extend to {window_ms} ms"
         ));
     }
     *tumbling_window_count = (window_ms / *tumbling_window_width_ms) as u32;
@@ -1970,7 +1975,7 @@ mod tests {
                 op: RollupOp::Sum
             }
         );
-        // A counter's rate reads more than merged panes: no nested window.
+        // A counter's rate reads more than merged tumbling windows: no nested window.
         assert_eq!(text(Relation::NestedShorterWindow), None);
         assert_eq!(text(Relation::OtherQuantileRank), None);
         assert_eq!(
@@ -2078,7 +2083,7 @@ mod tests {
                 text: "(sum by (job, instance) (rate(m_counter[5m]))) * 300".into()
             }]
         );
-        // As for (d), a rate's window is not merged pane state.
+        // As for (d), a rate's window is not merged tumbling-window state.
         assert_eq!(text(&rate, Relation::LongerWindow), None);
 
         let mut sum = sum_by(&["job", "instance"]);
diff --git a/crates/devtools/src/planner_fuzz/report.rs b/crates/devtools/src/planner_fuzz/report.rs
index b29aca898..88abee049 100644
--- a/crates/devtools/src/planner_fuzz/report.rs
+++ b/crates/devtools/src/planner_fuzz/report.rs
@@ -57,8 +57,8 @@ pub fn documented_patterns() -> Vec<DocumentedPattern> {
             note: "checked through the sketch rollup witness, which reads the finer query's scan and state",
         },
         DocumentedPattern {
-            pattern: "Nested window: a shorter window merges the newest panes of a longer window's chain",
-            doc_reference: "planner-layering.md window composition L790–807; asap-primitive-schema.md §5.6 \"Newest panes\" L669",
+            pattern: "Nested window: a shorter window merges the newest tumbling windows of a longer window's chain",
+            doc_reference: "planner-layering.md window composition L790–807; asap-primitive-schema.md §5.6 \"Newest tumbling windows\" L669",
             relation: Some(Relation::NestedShorterWindow),
             note: "",
         },
@@ -87,7 +87,7 @@ pub fn documented_patterns() -> Vec<DocumentedPattern> {
             note: "UnivMon's count, distinct count, L2 and entropy (ASAPWorkloads #57, #107–#108); the witness reads q's own state, or is W ∪ {q'} planned with UnivMon as the only family",
         },
         DocumentedPattern {
-            pattern: "gcd pane grid across repeat intervals: queries at different intervals read one chain at their own cadence",
+            pattern: "gcd tumbling-window grid across repeat intervals: queries at different intervals read one chain at their own cadence",
             doc_reference: "planner-layering.md L791–809",
             relation: Some(Relation::OtherRepeatInterval),
             note: "",
@@ -105,19 +105,19 @@ pub fn documented_patterns() -> Vec<DocumentedPattern> {
             note: "the merge operator is implemented; the docs name no Pass 2 rule that creates it",
         },
         DocumentedPattern {
-            pattern: "Panes kept across evaluations when the deployment retains query-time results",
+            pattern: "Tumbling windows kept across evaluations when the deployment retains query-time results",
             doc_reference: "planner-layering.md Materialization L889–893",
             relation: Some(Relation::ResultsRetained),
             note: "a capability never raises cost",
         },
         DocumentedPattern {
-            pattern: "Window = interval: the whole window maintained as a one-pane tumbling chain",
+            pattern: "Window = interval: the whole window maintained as a one-tumbling-window chain",
             doc_reference: "planner-layering.md Materialization L895–905",
             relation: None,
             note: "a Stage 2 choice within one query, not a q → q' derivation",
         },
         DocumentedPattern {
-            pattern: "Rollup over newest panes (windowed rollup)",
+            pattern: "Rollup over newest tumbling windows (windowed rollup)",
             doc_reference: "planner-layering.md L809–823",
             relation: None,
             note: "a composition of c and d; not checked as one relation",
@@ -135,7 +135,7 @@ pub fn documented_patterns() -> Vec<DocumentedPattern> {
             note: "",
         },
         DocumentedPattern {
-            pattern: "Longer window over the same panes: one chain serves 5m and 1h windows",
+            pattern: "Longer window over the same tumbling windows: one chain serves 5m and 1h windows",
             doc_reference: "planner-layering.md window composition L790–807; ASAPWorkloads #1–#2, #19, #122",
             relation: Some(Relation::LongerWindow),
             note: "rate and increase excluded, as for d",
@@ -725,8 +725,8 @@ fn derivation_text(witness: &Witness) -> String {
             "a `SummaryMerge` with `group_by` = ({}) over q's summary state, then q's estimate",
             labels.join(", ")
         ),
-        Witness::NewestPanes { window_ms } => format!(
-            "a `SummaryMerge` of the newest panes of q's pane chain covering {window_ms} ms"
+        Witness::NewestTumblingWindows { window_ms } => format!(
+            "a `SummaryMerge` of the newest tumbling windows of q's tumbling-window chain covering {window_ms} ms"
         ),
         Witness::QuantileRank { from, to } => {
             format!("q's quantile estimate at rank {to} instead of {from}, from the same state")
@@ -748,8 +748,8 @@ fn derivation_text(witness: &Witness) -> String {
         }
         Witness::LongerWindow { window_ms, rollup } => {
             let lengthened = format!(
-                "q's pane chain lengthened to cover {window_ms} ms (q merges its old newest \
-                 panes), merged whole"
+                "q's tumbling-window chain lengthened to cover {window_ms} ms (q merges its old newest \
+                 tumbling windows), merged whole"
             );
             match rollup {
                 Some(rollup) => format!("{lengthened}, then {}", derivation_text(rollup)),
@@ -806,7 +806,9 @@ fn write_draft(
             format!("A coarser grouping of `{q}` does not roll up its result or state")
         }
         Relation::NestedShorterWindow => {
-            format!("A shorter window of `{q}` does not merge the newest panes of its chain")
+            format!(
+                "A shorter window of `{q}` does not merge the newest tumbling windows of its chain"
+            )
         }
         Relation::OtherQuantileRank => {
             format!("Another quantile rank of `{q}` does not read the same sketch")
@@ -831,7 +833,7 @@ fn write_draft(
             format!("A ratio with `{q}` as an operand does not read `{q}`'s result")
         }
         Relation::LongerWindow => {
-            format!("A longer window of `{q}` does not extend its pane chain")
+            format!("A longer window of `{q}` does not extend its tumbling-window chain")
         }
         Relation::LongerWindowRollup => format!(
             "A longer window and coarser grouping of `{q}` does not roll up its extended chain"
diff --git a/crates/devtools/src/planning_stages.rs b/crates/devtools/src/planning_stages.rs
index 853987555..47618fdd6 100644
--- a/crates/devtools/src/planning_stages.rs
+++ b/crates/devtools/src/planning_stages.rs
@@ -21,7 +21,7 @@ pub const DEFAULT_REFERENCE_CHOICES: usize = 10_000;
 pub struct PlanningStagesRun {
     /// The query-language frontends' roots, one per workload entry.
     pub stage0_query_language_frontends: Vec<QueryRoot>,
-    /// The facade's run: Pass 1, the pane-width rounds and the selection.
+    /// The facade's run: Pass 1, the tumbling-window-width rounds and the selection.
     pub run: PlanningRun,
     /// `--exhaustive`: the selected round's memo choices, each implemented
     /// by Stage 2 and all priced by the reference pricer.
diff --git a/crates/devtools/tests/corpus_snapshots.rs b/crates/devtools/tests/corpus_snapshots.rs
index 251d5f7e5..10ef56a76 100644
--- a/crates/devtools/tests/corpus_snapshots.rs
+++ b/crates/devtools/tests/corpus_snapshots.rs
@@ -12,7 +12,7 @@
 //!
 //! A snapshot holds only the plan, never the search that found it: the
 //! selected plan's DAG (Stage 2 candidate `P1`) and display name, its cost
-//! and accepted accuracy per query, the materialized views, pane retention,
+//! and accepted accuracy per query, the materialized views, tumbling-window retention,
 //! and whether the search proved the plan optimal; for a query that does not
 //! plan, the error. Candidate ids, round and evaluation counters, timings, the
 //! Stage 1 and Stage 2 candidate lists and the memo vary from run to run
@@ -90,7 +90,7 @@ fn stage_pipeline(args: &[String], scratch: &Path) -> Value {
 }
 
 /// Whether the wall-clock budget ended the search: planning (Pass 1 and
-/// every pane-width round) used the whole budget. A round cut short by its
+/// every tumbling-window-width round) used the whole budget. A round cut short by its
 /// own budget is not visible in the report.
 fn hit_time_limit(document: &Value) -> bool {
     let report = &document["planning_report"];
@@ -118,10 +118,10 @@ fn search_status(document: &Value) -> &Value {
 }
 
 /// Whether the plan is proven optimal: its search says so and every legal
-/// pane width was searched.
+/// tumbling-window width was searched.
 fn proven_optimal(document: &Value) -> bool {
     search_status(document) == "optimal"
-        && document["planning_report"]["pane_widths_pending"] != json!(true)
+        && document["planning_report"]["tumbling_window_widths_pending"] != json!(true)
 }
 
 /// `value` with every non-integer number rounded to 12 significant digits.
@@ -420,14 +420,14 @@ fn time_limit_detection() {
     ));
 }
 
-/// An optimal search proves the plan optimal only when no legal pane width
+/// An optimal search proves the plan optimal only when no legal tumbling-window width
 /// was left unsearched.
 #[test]
-fn proven_optimal_needs_every_pane_width() {
+fn proven_optimal_needs_every_tumbling_window_width() {
     let document = |status: &str, pending: bool| {
         json!({
             "stage3_plan_selection": {"search_report": {"status": status}},
-            "planning_report": {"pane_widths_pending": pending},
+            "planning_report": {"tumbling_window_widths_pending": pending},
         })
     };
     assert!(proven_optimal(&document("optimal", false)));
diff --git a/crates/devtools/tests/corpus_snapshots/o11y_bench/q02.json b/crates/devtools/tests/corpus_snapshots/o11y_bench/q02.json
index 9937946e5..d803d90f7 100644
--- a/crates/devtools/tests/corpus_snapshots/o11y_bench/q02.json
+++ b/crates/devtools/tests/corpus_snapshots/o11y_bench/q02.json
@@ -262,9 +262,6 @@
       "stage2_node_id": 1
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 3900000
-  },
   "proven_optimal": true,
   "query": "histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket{job=\"order-service\"}[5m])) by (le))",
   "selected": {
@@ -295,7 +292,7 @@
         "1": {
           "cost_per_second": 0.464,
           "cpu_core_seconds_per_second": 2e-6,
-          "detail": "build exact Rate accumulator in 5 panes of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 3696000 bytes",
+          "detail": "build exact Rate accumulator in 5 tumbling windows of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 3696000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -947,9 +944,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 5,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -1313,6 +1310,9 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 Sum acc + Rate acc ×5 panes · ingestion time: Rate acc for Q1, 5 × 1m panes"
+    "display_name": "Q1 Sum acc + Rate acc ×5 tumbling windows · ingestion time: Rate acc for Q1, 5 × 1m tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 3900000
   }
 }
diff --git a/crates/devtools/tests/corpus_snapshots/o11y_bench/q05.json b/crates/devtools/tests/corpus_snapshots/o11y_bench/q05.json
index f64439876..1e72f4c5c 100644
--- a/crates/devtools/tests/corpus_snapshots/o11y_bench/q05.json
+++ b/crates/devtools/tests/corpus_snapshots/o11y_bench/q05.json
@@ -2,10 +2,6 @@
   "accuracy_guarantees": "enforced",
   "materialized_views": [],
   "materialized_views_error": "raw-data window of node 1 is unsupported: a subquery or a TimeShift above the range",
-  "tumbling_window_retention_ms": {
-    "1": 3900000,
-    "7": 3900000
-  },
   "proven_optimal": false,
   "query": "max_over_time((sum(rate(http_requests_total{job=\"order-service\",status=~\"5..\"}[5m])) / sum(rate(http_requests_total{job=\"order-service\"}[5m])))[6h:1m])",
   "selected": {
@@ -36,7 +32,7 @@
         "1": {
           "cost_per_second": 0.464,
           "cpu_core_seconds_per_second": 2e-6,
-          "detail": "build exact Rate accumulator in 5 panes of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 3696000 bytes",
+          "detail": "build exact Rate accumulator in 5 tumbling windows of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 3696000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -144,7 +140,7 @@
         "7": {
           "cost_per_second": 0.464,
           "cpu_core_seconds_per_second": 2e-6,
-          "detail": "build exact Rate accumulator in 5 panes of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 3696000 bytes",
+          "detail": "build exact Rate accumulator in 5 tumbling windows of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 3696000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -1121,9 +1117,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 5,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -1607,9 +1603,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 5,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -2078,6 +2074,10 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 Max acc + Sum acc + Rate acc ×5 panes · ingestion time: Rate acc for Q1, 5 × 1m panes, Rate acc for Q1, 5 × 1m panes"
+    "display_name": "Q1 Max acc + Sum acc + Rate acc ×5 tumbling windows · ingestion time: Rate acc for Q1, 5 × 1m tumbling windows, Rate acc for Q1, 5 × 1m tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 3900000,
+    "7": 3900000
   }
 }
diff --git a/crates/devtools/tests/corpus_snapshots/o11y_bench/q06.json b/crates/devtools/tests/corpus_snapshots/o11y_bench/q06.json
index f105a966d..99affb00a 100644
--- a/crates/devtools/tests/corpus_snapshots/o11y_bench/q06.json
+++ b/crates/devtools/tests/corpus_snapshots/o11y_bench/q06.json
@@ -2,9 +2,6 @@
   "accuracy_guarantees": "enforced",
   "materialized_views": [],
   "materialized_views_error": "raw-data window of node 1 is unsupported: a subquery or a TimeShift above the range",
-  "tumbling_window_retention_ms": {
-    "1": 3900000
-  },
   "proven_optimal": true,
   "query": "max_over_time(histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket{job=\"user-service\"}[5m])) by (le))[12h:1m])",
   "selected": {
@@ -35,7 +32,7 @@
         "1": {
           "cost_per_second": 0.464,
           "cpu_core_seconds_per_second": 2e-6,
-          "detail": "build exact Rate accumulator in 5 panes of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 3696000 bytes",
+          "detail": "build exact Rate accumulator in 5 tumbling windows of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 3696000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -795,9 +792,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 5,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -1317,6 +1314,9 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 Max acc + Sum acc + Rate acc ×5 panes · ingestion time: Rate acc for Q1, 5 × 1m panes"
+    "display_name": "Q1 Max acc + Sum acc + Rate acc ×5 tumbling windows · ingestion time: Rate acc for Q1, 5 × 1m tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 3900000
   }
 }
diff --git a/crates/devtools/tests/corpus_snapshots/o11y_bench/q11.json b/crates/devtools/tests/corpus_snapshots/o11y_bench/q11.json
index 4bb42ebd1..16f3c5c73 100644
--- a/crates/devtools/tests/corpus_snapshots/o11y_bench/q11.json
+++ b/crates/devtools/tests/corpus_snapshots/o11y_bench/q11.json
@@ -2,7 +2,6 @@
   "accuracy_guarantees": "enforced",
   "materialized_views": [],
   "materialized_views_error": "raw-data window of node 1 is unsupported: a subquery or a TimeShift above the range",
-  "tumbling_window_retention_ms": {},
   "proven_optimal": true,
   "query": "max_over_time(sum(process_resident_memory_bytes)[6h:1m])",
   "selected": {
@@ -758,5 +757,6 @@
       "scalar_roots": []
     },
     "display_name": "Q1 Max acc + Sum acc"
-  }
+  },
+  "tumbling_window_retention_ms": {}
 }
diff --git a/crates/devtools/tests/corpus_snapshots/o11y_bench/q12.json b/crates/devtools/tests/corpus_snapshots/o11y_bench/q12.json
index 1515e4fe8..2a4d99a83 100644
--- a/crates/devtools/tests/corpus_snapshots/o11y_bench/q12.json
+++ b/crates/devtools/tests/corpus_snapshots/o11y_bench/q12.json
@@ -1,7 +1,6 @@
 {
   "accuracy_guarantees": "enforced",
   "materialized_views": [],
-  "tumbling_window_retention_ms": {},
   "proven_optimal": true,
   "query": "service_cache_refresh_lag_seconds{job=\"user-service\"}",
   "selected": {
@@ -344,5 +343,6 @@
       "scalar_roots": []
     },
     "display_name": "Q1 exact"
-  }
+  },
+  "tumbling_window_retention_ms": {}
 }
diff --git a/crates/devtools/tests/corpus_snapshots/o11y_bench/q19.json b/crates/devtools/tests/corpus_snapshots/o11y_bench/q19.json
index c9266c6c7..5c0c496f3 100644
--- a/crates/devtools/tests/corpus_snapshots/o11y_bench/q19.json
+++ b/crates/devtools/tests/corpus_snapshots/o11y_bench/q19.json
@@ -6242,10 +6242,6 @@
       "stage2_node_id": 7
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 7200000,
-    "7": 7200000
-  },
   "proven_optimal": false,
   "query": "sum(increase(http_requests_total{job=\"payment-service\",status=~\"5..\"}[1h])) / sum(increase(http_requests_total{job=\"payment-service\"}[1h]))",
   "selected": {
@@ -6276,7 +6272,7 @@
         "1": {
           "cost_per_second": 0.849,
           "cpu_core_seconds_per_second": 2e-6,
-          "detail": "build exact Increase accumulator in 60 panes of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 6776000 bytes",
+          "detail": "build exact Increase accumulator in 60 tumbling windows of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 6776000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -6357,7 +6353,7 @@
         "7": {
           "cost_per_second": 0.849,
           "cpu_core_seconds_per_second": 2e-6,
-          "detail": "build exact Increase accumulator in 60 panes of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 6776000 bytes",
+          "detail": "build exact Increase accumulator in 60 tumbling windows of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 6776000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -7253,9 +7249,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 60,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -7739,9 +7735,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 60,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -8054,6 +8050,10 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 Sum acc + Increase acc ×60 panes · ingestion time: Increase acc for Q1, 60 × 1m panes, Increase acc for Q1, 60 × 1m panes"
+    "display_name": "Q1 Sum acc + Increase acc ×60 tumbling windows · ingestion time: Increase acc for Q1, 60 × 1m tumbling windows, Increase acc for Q1, 60 × 1m tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 7200000,
+    "7": 7200000
   }
 }
diff --git a/crates/devtools/tests/corpus_snapshots/o11y_bench/q20.json b/crates/devtools/tests/corpus_snapshots/o11y_bench/q20.json
index aeffc1c16..6b44c713b 100644
--- a/crates/devtools/tests/corpus_snapshots/o11y_bench/q20.json
+++ b/crates/devtools/tests/corpus_snapshots/o11y_bench/q20.json
@@ -1,7 +1,6 @@
 {
   "accuracy_guarantees": "enforced",
   "materialized_views": [],
-  "tumbling_window_retention_ms": {},
   "proven_optimal": true,
   "query": "sum(process_resident_memory_bytes)",
   "selected": {
@@ -493,5 +492,6 @@
       "scalar_roots": []
     },
     "display_name": "Q1 Sum acc"
-  }
+  },
+  "tumbling_window_retention_ms": {}
 }
diff --git a/crates/devtools/tests/corpus_snapshots/o11y_bench/q22.json b/crates/devtools/tests/corpus_snapshots/o11y_bench/q22.json
index d85712efc..b7c91f320 100644
--- a/crates/devtools/tests/corpus_snapshots/o11y_bench/q22.json
+++ b/crates/devtools/tests/corpus_snapshots/o11y_bench/q22.json
@@ -262,9 +262,6 @@
       "stage2_node_id": 1
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 3900000
-  },
   "proven_optimal": true,
   "query": "sum(rate(http_requests_total{job=\"order-service\"}[5m]))",
   "selected": {
@@ -295,7 +292,7 @@
         "1": {
           "cost_per_second": 0.464,
           "cpu_core_seconds_per_second": 2e-6,
-          "detail": "build exact Rate accumulator in 5 panes of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 3696000 bytes",
+          "detail": "build exact Rate accumulator in 5 tumbling windows of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 3696000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -832,9 +829,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 5,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -1089,6 +1086,9 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 Sum acc + Rate acc ×5 panes · ingestion time: Rate acc for Q1, 5 × 1m panes"
+    "display_name": "Q1 Sum acc + Rate acc ×5 tumbling windows · ingestion time: Rate acc for Q1, 5 × 1m tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 3900000
   }
 }
diff --git a/crates/devtools/tests/corpus_snapshots/o11y_bench/q23.json b/crates/devtools/tests/corpus_snapshots/o11y_bench/q23.json
index f8da85219..2ad030eed 100644
--- a/crates/devtools/tests/corpus_snapshots/o11y_bench/q23.json
+++ b/crates/devtools/tests/corpus_snapshots/o11y_bench/q23.json
@@ -192,9 +192,6 @@
       "stage2_node_id": 1
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 3900000
-  },
   "proven_optimal": true,
   "query": "sum(rate(http_requests_total{job=~\"user-service|order-service|payment-service\"}[5m]))",
   "selected": {
@@ -225,7 +222,7 @@
         "1": {
           "cost_per_second": 0.464,
           "cpu_core_seconds_per_second": 2e-6,
-          "detail": "build exact Rate accumulator in 5 panes of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 3696000 bytes",
+          "detail": "build exact Rate accumulator in 5 tumbling windows of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 3696000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -762,9 +759,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 5,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -1019,6 +1016,9 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 Sum acc + Rate acc ×5 panes · ingestion time: Rate acc for Q1, 5 × 1m panes"
+    "display_name": "Q1 Sum acc + Rate acc ×5 tumbling windows · ingestion time: Rate acc for Q1, 5 × 1m tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 3900000
   }
 }
diff --git a/crates/devtools/tests/corpus_snapshots/o11y_bench/q25.json b/crates/devtools/tests/corpus_snapshots/o11y_bench/q25.json
index 78a62793d..61dd6c49f 100644
--- a/crates/devtools/tests/corpus_snapshots/o11y_bench/q25.json
+++ b/crates/devtools/tests/corpus_snapshots/o11y_bench/q25.json
@@ -4562,10 +4562,6 @@
       "stage2_node_id": 7
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 7200000,
-    "7": 7200000
-  },
   "proven_optimal": false,
   "query": "sum(rate(http_requests_total{status=~\"5..\",job=~\"user-service|order-service|payment-service\"}[1h])) / sum(rate(http_requests_total{job=~\"user-service|order-service|payment-service\"}[1h]))",
   "selected": {
@@ -4596,7 +4592,7 @@
         "1": {
           "cost_per_second": 0.849,
           "cpu_core_seconds_per_second": 2e-6,
-          "detail": "build exact Rate accumulator in 60 panes of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 6776000 bytes",
+          "detail": "build exact Rate accumulator in 60 tumbling windows of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 6776000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -4677,7 +4673,7 @@
         "7": {
           "cost_per_second": 0.849,
           "cpu_core_seconds_per_second": 2e-6,
-          "detail": "build exact Rate accumulator in 60 panes of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 6776000 bytes",
+          "detail": "build exact Rate accumulator in 60 tumbling windows of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 6776000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -5573,9 +5569,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 60,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -6059,9 +6055,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 60,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -6374,6 +6370,10 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 Sum acc + Rate acc ×60 panes · ingestion time: Rate acc for Q1, 60 × 1m panes, Rate acc for Q1, 60 × 1m panes"
+    "display_name": "Q1 Sum acc + Rate acc ×60 tumbling windows · ingestion time: Rate acc for Q1, 60 × 1m tumbling windows, Rate acc for Q1, 60 × 1m tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 7200000,
+    "7": 7200000
   }
 }
diff --git a/crates/devtools/tests/corpus_snapshots/o11y_bench/q26.json b/crates/devtools/tests/corpus_snapshots/o11y_bench/q26.json
index 12c488c91..e33bf4553 100644
--- a/crates/devtools/tests/corpus_snapshots/o11y_bench/q26.json
+++ b/crates/devtools/tests/corpus_snapshots/o11y_bench/q26.json
@@ -2282,9 +2282,6 @@
       "stage2_node_id": 1
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 7200000
-  },
   "proven_optimal": true,
   "query": "sum(rate(process_cpu_seconds_total[1h]))",
   "selected": {
@@ -2315,7 +2312,7 @@
         "1": {
           "cost_per_second": 0.849,
           "cpu_core_seconds_per_second": 2e-6,
-          "detail": "build exact Rate accumulator in 60 panes of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 6776000 bytes",
+          "detail": "build exact Rate accumulator in 60 tumbling windows of 60000 ms for 1000 groups: 1000 rows x (1 + depth 1); x 1.0000/s; keeps 6776000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -2781,9 +2778,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 60,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -3022,6 +3019,9 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 Sum acc + Rate acc ×60 panes · ingestion time: Rate acc for Q1, 60 × 1m panes"
+    "display_name": "Q1 Sum acc + Rate acc ×60 tumbling windows · ingestion time: Rate acc for Q1, 60 × 1m tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 7200000
   }
 }
diff --git a/crates/devtools/tests/corpus_snapshots/o11y_bench/q27.json b/crates/devtools/tests/corpus_snapshots/o11y_bench/q27.json
index 091d09615..e119b2b13 100644
--- a/crates/devtools/tests/corpus_snapshots/o11y_bench/q27.json
+++ b/crates/devtools/tests/corpus_snapshots/o11y_bench/q27.json
@@ -1,7 +1,6 @@
 {
   "accuracy_guarantees": "enforced",
   "materialized_views": [],
-  "tumbling_window_retention_ms": {},
   "proven_optimal": true,
   "query": "sum(up)",
   "selected": {
@@ -493,5 +492,6 @@
       "scalar_roots": []
     },
     "display_name": "Q1 Sum acc"
-  }
+  },
+  "tumbling_window_retention_ms": {}
 }
diff --git a/crates/devtools/tests/planner_fuzz.rs b/crates/devtools/tests/planner_fuzz.rs
index c12e256f5..73df7cc00 100644
--- a/crates/devtools/tests/planner_fuzz.rs
+++ b/crates/devtools/tests/planner_fuzz.rs
@@ -344,7 +344,7 @@ fn threshold_witness_prices_over_the_result() {
     ));
 }
 
-/// (m): a longer window lengthens q's pane chain of exact sums.
+/// (m): a longer window lengthens q's tumbling-window chain of exact sums.
 #[test]
 fn longer_window_witness_prices_over_a_lengthened_chain() {
     let q = promql(
diff --git a/crates/devtools/tests/sketch_plan_snapshots.rs b/crates/devtools/tests/sketch_plan_snapshots.rs
index 7217ee0f2..88759ff63 100644
--- a/crates/devtools/tests/sketch_plan_snapshots.rs
+++ b/crates/devtools/tests/sketch_plan_snapshots.rs
@@ -2,9 +2,9 @@
 //!
 //! The corpus snapshots are single queries without an accuracy target, so
 //! their plans are exact. These workloads carry accuracy targets and select
-//! sketches (KLL, DDSketch, a CMS heap), share a sketch pane chain between
-//! queries or nested windows, answer a ratio of two quantiles from one pane
-//! chain, and materialize panes, under the MVP deployment (raw data not
+//! sketches (KLL, DDSketch, a CMS heap), share a sketch tumbling-window chain between
+//! queries or nested windows, answer a ratio of two quantiles from one tumbling window
+//! chain, and materialize tumbling windows, under the MVP deployment (raw data not
 //! retained) and raw data retained. A change to sketch kinds, parameters,
 //! sizes, sharing, timing, materialization or cost shows up as a snapshot
 //! diff.
@@ -18,14 +18,14 @@
 //! Regenerate with
 //! `UPDATE_SNAPSHOTS=1 cargo test --release -p asap-devtools --test corpus_snapshots -- --ignored sketch_plans_match_snapshots`.
 //!
-//! The search's seed and pane-width rounds have wall-clock budgets (5 s
+//! The search's seed and tumbling-window-width rounds have wall-clock budgets (5 s
 //! each), so a search that stops at a budget, of time or of evaluations, can
 //! select a different plan on a slower machine. Only a search that proves its
 //! plan optimal is independent of speed, so every workload must end with
-//! status `optimal` and no pane width left unsearched; any other ending
+//! status `optimal` and no tumbling-window width left unsearched; any other ending
 //! fails instead of being recorded. A workload with a
 //! `deadline_reached_reason` in the manifest may instead end with status
-//! `deadline_reached` (no pane width left unsearched); its snapshot records
+//! `deadline_reached` (no tumbling-window width left unsearched); its snapshot records
 //! that status, so the plan, cost and status must still match. Each
 //! kept workload gave the same plan in three runs and on one core.
 //! Workloads whose search stops at a budget (the raw-retained memo examples,
@@ -147,17 +147,17 @@ fn sketch_plans_match_snapshots() {
             continue;
         }
         // A `deadline_reached_reason` accepts a search that ended at its
-        // deadline after every pane width; plan and cost are still compared.
+        // deadline after every tumbling-window width; plan and cost are still compared.
         let deadline_accepted = entry.get("deadline_reached_reason").is_some()
             && search_status(&document) == "deadline_reached"
-            && document["planning_report"]["pane_widths_pending"] != json!(true);
+            && document["planning_report"]["tumbling_window_widths_pending"] != json!(true);
         if !proven_optimal(&document) && !deadline_accepted {
             failures.push(format!(
-                "{id}: the plan is not proven optimal (status {}, pane widths \
+                "{id}: the plan is not proven optimal (status {}, tumbling-window widths \
                  pending {}), so a round's budget may have chosen it; drop the \
                  workload or make it smaller",
                 search_status(&document),
-                document["planning_report"]["pane_widths_pending"]
+                document["planning_report"]["tumbling_window_widths_pending"]
             ));
             continue;
         }
diff --git a/crates/devtools/tests/sketch_plan_snapshots/fuzz-issue903-raw-retained.json b/crates/devtools/tests/sketch_plan_snapshots/fuzz-issue903-raw-retained.json
index 6ef669d60..225a81a8a 100644
--- a/crates/devtools/tests/sketch_plan_snapshots/fuzz-issue903-raw-retained.json
+++ b/crates/devtools/tests/sketch_plan_snapshots/fuzz-issue903-raw-retained.json
@@ -1,7 +1,6 @@
 {
   "accuracy_guarantees": "enforced",
   "materialized_views": [],
-  "tumbling_window_retention_ms": {},
   "proven_optimal": true,
   "queries": [
     "quantile_over_time(0.9, data[5m])",
@@ -913,5 +912,6 @@
       "scalar_roots": []
     },
     "display_name": "Q1 exact · Q2 Kll · shared Scan (Q1, Q2) · query time, shared: TimeRange"
-  }
+  },
+  "tumbling_window_retention_ms": {}
 }
diff --git a/crates/devtools/tests/sketch_plan_snapshots/nested-windows-15m-1h-mvp.json b/crates/devtools/tests/sketch_plan_snapshots/nested-windows-15m-1h-mvp.json
index d5f6f2441..9b4fb2c61 100644
--- a/crates/devtools/tests/sketch_plan_snapshots/nested-windows-15m-1h-mvp.json
+++ b/crates/devtools/tests/sketch_plan_snapshots/nested-windows-15m-1h-mvp.json
@@ -2282,9 +2282,6 @@
       "stage2_node_id": 1
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 3600000
-  },
   "proven_optimal": true,
   "queries": [
     "quantile_over_time(0.9, data[15m])",
@@ -2331,7 +2328,7 @@
         "1": {
           "cost_per_second": 3.89542189639e-6,
           "cpu_core_seconds_per_second": 0.004,
-          "detail": "build DDSketch in 60 panes of 60000 ms for 10000 groups: 2000000 rows x (1 + depth 1); x 1.0000/s; keeps 3347680000 bytes",
+          "detail": "build DDSketch in 60 tumbling windows of 60000 ms for 10000 groups: 2000000 rows x (1 + depth 1); x 1.0000/s; keeps 3347680000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -2979,9 +2976,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 60,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -3518,6 +3515,9 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 DDSketch ×60 panes · Q2 DDSketch ×60 panes · shared DDSketch ×60 panes (Q1, Q2) · shared Scan (Q1, Q2) · ingestion time: DDSketch for Q1, Q2, 60 × 1m panes"
+    "display_name": "Q1 DDSketch ×60 tumbling windows · Q2 DDSketch ×60 tumbling windows · shared DDSketch ×60 tumbling windows (Q1, Q2) · shared Scan (Q1, Q2) · ingestion time: DDSketch for Q1, Q2, 60 × 1m tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 3600000
   }
 }
diff --git a/crates/devtools/tests/sketch_plan_snapshots/quantile-grouped-mvp.json b/crates/devtools/tests/sketch_plan_snapshots/quantile-grouped-mvp.json
index 91def3992..3baaa111e 100644
--- a/crates/devtools/tests/sketch_plan_snapshots/quantile-grouped-mvp.json
+++ b/crates/devtools/tests/sketch_plan_snapshots/quantile-grouped-mvp.json
@@ -1142,9 +1142,6 @@
       "stage2_node_id": 1
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 300000
-  },
   "proven_optimal": true,
   "queries": [
     "avg by (region) (quantile_over_time(0.9, data[5m]))"
@@ -1180,7 +1177,7 @@
         "1": {
           "cost_per_second": 1.95903278013e-6,
           "cpu_core_seconds_per_second": 0.0002,
-          "detail": "build DDSketch in 30 panes of 10000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 1701280000 bytes",
+          "detail": "build DDSketch in 30 tumbling windows of 10000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 1701280000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -2099,9 +2096,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 30,
-                "tumbling_window_width_ms": 10000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 10000
               }
             }
           }
@@ -3156,6 +3153,9 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 Sum acc + DDSketch ×30 panes + Count acc · ingestion time: DDSketch for Q1, 30 × 10s panes"
+    "display_name": "Q1 Sum acc + DDSketch ×30 tumbling windows + Count acc · ingestion time: DDSketch for Q1, 30 × 10s tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 300000
   }
 }
diff --git a/crates/devtools/tests/sketch_plan_snapshots/quantile-single-mvp.json b/crates/devtools/tests/sketch_plan_snapshots/quantile-single-mvp.json
index a73b7542e..b1a914db3 100644
--- a/crates/devtools/tests/sketch_plan_snapshots/quantile-single-mvp.json
+++ b/crates/devtools/tests/sketch_plan_snapshots/quantile-single-mvp.json
@@ -1142,9 +1142,6 @@
       "stage2_node_id": 1
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 300000
-  },
   "proven_optimal": false,
   "queries": [
     "quantile_over_time(0.99, data[5m])"
@@ -1180,7 +1177,7 @@
         "1": {
           "cost_per_second": 6.32641306719e-7,
           "cpu_core_seconds_per_second": 0.0002,
-          "detail": "build Kll in 30 panes of 10000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 548080000 bytes",
+          "detail": "build Kll in 30 tumbling windows of 10000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 548080000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -1640,9 +1637,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 30,
-                "tumbling_window_width_ms": 10000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 10000
               }
             }
           }
@@ -1902,6 +1899,9 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 Kll ×30 panes · ingestion time: Kll for Q1, 30 × 10s panes"
+    "display_name": "Q1 Kll ×30 tumbling windows · ingestion time: Kll for Q1, 30 × 10s tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 300000
   }
 }
diff --git a/crates/devtools/tests/sketch_plan_snapshots/random-mixed-seed-862-long-w01-q3-mvp.json b/crates/devtools/tests/sketch_plan_snapshots/random-mixed-seed-862-long-w01-q3-mvp.json
index 812e10e7d..04ea77719 100644
--- a/crates/devtools/tests/sketch_plan_snapshots/random-mixed-seed-862-long-w01-q3-mvp.json
+++ b/crates/devtools/tests/sketch_plan_snapshots/random-mixed-seed-862-long-w01-q3-mvp.json
@@ -11402,9 +11402,6 @@
       "stage2_node_id": 1
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 300000
-  },
   "proven_optimal": true,
   "queries": [
     "avg by (region) (quantile_over_time(0.95, data[300s]))"
@@ -11440,7 +11437,7 @@
         "1": {
           "cost_per_second": 0.0000190019900264,
           "cpu_core_seconds_per_second": 0.0002,
-          "detail": "build DDSketch in 300 panes of 1000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 16518880000 bytes",
+          "detail": "build DDSketch in 300 tumbling windows of 1000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 16518880000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -12359,9 +12356,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 300,
-                "tumbling_window_width_ms": 1000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 1000
               }
             }
           }
@@ -13416,6 +13413,9 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 Sum acc + DDSketch ×300 panes + Count acc · ingestion time: DDSketch for Q1, 300 × 1s panes"
+    "display_name": "Q1 Sum acc + DDSketch ×300 tumbling windows + Count acc · ingestion time: DDSketch for Q1, 300 × 1s tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 300000
   }
 }
diff --git a/crates/devtools/tests/sketch_plan_snapshots/random-mixed-seed-862-w01-q3-q8-mvp.json b/crates/devtools/tests/sketch_plan_snapshots/random-mixed-seed-862-w01-q3-q8-mvp.json
index 2e13e936f..f9db2cbc5 100644
--- a/crates/devtools/tests/sketch_plan_snapshots/random-mixed-seed-862-w01-q3-q8-mvp.json
+++ b/crates/devtools/tests/sketch_plan_snapshots/random-mixed-seed-862-w01-q3-q8-mvp.json
@@ -5322,10 +5322,6 @@
       "stage2_node_id": 13
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 100000,
-    "13": 1200000
-  },
   "proven_optimal": true,
   "queries": [
     "avg by (region) (quantile_over_time(0.95, data[100s]))",
@@ -5370,7 +5366,7 @@
         "1": {
           "cost_per_second": 6.3775772514e-6,
           "cpu_core_seconds_per_second": 0.0002,
-          "detail": "build DDSketch in 100 panes of 1000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 5542880000 bytes",
+          "detail": "build DDSketch in 100 tumbling windows of 1000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 5542880000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -5406,7 +5402,7 @@
         "13": {
           "cost_per_second": 2.86570103968e-8,
           "cpu_core_seconds_per_second": 0.0002,
-          "detail": "build exact Rate accumulator in 40 panes of 30000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 22960000 bytes",
+          "detail": "build exact Rate accumulator in 40 tumbling windows of 30000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 22960000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -6692,9 +6688,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 100,
-                "tumbling_window_width_ms": 1000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 1000
               }
             }
           }
@@ -7947,9 +7943,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 40,
-                "tumbling_window_width_ms": 30000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 30000
               }
             }
           }
@@ -8359,6 +8355,10 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 Sum acc + DDSketch ×100 panes + Count acc · Q2 Rate acc ×40 panes · ingestion time: DDSketch for Q1, 100 × 1s panes, Rate acc for Q2, 40 × 30s panes"
+    "display_name": "Q1 Sum acc + DDSketch ×100 tumbling windows + Count acc · Q2 Rate acc ×40 tumbling windows · ingestion time: DDSketch for Q1, 100 × 1s tumbling windows, Rate acc for Q2, 40 × 30s tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 100000,
+    "13": 1200000
   }
 }
diff --git a/crates/devtools/tests/sketch_plan_snapshots/random-mixed-seed-862-w02-q2-q7-mvp.json b/crates/devtools/tests/sketch_plan_snapshots/random-mixed-seed-862-w02-q2-q7-mvp.json
index f4b488492..6de034914 100644
--- a/crates/devtools/tests/sketch_plan_snapshots/random-mixed-seed-862-w02-q2-q7-mvp.json
+++ b/crates/devtools/tests/sketch_plan_snapshots/random-mixed-seed-862-w02-q2-q7-mvp.json
@@ -6082,10 +6082,6 @@
       "stage2_node_id": 13
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 100000,
-    "13": 300000
-  },
   "proven_optimal": true,
   "queries": [
     "avg by (region) (quantile_over_time(0.75, data[100s]))",
@@ -6130,7 +6126,7 @@
         "1": {
           "cost_per_second": 6.3775772514e-6,
           "cpu_core_seconds_per_second": 0.0002,
-          "detail": "build DDSketch in 100 panes of 1000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 5542880000 bytes",
+          "detail": "build DDSketch in 100 tumbling windows of 1000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 5542880000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -6166,7 +6162,7 @@
         "13": {
           "cost_per_second": 4.15390642488e-8,
           "cpu_core_seconds_per_second": 0.0002,
-          "detail": "build exact Increase accumulator in 60 panes of 5000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 34160000 bytes",
+          "detail": "build exact Increase accumulator in 60 tumbling windows of 5000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 34160000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -7452,9 +7448,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 100,
-                "tumbling_window_width_ms": 1000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 1000
               }
             }
           }
@@ -8707,9 +8703,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 60,
-                "tumbling_window_width_ms": 5000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 5000
               }
             }
           }
@@ -9119,6 +9115,10 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 Sum acc + DDSketch ×100 panes + Count acc · Q2 Increase acc ×60 panes · ingestion time: DDSketch for Q1, 100 × 1s panes, Increase acc for Q2, 60 × 5s panes"
+    "display_name": "Q1 Sum acc + DDSketch ×100 tumbling windows + Count acc · Q2 Increase acc ×60 tumbling windows · ingestion time: DDSketch for Q1, 100 × 1s tumbling windows, Increase acc for Q2, 60 × 5s tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 100000,
+    "13": 300000
   }
 }
diff --git a/crates/devtools/tests/sketch_plan_snapshots/ratio-of-quantiles-1h-mvp.json b/crates/devtools/tests/sketch_plan_snapshots/ratio-of-quantiles-1h-mvp.json
index ab9bca0ec..0d170be65 100644
--- a/crates/devtools/tests/sketch_plan_snapshots/ratio-of-quantiles-1h-mvp.json
+++ b/crates/devtools/tests/sketch_plan_snapshots/ratio-of-quantiles-1h-mvp.json
@@ -2282,9 +2282,6 @@
       "stage2_node_id": 1
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 3600000
-  },
   "proven_optimal": true,
   "queries": [
     "quantile_over_time(0.9, data[1h]) / quantile_over_time(0.5, data[1h])"
@@ -2320,7 +2317,7 @@
         "1": {
           "cost_per_second": 6.38754722874e-6,
           "cpu_core_seconds_per_second": 0.004,
-          "detail": "build DDSketch in 60 panes of 60000 ms for 10000 groups: 2000000 rows x (1 + depth 1); x 1.0000/s; keeps 5514400000 bytes",
+          "detail": "build DDSketch in 60 tumbling windows of 60000 ms for 10000 groups: 2000000 rows x (1 + depth 1); x 1.0000/s; keeps 5514400000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -3067,9 +3064,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 60,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -3666,6 +3663,9 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 DDSketch ×60 panes · ingestion time: DDSketch for Q1, 60 × 1m panes"
+    "display_name": "Q1 DDSketch ×60 tumbling windows · ingestion time: DDSketch for Q1, 60 × 1m tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 3600000
   }
 }
diff --git a/crates/devtools/tests/sketch_plan_snapshots/shared-quantiles-1h-mvp.json b/crates/devtools/tests/sketch_plan_snapshots/shared-quantiles-1h-mvp.json
index 5947593fe..0c2de0f45 100644
--- a/crates/devtools/tests/sketch_plan_snapshots/shared-quantiles-1h-mvp.json
+++ b/crates/devtools/tests/sketch_plan_snapshots/shared-quantiles-1h-mvp.json
@@ -2282,9 +2282,6 @@
       "stage2_node_id": 1
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 3600000
-  },
   "proven_optimal": false,
   "queries": [
     "quantile_over_time(0.5, data[1h])",
@@ -2331,7 +2328,7 @@
         "1": {
           "cost_per_second": 3.89542189639e-6,
           "cpu_core_seconds_per_second": 0.004,
-          "detail": "build DDSketch in 60 panes of 60000 ms for 10000 groups: 2000000 rows x (1 + depth 1); x 1.0000/s; keeps 3347680000 bytes",
+          "detail": "build DDSketch in 60 tumbling windows of 60000 ms for 10000 groups: 2000000 rows x (1 + depth 1); x 1.0000/s; keeps 3347680000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -2979,9 +2976,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 60,
-                "tumbling_window_width_ms": 60000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 60000
               }
             }
           }
@@ -3517,6 +3514,9 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 DDSketch ×60 panes · Q2 DDSketch ×60 panes · shared DDSketch ×60 panes (Q1, Q2) · shared Scan (Q1, Q2) · ingestion time: DDSketch for Q1, Q2, 60 × 1m panes"
+    "display_name": "Q1 DDSketch ×60 tumbling windows · Q2 DDSketch ×60 tumbling windows · shared DDSketch ×60 tumbling windows (Q1, Q2) · shared Scan (Q1, Q2) · ingestion time: DDSketch for Q1, Q2, 60 × 1m tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 3600000
   }
 }
diff --git a/crates/devtools/tests/sketch_plan_snapshots/topk-rate-guarantees-ignored-mvp.json b/crates/devtools/tests/sketch_plan_snapshots/topk-rate-guarantees-ignored-mvp.json
index e2def6a64..b49a890c2 100644
--- a/crates/devtools/tests/sketch_plan_snapshots/topk-rate-guarantees-ignored-mvp.json
+++ b/crates/devtools/tests/sketch_plan_snapshots/topk-rate-guarantees-ignored-mvp.json
@@ -1142,9 +1142,6 @@
       "stage2_node_id": 1
     }
   ],
-  "tumbling_window_retention_ms": {
-    "1": 300000
-  },
   "proven_optimal": true,
   "queries": [
     "topk(5, sum by (job) (rate(data_total[5m])))"
@@ -1180,7 +1177,7 @@
         "1": {
           "cost_per_second": 2.22159834707e-8,
           "cpu_core_seconds_per_second": 0.0002,
-          "detail": "build exact Rate accumulator in 30 panes of 10000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 17360000 bytes",
+          "detail": "build exact Rate accumulator in 30 tumbling windows of 10000 ms for 10000 groups: 100000 rows x (1 + depth 1); x 1.0000/s; keeps 17360000 bytes",
           "multiplier": 1,
           "operator": "SummaryTumblingWindowChain",
           "price_source": "analytical",
@@ -1758,9 +1755,9 @@
                     "kind": "unknown_or_signed"
                   }
                 },
+                "reduction": "PerEntity",
                 "tumbling_window_count": 30,
-                "tumbling_window_width_ms": 10000,
-                "reduction": "PerEntity"
+                "tumbling_window_width_ms": 10000
               }
             }
           }
@@ -2096,6 +2093,9 @@
       ],
       "scalar_roots": []
     },
-    "display_name": "Q1 CMS+heap + Rate acc ×30 panes · ingestion time: Rate acc for Q1, 30 × 10s panes"
+    "display_name": "Q1 CMS+heap + Rate acc ×30 tumbling windows · ingestion time: Rate acc for Q1, 30 × 10s tumbling windows"
+  },
+  "tumbling_window_retention_ms": {
+    "1": 300000
   }
 }
diff --git a/crates/devtools/tests/stage_pipeline.rs b/crates/devtools/tests/stage_pipeline.rs
index 54669bcff..fd61757ba 100644
--- a/crates/devtools/tests/stage_pipeline.rs
+++ b/crates/devtools/tests/stage_pipeline.rs
@@ -177,7 +177,7 @@ fn example1_document_preserves_workload_and_validates_archived_plans() {
 #[test]
 fn display_cap_is_recorded_and_keeps_the_selection() {
     // Instant quantiles provide several implementations without expanding a
-    // pane-width domain. Exhaustive mode ensures the display cap is exercised.
+    // tumbling-window-width domain. Exhaustive mode ensures the display cap is exercised.
     let document = document_of(&[
         "--promql",
         "quantile(0.5, data)",
@@ -302,7 +302,7 @@ fn example3a_archive_and_viewer_select_consistently() {
 /// selects a plan.
 #[test]
 fn example2_plans_the_sql_workload() {
-    // The default search: its SQL windows get tumbling panes, so an
+    // The default search: its SQL windows get tumbling windows, so an
     // exhaustive run has over 10^4 Stage 2 candidates. The integration test
     // `stage1_logical_asap_optimization_sql_adds_one_univmon_for_all_three`
     // checks the shared UnivMon candidate.
@@ -871,9 +871,9 @@ fn cost_model_flag_chooses_how_candidates_are_compared() {
 /// at AWS Fargate's us-east-1 prices, in US dollars per second: the
 /// whole-window KLL (P2) is still selected, at $2.60278e-8/s (its 2.1
 /// CPU-ms/s at $1.1244e-8 per CPU-ms, and its states held while the query
-/// runs), and the panes
+/// runs), and the tumbling windows
 /// maintained at ingestion time (P3-m1) cost about $6.0238e-6/s, almost all
-/// for their 5.232 GB kept in memory (six panes of 1,000,000 series, each a
+/// for their 5.232 GB kept in memory (six tumbling windows of 1,000,000 series, each a
 /// KLL of 872 bytes: its fixed 744 and an item array grown for its 4
 /// samples). A costlier candidate's reason shows
 /// such small costs in scientific notation.
@@ -898,7 +898,7 @@ fn aws_fargate_preset_prices_example_4_in_dollars() {
 /// without the flag, every summary supported, raw data retained, no
 /// query-time result retained). For Pattern B with KLL only and query-time
 /// results retained: no DDSketch candidate is offered, and Stage 1's
-/// `pruned_candidates` says why; the KLL panes gain B3, built at query time and
+/// `pruned_candidates` says why; the KLL tumbling windows gain B3, built at query time and
 /// kept (`P3-m2`, 436.59 cost/s); the whole-window KLL (`P2`) is still
 /// selected. Without raw data, every query-time scan is invalid and B1
 /// (`P3-m1`) is selected when guarantees are enforced. A deployment with an
@@ -1038,7 +1038,7 @@ fn logical_candidate_labels_name_each_query() {
 /// alone: round 1 proves the selected plan optimal within 1e-5, and the
 /// last round finds nothing below the incumbent. That round's bound (the
 /// incumbent less the solver's pruning tolerance, scaled by the largest
-/// charge, here the query-time top-k panes at about 308 times the
+/// charge, here the query-time top-k tumbling windows at about 308 times the
 /// selected plan) used to replace round 1's, reporting a gap of 3.09e-4.
 #[test]
 fn milp_final_bound_keeps_the_bound_an_earlier_round_proved() {
@@ -1101,7 +1101,7 @@ fn milp_final_bound_keeps_the_bound_an_earlier_round_proved() {
 /// (`max_over_time(m[5m])` every minute over 1M series sampled every
 /// 1.5 s) answered as the last hour at 1-minute steps
 /// (`range_evaluation`) is priced as 61 evaluations per request: the kept
-/// panes (`P2-m2`, 460.04 cost/s) beat rebuilding the window at every step
+/// tumbling windows (`P2-m2`, 460.04 cost/s) beat rebuilding the window at every step
 /// (`P1`, 1,270.52), and the document reports their retention, 1 h + 5 min.
 /// The workload section shows the range. An invalid range is refused.
 #[test]
@@ -1140,16 +1140,16 @@ fn workload_file_with_a_range_evaluation_is_planned() {
     );
     let selection = &document["stage3_plan_selection"];
     let cost = selection["cost"]["cost_per_second"].as_f64().unwrap();
-    // The reference: the window merged from panes kept across evaluations,
+    // The reference: the window merged from tumbling windows kept across evaluations,
     // priced under the same models. Its absolute cost is pinned in
     // integration-tests/tests/range_evaluation.rs.
-    let kept_panes = {
+    let kept_tumbling_windows = {
         use asap_accuracy::propagation::recompose_guarantees;
         use asap_logical_asap_optimization::test_support::{
             compose_logical_candidate, generate_per_computation_candidates,
         };
         use asap_logical_asap_optimization::test_support::{
-            pane_candidates, window_composition_pass2_candidates,
+            tumbling_window_candidates, window_composition_pass2_candidates,
         };
         use asap_types::ir::physical_export::PhysicalASAPOperatorPayload;
         use asap_types::ir::ASAPOp;
@@ -1165,8 +1165,8 @@ fn workload_file_with_a_range_evaluation_is_planned() {
         .unwrap();
         let exact: Vec<_> = compose_logical_candidate(&inventory, &[0]).unwrap();
         let grids: Vec<_> = entries.iter().map(|e| e.evaluation_grid_ms()).collect();
-        let panes = pane_candidates(&exact, &grids);
-        let paned = window_composition_pass2_candidates(&exact, &panes)
+        let tumbling_windows = tumbling_window_candidates(&exact, &grids);
+        let windowed = window_composition_pass2_candidates(&exact, &tumbling_windows)
             .unwrap()
             .remove(0)
             .roots
@@ -1176,8 +1176,8 @@ fn workload_file_with_a_range_evaluation_is_planned() {
             ..Default::default()
         };
         let kept = asap_physical_asap_optimization::optimize_physical_asap(
-            "kept-panes",
-            &recompose_guarantees(&paned).unwrap(),
+            "kept-tumbling-windows",
+            &recompose_guarantees(&windowed).unwrap(),
             &entries,
             &data,
             deployment.query_time_results_retained,
@@ -1193,7 +1193,7 @@ fn workload_file_with_a_range_evaluation_is_planned() {
                     == Materialization::MatAtQueryKeptAcrossEvaluations(Medium::Memory)
             })
         })
-        .expect("a plan keeps its panes across evaluations");
+        .expect("a plan keeps its tumbling windows across evaluations");
         let settings = asap_cost::CostInputs::default();
         let priced = asap_devtools::memo_pricing::reference_select(
             std::slice::from_ref(&kept),
@@ -1207,8 +1207,8 @@ fn workload_file_with_a_range_evaluation_is_planned() {
         priced.costs[&priced.selected].cost_per_second.unwrap()
     };
     assert!(
-        cost <= kept_panes * (1.0 + 1e-9),
-        "selected {SELECTED} costs {cost}, more than the kept panes' {kept_panes}"
+        cost <= kept_tumbling_windows * (1.0 + 1e-9),
+        "selected {SELECTED} costs {cost}, more than the kept tumbling windows' {kept_tumbling_windows}"
     );
     assert!(selection["tumbling_window_retention_ms"]
         .as_object()
diff --git a/crates/executor/README.md b/crates/executor/README.md
index 717d33070..de199a07f 100644
--- a/crates/executor/README.md
+++ b/crates/executor/README.md
@@ -131,6 +131,6 @@ maintenance-policy admission remain deployment/planning contracts; this
 compiler does not discover storage or silently change a selected maintenance
 strategy.
 
-Pane construction and geometry belong to deployment. A deployment refreshes
-each pane view once per pane and returns the pane states from its store; the
+Tumbling window construction and geometry belong to deployment. A deployment refreshes
+each tumbling window view once per tumbling window and returns the tumbling-window states from its store; the
 query DAG merges and reads them out as computation.
diff --git a/crates/executor/src/evaluation.rs b/crates/executor/src/evaluation.rs
index 39b86538c..d294ec061 100644
--- a/crates/executor/src/evaluation.rs
+++ b/crates/executor/src/evaluation.rs
@@ -37,7 +37,7 @@ pub fn insufficient_counter_raw_data_samples(
             .is_some_and(|state| state.insufficient_counter_raw_data_samples(statistic, None))
 }
 
-/// Merge already selected exact panes and read one population. `None` means
+/// Merge already selected exact tumbling windows and read one population. `None` means
 /// the population is absent from the result: a counter with too few samples,
 /// or an empty MIN/MAX.
 pub fn exact_evaluation(
diff --git a/crates/executor/src/physical_planner/mod.rs b/crates/executor/src/physical_planner/mod.rs
index a7eac13a0..56f194fd1 100644
--- a/crates/executor/src/physical_planner/mod.rs
+++ b/crates/executor/src/physical_planner/mod.rs
@@ -110,7 +110,7 @@ fn compile_internal(
     deadline: Option<std::time::Instant>,
 ) -> Result<CompiledPhysicalDAG, Error> {
     preflight_depth(dag, deadline)?;
-    // A pane chain stands for its panes; the deployment binds each pane's
+    // A tumbling-window chain stands for its tumbling windows; the deployment binds each tumbling window's
     // raw input, so it runs only once expanded.
     if let Some(node) = dag.nodes.iter().find(|n| {
         matches!(
@@ -119,8 +119,8 @@ fn compile_internal(
         )
     }) {
         return Err(invalid(format!(
-            "node {}: a SummaryTumblingWindowChain runs as its panes; expand it with \
-             `asap_types::ir::operator::pane_chain::expand_pane_chains` before compiling",
+            "node {}: a SummaryTumblingWindowChain runs as its tumbling windows; expand it with \
+             `asap_types::ir::operator::tumbling_window_chain::expand_tumbling_window_chains` before compiling",
             node.id
         )));
     }
@@ -189,7 +189,7 @@ fn compile_internal(
         }
     }
     // Each view's and each `Scan`'s window, the DAG indexed once for all:
-    // a materialized pane chain has a view per pane.
+    // a materialized tumbling-window chain has a view per tumbling window.
     let view_windows = dag.view_windows(views.iter().map(|view| view.node_id));
     let scan_windows = dag.scan_windows(
         dag.nodes
@@ -496,7 +496,7 @@ fn compile_internal(
                         "per-entity summary requires a resolved raw time range",
                     ));
                 };
-                // A tumbling pane reads its window through `TimeShift`s; the
+                // A tumbling window reads its window through `TimeShift`s; the
                 // deployment supplies the shifted raw rows.
                 let source = below_time_shifts(child, |node| node.non_asap(), Ok)?;
                 let Some(NonASAPOp::Scan { schema, .. }) = source.non_asap() else {
@@ -627,7 +627,7 @@ fn compile_internal(
                     .ok_or_else(|| invalid(format!("node {id}: summary merge requires inputs")))?;
                 require_sound_merge(input).map_err(|e| invalid(format!("node {id}: {e}")))?;
                 if output.time_index.is_some() {
-                    // Pane timestamps describe their own builds. The merged
+                    // Tumbling window timestamps describe their own builds. The merged
                     // state covers this evaluation's window, so merge by
                     // series identity and attach the run scope's timestamp,
                     // as a per-series `SummaryAgg` does.
@@ -657,7 +657,7 @@ fn compile_internal(
                     continue;
                 }
             }
-            // A window over a table or a time series (and a tumbling pane's
+            // A window over a table or a time series (and a tumbling window's
             // shift under it) runs natively on the time column.
             if let Some(operator) = time_window_operator(id, &nodes, &dependencies, &schemas)
                 .map_err(|error| invalid(format!("node {id}: {error}")))?
@@ -714,7 +714,7 @@ fn built_from_relation(state: &OperatorNode) -> bool {
 /// each series' (each label set's) latest row. A `TimeShift` only moves
 /// the window its `TimeRange` reads (the range above applies its offset),
 /// so it passes the rows through; a shift is meaningful only under a
-/// range, the shape the frontends and Pass 2's tumbling panes build. An
+/// range, the shape the frontends and Pass 2's tumbling windows build. An
 /// `@` anchor has no lowering, so a range or shift over one gets `None` and
 /// the node fails compilation; an instant window over a table is refused.
 fn time_window_operator(
@@ -830,7 +830,7 @@ pub(crate) fn below_time_shifts<'a, N, C: 'a>(
 /// lookback)`: it ends `offset` ms before the evaluation time and spans
 /// `lookback` ms. It is the union of the range windows the evaluation
 /// reads, each moved back by the time shifts below its range: one range for
-/// a single build, back-to-back panes for merged tumbling panes. `None`
+/// a single build, back-to-back tumbling windows for merged tumbling windows. `None`
 /// without a range; an error when the ranges do not form one window.
 fn counter_window(
     id: NodeId,
@@ -1645,7 +1645,7 @@ mod compilation_deadline_tests {
 
     /// `window_count` one-minute windows over one table `Scan`, the `i`-th
     /// shifted `i` minutes back, each window a root (the shape of a
-    /// pane-expanded DAG), with the roots' node ids.
+    /// tumbling-window-expanded DAG), with the roots' node ids.
     fn shifted_windows_over_one_scan(window_count: i64) -> (PhysicalASAPDAG, Vec<NodeId>) {
         use planner_types::ir::operator::{Source, TimeShift};
         use planner_types::ir::physical_export::compile_physical_asap_workload;
@@ -1795,7 +1795,7 @@ pub mod test_support {
     /// not a view is marked `MatAtIngestion`, and it and every node below it
     /// run at ingestion time (their outputs and outgoing edges); then every
     /// view's `retention_ms` is set ([`PhysicalASAPDAG::set_retention`])
-    /// with no pane or range-evaluation span. For tests that bind states at
+    /// with no tumbling window or range-evaluation span. For tests that bind states at
     /// those nodes, as a deployment binds its views.
     pub fn views_at(
         dag: &mut PhysicalASAPDAG,
diff --git a/crates/executor/src/summary_kernels/exact.rs b/crates/executor/src/summary_kernels/exact.rs
index 8235fb066..ebfe857aa 100644
--- a/crates/executor/src/summary_kernels/exact.rs
+++ b/crates/executor/src/summary_kernels/exact.rs
@@ -106,7 +106,7 @@ impl ExactAccumulator {
 
     /// The earliest sample time of a counter (Rate/Increase) state, over
     /// all its populations; `None` for an empty or non-counter state.
-    /// Counter states merge pairwise in time order, so a merge of panes
+    /// Counter states merge pairwise in time order, so a merge of tumbling windows
     /// orders them by this first.
     pub fn earliest_sample_ms(&self) -> Option<i64> {
         std::iter::once(&self.scalar)
@@ -456,7 +456,7 @@ mod tests {
         SummaryFamilyType::ExactAggregate(ExactKind::Sum, ExactParams::Sum)
     }
 
-    // Stored Sum preserves low-order increments across updates, persistence and pane merge.
+    // Stored Sum preserves low-order increments across updates, persistence and tumbling-window merge.
     #[test]
     fn stored_sum_is_compensated() {
         let mut state = ExactAccumulator::new(sum(), false).unwrap();
diff --git a/crates/executor/src/summary_kernels/factory.rs b/crates/executor/src/summary_kernels/factory.rs
index b650f9bd4..e3345397f 100644
--- a/crates/executor/src/summary_kernels/factory.rs
+++ b/crates/executor/src/summary_kernels/factory.rs
@@ -26,7 +26,7 @@ macro_rules! impl_clone_accumulator_methods {
 
         fn into_accumulator(self: Box<Self>) -> Box<dyn AggregateCore> {
             // Consume the updater and MOVE the accumulator out — no clone.
-            // Avoids a clone when a pane is evicted at window close.
+            // Avoids a clone when a tumbling window is evicted at window close.
             let this = *self;
             Box::new(this.$acc_field)
         }
@@ -130,7 +130,7 @@ pub trait AccumulatorUpdater: Send {
     fn take_accumulator(&mut self) -> Box<dyn AggregateCore>;
 
     /// Non-destructive read of the current accumulator state (clone without reset).
-    /// Used by pane-based sliding windows to read shared panes.
+    /// Used by tumbling-window-based sliding windows to read shared tumbling windows.
     fn snapshot_accumulator(&self) -> Box<dyn AggregateCore>;
 
     /// Consume the updater and return its accumulator by move, avoiding the
diff --git a/crates/executor/src/summary_kernels/increase.rs b/crates/executor/src/summary_kernels/increase.rs
index 12c7df9d8..fcb9e5b6b 100644
--- a/crates/executor/src/summary_kernels/increase.rs
+++ b/crates/executor/src/summary_kernels/increase.rs
@@ -19,7 +19,7 @@ pub struct IncreaseAccumulator {
 
 impl IncreaseAccumulator {
     /// Merge two counter intervals without a temporary collection. Ties retain
-    /// the left input, matching the stable ordering of multi-pane merges.
+    /// the left input, matching the stable ordering of multi-tumbling-window merges.
     pub(crate) fn merge_pair(left: &Self, right: &Self) -> Self {
         let (first, second) = if left.starting_timestamp <= right.starting_timestamp {
             (left, right)
diff --git a/crates/executor/src/summary_kernels/state_column_updater.rs b/crates/executor/src/summary_kernels/state_column_updater.rs
index e4bce12fc..e059ab25c 100644
--- a/crates/executor/src/summary_kernels/state_column_updater.rs
+++ b/crates/executor/src/summary_kernels/state_column_updater.rs
@@ -350,7 +350,7 @@ impl StateColumnUpdater {
     }
 
     /// Merge `other`, an updater of the same family whose groups have the
-    /// same numbers (another shard of one pane), into this one, group by
+    /// same numbers (another shard of one tumbling window), into this one, group by
     /// group; a group only `other` has is added.
     ///
     /// For a counter (rate, increase), each group's samples in the two
diff --git a/crates/executor/src/values/batch.rs b/crates/executor/src/values/batch.rs
index 66439ff6b..2bc7e0284 100644
--- a/crates/executor/src/values/batch.rs
+++ b/crates/executor/src/values/batch.rs
@@ -150,15 +150,15 @@ impl Batch {
 
     /// The batch of `columns` in `schema`, one per field, without running
     /// the DAG: how a runtime installs states it built sample by sample
-    /// (a sealed [`crate::StateColumnUpdater`]) as a stored pane. Bad input
+    /// (a sealed [`crate::StateColumnUpdater`]) as a stored tumbling window. Bad input
     /// when a column's count, layout, length or nullability differs from
     /// the schema, a dictionary holds a NULL value (a NULL is a NULL key),
     /// a summary field's states are of another family, or a state index is
     /// NULL or past its states.
     ///
-    /// A stored pane has one row per group: the caller must not repeat a
+    /// A stored tumbling window has one row per group: the caller must not repeat a
     /// group's labels (two rows of one series would be merged as two
-    /// panes of it). This is not checked, as it would cost a pass grouping
+    /// tumbling windows of it). This is not checked, as it would cost a pass grouping
     /// every row.
     pub fn try_from_columns(schema: SchemaRef, columns: Vec<BatchColumn>) -> Result<Self, Error> {
         validate_schema(&schema)?;
@@ -575,7 +575,7 @@ impl Batch {
     }
 
     /// Records that something outside any run (the caller of a plan, a
-    /// store of panes) holds this batch's states, so runs that read them
+    /// store of tumbling windows) holds this batch's states, so runs that read them
     /// are not charged for them again. States a run copies or creates from
     /// them are new state columns and are charged.
     pub(crate) fn mark_states_held_outside_run(&self) {
@@ -839,7 +839,7 @@ mod tests {
         );
     }
 
-    // A runtime can share batches, stored panes included, across threads.
+    // A runtime can share batches, stored tumbling windows included, across threads.
     #[test]
     fn batches_and_state_columns_are_send_and_sync() {
         fn shareable<T: Send + Sync>() {}
@@ -999,7 +999,7 @@ mod tests {
         assert!(nulls.is_valid(0) && nulls.is_null(1));
     }
 
-    // A filter that keeps few rows keeps only their states: a pane filtered
+    // A filter that keeps few rows keeps only their states: a tumbling window filtered
     // to two of ten series holds two states, not ten.
     #[test]
     fn a_selective_filter_compacts_its_state_column() {
diff --git a/crates/executor/src/values/state_column.rs b/crates/executor/src/values/state_column.rs
index 24a4a1a37..d2b8c3ddd 100644
--- a/crates/executor/src/values/state_column.rs
+++ b/crates/executor/src/values/state_column.rs
@@ -18,7 +18,7 @@ pub struct StateColumn {
     /// Memory the states hold: each state's own footprint, plus each state
     /// shared by several states (one Hydra grid) once.
     state_memory_bytes: usize,
-    /// Whether something outside the run holds these states (a stored pane
+    /// Whether something outside the run holds these states (a stored tumbling window
     /// handed to a plan as a source): immutable and shared, so a run that
     /// reads them is not charged for them. Set once, never cleared.
     held_outside_run: AtomicBool,
diff --git a/crates/executor/tests/deployment.rs b/crates/executor/tests/deployment.rs
index c9e2da35f..70804d9f4 100644
--- a/crates/executor/tests/deployment.rs
+++ b/crates/executor/tests/deployment.rs
@@ -364,8 +364,8 @@ fn deep_plain_count_sketch_estimates_meet_the_certified_bound() {
     }
 }
 
-// Panes merge cell by cell: every pane seeds row `r` the same way, so merging
-// two panes equals building the union in one pane.
+// Tumbling-window merge cell by cell: every tumbling window seeds row `r` the same way, so merging
+// two tumbling windows equals building the union in one tumbling window.
 #[test]
 fn plain_count_sketch_merge_equals_union_build() {
     let family = plain_count_sketch(1_001, 7);
diff --git a/crates/executor/tests/exact_state_columns.rs b/crates/executor/tests/exact_state_columns.rs
index e676545d6..27cf337b7 100644
--- a/crates/executor/tests/exact_state_columns.rs
+++ b/crates/executor/tests/exact_state_columns.rs
@@ -35,7 +35,7 @@ fn input() -> SchemaRef {
 }
 
 /// Samples of 3 series in `(start, start + 1000]`, counters with a reset.
-fn pane_input(start: i64) -> Batch {
+fn tumbling_window_input(start: i64) -> Batch {
     let rows = (1..=40)
         .map(|i| {
             let series = i % 3;
@@ -81,8 +81,8 @@ fn run(operator: Operator, inputs: Vec<Batch>) -> Vec<Batch> {
     })
 }
 
-// For each exact family: two panes built as numeric records, merged and
-// evaluated, equal the same panes read back as kernel objects (all objects,
+// For each exact family: two tumbling windows built as numeric records, merged and
+// evaluated, equal the same tumbling windows read back as kernel objects (all objects,
 // or one of each), row for row.
 #[test]
 fn exact_records_merge_and_evaluate_as_kernel_objects_do() {
@@ -98,10 +98,16 @@ fn exact_records_merge_and_evaluate_as_kernel_objects_do() {
         let build = || {
             Operator::per_group_summary_build(input(), family.clone(), 2, Some(1), vec![0]).unwrap()
         };
-        let panes = [0, 1_000].map(|start| run(build(), vec![pane_input(start)]).remove(0));
-        let as_objects =
-            |pane: &Batch| Batch::try_new(pane.schema().clone(), pane.to_rows().to_vec()).unwrap();
-        let state_schema = panes[0].schema().clone();
+        let tumbling_windows =
+            [0, 1_000].map(|start| run(build(), vec![tumbling_window_input(start)]).remove(0));
+        let as_objects = |tumbling_window: &Batch| {
+            Batch::try_new(
+                tumbling_window.schema().clone(),
+                tumbling_window.to_rows().to_vec(),
+            )
+            .unwrap()
+        };
+        let state_schema = tumbling_windows[0].schema().clone();
         let answer = |inputs: Vec<Batch>| {
             let merged = run(
                 Operator::summary_merge(state_schema.clone(), 1, vec![0]).unwrap(),
@@ -121,10 +127,19 @@ fn exact_records_merge_and_evaluate_as_kernel_objects_do() {
             assert_eq!(rows.len(), 3, "{kind:?}: one row per series");
             format!("{rows:?}")
         };
-        // Newest pane first: counters must merge in time order regardless.
-        let records = answer(vec![panes[1].clone(), panes[0].clone()]);
-        let objects = answer(vec![as_objects(&panes[1]), as_objects(&panes[0])]);
-        let mixed = answer(vec![panes[1].clone(), as_objects(&panes[0])]);
+        // Newest tumbling window first: counters must merge in time order regardless.
+        let records = answer(vec![
+            tumbling_windows[1].clone(),
+            tumbling_windows[0].clone(),
+        ]);
+        let objects = answer(vec![
+            as_objects(&tumbling_windows[1]),
+            as_objects(&tumbling_windows[0]),
+        ]);
+        let mixed = answer(vec![
+            tumbling_windows[1].clone(),
+            as_objects(&tumbling_windows[0]),
+        ]);
         assert_eq!(records, objects, "{kind:?}");
         assert_eq!(records, mixed, "{kind:?}");
     }
diff --git a/crates/executor/tests/main.rs b/crates/executor/tests/main.rs
index 96a45776c..89abe7da8 100644
--- a/crates/executor/tests/main.rs
+++ b/crates/executor/tests/main.rs
@@ -23,7 +23,7 @@ mod promql_binary;
 mod promql_values;
 mod raw_scan;
 mod state_column_updater;
-mod stored_pane_memory_limit;
+mod stored_tumbling_window_memory_limit;
 mod summary_projection;
 mod text_extremum_memory;
 mod thread_safety;
diff --git a/crates/executor/tests/physical_semantics.rs b/crates/executor/tests/physical_semantics.rs
index 8319bd29c..2831befe1 100644
--- a/crates/executor/tests/physical_semantics.rs
+++ b/crates/executor/tests/physical_semantics.rs
@@ -646,18 +646,18 @@ fn kll_partial_merge_and_multiple_evaluations_preserve_population() {
     }
 }
 
-// KLL panes that each compact merge into a state within the calibrated
-// single-build rank error: 60 panes of 1000 values at k = 200.
+// KLL tumbling windows that each compact merge into a state within the calibrated
+// single-build rank error: 60 tumbling windows of 1000 values at k = 200.
 #[test]
-fn compacted_kll_panes_merge_within_the_calibrated_rank_error() {
+fn compacted_kll_tumbling_windows_merge_within_the_calibrated_rank_error() {
     use planner_types::ir::schema::{SketchAlgorithm, SketchKind, SketchParams, SketchStatistic};
-    const PANES: u64 = 60;
-    const PER_PANE: u64 = 1000;
+    const TUMBLING_WINDOW_COUNT: u64 = 60;
+    const ROWS_PER_TUMBLING_WINDOW: u64 = 1000;
     const K: u32 = 200;
     // The planner's empirical 99% KLL rank error, `2.296 / k^0.9723`
     // (`asap_logical_asap_optimization`'s `kll_rank_error_99`).
     let bound = 2.296 / f64::from(K).powf(0.9723);
-    let n = (PANES * PER_PANE) as f64;
+    let n = (TUMBLING_WINDOW_COUNT * ROWS_PER_TUMBLING_WINDOW) as f64;
     let input = schema(&[("v", DataType::Float64, false)]);
     let family = FieldDataType::Sketch(
         SketchKind::new(
@@ -674,14 +674,18 @@ fn compacted_kll_panes_merge_within_the_calibrated_rank_error() {
     };
     let state = build().schema();
     let mut dag = PhysicalDAG::default();
-    for pane in 0..PANES {
-        // Pane `p` holds `[p, p + 1) * 1000`, as tumbling panes of a
-        // rising value would, so a lost pane shifts every rank.
-        let rows = (0..PER_PANE)
-            .map(|j| vec![Value::Float64((pane * PER_PANE + j) as f64)])
+    for tumbling_window in 0..TUMBLING_WINDOW_COUNT {
+        // Tumbling window `p` holds `[p, p + 1) * 1000`, as tumbling windows of a
+        // rising value would, so a lost tumbling window shifts every rank.
+        let rows = (0..ROWS_PER_TUMBLING_WINDOW)
+            .map(|j| {
+                vec![Value::Float64(
+                    (tumbling_window * ROWS_PER_TUMBLING_WINDOW + j) as f64,
+                )]
+            })
             .collect();
         dag.add(
-            pane,
+            tumbling_window,
             vec![],
             Operator::source(
                 input.clone(),
@@ -690,13 +694,18 @@ fn compacted_kll_panes_merge_within_the_calibrated_rank_error() {
             .unwrap(),
         )
         .unwrap();
-        dag.add(PANES + pane, vec![pane], build()).unwrap();
+        dag.add(
+            TUMBLING_WINDOW_COUNT + tumbling_window,
+            vec![tumbling_window],
+            build(),
+        )
+        .unwrap();
     }
-    let union = 2 * PANES;
+    let union = 2 * TUMBLING_WINDOW_COUNT;
     dag.add(
         union,
-        (PANES..2 * PANES).collect(),
-        Operator::union(state.clone(), PANES as usize).unwrap(),
+        (TUMBLING_WINDOW_COUNT..2 * TUMBLING_WINDOW_COUNT).collect(),
+        Operator::union(state.clone(), TUMBLING_WINDOW_COUNT as usize).unwrap(),
     )
     .unwrap();
     dag.add(
@@ -732,11 +741,11 @@ fn compacted_kll_panes_merge_within_the_calibrated_rank_error() {
     }
 }
 
-// Counter panes merged in any input order (here A, C, B) give the increase
-// of one build over the whole window, including the jumps between panes
+// Counter tumbling windows merged in any input order (here A, C, B) give the increase
+// of one build over the whole window, including the jumps between tumbling windows
 // and a counter reset inside B.
 #[test]
-fn counter_panes_merge_in_any_order() {
+fn counter_tumbling_windows_merge_in_any_order() {
     use asap_executor::summary_kernels::exact::ExactAccumulator;
     use planner_types::ir::schema::{ExactKind, ExactParams};
     let input = schema(&[
@@ -772,7 +781,7 @@ fn counter_panes_merge_in_any_order() {
             .unwrap()
     };
     let mut dag = PhysicalDAG::default();
-    // Panes A = [0, 4), B = [4, 8), C = [8, 12), added as A, C, B.
+    // Tumbling windows A = [0, 4), B = [4, 8), C = [8, 12), added as A, C, B.
     for (id, range) in [(0, 0..4), (1, 8..12), (2, 4..8), (3, 0..12)] {
         let batch = Batch::try_new(input.clone(), samples(range)).unwrap();
         dag.add(
diff --git a/crates/executor/tests/precompute_population.rs b/crates/executor/tests/precompute_population.rs
index 265b1d55f..81e9b58cb 100644
--- a/crates/executor/tests/precompute_population.rs
+++ b/crates/executor/tests/precompute_population.rs
@@ -244,7 +244,7 @@ fn sum_state(value: f64) -> Arc<dyn asap_executor::AggregateCore> {
     Arc::new(state)
 }
 
-// Only an explicit merge may collapse distinct pane updates before finalization.
+// Only an explicit merge may collapse distinct tumbling window updates before finalization.
 #[test]
 fn precompute_merge_requires_a_family_with_a_sound_merge() {
     // IRate reads the window's last two samples, so the family-capability
@@ -258,7 +258,7 @@ fn precompute_merge_requires_a_family_with_a_sound_merge() {
 }
 
 #[test]
-fn explicit_merge_changes_pane_cardinality() {
+fn explicit_merge_changes_tumbling_window_cardinality() {
     let family = FieldDataType::ExactAggregate(ExactKind::Sum, ExactParams::Sum);
     for (merge, expected) in [(false, vec![2., 7.]), (true, vec![9.])] {
         let program = state_dag(family.clone(), None, merge);
diff --git a/crates/executor/tests/promql_values.rs b/crates/executor/tests/promql_values.rs
index 50160251f..0585c4198 100644
--- a/crates/executor/tests/promql_values.rs
+++ b/crates/executor/tests/promql_values.rs
@@ -195,7 +195,7 @@ fn exact_state_schema(family: planner_types::ir::schema::FieldDataType) -> Schem
     Arc::new(schema)
 }
 
-/// Merge stored exact panes per series and finalize them; a counter (`Rate`,
+/// Merge stored exact tumbling windows per series and finalize them; a counter (`Rate`,
 /// `Increase`) over the `lookback_ms` window ending at the evaluation time.
 fn compile_exact_evaluation(
     family: planner_types::ir::schema::FieldDataType,
@@ -519,10 +519,10 @@ fn scalar_broadcast_rejects_colliding_result_labels_after_recovery() {
     );
 }
 
-// Persisted exact evaluation graphs, rather than the storage adapter, merge panes,
+// Persisted exact evaluation graphs, rather than the storage adapter, merge tumbling windows,
 // finalize each population, and preserve the requested metric-name semantics.
 #[test]
-fn exact_state_evaluations_recover_and_finalize_panes() {
+fn exact_state_evaluations_recover_and_finalize_tumbling_windows() {
     use asap_executor::factory::create_planner_accumulator;
     use planner_types::ir::schema::*;
 
diff --git a/crates/executor/tests/raw_scan.rs b/crates/executor/tests/raw_scan.rs
index 952c477e2..5cdafc837 100644
--- a/crates/executor/tests/raw_scan.rs
+++ b/crates/executor/tests/raw_scan.rs
@@ -915,7 +915,7 @@ impl DataStore for RecordingViewStore {
     }
 }
 
-// A materialized view slot (the count over the range, as an expanded pane
+// A materialized view slot (the count over the range, as an expanded tumbling window
 // over its range) is asked for its window, `(T - 5m, T]` or
 // `(T - 15m, T - 10m]` under a 10-minute shift, and its state is the
 // answer's.
diff --git a/crates/executor/tests/stored_pane_memory_limit.rs b/crates/executor/tests/stored_tumbling_window_memory_limit.rs
similarity index 80%
rename from crates/executor/tests/stored_pane_memory_limit.rs
rename to crates/executor/tests/stored_tumbling_window_memory_limit.rs
index 81df883b5..350e66212 100644
--- a/crates/executor/tests/stored_pane_memory_limit.rs
+++ b/crates/executor/tests/stored_tumbling_window_memory_limit.rs
@@ -1,4 +1,4 @@
-//! Stored panes are immutable states the store holds and shares: a query
+//! Stored tumbling windows are immutable states the store holds and shares: a query
 //! that reads them is not charged for those states again, only for what it
 //! allocates. A merge over them still charges the states it creates.
 use asap_executor::arrow::array::{DictionaryArray, UInt32Array};
@@ -15,18 +15,18 @@ use futures::{executor::block_on, StreamExt};
 use std::sync::Arc;
 
 const SERIES: u32 = 1_000;
-const PANES: usize = 12;
+const TUMBLING_WINDOW_COUNT: usize = 12;
 /// Samples per state: past 1,024 a k = 200 KLL holds its whole item buffer.
 const SAMPLES: u32 = 1_100;
 
-/// One pane of `SERIES` KLL states (k = 200, about 11 kB charged each, so
-/// about 11 MB per pane), keyed by series.
-fn pane() -> (Arc<Schema>, Batch) {
-    pane_of(SERIES)
+/// One tumbling window of `SERIES` KLL states (k = 200, about 11 kB charged each, so
+/// about 11 MB per tumbling window), keyed by series.
+fn tumbling_window() -> (Arc<Schema>, Batch) {
+    tumbling_window_of(SERIES)
 }
 
-/// One pane of `series` KLL states (k = 200), keyed by series.
-fn pane_of(series_count: u32) -> (Arc<Schema>, Batch) {
+/// One tumbling window of `series` KLL states (k = 200), keyed by series.
+fn tumbling_window_of(series_count: u32) -> (Arc<Schema>, Batch) {
     let family = FieldDataType::Sketch(
         SketchKind::new(
             SketchAlgorithm::Kll,
@@ -83,14 +83,14 @@ fn pane_of(series_count: u32) -> (Arc<Schema>, Batch) {
     (schema, batch)
 }
 
-/// Merges `PANES` copies of one stored pane per series under `max_bytes`.
-fn merge_stored_panes(max_bytes: usize) -> Result<usize, Error> {
-    let (schema, pane) = pane();
+/// Merges `TUMBLING_WINDOW_COUNT` copies of one stored tumbling window per series under `max_bytes`.
+fn merge_stored_tumbling_windows(max_bytes: usize) -> Result<usize, Error> {
+    let (schema, tumbling_window) = tumbling_window();
     let mut dag = PhysicalDAG::default();
     dag.add(
         0,
         vec![],
-        Operator::source(schema.clone(), vec![pane; PANES]).unwrap(),
+        Operator::source(schema.clone(), vec![tumbling_window; TUMBLING_WINDOW_COUNT]).unwrap(),
     )
     .unwrap();
     dag.add(
@@ -119,36 +119,39 @@ fn merge_stored_panes(max_bytes: usize) -> Result<usize, Error> {
     })
 }
 
-// Twelve stored panes hold about 130 MB of states, which charging them per
+// Twelve stored tumbling windows hold about 130 MB of states, which charging them per
 // read would put far past a 32 MiB limit. The merge allocates one state per
 // series (about 11 MB), so it fits.
 #[test]
-fn reading_stored_panes_does_not_charge_their_states() {
-    assert_eq!(merge_stored_panes(32 << 20).unwrap(), SERIES as usize);
+fn reading_stored_tumbling_windows_does_not_charge_their_states() {
+    assert_eq!(
+        merge_stored_tumbling_windows(32 << 20).unwrap(),
+        SERIES as usize
+    );
 }
 
 // The merged states themselves (about 11 MB) do not fit in 4 MiB.
 #[test]
 fn a_merge_that_allocates_past_the_limit_still_fails() {
     assert!(matches!(
-        merge_stored_panes(4 << 20),
+        merge_stored_tumbling_windows(4 << 20),
         Err(Error::MemoryLimit)
     ));
 }
 
-// A Limit keeping 49% of a stored pane of 2,000 KLLs (about 21 MB of
+// A Limit keeping 49% of a stored tumbling window of 2,000 KLLs (about 21 MB of
 // states) compacts its state column, and the compacted column shares the
 // stored sketches by pointer: under an 8 MiB limit it is charged for the
 // pointers, not the sketches. Keeping 51% (no compaction) fits too.
 #[test]
-fn compacting_a_stored_pane_does_not_charge_its_shared_sketches() {
+fn compacting_a_stored_tumbling_window_does_not_charge_its_shared_sketches() {
     for kept in [980, 1_020] {
-        let (schema, pane) = pane_of(2_000);
+        let (schema, tumbling_window) = tumbling_window_of(2_000);
         let mut dag = PhysicalDAG::default();
         dag.add(
             0,
             vec![],
-            Operator::source(schema.clone(), vec![pane]).unwrap(),
+            Operator::source(schema.clone(), vec![tumbling_window]).unwrap(),
         )
         .unwrap();
         dag.add(
@@ -179,14 +182,14 @@ fn compacting_a_stored_pane_does_not_charge_its_shared_sketches() {
     }
 }
 
-// topk over several panes: a Sort concatenates two stored panes of 1,000
+// topk over several tumbling windows: a Sort concatenates two stored tumbling windows of 1,000
 // KLLs (about 21 MB of states), then a Limit keeps 49% and compacts the
 // concatenated column. Both derivations share the stored sketches by
 // pointer, so the run fits in 8 MiB.
 #[test]
-fn sorting_then_limiting_stored_panes_does_not_charge_their_sketches() {
-    let (schema, first) = pane_of(SERIES);
-    let (_, second) = pane_of(SERIES);
+fn sorting_then_limiting_stored_tumbling_windows_does_not_charge_their_sketches() {
+    let (schema, first) = tumbling_window_of(SERIES);
+    let (_, second) = tumbling_window_of(SERIES);
     let mut dag = PhysicalDAG::default();
     dag.add(
         0,
@@ -228,17 +231,17 @@ fn sorting_then_limiting_stored_panes_does_not_charge_their_sketches() {
     assert_eq!(rows.unwrap(), 980);
 }
 
-// A merge over one stored pane of 2,000 KLLs (about 21 MB of states), one
+// A merge over one stored tumbling window of 2,000 KLLs (about 21 MB of states), one
 // state per series: every state passes through unchanged, shared by
 // pointer, so the merge fits in 8 MiB.
 #[test]
 fn a_merge_passing_stored_states_through_does_not_charge_them() {
-    let (schema, pane) = pane_of(2_000);
+    let (schema, tumbling_window) = tumbling_window_of(2_000);
     let mut dag = PhysicalDAG::default();
     dag.add(
         0,
         vec![],
-        Operator::source(schema.clone(), vec![pane]).unwrap(),
+        Operator::source(schema.clone(), vec![tumbling_window]).unwrap(),
     )
     .unwrap();
     dag.add(
@@ -268,12 +271,12 @@ fn a_merge_passing_stored_states_through_does_not_charge_them() {
     assert_eq!(rows.unwrap(), 2_000);
 }
 
-/// A deployment's own data store (not `InMemoryDataStore`): returns `PANES`
-/// copies of one stored pane for every materialized view read.
-struct StoredPanes {
-    pane: Batch,
+/// A deployment's own data store (not `InMemoryDataStore`): returns `TUMBLING_WINDOW_COUNT`
+/// copies of one stored tumbling window for every materialized view read.
+struct StoredTumblingWindows {
+    tumbling_window: Batch,
 }
-impl asap_executor::sources::DataStore for StoredPanes {
+impl asap_executor::sources::DataStore for StoredTumblingWindows {
     fn read_raw_data(
         &self,
         source: &asap_executor::planner::ir::operator::Source,
@@ -288,14 +291,18 @@ impl asap_executor::sources::DataStore for StoredPanes {
         _: &asap_executor::sources::MaterializedViewRequest,
         _: RunContext,
     ) -> Result<asap_executor::runtime::OutputStream<'_, Batch>, Error> {
-        Ok(futures::stream::iter(vec![Ok(self.pane.clone()); PANES]).boxed_local())
+        Ok(futures::stream::iter(vec![
+            Ok(self.tumbling_window.clone());
+            TUMBLING_WINDOW_COUNT
+        ])
+        .boxed_local())
     }
 }
 
-/// `SummaryMerge` (node 1) over the materialized view of a pane (node 0):
-/// the pane's KLLs per series, built over a minute of raw samples of
+/// `SummaryMerge` (node 1) over the materialized view of a tumbling window (node 0):
+/// the tumbling window's KLLs per series, built over a minute of raw samples of
 /// `latency` (`Scan` node 2, `TimeRange` node 3).
-fn merge_over_a_stored_pane(
+fn merge_over_a_stored_tumbling_window(
     schema: &Schema,
 ) -> asap_executor::planner::ir::physical_export::PhysicalASAPDAG {
     use asap_executor::planner::ir::operator::{GroupKeys, Reduction, Source};
@@ -395,18 +402,18 @@ fn merge_over_a_stored_pane(
 }
 
 // A materialized view slot's states are the store's whatever store returns them: the
-// merge over twelve stored panes from a deployment's own store fits the
+// merge over twelve stored tumbling windows from a deployment's own store fits the
 // 32 MiB limit, as it does over `Operator::source`.
 #[test]
 fn a_materialized_view_providers_states_are_not_charged_to_the_run() {
     use asap_executor::physical_planner::{compile, test_support::views_at};
-    let (schema, pane) = pane();
-    let mut dag = merge_over_a_stored_pane(&schema);
+    let (schema, tumbling_window) = tumbling_window();
+    let mut dag = merge_over_a_stored_tumbling_window(&schema);
     let views = views_at(&mut dag, &[0]).unwrap();
     let compiled = compile(&dag, &views, &[1]).unwrap();
     assert_eq!(compiled.operator_name(0), Some("MaterializedView"));
     let dag = compiled
-        .instantiate(Arc::new(StoredPanes { pane }))
+        .instantiate(Arc::new(StoredTumblingWindows { tumbling_window }))
         .unwrap();
     let context = RunContext::new(
         Scope::Query {
diff --git a/crates/executor/tests/thread_safety.rs b/crates/executor/tests/thread_safety.rs
index 6bac1277d..1ddf3d4fd 100644
--- a/crates/executor/tests/thread_safety.rs
+++ b/crates/executor/tests/thread_safety.rs
@@ -20,6 +20,6 @@ fn the_compiled_plan_and_its_data_stores_are_send_and_sync() {
     shareable::<InMemoryDataStore>();
     shareable::<Batch>();
     shareable::<StateColumn>();
-    // An open pane's updater moves to the worker that ingests its shard.
+    // An open tumbling window's updater moves to the worker that ingests its shard.
     movable::<StateColumnUpdater>();
 }
diff --git a/crates/executor/tests/time_series_window.rs b/crates/executor/tests/time_series_window.rs
index 4e8adee9d..792a2881b 100644
--- a/crates/executor/tests/time_series_window.rs
+++ b/crates/executor/tests/time_series_window.rs
@@ -251,7 +251,7 @@ fn an_instant_window_whose_latest_sample_is_stale_has_no_row() {
 }
 
 // In an ingestion run a window ends at the run's `window_end_ms`, whatever
-// the shifts below it: the run builds the pane the shifts select.
+// the shifts below it: the run builds the tumbling window the shifts select.
 #[test]
 fn an_ingestion_run_builds_the_window_ending_at_its_end() {
     let dag = window_over(1_000, TimeRangeKind::Range, 5_000);
diff --git a/crates/frontend-sql/src/sql/mod.rs b/crates/frontend-sql/src/sql/mod.rs
index 935e99763..819941f7a 100644
--- a/crates/frontend-sql/src/sql/mod.rs
+++ b/crates/frontend-sql/src/sql/mod.rs
@@ -417,7 +417,7 @@ impl<'a> SqlLowerer<'a> {
         // A trailing window on the table's time column is the query's
         // lookback: a range `TimeRange` over the `Scan`, as PromQL's `m[w]`.
         // Only when no other conjunct reads `now()`: such a condition would
-        // be evaluated per pane and at ingestion time once the window is a
+        // be evaluated per tumbling window and at ingestion time once the window is a
         // `TimeRange`, and would select other rows there.
         let other_reads_now = |window: usize| {
             residual
diff --git a/crates/frontend-sql/tests/sql_lowering.rs b/crates/frontend-sql/tests/sql_lowering.rs
index 38ed8af0a..fcb2b731d 100644
--- a/crates/frontend-sql/tests/sql_lowering.rs
+++ b/crates/frontend-sql/tests/sql_lowering.rs
@@ -3175,7 +3175,7 @@ fn trailing_window(node: &OperatorNode) -> Option<(std::time::Duration, &Operato
 
 // A trailing window on the table's time column is the query's lookback, the
 // same `TimeRange` a PromQL range selector lowers to, so Pass 2 can build it
-// in panes and Stage 2 at ingestion time. Other conjuncts stay on the `Scan`.
+// in tumbling windows and Stage 2 at ingestion time. Other conjuncts stay on the `Scan`.
 #[tokio::test]
 async fn trailing_window_on_the_time_column_lowers_to_a_time_range() {
     for (sql, window_ms) in [
@@ -3218,7 +3218,7 @@ async fn trailing_window_on_the_time_column_lowers_to_a_time_range() {
 // predicates: an upper bound alone, a month-long (variable) interval, a
 // window under `OR`, a window on another column, two windows, and a window on
 // a table without a time index. A window next to another condition on
-// `now()` stays one too: that condition would read other rows in a pane or
+// `now()` stays one too: that condition would read other rows in a tumbling window or
 // at ingestion time.
 #[tokio::test]
 async fn other_time_conditions_stay_scan_predicates() {
diff --git a/crates/integration-tests/src/lib.rs b/crates/integration-tests/src/lib.rs
index e82b7f4b3..cee691bb9 100644
--- a/crates/integration-tests/src/lib.rs
+++ b/crates/integration-tests/src/lib.rs
@@ -340,7 +340,7 @@ pub mod planning {
             })
             .collect()
     }
-    /// Pass 1, local panes for `entries`' recurrences and every Pass 2 rule
+    /// Pass 1, local tumbling windows for `entries`' recurrences and every Pass 2 rule
     /// on the seed grids (no query pruning). Rule tests read a group's
     /// candidates by `OriginOfCandidateForMemoGroup`.
     pub fn expanded_memo(
@@ -351,7 +351,7 @@ pub mod planning {
         use asap_logical_asap_optimization::test_support::{
             add_local_window_composition, try_populate_pass1,
         };
-        use asap_logical_asap_optimization::PaneWidthDomain;
+        use asap_logical_asap_optimization::TumblingWindowWidthDomain;
         let initial = asap_logical_asap_optimization::generate_dag_of_logical_memo_groups(&roots);
         let inventory = generate_per_computation_candidates(
             &asap_logical_asap_optimization::generate_dag_of_logical_memo_groups(&roots),
@@ -361,7 +361,7 @@ pub mod planning {
         add_local_window_composition(&mut memo, entries);
         asap_logical_asap_optimization::test_support::sharing_rules_and_shared_state_groups(
             memo,
-            PaneWidthDomain::SeedGrids,
+            TumblingWindowWidthDomain::SeedGrids,
         )
         .unwrap()
     }
diff --git a/crates/integration-tests/tests/deployment_capabilities.rs b/crates/integration-tests/tests/deployment_capabilities.rs
index 0c8a19dc6..482ca9ac5 100644
--- a/crates/integration-tests/tests/deployment_capabilities.rs
+++ b/crates/integration-tests/tests/deployment_capabilities.rs
@@ -130,13 +130,13 @@ fn pattern_b_with_p50() -> asap_types::workload::PlanningWorkload {
     workload
 }
 
-/// One explicitly shared KLL pane chain, passed through normal physical rules.
-fn shared_pane_configurations(deployment: &DeploymentCapabilities) -> Run {
+/// One explicitly shared KLL tumbling-window chain, passed through normal physical rules.
+fn shared_tumbling_window_configurations(deployment: &DeploymentCapabilities) -> Run {
     use asap_logical_asap_optimization::test_support::{
         compose_logical_candidate, generate_per_computation_candidates,
     };
     use asap_logical_asap_optimization::test_support::{
-        pane_candidates, window_composition_pass2_candidates,
+        tumbling_window_candidates, window_composition_pass2_candidates,
     };
     use asap_types::ir::QueryRoot;
     use asap_types::stages::HowToComputeAggregateMeasure;
@@ -176,9 +176,9 @@ fn shared_pane_configurations(deployment: &DeploymentCapabilities) -> Run {
     .into_iter()
     .map(|(_, node)| QueryRoot::Operator(node))
     .collect::<Vec<_>>();
-    let panes = pane_candidates(&shared, &[Some(60_000), Some(60_000)]);
-    assert_eq!(panes.len(), 1, "both estimators share one build");
-    let pane_roots = window_composition_pass2_candidates(&shared, &panes)
+    let tumbling_windows = tumbling_window_candidates(&shared, &[Some(60_000), Some(60_000)]);
+    assert_eq!(tumbling_windows.len(), 1, "both estimators share one build");
+    let tumbling_window_roots = window_composition_pass2_candidates(&shared, &tumbling_windows)
         .unwrap()
         .remove(0)
         .roots
@@ -187,7 +187,7 @@ fn shared_pane_configurations(deployment: &DeploymentCapabilities) -> Run {
     run_explicit_candidates(
         &workload,
         original,
-        vec![pane_roots],
+        vec![tumbling_window_roots],
         asap_planner::PlanningModels::builtin()
             .with_cost_inputs(&settings)
             .with_deployment_capabilities(deployment),
@@ -197,7 +197,7 @@ fn shared_pane_configurations(deployment: &DeploymentCapabilities) -> Run {
 /// Physical candidate ids with their cost per second.
 type CandidateCosts = Vec<(String, f64)>;
 
-/// The per-second cost of every physical candidate whose pane chain both
+/// The per-second cost of every physical candidate whose tumbling-window chain both
 /// panels read is materialized at query time: shared within one evaluation
 /// (`MatAtQuery`), and kept across evaluations
 /// (`MatAtQueryKeptAcrossEvaluations`, which Stage 3 prices as such).
@@ -232,7 +232,7 @@ fn shared_chain_costs(run: &Run) -> (CandidateCosts, CandidateCosts) {
 /// With query-time results retained, a chain two panels read is offered
 /// both ways: shared within one evaluation (rebuilt from the 5-min window
 /// every minute, then reused by both panels) and kept across evaluations
-/// (B3: one new pane per evaluation, the 4 older panes held in memory
+/// (B3: one new tumbling window per evaluation, the 4 older tumbling windows held in memory
 /// between evaluations). Holding 1M per-series KLLs between evaluations
 /// costs far more than rebuilding them, so the shared option is cheaper
 /// and the kept one is not selected. Without query-time retention, the
@@ -243,7 +243,7 @@ fn query_time_results_retained_still_offers_the_chain_shared_within_one_evaluati
         query_time_results_retained: true,
         ..DeploymentCapabilities::default()
     };
-    let run = shared_pane_configurations(&keeping);
+    let run = shared_tumbling_window_configurations(&keeping);
     let (within_one, kept) = shared_chain_costs(&run);
     assert!(!within_one.is_empty(), "no shared option: kept {kept:?}");
     assert!(!kept.is_empty(), "no kept option: shared {within_one:?}");
@@ -264,7 +264,7 @@ fn query_time_results_retained_still_offers_the_chain_shared_within_one_evaluati
     );
     assert_selects_cheapest_valid(&run);
 
-    let (_, kept) = shared_chain_costs(&shared_pane_configurations(
+    let (_, kept) = shared_chain_costs(&shared_tumbling_window_configurations(
         &DeploymentCapabilities::default(),
     ));
     assert!(kept.is_empty(), "{kept:?}");
diff --git a/crates/integration-tests/tests/finer_aggregate_reuse.rs b/crates/integration-tests/tests/finer_aggregate_reuse.rs
index f8791fd06..c82760554 100644
--- a/crates/integration-tests/tests/finer_aggregate_reuse.rs
+++ b/crates/integration-tests/tests/finer_aggregate_reuse.rs
@@ -6,7 +6,7 @@ use asap_executor::values::Value;
 use asap_logical_asap_optimization::generate_dag_of_logical_memo_groups;
 use asap_logical_asap_optimization::{
     test_support::{generate_per_computation_candidates, try_populate_pass1},
-    PaneWidthDomain,
+    TumblingWindowWidthDomain,
 };
 use asap_types::ir::{ASAPOp, NonASAPOp, OperatorNode};
 use asap_types::stages::{CandidateForMemoGroup, MemoCandidates, OriginOfCandidateForMemoGroup};
@@ -57,7 +57,7 @@ fn expanded(queries: &[String]) -> MemoCandidates {
     let memo = try_populate_pass1(initial, &inventory).unwrap();
     asap_logical_asap_optimization::test_support::sharing_rules_and_shared_state_groups(
         memo,
-        PaneWidthDomain::SeedGrids,
+        TumblingWindowWidthDomain::SeedGrids,
     )
     .unwrap()
 }
diff --git a/crates/integration-tests/tests/having_shared_aggregate.rs b/crates/integration-tests/tests/having_shared_aggregate.rs
index 369c9e720..b4ced9e59 100644
--- a/crates/integration-tests/tests/having_shared_aggregate.rs
+++ b/crates/integration-tests/tests/having_shared_aggregate.rs
@@ -6,7 +6,7 @@ use asap_executor::values::Value;
 use asap_logical_asap_optimization::generate_dag_of_logical_memo_groups;
 use asap_logical_asap_optimization::{
     test_support::{generate_per_computation_candidates, try_populate_pass1},
-    PaneWidthDomain,
+    TumblingWindowWidthDomain,
 };
 use asap_types::ir::NonASAPOp;
 use asap_types::stages::MemoCandidates;
@@ -55,7 +55,7 @@ fn expanded(queries: &[String]) -> MemoCandidates {
     let memo = try_populate_pass1(dag, &inventory).unwrap();
     asap_logical_asap_optimization::test_support::sharing_rules_and_shared_state_groups(
         memo,
-        PaneWidthDomain::SeedGrids,
+        TumblingWindowWidthDomain::SeedGrids,
     )
     .unwrap()
 }
diff --git a/crates/integration-tests/tests/independent_plan_seed.rs b/crates/integration-tests/tests/independent_plan_seed.rs
index f7b31f130..6785d3532 100644
--- a/crates/integration-tests/tests/independent_plan_seed.rs
+++ b/crates/integration-tests/tests/independent_plan_seed.rs
@@ -78,7 +78,7 @@ fn assert_no_costlier_than_separate(queries: &[String]) -> (f64, f64) {
     (together, separate)
 }
 
-/// Two per-city p90 queries: each alone maintains an ingestion-time KLL pane
+/// Two per-city p90 queries: each alone maintains an ingestion-time KLL tumbling window
 /// chain; together the search used to stop at a query-time plan about twice
 /// as costly.
 #[test]
diff --git a/crates/integration-tests/tests/joint_search_equivalence.rs b/crates/integration-tests/tests/joint_search_equivalence.rs
index 5a5b47361..f1dc5d333 100644
--- a/crates/integration-tests/tests/joint_search_equivalence.rs
+++ b/crates/integration-tests/tests/joint_search_equivalence.rs
@@ -136,7 +136,7 @@ fn run_workload(
     run
 }
 
-// Bounded runs can stop at different progressive pane-width domains. Compare
+// Bounded runs can stop at different progressive tumbling-window-width domains. Compare
 // validated output semantics here, not inventory sizes from different catalogs.
 // Fixed-catalog terminal/producer scaling is tested in candidates::scopes.
 #[test]
diff --git a/crates/integration-tests/tests/kll_pane_execution.rs b/crates/integration-tests/tests/kll_tumbling_window_execution.rs
similarity index 79%
rename from crates/integration-tests/tests/kll_pane_execution.rs
rename to crates/integration-tests/tests/kll_tumbling_window_execution.rs
index 52b0aa5c1..7b0db2dfc 100644
--- a/crates/integration-tests/tests/kll_pane_execution.rs
+++ b/crates/integration-tests/tests/kll_tumbling_window_execution.rs
@@ -1,4 +1,4 @@
-//! Maintenance -> stored pane state -> independently bound query execution.
+//! Maintenance -> stored tumbling-window state -> independently bound query execution.
 use crate::physical_common;
 use asap_executor::sources::InMemoryDataStore;
 use asap_executor::{
@@ -34,7 +34,7 @@ use std::{
     },
 };
 
-const PANE_MS: i64 = 60_000;
+const TUMBLING_WINDOW_WIDTH_MS: i64 = 60_000;
 
 fn family(k: u32) -> FieldDataType {
     FieldDataType::Sketch(
@@ -65,12 +65,12 @@ fn query_scope() -> Scope {
     }
 }
 
-/// p50 and p99 of one KLL (k = 200) merged from five one-minute panes of
-/// `t`, each pane a materialized view.
+/// p50 and p99 of one KLL (k = 200) merged from five one-minute tumbling windows of
+/// `t`, each tumbling window a materialized view.
 struct Fixture {
     dag: PhysicalASAPDAG,
-    /// Pane `i` reads the minute ending `i` minutes before the evaluation time.
-    panes: Vec<u64>,
+    /// Tumbling window `i` reads the minute ending `i` minutes before the evaluation time.
+    tumbling_windows: Vec<u64>,
     views: Vec<MaterializedView>,
     merge: u64,
     p50: u64,
@@ -85,17 +85,17 @@ fn fixture() -> Fixture {
         predicates: vec![],
         schema: table_schema(),
     }));
-    let panes: Vec<Rc<OperatorNode>> = (0..5)
+    let tumbling_windows: Vec<Rc<OperatorNode>> = (0..5)
         .map(|i| {
             let shifted = new(asap_types::ir::Operator::NonASAP(NonASAPOp::TimeShift {
                 shift: TimeShift {
-                    offset_ms: i * PANE_MS,
+                    offset_ms: i * TUMBLING_WINDOW_WIDTH_MS,
                     at: None,
                 },
                 child: scan.clone(),
             }));
             let range = new(asap_types::ir::Operator::NonASAP(NonASAPOp::TimeRange {
-                range: std::time::Duration::from_millis(PANE_MS as u64),
+                range: std::time::Duration::from_millis(TUMBLING_WINDOW_WIDTH_MS as u64),
                 kind: TimeRangeKind::Range,
                 child: shifted,
             }));
@@ -110,7 +110,7 @@ fn fixture() -> Fixture {
         })
         .collect();
     let merge = new(asap_types::ir::Operator::ASAP(ASAPOp::SummaryMerge {
-        children: panes.clone(),
+        children: tumbling_windows.clone(),
         newest_tumbling_windows: None,
         group_by: None,
     }));
@@ -129,7 +129,7 @@ fn fixture() -> Fixture {
     )
     .unwrap();
     let compiled = compile_physical_asap_workload_with_node_ids(&roots).unwrap();
-    let mut pane_ids = vec![0; 5];
+    let mut tumbling_window_ids = vec![0; 5];
     let (mut merge, mut p50, mut p99) = (0, 0, 0);
     for node in &compiled.dag.nodes {
         let id = node.id as u64;
@@ -137,9 +137,9 @@ fn fixture() -> Fixture {
             asap_types::ir::Operator::ASAP(ASAPOp::SummaryAgg { child, .. }) => {
                 let shift = match child.children()[0].non_asap() {
                     Some(NonASAPOp::TimeShift { shift, .. }) => shift.offset_ms,
-                    _ => unreachable!("a pane reads a shifted range"),
+                    _ => unreachable!("a tumbling window reads a shifted range"),
                 };
-                pane_ids[(shift / PANE_MS) as usize] = id;
+                tumbling_window_ids[(shift / TUMBLING_WINDOW_WIDTH_MS) as usize] = id;
             }
             asap_types::ir::Operator::ASAP(ASAPOp::SummaryMerge { .. }) => merge = id,
             asap_types::ir::Operator::ASAP(ASAPOp::SummaryEstimate {
@@ -153,10 +153,10 @@ fn fixture() -> Fixture {
         }
     }
     let mut dag = compiled.dag;
-    let views = views_at(&mut dag, &pane_ids).unwrap();
+    let views = views_at(&mut dag, &tumbling_window_ids).unwrap();
     Fixture {
         dag,
-        panes: pane_ids,
+        tumbling_windows: tumbling_window_ids,
         views,
         merge,
         p50,
@@ -202,17 +202,17 @@ fn summary(batch: &Batch) -> Arc<dyn AggregateCore> {
         })
         .expect("missing KLL")
 }
-/// Pane `pane`'s state, built by `maintenance` (the newest pane's build) in
-/// the ingestion run of `(pane, pane + 1]` minutes.
-fn pane_state(maintenance: &CompiledPhysicalDAG, pane: i64) -> Batch {
-    // Twenty samples in each (start,end] one-minute pane; k=200 avoids
+/// Tumbling window `tumbling_window`'s state, built by `maintenance` (the newest tumbling window's build) in
+/// the ingestion run of `(tumbling_window, tumbling_window + 1]` minutes.
+fn tumbling_window_state(maintenance: &CompiledPhysicalDAG, tumbling_window: i64) -> Batch {
+    // Twenty samples in each (start,end] one-minute tumbling window; k=200 avoids
     // compaction so quantiles and sample counts have deterministic oracles.
     let schema = Arc::new(table_schema());
     let rows = (0..20)
         .map(|i| {
             vec![
-                Value::Timestamp(pane * PANE_MS + 1 + i * 1000),
-                Value::Float64((pane * 20 + i) as f64),
+                Value::Timestamp(tumbling_window * TUMBLING_WINDOW_WIDTH_MS + 1 + i * 1000),
+                Value::Float64((tumbling_window * 20 + i) as f64),
             ]
         })
         .collect();
@@ -229,8 +229,8 @@ fn pane_state(maintenance: &CompiledPhysicalDAG, pane: i64) -> Batch {
         maintenance,
         store,
         Scope::Ingestion {
-            window_start_ms: pane * PANE_MS,
-            window_end_ms: (pane + 1) * PANE_MS,
+            window_start_ms: tumbling_window * TUMBLING_WINDOW_WIDTH_MS,
+            window_end_ms: (tumbling_window + 1) * TUMBLING_WINDOW_WIDTH_MS,
         },
     );
     state[0][0].clone()
@@ -294,12 +294,14 @@ impl PhysicalOperator<Batch, SchemaRef> for CountStarts {
 /// Actual codec bytes survive destruction of maintenance state; one shared
 /// native merge supplies p50, p99 and the population-count oracle per run.
 #[test]
-fn five_panes_roundtrip_and_shared_merge_runs_once() {
+fn five_tumbling_windows_roundtrip_and_shared_merge_runs_once() {
     let fixture = fixture();
-    let maintenance = compile(&fixture.dag, &[], &[fixture.panes[0]]).unwrap();
-    let panes: Vec<Batch> = (0..6).map(|pane| pane_state(&maintenance, pane)).collect();
+    let maintenance = compile(&fixture.dag, &[], &[fixture.tumbling_windows[0]]).unwrap();
+    let tumbling_windows: Vec<Batch> = (0..6)
+        .map(|tumbling_window| tumbling_window_state(&maintenance, tumbling_window))
+        .collect();
     drop(maintenance);
-    let schema = schema_of(&fixture.dag, fixture.panes[0]);
+    let schema = schema_of(&fixture.dag, fixture.tumbling_windows[0]);
     let merge = Operator::summary_merge(schema.clone(), 0, vec![]).unwrap();
     let compiled = compile(
         &fixture.dag,
@@ -307,15 +309,15 @@ fn five_panes_roundtrip_and_shared_merge_runs_once() {
         &[fixture.merge, fixture.p50, fixture.p99],
     )
     .unwrap();
-    let layout = asap_physical_asap_optimization::test_support::PaneLayout {
+    let layout = asap_physical_asap_optimization::test_support::TumblingWindowLayout {
         tumbling_window_width_ms: 60_000,
-        pane_origin_ms: Some(0),
+        tumbling_window_origin_ms: Some(0),
     };
     assert!(
-        asap_physical_asap_optimization::test_support::validate_pane_coverage(
+        asap_physical_asap_optimization::test_support::validate_tumbling_window_coverage(
             &layout,
             Some(330_000),
-            &asap_physical_asap_optimization::test_support::WindowEdgeCoverage::PaneAligned
+            &asap_physical_asap_optimization::test_support::WindowEdgeCoverage::TumblingWindowAligned
         )
         .is_err(),
         "moving window edges require residual computation"
@@ -323,31 +325,34 @@ fn five_panes_roundtrip_and_shared_merge_runs_once() {
     for offset in [0, 1] {
         let restored = restore(
             schema.clone(),
-            &panes[offset..offset + 5]
+            &tumbling_windows[offset..offset + 5]
                 .iter()
                 .map(summary)
                 .collect::<Vec<_>>(),
         );
         let evaluation_time_ms = (5 + offset as i64) * 60_000;
-        asap_physical_asap_optimization::test_support::validate_pane_coverage(
+        asap_physical_asap_optimization::test_support::validate_tumbling_window_coverage(
             &layout,
             Some(evaluation_time_ms),
-            &asap_physical_asap_optimization::test_support::WindowEdgeCoverage::PaneAligned,
+            &asap_physical_asap_optimization::test_support::WindowEdgeCoverage::TumblingWindowAligned,
         )
         .unwrap();
-        // View `i` holds the pane ending `i` minutes before the evaluation time.
+        // View `i` holds the tumbling window ending `i` minutes before the evaluation time.
         let bind = |count: usize| {
-            fixture.panes[..count].iter().enumerate().fold(
+            fixture.tumbling_windows[..count].iter().enumerate().fold(
                 InMemoryDataStore::default(),
                 |store, (i, &view)| {
                     store
-                        .with_materialized_view(view as usize, vec![panes[offset + 4 - i].clone()])
+                        .with_materialized_view(
+                            view as usize,
+                            vec![tumbling_windows[offset + 4 - i].clone()],
+                        )
                         .unwrap()
                 },
             )
         };
         let scope = Scope::Query { evaluation_time_ms };
-        // A five-pane deployment cannot bind only four materialized views.
+        // A five-tumbling-window deployment cannot bind only four materialized views.
         let missing = try_execute(&compiled, bind(4), scope.clone())
             .err()
             .unwrap();
@@ -413,9 +418,9 @@ fn five_panes_roundtrip_and_shared_merge_runs_once() {
 /// Relabelled KLL parameters, a view bound in another schema and a missing
 /// view fail explicitly.
 #[test]
-fn panes_reject_parameters_schema_and_missing_binding() {
+fn tumbling_windows_reject_parameters_schema_and_missing_binding() {
     let fixture = fixture();
-    let schema = schema_of(&fixture.dag, fixture.panes[0]);
+    let schema = schema_of(&fixture.dag, fixture.tumbling_windows[0]);
     let wrong = Value::Summary {
         family: family(200),
         state: Arc::new(DatasketchesKLLAccumulator::new(128)),
@@ -432,14 +437,15 @@ fn panes_reject_parameters_schema_and_missing_binding() {
     let raw = Arc::new(table_schema());
     let raw_rows =
         Batch::try_new(raw, vec![vec![Value::Timestamp(1), Value::Float64(1.)]]).unwrap();
-    let store = fixture
-        .panes
-        .iter()
-        .fold(InMemoryDataStore::default(), |store, &view| {
-            store
-                .with_materialized_view(view as usize, vec![raw_rows.clone()])
-                .unwrap()
-        });
+    let store =
+        fixture
+            .tumbling_windows
+            .iter()
+            .fold(InMemoryDataStore::default(), |store, &view| {
+                store
+                    .with_materialized_view(view as usize, vec![raw_rows.clone()])
+                    .unwrap()
+            });
     let relabelled = try_execute(&compiled, store, query_scope()).err().unwrap();
     assert!(
         relabelled.to_string().contains("another schema"),
@@ -482,16 +488,18 @@ impl asap_executor::sources::DataStore for DefinitionStore {
     }
 }
 
-/// A store keyed only by `(definition_id, time range)` answers the five-pane
-/// query: the five panes share one definition and request the five
+/// A store keyed only by `(definition_id, time range)` answers the five-tumbling-window
+/// query: the five tumbling windows share one definition and request the five
 /// one-minute ranges that tile the window, and the answers equal those of
-/// binding each pane's state to its node.
+/// binding each tumbling window's state to its node.
 #[test]
-fn a_store_keyed_by_definition_and_time_range_answers_the_panes() {
+fn a_store_keyed_by_definition_and_time_range_answers_the_tumbling_windows() {
     let fixture = fixture();
-    let maintenance = compile(&fixture.dag, &[], &[fixture.panes[0]]).unwrap();
-    // The state of the pane of minute `m`, `(m, m + 1]` minutes.
-    let panes: Vec<Batch> = (0..5).map(|m| pane_state(&maintenance, m)).collect();
+    let maintenance = compile(&fixture.dag, &[], &[fixture.tumbling_windows[0]]).unwrap();
+    // The state of the tumbling window of minute `m`, `(m, m + 1]` minutes.
+    let tumbling_windows: Vec<Batch> = (0..5)
+        .map(|m| tumbling_window_state(&maintenance, m))
+        .collect();
     let definition = fixture.views[0].coverage().definition_id().to_owned();
     assert!(fixture
         .views
@@ -500,8 +508,14 @@ fn a_store_keyed_by_definition_and_time_range_answers_the_panes() {
     let states = (0..5)
         .map(|m| {
             (
-                (definition.clone(), (m * PANE_MS, (m + 1) * PANE_MS)),
-                panes[m as usize].clone(),
+                (
+                    definition.clone(),
+                    (
+                        m * TUMBLING_WINDOW_WIDTH_MS,
+                        (m + 1) * TUMBLING_WINDOW_WIDTH_MS,
+                    ),
+                ),
+                tumbling_windows[m as usize].clone(),
             )
         })
         .collect();
@@ -540,20 +554,21 @@ fn a_store_keyed_by_definition_and_time_range_answers_the_panes() {
     assert_eq!(
         requested,
         (0..5)
-            .map(|m| (m * PANE_MS, (m + 1) * PANE_MS))
+            .map(|m| (
+                m * TUMBLING_WINDOW_WIDTH_MS,
+                (m + 1) * TUMBLING_WINDOW_WIDTH_MS
+            ))
             .collect::<Vec<_>>()
     );
-    // View `i` holds the pane ending `i` minutes before the evaluation time.
-    let by_node =
-        fixture
-            .panes
-            .iter()
-            .enumerate()
-            .fold(InMemoryDataStore::default(), |store, (i, &view)| {
-                store
-                    .with_materialized_view(view as usize, vec![panes[4 - i].clone()])
-                    .unwrap()
-            });
+    // View `i` holds the tumbling window ending `i` minutes before the evaluation time.
+    let by_node = fixture.tumbling_windows.iter().enumerate().fold(
+        InMemoryDataStore::default(),
+        |store, (i, &view)| {
+            store
+                .with_materialized_view(view as usize, vec![tumbling_windows[4 - i].clone()])
+                .unwrap()
+        },
+    );
     let by_node: Vec<Vec<Vec<Value>>> = physical_common::execute(&compiled, by_node, scope)
         .iter()
         .map(|batches| batches.iter().flat_map(Batch::to_rows).collect())
diff --git a/crates/integration-tests/tests/main.rs b/crates/integration-tests/tests/main.rs
index c61f0cdab..bf81ee35d 100644
--- a/crates/integration-tests/tests/main.rs
+++ b/crates/integration-tests/tests/main.rs
@@ -19,7 +19,7 @@ mod having_shared_aggregate;
 mod identical_exact_queries;
 mod independent_plan_seed;
 mod joint_search_equivalence;
-mod kll_pane_execution;
+mod kll_tumbling_window_execution;
 mod materialization_e2e;
 mod materialized_views;
 mod memo_enumeration;
@@ -56,4 +56,4 @@ mod stage1_logical_asap_optimization;
 mod stage2_physical_asap_optimization_sql;
 mod summary_coverage_e2e;
 mod time_range;
-mod tumbling_pane_merge;
+mod tumbling_window_merge;
diff --git a/crates/integration-tests/tests/materialized_views.rs b/crates/integration-tests/tests/materialized_views.rs
index 4504fff52..c6fad2f29 100644
--- a/crates/integration-tests/tests/materialized_views.rs
+++ b/crates/integration-tests/tests/materialized_views.rs
@@ -44,9 +44,9 @@ fn repeating_with(queries: &[&str], extra: &str) -> PlanningWorkload {
 }
 
 /// Stage 3's priced raw lookback of `dag` (the selected candidate's
-/// physical DAG, pane chains unexpanded), per source: each query-time
+/// physical DAG, tumbling-window chains unexpanded), per source: each query-time
 /// scan's `PhysicalASAPDAG::scan_window` with every chain kept across
-/// evaluations reading its newest pane, as `asap-plan-selection` prices
+/// evaluations reading its newest tumbling window, as `asap-plan-selection` prices
 /// it, the longest per source.
 fn stage3_raw_lookback_ms(dag: &PhysicalASAPDAG) -> Vec<(Source, Option<u64>)> {
     let kept_chains: HashSet<_> = dag
diff --git a/crates/integration-tests/tests/memo_enumeration.rs b/crates/integration-tests/tests/memo_enumeration.rs
index 61c28df7d..5ff0fdca6 100644
--- a/crates/integration-tests/tests/memo_enumeration.rs
+++ b/crates/integration-tests/tests/memo_enumeration.rs
@@ -10,11 +10,11 @@
 //! Pass 1) and `PlanningRun::memo_steps` (the other steps).
 //!
 //! **Which round's memo.** The default search plans in rounds of growing
-//! pane-width domains and records the memo of the round whose plan it
+//! tumbling-window-width domains and records the memo of the round whose plan it
 //! selected, so its last step depends on the time budget (the seed-grid
 //! round when a debug build runs out of it; round 5 of the release run that
 //! made the doc's document, 354 groups and 1738 candidates). The ratio test
-//! runs one round over the complete pane-width domain (a search with fewer
+//! runs one round over the complete tumbling-window-width domain (a search with fewer
 //! than 4 evaluations has no progressive rounds), so its last step is the
 //! same on every machine. Stage 0 and Pass 1 are the same in every round.
 //!
@@ -127,7 +127,7 @@ impl asap_accuracy::AccuracyModel for AcceptsNoOutput {
     }
 }
 
-/// Rounds up to the complete pane-width domain, with a time limit a slow
+/// Rounds up to the complete tumbling-window-width domain, with a time limit a slow
 /// machine's Pass 2 does not reach. Stage 3 may use the whole budget: when
 /// it validates no plan, it searches until the deadline; the memo steps are
 /// recorded either way.
@@ -344,7 +344,7 @@ fn ratio_of_quantiles_production_memo() {
     // groups: no query has a guarantee through `/` and `+` over a KLL rank
     // error or a DDSketch relative one. The memo below is planned with a
     // model that prunes none and accepts no output, so its summaries stay
-    // and its last round, over the complete pane-width domain, is recorded.
+    // and its last round, over the complete tumbling-window-width domain, is recorded.
     let enforced = production_run(&ratio_of_quantiles(), PlanSearchSettings::default());
     assert_eq!(candidate_count(pass1_memo(&enforced)), 7);
     let models = PlanningModels::builtin().with_accuracy(&AcceptsNoOutput);
@@ -368,7 +368,7 @@ fn ratio_of_quantiles_production_memo() {
         ),
         (25, 9, 9, 4)
     );
-    // The last step, over the complete pane-width domain.
+    // The last step, over the complete tumbling-window-width domain.
     let last = &steps.concrete_states;
     assert_eq!(last.groups.len(), 255);
     assert_eq!(candidate_count(last), 1243);
diff --git a/crates/integration-tests/tests/planner_layering_common/mod.rs b/crates/integration-tests/tests/planner_layering_common/mod.rs
index efa47f81b..45e59b423 100644
--- a/crates/integration-tests/tests/planner_layering_common/mod.rs
+++ b/crates/integration-tests/tests/planner_layering_common/mod.rs
@@ -413,13 +413,13 @@ pub fn run_pattern_b_fixture(
 }
 
 /// Three fixed Pattern-B computations used by cost/retention fixtures:
-/// exact, whole-window KLL, and a KLL chain of sixty-second panes.
+/// exact, whole-window KLL, and a KLL chain of sixty-second tumbling windows.
 pub fn pattern_b_computations(workload: &PlanningWorkload) -> Vec<Vec<QueryRoot>> {
     use asap_logical_asap_optimization::test_support::{
         compose_logical_candidate, generate_per_computation_candidates,
     };
     use asap_logical_asap_optimization::test_support::{
-        pane_candidates, window_composition_pass2_candidates,
+        tumbling_window_candidates, window_composition_pass2_candidates,
     };
     use asap_types::stages::HowToComputeAggregateMeasure;
     let roots = lower_promql(workload);
@@ -443,13 +443,13 @@ pub fn pattern_b_computations(workload: &PlanningWorkload) -> Vec<Vec<QueryRoot>
         })
         .unwrap();
     let whole: Vec<_> = compose_logical_candidate(&local, &[kll]).unwrap();
-    let panes = pane_candidates(&whole, &[Some(60_000)]);
-    assert_eq!(panes.len(), 1);
-    let chain = window_composition_pass2_candidates(&whole, &panes)
+    let tumbling_windows = tumbling_window_candidates(&whole, &[Some(60_000)]);
+    assert_eq!(tumbling_windows.len(), 1);
+    let chain = window_composition_pass2_candidates(&whole, &tumbling_windows)
         .unwrap()
         .remove(0)
         .roots
-        .expect("sixty-second panes compose");
+        .expect("sixty-second tumbling windows compose");
     vec![roots, whole, chain]
 }
 
@@ -576,7 +576,7 @@ pub fn is_merge(payload: &Payload) -> bool {
     matches!(payload, Operator::ASAP(ASAPOp::SummaryMerge { .. }))
 }
 
-/// The sketch build nodes (`SummaryAgg` or tumbling-pane `SummaryTumblingWindowChain` over a
+/// The sketch build nodes (`SummaryAgg` or tumbling-window `SummaryTumblingWindowChain` over a
 /// sketch family) of `dag`, with their algorithm and parameters.
 pub fn sketch_builds(dag: &impl ExportedDag) -> Vec<(NodeId, SketchAlgorithm, SketchParams)> {
     dag.node_ids()
@@ -907,8 +907,8 @@ pub enum WindowForm {
     ExponentialHistogram { horizon_ms: u64 },
 }
 
-/// The window summary of a build: a `SummaryTumblingWindowChain` keeps back-to-back panes of
-/// its pane width (tumbling); a `SummaryAgg` is rebuilt from its query
+/// The window summary of a build: a `SummaryTumblingWindowChain` keeps back-to-back tumbling windows of
+/// its tumbling-window width (tumbling); a `SummaryAgg` is rebuilt from its query
 /// window. Sliding windows and Exponential Histograms are not planned yet
 /// (#628).
 pub fn window_form(dag: &impl ExportedDag, build: NodeId) -> WindowForm {
@@ -925,8 +925,8 @@ pub fn window_form(dag: &impl ExportedDag, build: NodeId) -> WindowForm {
 
 /// How far back from an evaluation a materialized node's kept output
 /// reaches in event time, derived the way plan selection prices what it
-/// keeps: a pane chain keeps its `N`
-/// panes of width `w`, plus the one being built when maintained at
+/// keeps: a tumbling-window chain keeps its `N`
+/// tumbling windows of width `w`, plus the one being built when maintained at
 /// ingestion time; a whole-window build keeps its window, and the next one
 /// being built at ingestion time; each plus the offset of the time shifts
 /// below it. `None` for any other node.
@@ -954,8 +954,8 @@ pub fn retention_ms(p: &Physical, node: NodeId) -> Option<u64> {
             tumbling_window_count,
             ..
         }) => {
-            let panes = u64::from(*tumbling_window_count) + u64::from(at_ingestion);
-            Some(panes * tumbling_window_width_ms + offset_below(below(node)))
+            let tumbling_windows = u64::from(*tumbling_window_count) + u64::from(at_ingestion);
+            Some(tumbling_windows * tumbling_window_width_ms + offset_below(below(node)))
         }
         Operator::ASAP(ASAPOp::SummaryAgg { .. }) => {
             let child = below(node)?;
diff --git a/crates/integration-tests/tests/planner_layering_example1.rs b/crates/integration-tests/tests/planner_layering_example1.rs
index ba84e0f5e..bc12132e0 100644
--- a/crates/integration-tests/tests/planner_layering_example1.rs
+++ b/crates/integration-tests/tests/planner_layering_example1.rs
@@ -25,14 +25,14 @@ fn pipeline() -> Run {
 }
 
 // Explicit rule fixtures: vary Q2's three documented algorithms while Q1
-// stays exact, and exercise source sharing and ten-second panes. This is not
+// stays exact, and exercise source sharing and ten-second tumbling windows. This is not
 // a production workload search or an exhaustive memo archive.
 fn rule_fixture(workload: &asap_types::workload::PlanningWorkload) -> Run {
     use asap_logical_asap_optimization::test_support::{
         compose_logical_candidate, generate_per_computation_candidates,
     };
     use asap_logical_asap_optimization::test_support::{
-        pane_candidates, window_composition_pass2_candidates,
+        tumbling_window_candidates, window_composition_pass2_candidates,
     };
     use asap_types::stages::HowToComputeAggregateMeasure;
     let roots = lower_promql(workload);
@@ -65,9 +65,9 @@ fn rule_fixture(workload: &asap_types::workload::PlanningWorkload) -> Run {
         }
         let whole = unshare(&compose_logical_candidate(&local, &choice).unwrap());
         let mut windows = vec![whole.clone()];
-        let panes = pane_candidates(&whole, &[Some(10_000), Some(10_000)]);
+        let tumbling_windows = tumbling_window_candidates(&whole, &[Some(10_000), Some(10_000)]);
         windows.extend(
-            window_composition_pass2_candidates(&whole, &panes)
+            window_composition_pass2_candidates(&whole, &tumbling_windows)
                 .unwrap()
                 .into_iter()
                 .map(|candidate| candidate.roots.unwrap()),
@@ -151,7 +151,7 @@ fn sketch_options(dag: &impl ExportedDag, nodes: &HashSet<NodeId>) -> BTreeSet<Q
 }
 
 /// Whether every summary of `dag` is built over its whole window: no
-/// tumbling panes (Pass 2's window-composition rule).
+/// tumbling windows (Pass 2's window-composition rule).
 fn whole_windows(dag: &impl ExportedDag) -> bool {
     dag.node_ids().into_iter().all(|id| {
         !matches!(
@@ -178,7 +178,7 @@ fn classify(dag: &impl ExportedDag, query_roots: &[NodeId]) -> (Q2Option, bool)
 
 /// The candidate with Q2 `option` whose queries share no node and whose
 /// summaries are built over whole windows (Pass 2 adds shared-input and
-/// tumbling-pane variants of each).
+/// tumbling-window variants of each).
 fn physical_with(run: &Run, option: Q2Option) -> &Physical {
     let mut found = run
         .physical
@@ -258,7 +258,7 @@ fn stage0_query_language_frontends_queries_do_not_share_nodes() {
 
 /// Pass 1 gives 1 × 3 = 3 candidates without a shared input: Q2's top-k is
 /// exact, Count-Min + heap or CountSketch + heap. (Pass 2 adds shared-input
-/// and tumbling-pane variants of each.)
+/// and tumbling-window variants of each.)
 #[test]
 fn stage1_logical_asap_optimization_has_three_pass1_candidates() {
     let run = pipeline();
@@ -276,7 +276,7 @@ fn stage1_logical_asap_optimization_has_three_pass1_candidates() {
 }
 
 /// Q1 is exact in every candidate: no sketch build or estimate is reachable
-/// from its root (its rate may be merged from exact tumbling panes).
+/// from its root (its rate may be merged from exact tumbling windows).
 #[test]
 fn stage1_logical_asap_optimization_q1_is_always_exact() {
     let run = pipeline();
@@ -367,11 +367,11 @@ fn stage1_logical_asap_optimization_keeps_independent_and_shared_variants() {
 }
 
 /// Pass 2's window-composition rule builds Q1's rate and Q2's option in six
-/// 10-s tumbling panes (the gcd of the 1-min window and the 10-s interval),
+/// 10-s tumbling windows (the gcd of the 1-min window and the 10-s interval),
 /// each alone and both together, next to the whole-window candidates: 27
 /// candidates in all.
 #[test]
-fn stage1_logical_asap_optimization_window_composition_adds_10s_tumbling_panes() {
+fn stage1_logical_asap_optimization_window_composition_adds_10s_tumbling_windows() {
     let run = pipeline();
     let mut chains = BTreeSet::new();
     for c in &run.logical {
@@ -438,7 +438,7 @@ fn stage1_logical_asap_optimization_candidates_are_valid_and_uniquely_named() {
 
 /// No candidate is discarded before plan selection: each logical candidate
 /// keeps one physical candidate with nothing materialized, 3 of them
-/// without a shared input or tumbling panes.
+/// without a shared input or tumbling windows.
 #[test]
 fn stage2_physical_asap_optimization_keeps_every_logical_candidate() {
     let run = pipeline();
@@ -450,7 +450,7 @@ fn stage2_physical_asap_optimization_keeps_every_logical_candidate() {
 }
 
 /// Each physical candidate keeps its logical Q2 option, and one with
-/// nothing materialized keeps its input sharing. Maintaining Q2's panes at
+/// nothing materialized keeps its input sharing. Maintaining Q2's tumbling windows at
 /// ingestion time splits a scan Q1 reads at query time, one copy per phase.
 #[test]
 fn stage2_physical_asap_optimization_preserves_logical_choices() {
@@ -556,11 +556,11 @@ fn stage2_physical_asap_optimization_summary_topk_is_build_then_estimate() {
     }
 }
 
-/// Only tumbling panes can be maintained at ingestion time: the
+/// Only tumbling windows can be maintained at ingestion time: the
 /// whole-window builds' fixed interval has no phase, and no summary is read
-/// by both queries. Q1's rate panes are counter states, which need each
+/// by both queries. Q1's rate tumbling windows are counter states, which need each
 /// series' samples in time order; continuously ingesting PromQL data is
-/// taken to arrive in that order, so they are maintained too. Each pane
+/// taken to arrive in that order, so they are maintained too. Each tumbling window
 /// chain is maintained or not independently: a logical candidate with `c`
 /// chains has `2^c` physical candidates. A shared input (the highest node
 /// both queries read: the scan, or the time range above it) is also built
@@ -568,7 +568,7 @@ fn stage2_physical_asap_optimization_summary_topk_is_build_then_estimate() {
 /// with every chain at query time, since a chain maintained at ingestion
 /// time leaves one query reading the input at query time.
 #[test]
-fn stage2_physical_asap_optimization_materializes_only_panes_at_ingestion() {
+fn stage2_physical_asap_optimization_materializes_only_tumbling_windows_at_ingestion() {
     let run = pipeline();
     let mut counter_maintained = 0;
     let mut shared_once = 0;
@@ -580,7 +580,7 @@ fn stage2_physical_asap_optimization_materializes_only_panes_at_ingestion() {
                     let Operator::ASAP(ASAPOp::SummaryTumblingWindowChain { family, .. }) =
                         p.dag().payload(n.id)
                     else {
-                        panic!("{}: {:?} is not a pane chain", p.id, n.id)
+                        panic!("{}: {:?} is not a tumbling-window chain", p.id, n.id)
                     };
                     if matches!(
                         family,
@@ -616,7 +616,10 @@ fn stage2_physical_asap_optimization_materializes_only_panes_at_ingestion() {
             }
         }
     }
-    assert!(counter_maintained > 0, "Q1's rate panes are maintained");
+    assert!(
+        counter_maintained > 0,
+        "Q1's rate tumbling windows are maintained"
+    );
     assert!(
         shared_once > 0,
         "explicit shared-source fixtures are materialized"
@@ -780,12 +783,12 @@ fn stage3_plan_selection_shared_input_ties_up_to_rounding_unless_built_once() {
     );
 }
 
-/// Tumbling panes rebuilt at every evaluation cost more than the whole
-/// window: the panes read the same rows and update the same states, and
-/// merging them adds work. Heap panes are invalid like their whole-window
+/// Tumbling windows rebuilt at every evaluation cost more than the whole
+/// window: the tumbling windows read the same rows and update the same states, and
+/// merging them adds work. Heap tumbling windows are invalid like their whole-window
 /// builds (and their merged top-k is only approximate).
 #[test]
-fn stage3_plan_selection_tumbling_panes_at_query_time_cost_more() {
+fn stage3_plan_selection_tumbling_windows_at_query_time_cost_more() {
     let run = pipeline();
     let selected = run.cost(&run.selection.selected).unwrap();
     let invalid = run.invalid();
diff --git a/crates/integration-tests/tests/planner_layering_example2.rs b/crates/integration-tests/tests/planner_layering_example2.rs
index c4812fd6a..a71a9c7e6 100644
--- a/crates/integration-tests/tests/planner_layering_example2.rs
+++ b/crates/integration-tests/tests/planner_layering_example2.rs
@@ -181,7 +181,7 @@ fn rule_fixture_computations(
         compose_logical_candidate, generate_per_computation_candidates,
     };
     use asap_logical_asap_optimization::test_support::{
-        pane_candidates, window_composition_pass2_candidates,
+        tumbling_window_candidates, window_composition_pass2_candidates,
     };
     use asap_types::stages::HowToComputeAggregateMeasure;
     let local = generate_per_computation_candidates(
@@ -235,12 +235,12 @@ fn rule_fixture_computations(
         if distinct_nodes(&shared) < distinct_nodes(&whole) {
             computations.push(shared);
         }
-        let panes = pane_candidates(&whole, &grid);
-        // Isolate one pane configuration at a time; no Cartesian products of
+        let tumbling_windows = tumbling_window_candidates(&whole, &grid);
+        // Isolate one tumbling-window configuration at a time; no Cartesian products of
         // independent window implementations are needed for the error tests.
-        for pane in panes {
+        for tumbling_window in tumbling_windows {
             computations.extend(
-                window_composition_pass2_candidates(&whole, &[pane])
+                window_composition_pass2_candidates(&whole, &[tumbling_window])
                     .unwrap()
                     .into_iter()
                     .map(|candidate| candidate.roots.unwrap()),
@@ -878,7 +878,7 @@ fn stage3_plan_selection_accepts_kmv_for_any_failure_probability_without_a_bound
 }
 
 /// The physical candidates among `ids` that build their sketch as a
-/// tumbling-pane `SummaryTumblingWindowChain`.
+/// tumbling-window `SummaryTumblingWindowChain`.
 fn tumbling<'a>(run: &Run, ids: Vec<&'a str>) -> Vec<&'a str> {
     ids.into_iter()
         .filter(|id| {
@@ -890,15 +890,18 @@ fn tumbling<'a>(run: &Run, ids: Vec<&'a str>) -> Vec<&'a str> {
         .collect()
 }
 
-/// The enlarged precision reaches a sketch carried by a tumbling-pane
+/// The enlarged precision reaches a sketch carried by a tumbling-window
 /// `SummaryTumblingWindowChain` too (#713): Q1's HLL over a bound of 3,000 is valid only at
-/// precision 18, above the 17 sized for ε alone, so a valid tumbling-pane
+/// precision 18, above the 17 sized for ε alone, so a valid tumbling-window
 /// HLL candidate carries precision 18 in its chain.
 #[test]
-fn pass1_sizing_enlarges_tumbling_pane_hll() {
+fn pass1_sizing_enlarges_tumbling_window_hll() {
     let run = pipeline_with_distinct_bound(Some(3_000));
     let hll = tumbling(&run, hll_only_candidates(&run));
-    assert!(!hll.is_empty(), "a tumbling-pane HLL candidate answers Q1");
+    assert!(
+        !hll.is_empty(),
+        "a tumbling-window HLL candidate answers Q1"
+    );
     for id in hll {
         assert!(run.cost(id).is_some(), "{id}: {:?}", run.invalid().get(id));
     }
diff --git a/crates/integration-tests/tests/planner_layering_example3.rs b/crates/integration-tests/tests/planner_layering_example3.rs
index 651719a65..c0c8ab6ed 100644
--- a/crates/integration-tests/tests/planner_layering_example3.rs
+++ b/crates/integration-tests/tests/planner_layering_example3.rs
@@ -74,7 +74,7 @@ fn run_b() -> Run {
         compose_logical_candidate, generate_per_computation_candidates,
     };
     use asap_logical_asap_optimization::test_support::{
-        pane_candidates, window_composition_pass2_candidates,
+        tumbling_window_candidates, window_composition_pass2_candidates,
     };
     use asap_types::stages::HowToComputeAggregateMeasure;
     let workload = pattern_b();
@@ -92,8 +92,8 @@ fn run_b() -> Run {
             continue;
         }
         let whole: Vec<_> = compose_logical_candidate(&local, &[option]).unwrap();
-        let panes = pane_candidates(&whole, &[Some(PATTERN_B_INTERVAL_MS)]);
-        let chain = window_composition_pass2_candidates(&whole, &panes)
+        let tumbling_windows = tumbling_window_candidates(&whole, &[Some(PATTERN_B_INTERVAL_MS)]);
+        let chain = window_composition_pass2_candidates(&whole, &tumbling_windows)
             .unwrap()
             .remove(0)
             .roots
@@ -455,7 +455,7 @@ fn stage1_logical_asap_optimization_b_window_composition_adds_sliding_and_tumbli
 }
 
 /// Each summary option of Pass 1 (KLL and DDSketch, both mergeable) also
-/// comes as 1-min tumbling panes, gcd(5 min, 1 min), merged five at a time
+/// comes as 1-min tumbling windows, gcd(5 min, 1 min), merged five at a time
 /// before its p99 estimate; the whole-window builds are kept and read no
 /// merge. Exact has no summary to split: 2 options × 2 forms + exact = 5.
 #[test]
@@ -591,38 +591,45 @@ fn stage3_plan_selection_b_selects_cheapest_valid() {
     assert_each_node_charged_per_consuming_query(&run);
 }
 
-/// With nothing materialized, the 1-min KLL panes are all rebuilt at every
+/// With nothing materialized, the 1-min KLL tumbling windows are all rebuilt at every
 /// evaluation: they read the same 5 minutes of samples and update the same
-/// states as one whole-window KLL, and merging five panes per series adds
+/// states as one whole-window KLL, and merging five tumbling windows per series adds
 /// 1M × 5 operations a minute. Each evaluation also holds its states while
-/// it runs: the whole window's 1M KLLs, or the five panes' 5M smaller ones,
+/// it runs: the whole window's 1M KLLs, or the five tumbling windows' 5M smaller ones,
 /// for the evaluation's latency. So whole-window KLL is selected at 2.363 per
-/// second and the panes cost 3.611; exact costs 2.458. DDSketch, whole or in
-/// panes, misses the rank target.
+/// second and the tumbling windows cost 3.611; exact costs 2.458. DDSketch, whole or in
+/// tumbling windows, misses the rank target.
 #[test]
-fn stage3_plan_selection_b_panes_rebuilt_at_query_time_add_the_merge() {
+fn stage3_plan_selection_b_tumbling_windows_rebuilt_at_query_time_add_the_merge() {
     let run = run_b();
     let cost = |c: &Logical| run.cost(&run.physical_of(c).next().unwrap().id);
-    let with = |algorithm: &str, panes: bool| {
+    let with = |algorithm: &str, tumbling_windows: bool| {
         run.logical
             .iter()
             .find(|c| {
                 query_option(&c.dag, &c.query_roots, 0) == algorithm
                     && windowed_builds(c)
                         .iter()
-                        .any(|(_, _, f, _)| (*f != WindowForm::None) == panes)
+                        .any(|(_, _, f, _)| (*f != WindowForm::None) == tumbling_windows)
             })
-            .unwrap_or_else(|| panic!("{algorithm} panes={panes}"))
+            .unwrap_or_else(|| panic!("{algorithm} tumbling_windows={tumbling_windows}"))
     };
     let whole = cost(with("Kll", false)).unwrap();
-    let panes = cost(with("Kll", true)).unwrap();
+    let tumbling_windows = cost(with("Kll", true)).unwrap();
     assert!((whole - 2.362_500_025_2).abs() < 1e-9, "{whole}");
-    assert!((panes - 3.611_233_350_8).abs() < 1e-9, "{panes}");
+    assert!(
+        (tumbling_windows - 3.611_233_350_8).abs() < 1e-9,
+        "{tumbling_windows}"
+    );
     assert_eq!(
         run.selection.selected,
         run.physical_of(with("Kll", false)).next().unwrap().id
     );
-    for panes in [false, true] {
-        assert_eq!(cost(with("DDSketch", panes)), None, "panes={panes}");
+    for tumbling_windows in [false, true] {
+        assert_eq!(
+            cost(with("DDSketch", tumbling_windows)),
+            None,
+            "tumbling_windows={tumbling_windows}"
+        );
     }
 }
diff --git a/crates/integration-tests/tests/planner_layering_example4.rs b/crates/integration-tests/tests/planner_layering_example4.rs
index e40446600..a47c5fbfa 100644
--- a/crates/integration-tests/tests/planner_layering_example4.rs
+++ b/crates/integration-tests/tests/planner_layering_example4.rs
@@ -381,7 +381,7 @@ fn stage2_physical_asap_optimization_b_tumbling_kll_has_b1_and_b2() {
 
 /// B3 runs nothing at ingestion time; it keeps the tumbling KLLs it builds at query time.
 /// Implementer addition: kept for the readers' 5-min look-back, it is
-/// priced as building one 1-min pane per evaluation, so it reads a fifth of
+/// priced as building one 1-min tumbling window per evaluation, so it reads a fifth of
 /// B2's raw data and keeps a fifth of it on disk.
 #[test]
 fn stage2_physical_asap_optimization_b_b3_keeps_query_time_windows() {
@@ -435,7 +435,7 @@ fn pattern_b_under(cost_model: CostModel) -> Run {
 }
 
 /// The candidates the cost models choose between: the exact plan, the KLL
-/// rebuilt over the whole window at query time and B1 (the panes maintained at ingestion time).
+/// rebuilt over the whole window at query time and B1 (the tumbling windows maintained at ingestion time).
 struct PatternBCandidates {
     exact: String,
     whole_window_kll: String,
@@ -443,7 +443,7 @@ struct PatternBCandidates {
 }
 
 fn pattern_b_candidates(run: &Run) -> PatternBCandidates {
-    let panes = options_of(run, tumbling(), 1);
+    let tumbling_windows = options_of(run, tumbling(), 1);
     PatternBCandidates {
         exact: run
             .physical
@@ -455,7 +455,7 @@ fn pattern_b_candidates(run: &Run) -> PatternBCandidates {
         whole_window_kll: options_of(run, Some(WindowForm::None), 1)[&NotMaterialized]
             .0
             .clone(),
-        b1: panes[&MatAtIngestion].0.clone(),
+        b1: tumbling_windows[&MatAtIngestion].0.clone(),
     }
 }
 
@@ -471,13 +471,13 @@ fn cluster(memory_gb: u64, objective: ClusterObjective) -> CostModel {
 
 /// Each cost model chooses what its deployment pays for. Cost model 1
 /// (usage over time) picks the KLL rebuilt every minute: it uses memory only
-/// while it runs, and B1 pays for 5.2 GB of panes every second. Cost model 2
+/// while it runs, and B1 pays for 5.2 GB of tumbling windows every second. Cost model 2
 /// (provisioned capacity) picks the exact plan: every candidate needs one
 /// core for its evaluation, and the exact plan's peak memory (192 MB of
 /// per-series values) is the smallest, while the KLL's 1M states, each
 /// grown for its 20 samples, take 1 GB at once. Cost model 3 (own cluster,
 /// lowest latency) picks B1 when its 6.1 GB fit, since merging maintained
-/// panes takes 7 ms against 126 ms for rebuilding; in 4 GB, B1 is invalid
+/// tumbling windows takes 7 ms against 126 ms for rebuilding; in 4 GB, B1 is invalid
 /// and the KLL is fastest.
 #[test]
 fn stage3_plan_selection_b_cost_models_choose_differently() {
diff --git a/crates/integration-tests/tests/range_evaluation.rs b/crates/integration-tests/tests/range_evaluation.rs
index f4f00b6b8..2f97eeb72 100644
--- a/crates/integration-tests/tests/range_evaluation.rs
+++ b/crates/integration-tests/tests/range_evaluation.rs
@@ -1,8 +1,8 @@
 //! #757: a query answered as a range request (`RangeEvaluation`), e.g. a
 //! dashboard panel that evaluates the last hour at 1-minute steps on every
-//! refresh. Stage 1 and Stage 2 keep pane widths on the step grid, and
+//! refresh. Stage 1 and Stage 2 keep tumbling-window widths on the step grid, and
 //! Stage 3 prices `span_ms / step_ms + 1` evaluations per request, credits
-//! the panes kept across steps and requests, and retains kept panes for
+//! the tumbling windows kept across steps and requests, and retains kept tumbling windows for
 //! the span plus the window.
 
 use crate::planner_layering_common;
@@ -27,14 +27,14 @@ const LAST_HOUR_BY_MINUTE: RangeEvaluation = RangeEvaluation {
 };
 
 /// Price explicitly named computations under the same models as production.
-/// This fixture controls its pane width; a timed MILP archive is not a catalog
+/// This fixture controls its tumbling-window width; a timed MILP archive is not a catalog
 /// of every legal materialization or a stable source of P1/P2 identifiers.
 fn run_explicit_for(workload: &PlanningWorkload, deployment: &DeploymentCapabilities) -> Run {
     use asap_logical_asap_optimization::test_support::{
         compose_logical_candidate, generate_per_computation_candidates,
     };
     use asap_logical_asap_optimization::test_support::{
-        pane_candidates, window_composition_pass2_candidates,
+        tumbling_window_candidates, window_composition_pass2_candidates,
     };
     use asap_types::ir::schema::SketchAlgorithm;
     use asap_types::stages::HowToComputeAggregateMeasure;
@@ -64,10 +64,14 @@ fn run_explicit_for(workload: &PlanningWorkload, deployment: &DeploymentCapabili
         .entries()
         .map(|entry| entry.evaluation_grid_ms())
         .collect::<Vec<_>>();
-    let panes = pane_candidates(build, &grids);
-    assert_eq!(panes.len(), 1, "one explicit pane computation");
+    let tumbling_windows = tumbling_window_candidates(build, &grids);
+    assert_eq!(
+        tumbling_windows.len(),
+        1,
+        "one explicit tumbling window computation"
+    );
     candidates.push(
-        window_composition_pass2_candidates(build, &panes)
+        window_composition_pass2_candidates(build, &tumbling_windows)
             .unwrap()
             .remove(0)
             .roots
@@ -151,8 +155,8 @@ fn close(actual: f64, expected: f64) -> bool {
     (actual - expected).abs() <= 1e-6 * expected.abs().max(1.0)
 }
 
-/// Each physical candidate's pane chains: (pane width, materialization).
-fn pane_chains(run: &Run) -> Vec<(String, u64, Materialization)> {
+/// Each physical candidate's tumbling-window chains: (tumbling-window width, materialization).
+fn tumbling_window_chains(run: &Run) -> Vec<(String, u64, Materialization)> {
     run.physical
         .iter()
         .flat_map(|p| {
@@ -167,9 +171,9 @@ fn pane_chains(run: &Run) -> Vec<(String, u64, Materialization)> {
         .collect()
 }
 
-/// The candidate whose single pane chain is materialized as `wanted`.
+/// The candidate whose single tumbling-window chain is materialized as `wanted`.
 fn with_chain(run: &Run, wanted: Materialization) -> String {
-    pane_chains(run)
+    tumbling_window_chains(run)
         .into_iter()
         .find(|(_, _, m)| *m == wanted)
         .unwrap_or_else(|| panic!("no candidate with a {wanted:?} chain"))
@@ -179,11 +183,11 @@ fn with_chain(run: &Run, wanted: Materialization) -> String {
 /// (a) The issue's acceptance example: Pattern B as a dashboard over the
 /// last hour at 1-minute steps prices 61 evaluations per request. Every
 /// query-time computation runs at every step, so the whole-window KLL
-/// (2.3625 → 144.1125 cost/s), the panes rebuilt per step (3.6112 →
+/// (2.3625 → 144.1125 cost/s), the tumbling windows rebuilt per step (3.6112 →
 /// 220.2852) and the exact plan (2.4576 → 149.9136) cost 61 times as much,
-/// the memory each step holds while it runs included. The kept panes (B3)
-/// are built once per request (one new 1-min pane) but merged at every
-/// step, and keep 64 older panes instead of 4 (1 h + 5 min of panes):
+/// the memory each step holds while it runs included. The kept tumbling windows (B3)
+/// are built once per request (one new 1-min tumbling window) but merged at every
+/// step, and keep 64 older tumbling windows instead of 4 (1 h + 5 min of tumbling windows):
 /// 436.59 → 6,987.05. B1 keeps 66 instead of 6: 654.54 → 7,202.31. The
 /// whole-window KLL is still selected.
 #[test]
@@ -206,7 +210,7 @@ fn stage3_plan_selection_prices_61_evaluations_per_dashboard_request() {
     for id in ["P1", "P2", "P3"] {
         assert!(close(cost(&range, id), 61.0 * cost(&none, id)), "{id}");
     }
-    // B3: 4 → 64 panes kept between requests; B1: 6 → 66 panes kept.
+    // B3: 4 → 64 tumbling windows kept between requests; B1: 6 → 66 tumbling windows kept.
     let keeps = |run: &Run, id: &str, bytes: &str| {
         assert!(
             run.selection.costs[id]
@@ -224,36 +228,42 @@ fn stage3_plan_selection_prices_61_evaluations_per_dashboard_request() {
 }
 
 /// (b) For this explicit fixture, refreshing every minute at 30-second steps
-/// supplies panes of
+/// supplies tumbling windows of
 /// `gcd(5 min, 1 min, 30 s) = 30 s`, on the step grid, and Stage 2 keeps
-/// them; without the range, the fixture uses 1 min panes. Both configurations
+/// them; without the range, the fixture uses 1 min tumbling windows. Both configurations
 /// must divide the evaluation step; production also offers finer legal widths.
 #[test]
-fn explicit_pane_candidates_follow_the_evaluation_step_grid() {
+fn explicit_tumbling_window_candidates_follow_the_evaluation_step_grid() {
     let step_30s = RangeEvaluation {
         step_ms: 30_000,
         span_ms: 3_600_000,
     };
     let range = run_explicit(&exact_panel("max_over_time(m[5m])", 60_000, Some(step_30s)));
-    let widths: Vec<u64> = pane_chains(&range).into_iter().map(|(_, w, _)| w).collect();
-    assert!(!widths.is_empty(), "panes are offered");
+    let widths: Vec<u64> = tumbling_window_chains(&range)
+        .into_iter()
+        .map(|(_, w, _)| w)
+        .collect();
+    assert!(!widths.is_empty(), "tumbling windows are offered");
     assert!(widths.iter().all(|&w| w == 30_000), "{widths:?}");
     assert!(range.pruned.is_empty(), "{:?}", range.pruned);
 
     let none = run_explicit(&exact_panel("max_over_time(m[5m])", 60_000, None));
-    let widths: Vec<u64> = pane_chains(&none).into_iter().map(|(_, w, _)| w).collect();
+    let widths: Vec<u64> = tumbling_window_chains(&none)
+        .into_iter()
+        .map(|(_, w, _)| w)
+        .collect();
     assert!(
         !widths.is_empty() && widths.iter().all(|&w| w == 60_000),
         "{widths:?}"
     );
 }
 
-/// (c) A plan that keeps panes reports how long the runtime must keep
+/// (c) A plan that keeps tumbling windows reports how long the runtime must keep
 /// them: the window plus the range-evaluation span, 5 min + 1 h =
-/// 3,900,000 ms, so the next refresh's earliest step finds its panes.
+/// 3,900,000 ms, so the next refresh's earliest step finds its tumbling windows.
 /// Without the range it is the window, 300,000 ms.
 #[test]
-fn stage3_plan_selection_reports_the_retention_of_kept_panes() {
+fn stage3_plan_selection_reports_the_retention_of_kept_tumbling_windows() {
     let deployment = keeping_query_time_results();
     let query = "max_over_time(m[5m])";
     let range = run_explicit_for(
@@ -294,7 +304,7 @@ fn stage3_plan_selection_reports_the_retention_of_kept_panes() {
 }
 
 /// (d) Without a range evaluation nothing changes: Pattern B's pinned
-/// costs (#509 Example 3 and 4: whole-window KLL 2.3625, panes 3.6112, B3
+/// costs (#509 Example 3 and 4: whole-window KLL 2.3625, tumbling windows 3.6112, B3
 /// 436.59, B1 5.232 GB kept) are as before, and a range of one step per
 /// request (`span_ms: 0`) prices exactly as no range.
 #[test]
@@ -322,14 +332,14 @@ fn no_range_evaluation_leaves_every_price_unchanged() {
 /// The example where declaring the range makes Stage 3 prefer sharing:
 /// `max_over_time(m[5m])` every minute over 1M series. As one evaluation
 /// per minute, rebuilding the window (P1, 20.8281 cost/s) beats the kept
-/// panes (P2-m2, 32.2630: 224 MB of 56-byte per-series maxima kept) and the
-/// panes maintained at ingestion (P2-m1, 46.2340). As a dashboard over the
+/// tumbling windows (P2-m2, 32.2630: 224 MB of 56-byte per-series maxima kept) and the
+/// tumbling windows maintained at ingestion (P2-m1, 46.2340). As a dashboard over the
 /// last hour at 1-minute steps, rebuilding costs 61 times as much
-/// (1,270.5151), while the kept panes add only the per-step merges and 1 h
-/// of panes (460.0410), and B1 472.2760: the kept panes are selected, and without
-/// query-time retention, the ingestion-time panes.
+/// (1,270.5151), while the kept tumbling windows add only the per-step merges and 1 h
+/// of tumbling windows (460.0410), and B1 472.2760: the kept tumbling windows are selected, and without
+/// query-time retention, the ingestion-time tumbling windows.
 #[test]
-fn stage3_plan_selection_prefers_kept_panes_once_the_range_is_declared() {
+fn stage3_plan_selection_prefers_kept_tumbling_windows_once_the_range_is_declared() {
     let query = "max_over_time(m[5m])";
     let deployment = keeping_query_time_results();
     let none = run_explicit_for(&exact_panel(query, 60_000, None), &deployment);
@@ -372,9 +382,9 @@ fn stage3_plan_selection_prefers_kept_panes_once_the_range_is_declared() {
 
 /// (e) A chain over an offset input reaches back its offset further: with
 /// no raw data kept, `max_over_time(m[60m] offset 10m)` every 10 minutes
-/// keeps six 10-minute panes ending 10 minutes before each evaluation, so
-/// its panes must be kept for 10 min + 60 min = 4,200,000 ms, and the kept
-/// memory Stage 3 prices covers that seventh pane; without the offset the
+/// keeps six 10-minute tumbling windows ending 10 minutes before each evaluation, so
+/// its tumbling windows must be kept for 10 min + 60 min = 4,200,000 ms, and the kept
+/// memory Stage 3 prices covers that seventh tumbling window; without the offset the
 /// retention is the window, 3,600,000 ms.
 #[test]
 fn an_offset_chain_is_retained_and_priced_for_its_offset() {
diff --git a/crates/integration-tests/tests/reuse_rules.rs b/crates/integration-tests/tests/reuse_rules.rs
index 5c37b436b..e4078f997 100644
--- a/crates/integration-tests/tests/reuse_rules.rs
+++ b/crates/integration-tests/tests/reuse_rules.rs
@@ -109,7 +109,7 @@ fn samples() -> Vec<(&'static str, &'static str, i64, f64)> {
 }
 
 /// Execute `root` at query time over the `samples` bound as raw data at its
-/// `Scan`; each `TimeRange` keeps its own window (a tumbling pane's moved
+/// `Scan`; each `TimeRange` keeps its own window (a tumbling window's moved
 /// back by the `TimeShift` below it).
 fn execute(root: &Rc<OperatorNode>) -> Vec<String> {
     let timed = apply_materialization_timings(
@@ -118,8 +118,10 @@ fn execute(root: &Rc<OperatorNode>) -> Vec<String> {
         &mut NodeToTimedNodeCache::new(),
     )
     .unwrap();
-    // Tumbling panes run as their panes, each over its own window.
-    let timed = asap_types::ir::operator::pane_chain::expand_pane_chains(&timed).unwrap();
+    // Tumbling windows run as their tumbling windows, each over its own window.
+    let timed =
+        asap_types::ir::operator::tumbling_window_chain::expand_tumbling_window_chains(&timed)
+            .unwrap();
     let dag = compile_physical_asap_dag(&timed).unwrap();
     let store = physical_common::raw_data_store(&dag, |_, schema| {
         samples()
@@ -272,7 +274,7 @@ fn own_candidates<'a>(
 /// same per-job sums.
 #[test]
 fn nested_sum_merge_is_selected_and_answers_as_the_nested_sums() {
-    // Evaluated once, so no tumbling-pane candidates.
+    // Evaluated once, so no tumbling-window candidates.
     let query = "sum by (job) (sum_over_time(m[5m]))";
     let memo = memo(&exact_queries(&[query]), QueryRecurrence::Unknown);
     let variants: Vec<_> = choices(&memo, &[OriginOfCandidateForMemoGroup::Pass1])
diff --git a/crates/integration-tests/tests/runtime_handoff.rs b/crates/integration-tests/tests/runtime_handoff.rs
index 53e645416..42b8434fe 100644
--- a/crates/integration-tests/tests/runtime_handoff.rs
+++ b/crates/integration-tests/tests/runtime_handoff.rs
@@ -69,7 +69,7 @@ fn materialized_count(dag: &PhysicalASAPDAG) -> usize {
         .count()
 }
 
-/// Without raw data Stage 3 selects ingestion-time panes; the facade's
+/// Without raw data Stage 3 selects ingestion-time tumbling windows; the facade's
 /// export carries that selection rather than resetting every node to
 /// query time.
 #[tokio::test]
@@ -79,7 +79,7 @@ async fn export_carries_the_selected_materialization() {
     let dag = output.physical_asap_dag().expect("exports");
     assert!(
         materialized_count(&dag) > 0,
-        "the selected panes are stored"
+        "the selected tumbling windows are stored"
     );
     assert!(dag
         .nodes
@@ -109,7 +109,7 @@ async fn installable(workload: &PlanningWorkload) -> InstallablePlan {
     installable_with_report(workload).await.0
 }
 
-fn pane_chain_count(dag: &PhysicalASAPDAG) -> usize {
+fn tumbling_window_chain_count(dag: &PhysicalASAPDAG) -> usize {
     dag.nodes
         .iter()
         .filter(|n| {
@@ -121,19 +121,19 @@ fn pane_chain_count(dag: &PhysicalASAPDAG) -> usize {
         .count()
 }
 
-/// The installable plan expands its selected pane width into contiguous
-/// panes, each a materialized view refreshed at ingestion time, and
+/// The installable plan expands its selected tumbling-window width into contiguous
+/// tumbling windows, each a materialized view refreshed at ingestion time, and
 /// the executor compiles it. The stage export keeps the chain for costing
 /// and display. Its one query is answered by the DAG's one root.
 #[tokio::test]
-async fn installable_plan_has_its_pane_chains_expanded() {
+async fn installable_plan_has_its_tumbling_window_chains_expanded() {
     let workload = example4b();
     let (installed, report) = installable_with_report(&workload).await;
     installed.validate().unwrap();
     let plan = &installed;
     let dag = &installed.dag;
     let views = plan.materialized_views().unwrap();
-    assert_eq!(pane_chain_count(dag), 0);
+    assert_eq!(tumbling_window_chain_count(dag), 0);
     assert_eq!(materialized_count(dag), views.len());
     let roots: Vec<u64> = dag.roots.iter().map(|&r| r as u64).collect();
     let compiled = compile(dag, &views, &roots).expect("the executor compiles it");
@@ -146,7 +146,7 @@ async fn installable_plan_has_its_pane_chains_expanded() {
     let refreshed: BTreeSet<u64> = views.iter().map(|v| v.node_id as u64).collect();
     let slots: BTreeSet<u64> = compiled.input_slots().map(|(id, _)| id).collect();
     assert_eq!(slots, refreshed);
-    assert_pane_coverage(plan, dag.roots[0], 0, 3_600_000);
+    assert_tumbling_window_coverage(plan, dag.roots[0], 0, 3_600_000);
     assert!(
         plan.raw_data_retention().unwrap().is_empty(),
         "no raw data kept"
@@ -156,7 +156,7 @@ async fn installable_plan_has_its_pane_chains_expanded() {
 
     let staged = plan_for_stages(&workload).await;
     assert_eq!(
-        pane_chain_count(&staged),
+        tumbling_window_chain_count(&staged),
         1,
         "the stage export keeps the chain"
     );
@@ -235,10 +235,10 @@ fn repeating(queries: &[&str]) -> PlanningWorkload {
     .unwrap()
 }
 
-/// p99 and p50 over the same 60 minutes share one chain of panes: the
-/// installable plan materializes one shared set of panes.
+/// p99 and p50 over the same 60 minutes share one chain of tumbling windows: the
+/// installable plan materializes one shared set of tumbling windows.
 #[tokio::test]
-async fn two_queries_on_one_chain_store_its_panes_once() {
+async fn two_queries_on_one_chain_store_its_tumbling_windows_once() {
     let plan = installable(&repeating(&[
         "quantile_over_time(0.99, latency_ms[60m])",
         "quantile_over_time(0.5, latency_ms[60m])",
@@ -259,7 +259,7 @@ async fn two_queries_on_one_chain_store_its_panes_once() {
         views_below(plan.dag.roots[1])
     );
     assert_eq!(views_below(plan.dag.roots[0]).len(), views.len());
-    assert_pane_coverage(&plan, plan.dag.roots[0], 0, 3_600_000);
+    assert_tumbling_window_coverage(&plan, plan.dag.roots[0], 0, 3_600_000);
 }
 
 /// Planned with raw data kept (everything at query time), so each query's
@@ -324,11 +324,11 @@ async fn raw_data_windows_of_unsupported_shapes_are_refused() {
 }
 
 /// Example 4b answered as the last hour at 10-minute steps (a range
-/// evaluation): each selected pane view is kept for the hour its window reads
+/// evaluation): each selected tumbling window view is kept for the hour its window reads
 /// plus the hour the range spans, 7,200,000 ms, as Stage 3 records for the
 /// chain (`Selection::tumbling_window_retention_ms`); without the range, for the hour.
 #[tokio::test]
-async fn stored_panes_carry_stage3_pane_retention() {
+async fn stored_tumbling_windows_carry_stage3_tumbling_window_retention() {
     let mut workload = example4b();
     let plain = installable(&workload).await;
     assert!(plain
@@ -341,7 +341,7 @@ async fn stored_panes_carry_stage3_pane_retention() {
         serde_json::json!({"step_ms": 600000, "span_ms": 3600000});
     workload = serde_json::from_value(json).unwrap();
     let ranged = installable(&workload).await;
-    assert_pane_coverage(&ranged, ranged.dag.roots[0], 0, 3_600_000);
+    assert_tumbling_window_coverage(&ranged, ranged.dag.roots[0], 0, 3_600_000);
     assert!(ranged
         .materialized_views()
         .unwrap()
@@ -356,7 +356,7 @@ async fn stored_panes_carry_stage3_pane_retention() {
             .collect::<Vec<_>>(),
         [7_200_000]
     );
-    // A plan file that keeps a pane for less than it reads is refused.
+    // A plan file that keeps a tumbling window for less than it reads is refused.
     let mut short = ranged.clone();
     let view = ranged.materialized_views().unwrap()[0].node_id;
     short
@@ -374,20 +374,20 @@ async fn stored_panes_carry_stage3_pane_retention() {
     ));
 }
 
-/// A chain over an offset input keeps its panes for its window plus the
+/// A chain over an offset input keeps its tumbling windows for its window plus the
 /// offset: `[60m] offset 10m` reaches 70 minutes back (4,200,000 ms), the
 /// unshifted query's chain 60 minutes (3,600,000 ms). Each materialized view
 /// carries its own node's requirement; a runtime that keeps the twins'
-/// identical panes once keeps them for the larger one.
+/// identical tumbling windows once keeps them for the larger one.
 #[tokio::test]
-async fn an_offset_chain_keeps_its_panes_for_its_window_plus_the_offset() {
+async fn an_offset_chain_keeps_its_tumbling_windows_for_its_window_plus_the_offset() {
     let plan = installable(&repeating(&[
         "quantile_over_time(0.99, latency_ms[60m])",
         "quantile_over_time(0.99, latency_ms[60m] offset 10m)",
     ]))
     .await;
-    assert_pane_coverage(&plan, plan.dag.roots[0], 0, 3_600_000);
-    assert_pane_coverage(&plan, plan.dag.roots[1], 600_000, 4_200_000);
+    assert_tumbling_window_coverage(&plan, plan.dag.roots[0], 0, 3_600_000);
+    assert_tumbling_window_coverage(&plan, plan.dag.roots[1], 600_000, 4_200_000);
     let below: Vec<_> = plan
         .dag
         .roots
@@ -401,14 +401,19 @@ async fn an_offset_chain_keeps_its_panes_for_its_window_plus_the_offset() {
             .filter(|(_, nodes)| nodes.contains(&view.node_id))
             .map(|(retention, _)| retention)
             .max()
-            .expect("materialized pane is consumed");
+            .expect("materialized tumbling window is consumed");
         assert_eq!(view.retention_ms(), required);
     }
     plan.validate().unwrap();
 }
 
-/// Any selected legal pane width must cover the requested interval exactly.
-fn assert_pane_coverage(plan: &InstallablePlan, root: PhysicalASAPNodeId, start: i64, end: i64) {
+/// Any selected legal tumbling-window width must cover the requested interval exactly.
+fn assert_tumbling_window_coverage(
+    plan: &InstallablePlan,
+    root: PhysicalASAPNodeId,
+    start: i64,
+    end: i64,
+) {
     let below = nodes_below(&plan.dag, root);
     let mut intervals: Vec<_> = plan
         .materialized_views()
@@ -417,7 +422,7 @@ fn assert_pane_coverage(plan: &InstallablePlan, root: PhysicalASAPNodeId, start:
         .filter(|view| below.contains(&view.node_id))
         .map(|view| {
             let [window] = view.inputs.raw_data_windows() else {
-                panic!("pane reads one raw interval: {:?}", view.inputs);
+                panic!("tumbling window reads one raw interval: {:?}", view.inputs);
             };
             assert!(window.width_ms() > 0 && 600_000 % window.width_ms() == 0);
             (
diff --git a/crates/integration-tests/tests/sharing_issue_regressions.rs b/crates/integration-tests/tests/sharing_issue_regressions.rs
index f2c56e230..d75b91580 100644
--- a/crates/integration-tests/tests/sharing_issue_regressions.rs
+++ b/crates/integration-tests/tests/sharing_issue_regressions.rs
@@ -81,10 +81,10 @@ fn exact_coarse_sum_reuses_fine_sum() {
     );
 }
 
-/// #924: the 1m sum reads the newest pane of the existing 2m chain.
+/// #924: the 1m sum reads the newest tumbling window of the existing 2m chain.
 #[test]
 #[ignore = "flaky: depends on wall-clock search budgets (#1067)"]
-fn nested_exact_sum_reuses_newest_panes() {
+fn nested_exact_sum_reuses_newest_tumbling_windows() {
     let related = workload(924);
     let mut base = related.clone();
     base.queries.truncate(1);
@@ -207,7 +207,7 @@ fn sql_count_topk_has_a_fused_raw_row_heap() {
 fn exact_rollup_catalog_crosses_identical_per_series_average() {
     use asap_logical_asap_optimization::{
         test_support::{generate_per_computation_candidates, try_populate_pass1},
-        PaneWidthDomain,
+        TumblingWindowWidthDomain,
     };
     use asap_types::stages::OriginOfCandidateForMemoGroup;
     let roots: Vec<_> = Planner::new(FuzzSettings::default())
@@ -224,7 +224,7 @@ fn exact_rollup_catalog_crosses_identical_per_series_average() {
     let expanded =
         asap_logical_asap_optimization::test_support::sharing_rules_and_shared_state_groups(
             memo,
-            PaneWidthDomain::SeedGrids,
+            TumblingWindowWidthDomain::SeedGrids,
         )
         .unwrap();
     let owner = expanded.query_roots[1].as_operator().unwrap().0 as usize;
@@ -245,7 +245,7 @@ fn filtered_group_preserves_sql_empty_and_null_semantics() {
     use asap_executor::values::Value;
     use asap_logical_asap_optimization::{
         test_support::{generate_per_computation_candidates, try_populate_pass1},
-        PaneWidthDomain,
+        TumblingWindowWidthDomain,
     };
     use asap_types::ir::{operator::AggIntent, NonASAPOp};
     use asap_types::stages::OriginOfCandidateForMemoGroup;
@@ -263,7 +263,7 @@ fn filtered_group_preserves_sql_empty_and_null_semantics() {
     let expanded =
         asap_logical_asap_optimization::test_support::sharing_rules_and_shared_state_groups(
             memo,
-            PaneWidthDomain::SeedGrids,
+            TumblingWindowWidthDomain::SeedGrids,
         )
         .unwrap();
     let (owner, candidate) = expanded.candidates.iter().enumerate().flat_map(|(owner, candidates)| candidates.iter().map(move |c| (owner,c)))
@@ -403,7 +403,7 @@ fn sql_count_rollup_executes_with_integer_results() {
     use asap_executor::values::Value;
     use asap_logical_asap_optimization::{
         test_support::{generate_per_computation_candidates, try_populate_pass1},
-        PaneWidthDomain,
+        TumblingWindowWidthDomain,
     };
     use asap_types::ir::ASAPOp;
     use asap_types::stages::OriginOfCandidateForMemoGroup;
@@ -430,7 +430,7 @@ fn sql_count_rollup_executes_with_integer_results() {
         let expanded =
             asap_logical_asap_optimization::test_support::sharing_rules_and_shared_state_groups(
                 memo,
-                PaneWidthDomain::SeedGrids,
+                TumblingWindowWidthDomain::SeedGrids,
             )
             .unwrap();
         let (owner, candidate) = expanded
@@ -533,7 +533,7 @@ fn sql_sum_shares_nested_windows_and_slower_readers() {
 fn sketch_rollup_crosses_inner_range_function() {
     use asap_logical_asap_optimization::{
         test_support::{generate_per_computation_candidates, try_populate_pass1},
-        PaneWidthDomain,
+        TumblingWindowWidthDomain,
     };
     use asap_types::stages::OriginOfCandidateForMemoGroup;
     let mut w = workload(923);
@@ -556,7 +556,7 @@ fn sketch_rollup_crosses_inner_range_function() {
     let expanded =
         asap_logical_asap_optimization::test_support::sharing_rules_and_shared_state_groups(
             memo,
-            PaneWidthDomain::SeedGrids,
+            TumblingWindowWidthDomain::SeedGrids,
         )
         .unwrap();
     let owner = expanded.query_roots[1].as_operator().unwrap().0 as usize;
diff --git a/crates/integration-tests/tests/sql_trailing_window.rs b/crates/integration-tests/tests/sql_trailing_window.rs
index 6b4dd004e..81a229329 100644
--- a/crates/integration-tests/tests/sql_trailing_window.rs
+++ b/crates/integration-tests/tests/sql_trailing_window.rs
@@ -1,6 +1,6 @@
 //! A SQL trailing window, `WHERE ts >= now() - INTERVAL 'w'` on the table's
 //! time index, plans like a PromQL range selector `m[w]`: Pass 2 builds its
-//! summaries in tumbling panes, Stage 2 maintains them at ingestion time,
+//! summaries in tumbling windows, Stage 2 maintains them at ingestion time,
 //! a deployment that keeps no raw data still gets a plan, and Stage 3 prices
 //! each scan by its window.
 
@@ -105,7 +105,7 @@ async fn run(deployment: &DeploymentCapabilities) -> Run {
         compose_logical_candidate, generate_per_computation_candidates,
     };
     use asap_logical_asap_optimization::test_support::{
-        pane_candidates, window_composition_pass2_candidates,
+        tumbling_window_candidates, window_composition_pass2_candidates,
     };
     use asap_types::stages::HowToComputeAggregateMeasure;
     let local = generate_per_computation_candidates(
@@ -138,14 +138,16 @@ async fn run(deployment: &DeploymentCapabilities) -> Run {
         .entries()
         .map(|entry| entry.evaluation_grid_ms())
         .collect::<Vec<_>>();
-    let panes = pane_candidates(&summary, &grids);
-    assert_eq!(panes.len(), WINDOWS_MS.len());
+    let tumbling_windows = tumbling_window_candidates(&summary, &grids);
+    assert_eq!(tumbling_windows.len(), WINDOWS_MS.len());
     let mut candidates = vec![exact, summary.clone()];
     candidates.extend(
-        window_composition_pass2_candidates(&summary, &panes)
+        window_composition_pass2_candidates(&summary, &tumbling_windows)
             .unwrap()
             .into_iter()
-            .filter(|candidate| candidate.pane_candidates.len() == panes.len())
+            .filter(|candidate| {
+                candidate.tumbling_window_candidates.len() == tumbling_windows.len()
+            })
             .map(|candidate| candidate.roots.unwrap()),
     );
     let settings = CostInputs::default();
@@ -159,10 +161,10 @@ async fn run(deployment: &DeploymentCapabilities) -> Run {
     )
 }
 
-/// Pass 2 offers each query's distinct-count sketch in tumbling panes, and
-/// Stage 2 maintains a pane chain at ingestion time, as for `m[5m]`.
+/// Pass 2 offers each query's distinct-count sketch in tumbling windows, and
+/// Stage 2 maintains a tumbling-window chain at ingestion time, as for `m[5m]`.
 #[tokio::test]
-async fn sql_windows_get_tumbling_panes_and_ingestion_time_builds() {
+async fn sql_windows_get_tumbling_windows_and_ingestion_time_builds() {
     let run = run(&DeploymentCapabilities::default()).await;
     for (query, window_ms) in WINDOWS_MS.iter().enumerate() {
         let tumbling = run.logical.iter().any(|c| {
@@ -173,7 +175,7 @@ async fn sql_windows_get_tumbling_panes_and_ingestion_time_builds() {
         });
         assert!(
             tumbling,
-            "query {query} ({window_ms} ms) has no pane candidate"
+            "query {query} ({window_ms} ms) has no tumbling-window candidate"
         );
     }
     let at_ingestion = run.physical.iter().any(|p| {
@@ -184,7 +186,10 @@ async fn sql_windows_get_tumbling_panes_and_ingestion_time_builds() {
             ) && runs_at_ingestion(p, n.id)
         })
     });
-    assert!(at_ingestion, "no pane chain maintained at ingestion time");
+    assert!(
+        at_ingestion,
+        "no tumbling-window chain maintained at ingestion time"
+    );
 }
 
 /// Without raw data at query time, the ingestion-time builds still answer
diff --git a/crates/integration-tests/tests/sql_two_percentiles.rs b/crates/integration-tests/tests/sql_two_percentiles.rs
index beffb6e34..b868d1ed0 100644
--- a/crates/integration-tests/tests/sql_two_percentiles.rs
+++ b/crates/integration-tests/tests/sql_two_percentiles.rs
@@ -4,7 +4,7 @@
 //! compiles, is priced, and answers the exact one as `percentile_cont` does
 //! and the sketched one within the sketch's bound. With Q2, the p90 per
 //! city over the last 20 minutes, Q1 and Q2 share the table scan, and Q2's
-//! per-city pane chain serves Q1 through its newest panes rolled up across
+//! per-city tumbling-window chain serves Q1 through its newest tumbling windows rolled up across
 //! cities.
 
 use crate::physical_common;
@@ -165,7 +165,7 @@ fn within_bound(algorithm: Option<&SketchAlgorithm>, q: f64, answer: f64, values
 }
 
 /// `root`'s answer rows at [`EVALUATION_TIME_MS`] over [`rows`], every node at
-/// query time, each pane chain as its panes.
+/// query time, each tumbling-window chain as its tumbling windows.
 fn answers(root: &Rc<OperatorNode>) -> Vec<Vec<Value>> {
     answers_over(root, rows())
 }
@@ -185,8 +185,9 @@ fn answers_over(
             ]
         })
         .collect();
-    // The executor runs a pane chain as its panes.
-    let root = asap_types::ir::operator::pane_chain::expand_pane_chains(root).unwrap();
+    // The executor runs a tumbling-window chain as its tumbling windows.
+    let root = asap_types::ir::operator::tumbling_window_chain::expand_tumbling_window_chains(root)
+        .unwrap();
     physical_common::execute_raw_rows_at(&root, table, EVALUATION_TIME_MS)
 }
 
@@ -298,7 +299,7 @@ async fn stage1(queries: &[&str]) -> Vec<(String, Vec<QueryRoot>)> {
         compose_logical_candidate, generate_per_computation_candidates,
     };
     use asap_logical_asap_optimization::test_support::{
-        pane_candidates, window_composition_pass2_candidates,
+        tumbling_window_candidates, window_composition_pass2_candidates,
     };
     use asap_types::stages::HowToComputeAggregateMeasure;
     let workload = workload(queries);
@@ -361,13 +362,15 @@ async fn stage1(queries: &[&str]) -> Vec<(String, Vec<QueryRoot>)> {
     for choice in choices {
         let roots = share(compose_logical_candidate(&local, &choice).unwrap());
         candidates.push(roots.clone());
-        let panes = pane_candidates(&roots, &grids);
-        if !panes.is_empty() {
+        let tumbling_windows = tumbling_window_candidates(&roots, &grids);
+        if !tumbling_windows.is_empty() {
             candidates.extend(
-                window_composition_pass2_candidates(&roots, &panes)
+                window_composition_pass2_candidates(&roots, &tumbling_windows)
                     .unwrap()
                     .into_iter()
-                    .filter(|candidate| candidate.pane_candidates.len() == panes.len())
+                    .filter(|candidate| {
+                        candidate.tumbling_window_candidates.len() == tumbling_windows.len()
+                    })
                     .filter_map(|candidate| candidate.roots.ok())
                     .map(share),
             );
@@ -402,11 +405,11 @@ async fn q1_and_q2_share_the_table_scan() {
     );
 }
 
-/// Whether Q2's per-city pane chain (120 panes of 10 s) serves both of
-/// Q1's percentiles in `roots`: Q1 merges each city's newest 30 panes (its
+/// Whether Q2's per-city tumbling-window chain (120 tumbling windows of 10 s) serves both of
+/// Q1's percentiles in `roots`: Q1 merges each city's newest 30 tumbling windows (its
 /// 5 minutes), then rolls the cities up into one state, which both of its
 /// estimates read.
-fn newest_panes_rolled_up(roots: &[QueryRoot]) -> bool {
+fn newest_tumbling_windows_rolled_up(roots: &[QueryRoot]) -> bool {
     let (q1, q2) = (operator(&roots[0]), operator(&roots[1]));
     let q2_chains: Vec<*const OperatorNode> = OperatorNode::reachable(q2)
         .iter()
@@ -469,20 +472,21 @@ fn city_values(city: Option<&str>) -> Vec<f64> {
 }
 
 /// Q2's per-city chain serves both of Q1's percentiles through its newest
-/// 30 panes rolled up across cities. Each query's answers are within the
+/// 30 tumbling windows rolled up across cities. Each query's answers are within the
 /// sketch's bound of the exact `percentile_cont`, and over a window with
 /// no row Q1 still answers one NULL row, as the global SQL aggregate the
 /// rollup stands for.
 #[tokio::test]
-async fn q2_pane_chain_serves_q1_through_newest_panes_and_a_rollup() {
+async fn q2_tumbling_window_chain_serves_q1_through_newest_tumbling_windows_and_a_rollup() {
     let candidates = stage1(&[Q1, Q2]).await;
     for algorithm in [SketchAlgorithm::Kll, SketchAlgorithm::DDSketch] {
         let (id, roots) = candidates
             .iter()
             .find(|(_, roots)| {
-                newest_panes_rolled_up(roots) && sketch_of(operator(&roots[0])) == Some(algorithm)
+                newest_tumbling_windows_rolled_up(roots)
+                    && sketch_of(operator(&roots[0])) == Some(algorithm)
             })
-            .unwrap_or_else(|| panic!("no {algorithm:?} newest-panes rollup candidate"));
+            .unwrap_or_else(|| panic!("no {algorithm:?} newest-tumbling-windows rollup candidate"));
         let q1 = answers(operator(&roots[0]));
         let values = values_in(5 * MINUTE_MS, None);
         assert_eq!(q1.len(), 1, "{id}");
diff --git a/crates/integration-tests/tests/tumbling_pane_merge.rs b/crates/integration-tests/tests/tumbling_window_merge.rs
similarity index 73%
rename from crates/integration-tests/tests/tumbling_pane_merge.rs
rename to crates/integration-tests/tests/tumbling_window_merge.rs
index 72cf36487..7f5c7cff2 100644
--- a/crates/integration-tests/tests/tumbling_pane_merge.rs
+++ b/crates/integration-tests/tests/tumbling_window_merge.rs
@@ -1,7 +1,7 @@
-//! Tumbling panes merged by `SummaryMerge` answer the same per-series query
-//! as one build over the whole window (#509 Example 3/4, Pattern B): panes
+//! Tumbling windows merged by `SummaryMerge` answer the same per-series query
+//! as one build over the whole window (#509 Example 3/4, Pattern B): tumbling windows
 //! written by hand, and the planner's window-composition rule's
-//! `SummaryTumblingWindowChain`, expanded into the panes the executor runs.
+//! `SummaryTumblingWindowChain`, expanded into the tumbling windows the executor runs.
 use crate::physical_common;
 
 use std::collections::BTreeMap;
@@ -16,11 +16,11 @@ use asap_executor::values::{Batch, Value};
 use asap_integration_tests::fixtures::lower_promql;
 use asap_integration_tests::planning::{explicit_local_candidates, explicit_summary_candidate};
 use asap_logical_asap_optimization::test_support::{
-    pane_candidates, window_composition_pass2_candidates,
+    tumbling_window_candidates, window_composition_pass2_candidates,
     window_composition_shared_chain_candidates,
 };
 use asap_types::ir::operator::operator_properties::TimeShift;
-use asap_types::ir::operator::pane_chain::expand_pane_chains;
+use asap_types::ir::operator::tumbling_window_chain::expand_tumbling_window_chains;
 use asap_types::ir::physical_export::PhysicalASAPDAG;
 use asap_types::ir::properties::{AccuracyMetric, AccuracyTarget};
 use asap_types::ir::schema::Schema;
@@ -32,10 +32,10 @@ use asap_types::physical::{Materialization, Medium};
 use asap_types::test_support::compile_physical_asap_dag_with_node_ids;
 
 const EVALUATION_MS: i64 = 300_000;
-const PANE_MS: i64 = 60_000;
-const PANES: i64 = 5;
+const TUMBLING_WINDOW_WIDTH_MS: i64 = 60_000;
+const TUMBLING_WINDOW_COUNT: i64 = 5;
 
-/// An explicit supported single-build fixture for the pane merge rules.
+/// An explicit supported single-build fixture for the tumbling-window merge rules.
 fn single_build(query: &str, accuracy: AccuracyTarget) -> Rc<OperatorNode> {
     let root = lower_promql(query, accuracy.clone()).unwrap();
     let root = promql_rows::with_series_identity(&root).unwrap();
@@ -49,7 +49,7 @@ fn single_build(query: &str, accuracy: AccuracyTarget) -> Rc<OperatorNode> {
             })
             .expect("an exact accumulator fixture")
     } else {
-        // Pin DDS so the actual positive-sample interpolation and pane merge
+        // Pin DDS so the actual positive-sample interpolation and tumbling-window merge
         // checks do not depend on the optimizer's preferred implementation.
         explicit_summary_candidate(root, asap_types::ir::schema::SketchAlgorithm::DDSketch)
     }
@@ -63,26 +63,26 @@ fn summary_agg(root: &Rc<OperatorNode>) -> Rc<OperatorNode> {
         .expect("a summary build")
 }
 
-/// Rewrite `root` so its summary is built in tumbling panes: pane `i` is
+/// Rewrite `root` so its summary is built in tumbling windows: tumbling window `i` is
 /// `TimeRange(1m)` over `TimeShift(i·1m)` over the same `Scan`, and a
-/// `SummaryMerge` combines the panes. Returns the root and the panes.
-fn tumbling_panes(root: &Rc<OperatorNode>) -> (Rc<OperatorNode>, Vec<Rc<OperatorNode>>) {
+/// `SummaryMerge` combines the tumbling windows. Returns the root and the tumbling windows.
+fn tumbling_windows(root: &Rc<OperatorNode>) -> (Rc<OperatorNode>, Vec<Rc<OperatorNode>>) {
     let agg = summary_agg(root);
     let Some(NonASAPOp::TimeRange { kind, child, .. }) = agg.children()[0].non_asap() else {
         panic!("expected a raw time range under the summary");
     };
-    let panes: Vec<_> = (0..PANES)
+    let tumbling_windows: Vec<_> = (0..TUMBLING_WINDOW_COUNT)
         .map(|i| {
             let shifted = OperatorNode::new_shared(Operator::NonASAP(NonASAPOp::TimeShift {
                 shift: TimeShift {
-                    offset_ms: i * PANE_MS,
+                    offset_ms: i * TUMBLING_WINDOW_WIDTH_MS,
                     at: None,
                 },
                 child: child.clone(),
             }))
             .unwrap();
             let range = OperatorNode::new_shared(Operator::NonASAP(NonASAPOp::TimeRange {
-                range: std::time::Duration::from_millis(PANE_MS as u64),
+                range: std::time::Duration::from_millis(TUMBLING_WINDOW_WIDTH_MS as u64),
                 kind: *kind,
                 child: shifted,
             }))
@@ -91,23 +91,24 @@ fn tumbling_panes(root: &Rc<OperatorNode>) -> (Rc<OperatorNode>, Vec<Rc<Operator
         })
         .collect();
     let merged = OperatorNode::new_shared(Operator::ASAP(ASAPOp::SummaryMerge {
-        children: panes.clone(),
+        children: tumbling_windows.clone(),
         newest_tumbling_windows: None,
         group_by: None,
     }))
     .unwrap();
     let root = replace(root, &agg, &merged);
     root.validate_structure().unwrap();
-    (root, panes)
+    (root, tumbling_windows)
 }
 
-/// `root` with its summary built in tumbling panes by the planner's
+/// `root` with its summary built in tumbling windows by the planner's
 /// window-composition rule, for a query repeating every minute: the
 /// planned root (a `SummaryMerge` over one `SummaryTumblingWindowChain`) and its expansion
-/// into the panes the executor runs.
-fn planned_panes(root: &Rc<OperatorNode>) -> (Rc<OperatorNode>, Rc<OperatorNode>) {
+/// into the tumbling windows the executor runs.
+fn planned_tumbling_windows(root: &Rc<OperatorNode>) -> (Rc<OperatorNode>, Rc<OperatorNode>) {
     let roots = [QueryRoot::Operator(Rc::clone(root))];
-    let rule_candidates = pane_candidates(&roots, &[Some(PANE_MS as u64)]);
+    let rule_candidates =
+        tumbling_window_candidates(&roots, &[Some(TUMBLING_WINDOW_WIDTH_MS as u64)]);
     let [rule_candidate] = rule_candidates.as_slice() else {
         panic!("one build to split: {rule_candidates:?}")
     };
@@ -116,7 +117,7 @@ fn planned_panes(root: &Rc<OperatorNode>) -> (Rc<OperatorNode>, Rc<OperatorNode>
             rule_candidate.tumbling_window_width_ms,
             rule_candidate.tumbling_window_count
         ),
-        (PANE_MS as u64, 5)
+        (TUMBLING_WINDOW_WIDTH_MS as u64, 5)
     );
     let mut pass2_candidates =
         window_composition_pass2_candidates(&roots, &rule_candidates).unwrap();
@@ -128,9 +129,9 @@ fn planned_panes(root: &Rc<OperatorNode>) -> (Rc<OperatorNode>, Rc<OperatorNode>
     planned.validate_structure().unwrap();
     assert_eq!(
         planned.guarantee, root.guarantee,
-        "merged panes keep the whole build's guarantee"
+        "merged tumbling windows keep the whole build's guarantee"
     );
-    let expanded = expand_pane_chains(&planned).unwrap();
+    let expanded = expand_tumbling_window_chains(&planned).unwrap();
     expanded.validate_structure().unwrap();
     (planned, expanded)
 }
@@ -155,13 +156,13 @@ fn replace(
 type RawDataSample = (&'static str, i64, f64);
 
 /// Two series, four positive samples per minute in [0, 5m), each
-/// `phase_ms` after its 15-s step (0: on the pane boundaries).
+/// `phase_ms` after its 15-s step (0: on the tumbling-window boundaries).
 fn samples(phase_ms: i64) -> Vec<RawDataSample> {
     let mut rows = vec![];
     for (s, series) in ["a", "b"].into_iter().enumerate() {
-        for minute in 0..PANES {
+        for minute in 0..TUMBLING_WINDOW_COUNT {
             for j in 0..4 {
-                let ts = minute * PANE_MS + j * 15_000 + phase_ms;
+                let ts = minute * TUMBLING_WINDOW_WIDTH_MS + j * 15_000 + phase_ms;
                 rows.push((series, ts, (s * 100) as f64 + (minute * 4 + j + 1) as f64));
             }
         }
@@ -171,7 +172,7 @@ fn samples(phase_ms: i64) -> Vec<RawDataSample> {
 
 struct Exported {
     dag: PhysicalASAPDAG,
-    /// Each `SummaryAgg` node with its pane.
+    /// Each `SummaryAgg` node with its tumbling window.
     builds: Vec<(u64, i64)>,
 }
 
@@ -179,9 +180,9 @@ fn export(root: &Rc<OperatorNode>, assignment: &MaterializationAssignment) -> Ex
     let timed =
         apply_materialization_timings(root, assignment, &mut NodeToTimedNodeCache::new()).unwrap();
     let compiled = compile_physical_asap_dag_with_node_ids(&timed).unwrap();
-    let pane = |node: &OperatorNode| -> i64 {
+    let tumbling_window = |node: &OperatorNode| -> i64 {
         match node.children()[0].non_asap() {
-            Some(NonASAPOp::TimeShift { shift, .. }) => shift.offset_ms / PANE_MS,
+            Some(NonASAPOp::TimeShift { shift, .. }) => shift.offset_ms / TUMBLING_WINDOW_WIDTH_MS,
             _ => 0,
         }
     };
@@ -189,7 +190,7 @@ fn export(root: &Rc<OperatorNode>, assignment: &MaterializationAssignment) -> Ex
     for node in &compiled.dag.nodes {
         let logical = compiled.node_ids.operator_node(node.id).unwrap();
         if let Operator::ASAP(ASAPOp::SummaryAgg { child, .. }) = &logical.operator {
-            builds.push((node.id as u64, pane(child)));
+            builds.push((node.id as u64, tumbling_window(child)));
         }
     }
     Exported {
@@ -252,7 +253,7 @@ fn query_scope() -> Scope {
     }
 }
 
-/// Compile `root` with everything at query time (Pattern B2: panes rebuilt
+/// Compile `root` with everything at query time (Pattern B2: tumbling windows rebuilt
 /// from raw rows at query time).
 fn compile_at_query_time(
     root: &Rc<OperatorNode>,
@@ -268,23 +269,26 @@ fn execute(root: &Rc<OperatorNode>, samples: &[RawDataSample]) -> Vec<Vec<Value>
     run(&plan, raw_store(&exported.dag, samples), query_scope())
 }
 
-/// Build the panes in ingestion runs (stored `MatAtIngestion`, each with its
+/// Build the tumbling windows in ingestion runs (stored `MatAtIngestion`, each with its
 /// own build timestamp), then merge them in the query run (Pattern B1).
 fn execute_retained(
     root: &Rc<OperatorNode>,
-    panes: &[Rc<OperatorNode>],
+    tumbling_windows: &[Rc<OperatorNode>],
     samples: &[RawDataSample],
 ) -> Vec<Vec<Value>> {
     let mut assignment = MaterializationAssignment::default();
-    for pane in panes {
-        assignment.set(pane, Materialization::MatAtIngestion(Medium::Memory));
+    for tumbling_window in tumbling_windows {
+        assignment.set(
+            tumbling_window,
+            Materialization::MatAtIngestion(Medium::Memory),
+        );
     }
     execute_retained_as(root, &assignment, samples)
 }
 
-/// The planner's pane chain maintained at ingestion time, as Stage 2's B1
+/// The planner's tumbling-window chain maintained at ingestion time, as Stage 2's B1
 /// option assigns it (`MatAtIngestion` on the chain), then expanded: each
-/// pane carries the chain's timing and materialization, so the panes are
+/// tumbling window carries the chain's timing and materialization, so the tumbling windows are
 /// built in ingestion runs and merged in the query run.
 fn execute_maintained_chain(
     planned: &Rc<OperatorNode>,
@@ -293,19 +297,19 @@ fn execute_maintained_chain(
     let chain = OperatorNode::reachable(planned)
         .into_iter()
         .find(|n| matches!(n.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. })))
-        .expect("a pane chain");
+        .expect("a tumbling-window chain");
     let mut assignment = MaterializationAssignment::default();
     assignment.set(&chain, Materialization::MatAtIngestion(Medium::Memory));
     let timed =
         apply_materialization_timings(planned, &assignment, &mut NodeToTimedNodeCache::new())
             .unwrap();
-    let expanded = expand_pane_chains(&timed).unwrap();
-    for pane in OperatorNode::reachable(&expanded)
+    let expanded = expand_tumbling_window_chains(&timed).unwrap();
+    for tumbling_window in OperatorNode::reachable(&expanded)
         .iter()
         .filter(|n| matches!(n.asap(), Some(ASAPOp::SummaryAgg { .. })))
     {
         assert_eq!(
-            pane.materialization,
+            tumbling_window.materialization,
             Materialization::MatAtIngestion(Medium::Memory)
         );
     }
@@ -320,16 +324,16 @@ fn execute_retained_as(
     let mut exported = export(root, assignment);
     let builds: Vec<u64> = exported.builds.iter().map(|&(build, _)| build).collect();
     let views = views_at(&mut exported.dag, &builds).unwrap();
-    // Each pane's ingestion run refreshes its view from the raw samples.
+    // Each tumbling window's ingestion run refreshes its view from the raw samples.
     let mut store = InMemoryDataStore::default();
-    for &(build, pane) in &exported.builds {
+    for &(build, tumbling_window) in &exported.builds {
         let plan = compile(&exported.dag, &[], &[build]).unwrap();
-        let end = EVALUATION_MS - pane * PANE_MS;
+        let end = EVALUATION_MS - tumbling_window * TUMBLING_WINDOW_WIDTH_MS;
         let rows = run(
             &plan,
             raw_store(&exported.dag, samples),
             Scope::Ingestion {
-                window_start_ms: end - PANE_MS,
+                window_start_ms: end - TUMBLING_WINDOW_WIDTH_MS,
                 window_end_ms: end,
             },
         );
@@ -357,38 +361,42 @@ fn values(rows: &[Vec<Value>]) -> Vec<f64> {
 }
 
 /// Returns the per-series values, which every execution path agrees on.
-fn assert_pane_merge_matches_single_build(
+fn assert_tumbling_window_merge_matches_single_build(
     query: &str,
     accuracy: AccuracyTarget,
     samples: &[RawDataSample],
 ) -> Vec<f64> {
     let single = single_build(query, accuracy);
-    let (panes, pane_builds) = tumbling_panes(&single);
+    let (tumbling_windows, tumbling_window_builds) = tumbling_windows(&single);
     let expected = execute(&single, samples);
     assert_eq!(expected.len(), 2, "{expected:?}");
     assert!(expected.iter().all(|row| has_timestamp(row, EVALUATION_MS)));
     let result = values(&expected);
     let expected = render(&expected);
     assert_eq!(
-        render(&execute(&panes, samples)),
+        render(&execute(&tumbling_windows, samples)),
         expected,
-        "panes rebuilt at query time"
+        "tumbling windows rebuilt at query time"
     );
     assert_eq!(
-        render(&execute_retained(&panes, &pane_builds, samples)),
+        render(&execute_retained(
+            &tumbling_windows,
+            &tumbling_window_builds,
+            samples
+        )),
         expected,
-        "retained panes"
+        "retained tumbling windows"
     );
-    let (planned, expanded) = planned_panes(&single);
+    let (planned, expanded) = planned_tumbling_windows(&single);
     assert_eq!(
         render(&execute(&expanded, samples)),
         expected,
-        "the planner's pane chain, expanded"
+        "the planner's tumbling-window chain, expanded"
     );
     assert_eq!(
         render(&execute_maintained_chain(&planned, samples)),
         expected,
-        "the planner's pane chain, maintained at ingestion time"
+        "the planner's tumbling-window chain, maintained at ingestion time"
     );
     let unexpanded = compile_at_query_time(&planned).err().unwrap_or_default();
     assert!(
@@ -398,11 +406,11 @@ fn assert_pane_merge_matches_single_build(
     result
 }
 
-/// Exact per-series Sum over 5 merged 1-minute panes equals one 5-minute
+/// Exact per-series Sum over 5 merged 1-minute tumbling windows equals one 5-minute
 /// build, timestamped at the evaluation time.
 #[test]
-fn exact_sum_over_tumbling_panes_matches_single_build() {
-    let sums = assert_pane_merge_matches_single_build(
+fn exact_sum_over_tumbling_windows_matches_single_build() {
+    let sums = assert_tumbling_window_merge_matches_single_build(
         "sum_over_time(m[5m])",
         AccuracyTarget::exact(),
         // 1 ms past each step: the window `(0, 5m]` holds all 20 samples.
@@ -411,11 +419,11 @@ fn exact_sum_over_tumbling_panes_matches_single_build() {
     assert_eq!(sums, vec![210., 2210.]);
 }
 
-/// The selected quantile sketch over 5 merged 1-minute panes equals one
+/// The selected quantile sketch over 5 merged 1-minute tumbling windows equals one
 /// 5-minute build, within the target of the exact p99 (20 and 120).
 #[test]
-fn quantile_over_tumbling_panes_matches_single_build() {
-    let p99 = assert_pane_merge_matches_single_build(
+fn quantile_over_tumbling_windows_matches_single_build() {
+    let p99 = assert_tumbling_window_merge_matches_single_build(
         "quantile_over_time(0.99, m[5m])",
         AccuracyTarget::max_error(0.05).accuracy_metric(AccuracyMetric::Relative),
         &samples(0),
@@ -431,13 +439,16 @@ fn quantile_over_tumbling_panes_matches_single_build() {
     }
 }
 
-/// Exact counter Rate over 5 merged 1-minute panes equals one 5-minute
+/// Exact counter Rate over 5 merged 1-minute tumbling windows equals one 5-minute
 /// build: the merged increase is divided by the whole 5-minute window, not
-/// by one pane's minute.
+/// by one tumbling window's minute.
 #[test]
-fn exact_rate_over_tumbling_panes_matches_single_build() {
-    let rates =
-        assert_pane_merge_matches_single_build("rate(m[5m])", AccuracyTarget::exact(), &samples(0));
+fn exact_rate_over_tumbling_windows_matches_single_build() {
+    let rates = assert_tumbling_window_merge_matches_single_build(
+        "rate(m[5m])",
+        AccuracyTarget::exact(),
+        &samples(0),
+    );
     assert_eq!(rates.len(), 2);
     // 19 counted over 285 s of samples, extrapolated to the 5-min window.
     for rate in rates {
@@ -445,12 +456,12 @@ fn exact_rate_over_tumbling_panes_matches_single_build() {
     }
 }
 
-/// With samples off the pane boundaries, Increase extrapolates to the
+/// With samples off the tumbling-window boundaries, Increase extrapolates to the
 /// start of the whole 5-minute window, as one build does, not to the start
-/// of the newest pane.
+/// of the newest tumbling window.
 #[test]
-fn exact_increase_off_the_pane_boundaries_matches_single_build() {
-    let increases = assert_pane_merge_matches_single_build(
+fn exact_increase_off_the_tumbling_window_boundaries_matches_single_build() {
+    let increases = assert_tumbling_window_merge_matches_single_build(
         "increase(m[5m])",
         AccuracyTarget::exact(),
         &samples(7_000),
@@ -482,7 +493,7 @@ fn offset_counter_window_ends_at_the_offset() {
         let plain = whole_build_values_at(&format!("{function}(m[5m])"), EVALUATION_MS, &samples);
         let shifted = whole_build_values_at(
             &format!("{function}(m[5m] offset 1m)"),
-            EVALUATION_MS + PANE_MS,
+            EVALUATION_MS + TUMBLING_WINDOW_WIDTH_MS,
             &samples,
         );
         assert_eq!(shifted, plain, "{function}");
@@ -501,32 +512,32 @@ fn anchored_counter_window_ends_at_the_anchor() {
         let at_300 = whole_build_values_at(&format!("{function}(m[5m])"), EVALUATION_MS, &samples);
         let at_240 = whole_build_values_at(
             &format!("{function}(m[5m])"),
-            EVALUATION_MS - PANE_MS,
+            EVALUATION_MS - TUMBLING_WINDOW_WIDTH_MS,
             &samples,
         );
         assert_ne!(at_300, at_240, "{function}: the two windows differ");
         let anchored = whole_build_values_at(
             &format!("{function}(m[5m] @ 300)"),
-            EVALUATION_MS + PANE_MS,
+            EVALUATION_MS + TUMBLING_WINDOW_WIDTH_MS,
             &samples,
         );
         assert_eq!(anchored, at_300, "{function} @ 300");
         let anchored_offset = whole_build_values_at(
             &format!("{function}(m[5m] @ 300 offset 1m)"),
-            EVALUATION_MS + PANE_MS,
+            EVALUATION_MS + TUMBLING_WINDOW_WIDTH_MS,
             &samples,
         );
         assert_eq!(anchored_offset, at_240, "{function} @ 300 offset 1m");
     }
 }
 
-/// Panes whose ranges read the scan through two stacked `TimeShift`s (the
-/// pane's shift over a zero shift) compile and answer as the single build:
+/// Tumbling windows whose ranges read the scan through two stacked `TimeShift`s (the
+/// tumbling window's shift over a zero shift) compile and answer as the single build:
 /// the per-entity build looks through every shift to its raw source.
 #[test]
-fn panes_over_stacked_time_shifts_match_single_build() {
+fn tumbling_windows_over_stacked_time_shifts_match_single_build() {
     let single = single_build("increase(m[5m])", AccuracyTarget::exact());
-    let (panes, _) = tumbling_panes(&single);
+    let (tumbling_windows, _) = tumbling_windows(&single);
     let agg = summary_agg(&single);
     let Some(NonASAPOp::TimeRange { child: scan, .. }) = agg.children()[0].non_asap() else {
         panic!("expected a raw time range under the summary");
@@ -539,17 +550,17 @@ fn panes_over_stacked_time_shifts_match_single_build() {
         child: scan.clone(),
     }))
     .unwrap();
-    let stacked = replace(&panes, scan, &zero_shift);
+    let stacked = replace(&tumbling_windows, scan, &zero_shift);
     let expected = render(&execute(&single, &samples(0)));
     assert_eq!(expected.len(), 2, "{expected:?}");
     assert_eq!(render(&execute(&stacked, &samples(0))), expected);
 }
 
-/// Exact counter Increase over 5 merged 1-minute panes equals one 5-minute
-/// build: the merge joins consecutive panes across their boundaries.
+/// Exact counter Increase over 5 merged 1-minute tumbling windows equals one 5-minute
+/// build: the merge joins consecutive tumbling windows across their boundaries.
 #[test]
-fn exact_increase_over_tumbling_panes_matches_single_build() {
-    let increases = assert_pane_merge_matches_single_build(
+fn exact_increase_over_tumbling_windows_matches_single_build() {
+    let increases = assert_tumbling_window_merge_matches_single_build(
         "increase(m[5m])",
         AccuracyTarget::exact(),
         &samples(0),
@@ -557,18 +568,18 @@ fn exact_increase_over_tumbling_panes_matches_single_build() {
     assert_eq!(increases.len(), 2);
 }
 
-/// A middle pane with no samples, for one series or for every series: the
-/// merge joins the panes on either side of the empty one, and Increase
+/// A middle tumbling window with no samples, for one series or for every series: the
+/// merge joins the tumbling windows on either side of the empty one, and Increase
 /// matches one 5-minute build.
 #[test]
-fn exact_increase_over_an_empty_middle_pane_matches_single_build() {
-    let middle = 2 * PANE_MS..3 * PANE_MS;
+fn exact_increase_over_an_empty_middle_tumbling_window_matches_single_build() {
+    let middle = 2 * TUMBLING_WINDOW_WIDTH_MS..3 * TUMBLING_WINDOW_WIDTH_MS;
     for emptied in [&["a"][..], &["a", "b"]] {
         let gapped: Vec<RawDataSample> = samples(0)
             .into_iter()
             .filter(|(series, ts, _)| !(emptied.contains(series) && middle.contains(ts)))
             .collect();
-        let increases = assert_pane_merge_matches_single_build(
+        let increases = assert_tumbling_window_merge_matches_single_build(
             "increase(m[5m])",
             AccuracyTarget::exact(),
             &gapped,
@@ -577,12 +588,12 @@ fn exact_increase_over_an_empty_middle_pane_matches_single_build() {
     }
 }
 
-/// A counter over `[5m] offset 1m` split into the planner's panes, read
+/// A counter over `[5m] offset 1m` split into the planner's tumbling windows, read
 /// at query time or maintained at ingestion time, matches one build: the
-/// panes' shifts fold the outer offset, and the merged counter window ends
+/// tumbling windows' shifts fold the outer offset, and the merged counter window ends
 /// at the evaluation time minus the offset.
 #[test]
-fn a_counter_over_panes_with_an_outer_offset_matches_single_build() {
+fn a_counter_over_tumbling_windows_with_an_outer_offset_matches_single_build() {
     let samples = samples(7_000);
     for function in ["rate", "increase"] {
         let single = single_build(
@@ -591,40 +602,43 @@ fn a_counter_over_panes_with_an_outer_offset_matches_single_build() {
         );
         let expected = render(&execute(&single, &samples));
         assert_eq!(expected.len(), 2, "{function}: {expected:?}");
-        let (planned, expanded) = planned_panes(&single);
+        let (planned, expanded) = planned_tumbling_windows(&single);
         assert_eq!(
             render(&execute(&expanded, &samples)),
             expected,
-            "{function}: expanded panes"
+            "{function}: expanded tumbling windows"
         );
         assert_eq!(
             render(&execute_maintained_chain(&planned, &samples)),
             expected,
-            "{function}: panes maintained at ingestion time"
+            "{function}: tumbling windows maintained at ingestion time"
         );
     }
 }
 
-/// `root`'s summary built from panes `(shift, width)` merged by one
+/// `root`'s summary built from tumbling windows `(shift, width)` merged by one
 /// `SummaryMerge`, both in minutes, or the IR's refusal of that merge.
-fn panes_at(root: &Rc<OperatorNode>, panes: &[(i64, i64)]) -> Result<Rc<OperatorNode>, String> {
+fn tumbling_windows_at(
+    root: &Rc<OperatorNode>,
+    tumbling_windows: &[(i64, i64)],
+) -> Result<Rc<OperatorNode>, String> {
     let agg = summary_agg(root);
     let Some(NonASAPOp::TimeRange { kind, child, .. }) = agg.children()[0].non_asap() else {
         panic!("expected a raw time range under the summary");
     };
-    let children = panes
+    let children = tumbling_windows
         .iter()
         .map(|&(shift, width)| {
             let shifted = OperatorNode::new_shared(Operator::NonASAP(NonASAPOp::TimeShift {
                 shift: TimeShift {
-                    offset_ms: shift * PANE_MS,
+                    offset_ms: shift * TUMBLING_WINDOW_WIDTH_MS,
                     at: None,
                 },
                 child: child.clone(),
             }))
             .unwrap();
             let range = OperatorNode::new_shared(Operator::NonASAP(NonASAPOp::TimeRange {
-                range: std::time::Duration::from_millis((width * PANE_MS) as u64),
+                range: std::time::Duration::from_millis((width * TUMBLING_WINDOW_WIDTH_MS) as u64),
                 kind: *kind,
                 child: shifted,
             }))
@@ -641,29 +655,29 @@ fn panes_at(root: &Rc<OperatorNode>, panes: &[(i64, i64)]) -> Result<Rc<Operator
     Ok(replace(root, &agg, &merged))
 }
 
-/// Counter panes form one window only back to back: with a gap between
-/// them, compiling the counter evaluation is an error; overlapping panes
+/// Counter tumbling windows form one window only back to back: with a gap between
+/// them, compiling the counter evaluation is an error; overlapping tumbling windows
 /// are already refused by the `SummaryMerge`, whose counter inputs must be
 /// disjoint in time.
 #[test]
-fn counter_panes_with_a_gap_or_an_overlap_are_rejected() {
+fn counter_tumbling_windows_with_a_gap_or_an_overlap_are_rejected() {
     let single = single_build("rate(m[5m])", AccuracyTarget::exact());
-    let gapped = panes_at(&single, &[(0, 1), (2, 1)]).unwrap();
+    let gapped = tumbling_windows_at(&single, &[(0, 1), (2, 1)]).unwrap();
     let error = compile_at_query_time(&gapped).err().unwrap_or_default();
     assert!(error.contains("ambiguous logical windows"), "{error}");
-    let overlap = panes_at(&single, &[(0, 2), (1, 2)])
+    let overlap = tumbling_windows_at(&single, &[(0, 2), (1, 2)])
         .err()
         .unwrap_or_default();
     assert!(overlap.contains("InputsOverlap"), "{overlap}");
 }
 
-/// A 2-min and a 5-min quantile, both every minute, on 1-min panes: the
-/// window-composition rule offers one 5-pane chain both read, the 2-min
-/// query merging only its newest 2 panes. Expanded, rebuilt at query time
+/// A 2-min and a 5-min quantile, both every minute, on 1-min tumbling windows: the
+/// window-composition rule offers one 5-tumbling-window chain both read, the 2-min
+/// query merging only its newest 2 tumbling windows. Expanded, rebuilt at query time
 /// or maintained at ingestion time, each query's answer from the shared
 /// chain equals its answer from its own chain.
 #[test]
-fn newest_panes_of_a_shared_chain_match_a_separate_chain() {
+fn newest_tumbling_windows_of_a_shared_chain_match_a_separate_chain() {
     let accuracy = AccuracyTarget::max_error(0.05).accuracy_metric(AccuracyMetric::Relative);
     let roots = [
         QueryRoot::Operator(single_build(
@@ -672,15 +686,17 @@ fn newest_panes_of_a_shared_chain_match_a_separate_chain() {
         )),
         QueryRoot::Operator(single_build("quantile_over_time(0.99, m[5m])", accuracy)),
     ];
-    let grid = Some(PANE_MS as u64);
-    let rule_candidates = pane_candidates(&roots, &[grid, grid]);
+    let grid = Some(TUMBLING_WINDOW_WIDTH_MS as u64);
+    let rule_candidates = tumbling_window_candidates(&roots, &[grid, grid]);
     assert_eq!(rule_candidates.len(), 2, "{rule_candidates:?}");
     let pass2_candidates = window_composition_pass2_candidates(&roots, &rule_candidates).unwrap();
     let both = |shared: bool| -> Vec<Rc<OperatorNode>> {
         pass2_candidates
             .iter()
-            .find(|c| c.pane_candidates.len() == 2 && c.shared_chains.is_empty() != shared)
-            .expect("both builds in panes")
+            .find(|c| {
+                c.tumbling_window_candidates.len() == 2 && c.shared_chains.is_empty() != shared
+            })
+            .expect("both builds in tumbling windows")
             .roots
             .as_ref()
             .unwrap()
@@ -704,10 +720,13 @@ fn newest_panes_of_a_shared_chain_match_a_separate_chain() {
     assert_eq!(newest, Some(Some(2)));
     let data = samples(0);
     for (query, (shared, separate)) in shared.iter().zip(&separate).enumerate() {
-        let expected = execute(&expand_pane_chains(separate).unwrap(), &data);
+        let expected = execute(&expand_tumbling_window_chains(separate).unwrap(), &data);
         assert!(!expected.is_empty());
         assert_eq!(
-            render(&execute(&expand_pane_chains(shared).unwrap(), &data)),
+            render(&execute(
+                &expand_tumbling_window_chains(shared).unwrap(),
+                &data
+            )),
             render(&expected),
             "Q{}: the shared chain rebuilt at query time",
             query + 1
@@ -736,13 +755,13 @@ fn execute_ranges_at_their_windows(
     run(&plan, raw_store(&exported.dag, samples), scope)
 }
 
-/// A 5-min quantile every 30 s (10 × 30-s panes) and a 5-min quantile
-/// every minute (5 × 1-min panes): the rule offers one chain of 30-s
-/// panes both read in full, each at its own interval. Expanded, each
+/// A 5-min quantile every 30 s (10 × 30-s tumbling windows) and a 5-min quantile
+/// every minute (5 × 1-min tumbling windows): the rule offers one chain of 30-s
+/// tumbling windows both read in full, each at its own interval. Expanded, each
 /// query's answer from the shared chain equals one build over its window,
 /// at 5 min, and for the 30-s query also at 4.5 min, off the 1-min grid.
 #[test]
-fn queries_at_different_intervals_read_one_chain_of_the_finer_panes() {
+fn queries_at_different_intervals_read_one_chain_of_the_finer_tumbling_windows() {
     let accuracy = AccuracyTarget::max_error(0.05).accuracy_metric(AccuracyMetric::Relative);
     let singles = [
         single_build("quantile_over_time(0.5, m[5m])", accuracy.clone()),
@@ -752,16 +771,19 @@ fn queries_at_different_intervals_read_one_chain_of_the_finer_panes() {
         .iter()
         .map(|root| QueryRoot::Operator(Rc::clone(root)))
         .collect();
-    let rule_candidates = pane_candidates(&roots, &[Some(30_000), Some(PANE_MS as u64)]);
+    let rule_candidates = tumbling_window_candidates(
+        &roots,
+        &[Some(30_000), Some(TUMBLING_WINDOW_WIDTH_MS as u64)],
+    );
     let widths: Vec<u64> = rule_candidates
         .iter()
         .map(|c| c.tumbling_window_width_ms)
         .collect();
-    assert_eq!(widths, [30_000, PANE_MS as u64]);
+    assert_eq!(widths, [30_000, TUMBLING_WINDOW_WIDTH_MS as u64]);
     let shared = window_composition_pass2_candidates(&roots, &rule_candidates)
         .unwrap()
         .into_iter()
-        .find(|c| c.pane_candidates.len() == 2 && !c.shared_chains.is_empty())
+        .find(|c| c.tumbling_window_candidates.len() == 2 && !c.shared_chains.is_empty())
         .expect("one shared chain");
     // The whole set's shared chains, built alone, are the same candidates.
     let alone = window_composition_shared_chain_candidates(&roots, &rule_candidates);
@@ -781,7 +803,7 @@ fn queries_at_different_intervals_read_one_chain_of_the_finer_panes() {
         .unwrap()
         .into_iter()
         .map(|root| match root {
-            QueryRoot::Operator(node) => expand_pane_chains(&node).unwrap(),
+            QueryRoot::Operator(node) => expand_tumbling_window_chains(&node).unwrap(),
             QueryRoot::Scalar(_) => panic!("an operator root"),
         })
         .collect();
@@ -801,13 +823,13 @@ fn queries_at_different_intervals_read_one_chain_of_the_finer_panes() {
     }
 }
 
-/// A 5-min quantile every minute (5 × 1-min panes) and a 3-min one every
-/// 90 s (2 × 90-s panes): neither width divides the other, so the rule
-/// offers one chain at their gcd, 10 × 30-s panes, the 3-min query merging
+/// A 5-min quantile every minute (5 × 1-min tumbling windows) and a 3-min one every
+/// 90 s (2 × 90-s tumbling windows): neither width divides the other, so the rule
+/// offers one chain at their gcd, 10 × 30-s tumbling windows, the 3-min query merging
 /// the newest 6. Expanded, each query's answer from the shared chain equals
 /// one build over its window, at times on each query's own grid.
 #[test]
-fn queries_at_60_and_90_seconds_read_one_chain_of_30_second_panes() {
+fn queries_at_60_and_90_seconds_read_one_chain_of_30_second_tumbling_windows() {
     let accuracy = AccuracyTarget::max_error(0.05).accuracy_metric(AccuracyMetric::Relative);
     let singles = [
         single_build("quantile_over_time(0.5, m[5m])", accuracy.clone()),
@@ -817,16 +839,19 @@ fn queries_at_60_and_90_seconds_read_one_chain_of_30_second_panes() {
         .iter()
         .map(|root| QueryRoot::Operator(Rc::clone(root)))
         .collect();
-    let rule_candidates = pane_candidates(&roots, &[Some(PANE_MS as u64), Some(90_000)]);
+    let rule_candidates = tumbling_window_candidates(
+        &roots,
+        &[Some(TUMBLING_WINDOW_WIDTH_MS as u64), Some(90_000)],
+    );
     let widths: Vec<(u64, u32)> = rule_candidates
         .iter()
         .map(|c| (c.tumbling_window_width_ms, c.tumbling_window_count))
         .collect();
-    assert_eq!(widths, [(PANE_MS as u64, 5), (90_000, 2)]);
+    assert_eq!(widths, [(TUMBLING_WINDOW_WIDTH_MS as u64, 5), (90_000, 2)]);
     let shared = window_composition_pass2_candidates(&roots, &rule_candidates)
         .unwrap()
         .into_iter()
-        .find(|c| c.pane_candidates.len() == 2 && !c.shared_chains.is_empty())
+        .find(|c| c.tumbling_window_candidates.len() == 2 && !c.shared_chains.is_empty())
         .expect("one shared chain at the gcd");
     assert_eq!(
         (
@@ -841,7 +866,7 @@ fn queries_at_60_and_90_seconds_read_one_chain_of_30_second_panes() {
         .unwrap()
         .into_iter()
         .map(|root| match root {
-            QueryRoot::Operator(node) => expand_pane_chains(&node).unwrap(),
+            QueryRoot::Operator(node) => expand_tumbling_window_chains(&node).unwrap(),
             QueryRoot::Scalar(_) => panic!("an operator root"),
         })
         .collect();
diff --git a/crates/logical-asap-optimization/src/deployment_capabilities.rs b/crates/logical-asap-optimization/src/deployment_capabilities.rs
index 220a4e988..945d72cb3 100644
--- a/crates/logical-asap-optimization/src/deployment_capabilities.rs
+++ b/crates/logical-asap-optimization/src/deployment_capabilities.rs
@@ -8,7 +8,7 @@
 //!   its state, and a readout of it when the executor can answer that
 //!   statistic ([`StatisticKind`]) from the state. Stage 1 (Pass 1) offers
 //!   no summary candidate whose family or readout is unsupported, so no
-//!   Pass 2 candidate has one either (Pass 2 rules share, split into panes
+//!   Pass 2 candidate has one either (Pass 2 rules share, split into tumbling windows
 //!   or reuse existing builds; none adds a family or a readout). Exact
 //!   accumulators and plain exact execution are always supported;
 //! * whether raw data samples are retained. If they are, Stage 3 counts them on
@@ -19,9 +19,9 @@
 //!   rows. Stored data (at rest or mixed) with no raw data retained is a
 //!   contradiction, refused as bad input ([`DeploymentCapabilities::validate`]);
 //! * whether query-time results are retained across evaluations. If they
-//!   are, Stage 2 also offers a tumbling-pane chain whose readers evaluate
-//!   together at its pane width as `MatAtQueryKeptAcrossEvaluations`: each
-//!   evaluation builds one new pane and keeps the others for the next ones,
+//!   are, Stage 2 also offers a tumbling-window chain whose readers evaluate
+//!   together at its tumbling-window width as `MatAtQueryKeptAcrossEvaluations`: each
+//!   evaluation builds one new tumbling window and keeps the others for the next ones,
 //!   covering the readers' longest look-back. A chain two or more queries
 //!   read keeps its `MatAtQuery` option too (shared within one evaluation),
 //!   and Stage 3 picks the cheaper. If they are not, a query-time result is
diff --git a/crates/logical-asap-optimization/src/lib.rs b/crates/logical-asap-optimization/src/lib.rs
index 8a4bd9f6c..539f8bc05 100644
--- a/crates/logical-asap-optimization/src/lib.rs
+++ b/crates/logical-asap-optimization/src/lib.rs
@@ -83,13 +83,15 @@ pub use pass1::{
     generate_per_computation_logical_memo_candidates, PerComputationCandidateError,
     PerComputationLogicalMemoCandidatesError,
 };
-// Pass 2: its entry, the state it keeps between pane-width rounds, and the
-// pane-width domain of a round.
+// Pass 2: its entry, the state it keeps between tumbling-window-width rounds, and the
+// tumbling-window-width domain of a round.
 pub use pass2::logical_memo_candidates::{
     generate_logical_asap_memo_candidates, LogicalASAPMemoCandidatesError, Pass2RoundState,
 };
 pub use pass2::memo::candidates::CandidatePopulationError;
-pub use pass2::memo::shared_configurations::{PaneWidthDomain, PaneWidthFrontier};
+pub use pass2::memo::shared_configurations::{
+    TumblingWindowWidthDomain, TumblingWindowWidthFrontier,
+};
 pub use pass2::memo::state_groups::StateGroupExpansionError;
 // The CandidateLogicalASAPDAGs a memo stands for (developer tools'
 // reference pricing).
diff --git a/crates/logical-asap-optimization/src/pass1/logical_memo_candidates.rs b/crates/logical-asap-optimization/src/pass1/logical_memo_candidates.rs
index 08b452498..872c68173 100644
--- a/crates/logical-asap-optimization/src/pass1/logical_memo_candidates.rs
+++ b/crates/logical-asap-optimization/src/pass1/logical_memo_candidates.rs
@@ -154,7 +154,7 @@ fn size_for_failure_probability(
 mod tests {
     use super::*;
     use crate::pass2::memo::generate_dag_of_logical_memo_groups;
-    use crate::pass2::memo::shared_configurations::PaneWidthDomain;
+    use crate::pass2::memo::shared_configurations::TumblingWindowWidthDomain;
     use crate::test_support::{
         lower_promql, shared_summary_state_groups, sharing_rules_and_shared_state_groups,
     };
@@ -314,7 +314,9 @@ mod tests {
             ],
             &data(Some(10_000)),
         );
-        let memo = sharing_rules_and_shared_state_groups(memo, PaneWidthDomain::SeedGrids).unwrap();
+        let memo =
+            sharing_rules_and_shared_state_groups(memo, TumblingWindowWidthDomain::SeedGrids)
+                .unwrap();
         let found = kll_failure_probabilities(
             shared_summary_state_groups(&memo)
                 .iter()
diff --git a/crates/logical-asap-optimization/src/pass1/per_computation_candidates.rs b/crates/logical-asap-optimization/src/pass1/per_computation_candidates.rs
index 337b1cec6..de93777bc 100644
--- a/crates/logical-asap-optimization/src/pass1/per_computation_candidates.rs
+++ b/crates/logical-asap-optimization/src/pass1/per_computation_candidates.rs
@@ -3842,12 +3842,12 @@ mod tests {
         }
     }
 
-    /// A quantile read from merged tumbling panes of a metric's samples is
+    /// A quantile read from merged tumbling windows of a metric's samples is
     /// still one of the samples (or between two), so it carries their sign
     /// as the same quantile over the raw window does; φ outside [0, 1]
     /// still carries none.
     #[test]
-    fn a_quantile_of_merged_panes_shares_its_raw_data_samples_sign() {
+    fn a_quantile_of_merged_tumbling_windows_shares_its_raw_data_samples_sign() {
         let inventory = inventory("quantile_over_time(0.99, m[100s])");
         let estimate = (0..inventory.targets.len())
             .flat_map(|t| composed_with(&inventory, t))
diff --git a/crates/logical-asap-optimization/src/pass2/asap_aware_cse.rs b/crates/logical-asap-optimization/src/pass2/asap_aware_cse.rs
index 420379e93..bc14d4e68 100644
--- a/crates/logical-asap-optimization/src/pass2/asap_aware_cse.rs
+++ b/crates/logical-asap-optimization/src/pass2/asap_aware_cse.rs
@@ -3,7 +3,7 @@
 //! `docs/design_docs/proposals/planner-layering.md` (Algorithm 2).
 //!
 //! The memo rules (`pass2::memo::rules`) are built on these helpers: the
-//! window-composition rule for tumbling panes, and two reuse rules (#680),
+//! window-composition rule for tumbling windows, and two reuse rules (#680),
 //! rollup and exact top-k reuse. Identical expressions are shared by memo
 //! group identity, and summary builds of one family at different sizes by
 //! the memo's shared-producer rule (`memo::rules::shared_producer`); both
@@ -16,43 +16,43 @@
 //! # Window-composition rule
 //!
 //! A query repeating every `E` over a window `W` can build its summary as
-//! back-to-back tumbling panes of width `w = gcd(W, E)` (Algorithm 2's
-//! `Tumbling(L)` for one query), merged before each read. A *pane
-//! candidate* ([`pane_candidates`]) is a `SummaryAgg` over a range
+//! back-to-back tumbling windows of width `w = gcd(W, E)` (Algorithm 2's
+//! `Tumbling(L)` for one query), merged before each read. A *tumbling window
+//! candidate* ([`tumbling_window_candidates`]) is a `SummaryAgg` over a range
 //! `TimeRange(W)` whose
 //! family merges in the family-capability table ([`FamilyCapability`]):
 //! exact accumulators included, and also families whose merged readouts
 //! are only approximate (heap top-k), whose readers then carry no
 //! guarantee and are left to plan selection's evidence. A family without a
-//! merge (IRate) has no pane candidate.
+//! merge (IRate) has no tumbling-window candidate.
 //! [`window_composition_pass2_candidates`] returns one Pass 2 candidate per
-//! non-empty subset of the pane candidates: the build of each in the subset
-//! becomes a `SummaryMerge` over one [`ASAPOp::SummaryTumblingWindowChain`] of `W / w` panes,
-//! a compact node whatever the pane count, with the build's family and
+//! non-empty subset of the tumbling-window candidates: the build of each in the subset
+//! becomes a `SummaryMerge` over one [`ASAPOp::SummaryTumblingWindowChain`] of `W / w` tumbling windows,
+//! a compact node whatever the tumbling-window count, with the build's family and
 //! size (a mergeable family's merged state has one build's guarantee), and
 //! every guarantee above is composed again. Nothing is materialized here:
-//! the panes are rebuilt at each evaluation until Stage 2 keeps them.
+//! the tumbling windows are rebuilt at each evaluation until Stage 2 keeps them.
 //!
 //! Nested windows share one chain: when a subset holds builds of one family
 //! (at any size) over the same input below their ranges, read the same way,
-//! with the same output column names, whose panes differ in width or count,
+//! with the same output column names, whose tumbling windows differ in width or count,
 //! the subset also comes as a Pass 2 candidate in which each such group
-//! reads one chain ([`SharedPaneChain`]) over the longest window, sized for
+//! reads one chain ([`SharedTumblingWindowChain`]) over the longest window, sized for
 //! every member ([`size_for_all_readers`]). Two grids are offered: the
-//! finest member's own panes, for the members whose widths it divides
+//! finest member's own tumbling windows, for the members whose widths it divides
 //! ([`nested_window_groups`]), and, when that differs, the gcd of all the
-//! members' widths, even finer than every member's own panes
+//! members' widths, even finer than every member's own tumbling windows
 //! ([`gcd_window_groups`]); Stage 3's pricing weighs the extra states and
-//! merges of finer panes. Queries repeating at different intervals read the
-//! same panes, each at its own cadence. Every window ends at the evaluation
-//! time, so each shorter one is the chain's newest panes: its
+//! merges of finer tumbling windows. Queries repeating at different intervals read the
+//! same tumbling windows, each at its own cadence. Every window ends at the evaluation
+//! time, so each shorter one is the chain's newest tumbling windows: its
 //! `SummaryMerge` merges only those (`newest_tumbling_windows`), and has the guarantee
 //! of one build over its own window. A build grouped by fewer keys also
 //! reads the chain of a finer grouping over a window at least its own
-//! ([`rollup_window_groups`]): it merges its newest panes, then rolls the
+//! ([`rollup_window_groups`]): it merges its newest tumbling windows, then rolls the
 //! groups up into its own, as the rollup rule does. Stage 2 never keeps a
 //! chain read at different intervals across evaluations from query time
-//! (each reader would need one new pane per evaluation). Long-window segments, sliding
+//! (each reader would need one new tumbling window per evaluation). Long-window segments, sliding
 //! windows and Exponential Histograms are not implemented.
 //!
 //! # Rollup rule
@@ -137,7 +137,7 @@ use asap_accuracy::propagation::recompose_guarantees;
 /// `Project` that keeps the columns it read, by name. `None` when every metric's scans already
 /// agree, when two of them give one label different types or one is closed
 /// and the other not, when a node would change arity, or when a consumer
-/// would have to narrow a summary state or a grouped or filtered pane chain
+/// would have to narrow a summary state or a grouped or filtered tumbling-window chain
 /// would read a `Project`.
 pub fn with_union_scan_labels(
     roots: &[QueryRoot],
@@ -224,7 +224,7 @@ pub fn with_union_scan_labels(
                     Err(_) => return Ok(None),
                 }
             }
-            // A grouped or filtered pane chain over a `Project` would hide
+            // A grouped or filtered tumbling-window chain over a `Project` would hide
             // its window from plan selection.
             _ if matches!(node.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. })) => {
                 return Ok(None);
@@ -276,10 +276,10 @@ fn unfiltered_series_scan(node: &OperatorNode) -> Option<(&Source, &Schema)> {
 
 /// Whether `node`, over a child with more labels, keeps them in its own
 /// output: a time range or shift of the rows, and a per-series build or
-/// pane chain without a filter (keyed by the series identity, which
+/// tumbling-window chain without a filter (keyed by the series identity, which
 /// determines every label) with its merges, estimates and finalizations.
 /// The executor reads a per-series build's raw rows from its `TimeRange`
-/// directly, and plan selection reads a pane chain's window from the rows
+/// directly, and plan selection reads a tumbling-window chain's window from the rows
 /// below it, so nothing may sit between them.
 fn passes_labels_on(node: &OperatorNode) -> bool {
     matches!(
@@ -430,78 +430,78 @@ fn sized_for_all(
 }
 
 /// One summary build the window-composition rule can build as tumbling
-/// panes: a `SummaryAgg` over a range `TimeRange(W)` whose family merges
+/// tumbling windows: a `SummaryAgg` over a range `TimeRange(W)` whose family merges
 /// (the family-capability table: exact accumulators included, and families
 /// whose merged readouts are only approximate), read only by queries that
-/// repeat at a fixed interval. Its panes are `tumbling_window_count = W / w` back-to-back
+/// repeat at a fixed interval. Its tumbling windows are `tumbling_window_count = W / w` back-to-back
 /// windows of `w = gcd(W, E)` over the queries' intervals `E` (and, for a
 /// query with a range evaluation, its step), at least two.
 #[derive(Debug, Clone)]
-pub struct PaneCandidate {
-    /// The `SummaryAgg` over `TimeRange(W)` built as panes.
+pub struct TumblingWindowCandidate {
+    /// The `SummaryAgg` over `TimeRange(W)` built as tumbling windows.
     pub build: Rc<OperatorNode>,
-    /// The width `w` of one pane.
+    /// The width `w` of one tumbling window.
     pub tumbling_window_width_ms: u64,
-    /// The number of panes, `W / w`, at least two.
+    /// The number of tumbling windows, `W / w`, at least two.
     pub tumbling_window_count: u32,
 }
 
-impl PaneCandidate {
-    /// The window `W` its panes cover, `tumbling_window_width_ms · tumbling_window_count`.
+impl TumblingWindowCandidate {
+    /// The window `W` its tumbling windows cover, `tumbling_window_width_ms · tumbling_window_count`.
     pub fn window_ms(&self) -> u64 {
         self.tumbling_window_width_ms * u64::from(self.tumbling_window_count)
     }
 }
 
 /// A Pass 2 candidate of the window-composition rule: the candidate's roots
-/// with the build of each of `pane_candidates` built as its tumbling panes,
+/// with the build of each of `tumbling_window_candidates` built as its tumbling windows,
 /// merged before every read, and every guarantee composed again; the error
 /// when that fails, which leaves the other Pass 2 candidates unaffected.
 #[derive(Debug)]
 pub struct WindowCompositionPass2Candidate {
-    /// The builds built as tumbling panes, in [`pane_candidates`] order.
+    /// The builds built as tumbling windows, in [`tumbling_window_candidates`] order.
     /// Only tests read it.
     #[cfg_attr(not(any(test, feature = "test-support")), allow(dead_code))]
-    pub pane_candidates: Vec<PaneCandidate>,
-    /// The chains each shared by several of `pane_candidates`
+    pub tumbling_window_candidates: Vec<TumblingWindowCandidate>,
+    /// The chains each shared by several of `tumbling_window_candidates`
     /// ([`nested_window_groups`] or [`gcd_window_groups`]); empty when each
     /// build has its own chain.
-    pub shared_chains: Vec<SharedPaneChain>,
-    /// The candidate's roots with those builds in panes.
+    pub shared_chains: Vec<SharedTumblingWindowChain>,
+    /// The candidate's roots with those builds in tumbling windows.
     pub roots: Result<Vec<QueryRoot>, PerComputationCandidateError>,
 }
 
-/// One pane chain several pane candidates read (window-composition rule):
-/// panes of `tumbling_window_width_ms`, a width that divides every member's own pane
+/// One tumbling-window chain several tumbling-window candidates read (window-composition rule):
+/// tumbling windows of `tumbling_window_width_ms`, a width that divides every member's own tumbling window
 /// width, and `tumbling_window_count` of them, covering the longest member's window.
-/// Each member merges the newest `W / tumbling_window_width_ms` panes of its window `W`.
+/// Each member merges the newest `W / tumbling_window_width_ms` tumbling windows of its window `W`.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SharedPaneChain {
-    /// Positions in the Pass 2 candidate's `pane_candidates`, two or more.
+pub struct SharedTumblingWindowChain {
+    /// Positions in the Pass 2 candidate's `tumbling_window_candidates`, two or more.
     pub members: Vec<usize>,
-    /// The width of one pane of the shared chain.
+    /// The width of one tumbling window of the shared chain.
     pub tumbling_window_width_ms: u64,
-    /// The number of panes of the shared chain.
+    /// The number of tumbling windows of the shared chain.
     pub tumbling_window_count: u32,
 }
 
-/// The most pane candidates one candidate may have: every non-empty subset
+/// The most tumbling-window candidates one candidate may have: every non-empty subset
 /// is a Pass 2 candidate, and with shared grids up to three, about three
 /// million at 20.
-pub(crate) const MAX_PANE_CANDIDATES: usize = 20;
+pub(crate) const MAX_TUMBLING_WINDOW_CANDIDATES: usize = 20;
 
-/// The pane candidates of the candidate with query roots `roots`, children
+/// The tumbling-window candidates of the candidate with query roots `roots`, children
 /// first. `evaluation_grid_ms[q]` is the grid query `q`'s evaluations fall
 /// on: how often it repeats, or with a range evaluation the greatest common
 /// divisor of that and its step, and of its phase if declared
 /// (`QueryWorkloadEntry::evaluation_grid_ms`); `None` when it does not
-/// repeat at a fixed interval. Each pane width divides every reader's grid,
-/// so with panes anchored at the epoch every evaluation, every range step
-/// included, ends on a pane boundary.
-pub fn pane_candidates(
+/// repeat at a fixed interval. Each tumbling-window width divides every reader's grid,
+/// so with tumbling windows anchored at the epoch every evaluation, every range step
+/// included, ends on a tumbling-window boundary.
+pub fn tumbling_window_candidates(
     roots: &[QueryRoot],
     evaluation_grid_ms: &[Option<u64>],
-) -> Vec<PaneCandidate> {
+) -> Vec<TumblingWindowCandidate> {
     let mut nodes = Vec::new();
     let mut seen = std::collections::HashSet::new();
     for node in roots.iter().flat_map(root_operators) {
@@ -520,7 +520,7 @@ pub fn pane_candidates(
     nodes
         .into_iter()
         .filter_map(|build| {
-            let window_ms = pane_window_ms(&build)?;
+            let window_ms = splittable_window_ms(&build)?;
             let readers: Vec<usize> = (0..roots.len())
                 .filter(|&q| reach[q].contains(&Rc::as_ptr(&build)))
                 .collect();
@@ -532,7 +532,7 @@ pub fn pane_candidates(
                 );
             }
             let tumbling_window_count = u32::try_from(window_ms / width).ok()?;
-            (!readers.is_empty() && tumbling_window_count >= 1).then_some(PaneCandidate {
+            (!readers.is_empty() && tumbling_window_count >= 1).then_some(TumblingWindowCandidate {
                 build,
                 tumbling_window_width_ms: width,
                 tumbling_window_count,
@@ -545,7 +545,7 @@ pub fn pane_candidates(
 /// family merges, over a range `TimeRange(W)` over an instant vector or a
 /// SQL table's rows, read at the query's time or a fixed offset from it: no `@` anchor on any of
 /// the time shifts stacked below the range.
-fn pane_window_ms(build: &OperatorNode) -> Option<u64> {
+fn splittable_window_ms(build: &OperatorNode) -> Option<u64> {
     let Some(ASAPOp::SummaryAgg { child, family, .. }) = build.asap() else {
         return None;
     };
@@ -578,42 +578,42 @@ fn pane_window_ms(build: &OperatorNode) -> Option<u64> {
 }
 
 /// Every Pass 2 candidate of the window-composition rule for the candidate
-/// with query roots `roots` and pane candidates `candidates`
-/// ([`pane_candidates`]): one per non-empty subset of them, in
+/// with query roots `roots` and tumbling-window candidates `candidates`
+/// ([`tumbling_window_candidates`]): one per non-empty subset of them, in
 /// binary-counter order (the first candidate the lowest bit). Each build in
 /// the subset becomes a `SummaryMerge` over one [`ASAPOp::SummaryTumblingWindowChain`] of
-/// its panes; every other build is untouched. A subset whose builds can
+/// its tumbling windows; every other build is untouched. A subset whose builds can
 /// share chains is followed by one Pass 2 candidate per shared grid, in
 /// which each group reads one shared chain, each member merging its newest
-/// panes: the finest member's panes (`nested_window_groups`), then the
+/// tumbling windows: the finest member's tumbling windows (`nested_window_groups`), then the
 /// gcd of the members' widths when that groups them differently
 /// (`gcd_window_groups`); and by one error candidate per group whose
 /// sizing fails. Each grid groups every build of a subset at once: a
 /// shared gcd grid over only some of the builds that could share it is not
 /// listed. An error only for more than
-/// `MAX_PANE_CANDIDATES` pane candidates; a Pass 2 candidate whose
+/// `MAX_TUMBLING_WINDOW_CANDIDATES` tumbling-window candidates; a Pass 2 candidate whose
 /// composition fails carries its own error.
 pub fn window_composition_pass2_candidates(
     roots: &[QueryRoot],
-    candidates: &[PaneCandidate],
+    candidates: &[TumblingWindowCandidate],
 ) -> Result<Vec<WindowCompositionPass2Candidate>, PerComputationCandidateError> {
-    if candidates.len() > MAX_PANE_CANDIDATES {
+    if candidates.len() > MAX_TUMBLING_WINDOW_CANDIDATES {
         return Err(PerComputationCandidateError::TooManyCandidates {
-            counted: "summary builds that could be built in tumbling panes",
+            counted: "summary builds that could be built in tumbling windows",
             found: candidates.len(),
-            max: MAX_PANE_CANDIDATES,
+            max: MAX_TUMBLING_WINDOW_CANDIDATES,
         });
     }
-    let rollable = rollable_pane_candidates(roots, candidates);
+    let rollable = rollable_tumbling_window_candidates(roots, candidates);
     let mut pass2_candidates = Vec::new();
     for mask in 1u64..(1u64 << candidates.len()) {
-        let chosen: Vec<PaneCandidate> = (0..candidates.len())
+        let chosen: Vec<TumblingWindowCandidate> = (0..candidates.len())
             .filter(|&i| mask >> i & 1 == 1)
             .map(|i| candidates[i].clone())
             .collect();
         pass2_candidates.push(WindowCompositionPass2Candidate {
-            roots: in_panes(roots, &chosen, &[]),
-            pane_candidates: chosen.clone(),
+            roots: in_tumbling_windows(roots, &chosen, &[]),
+            tumbling_window_candidates: chosen.clone(),
             shared_chains: Vec::new(),
         });
         let chosen_rollable: Vec<bool> = (0..candidates.len())
@@ -626,14 +626,14 @@ pub fn window_composition_pass2_candidates(
 }
 
 /// The Pass 2 candidates of [`window_composition_pass2_candidates`] in
-/// which every one of `candidates` is in panes and reads a shared chain:
+/// which every one of `candidates` is in tumbling windows and reads a shared chain:
 /// that function's candidates of the whole set with shared chains, in its
 /// order, without building the other subsets'.
 pub fn window_composition_shared_chain_candidates(
     roots: &[QueryRoot],
-    candidates: &[PaneCandidate],
+    candidates: &[TumblingWindowCandidate],
 ) -> Vec<WindowCompositionPass2Candidate> {
-    let rollable = rollable_pane_candidates(roots, candidates);
+    let rollable = rollable_tumbling_window_candidates(roots, candidates);
     let mut pass2_candidates = Vec::new();
     push_every_shared_chain(roots, candidates, &rollable, &mut pass2_candidates);
     pass2_candidates
@@ -643,17 +643,17 @@ pub fn window_composition_shared_chain_candidates(
 /// rollable or not, `chosen_rollable`) of [`window_composition_pass2_candidates`].
 fn push_every_shared_chain(
     roots: &[QueryRoot],
-    chosen: &[PaneCandidate],
+    chosen: &[TumblingWindowCandidate],
     chosen_rollable: &[bool],
     pass2_candidates: &mut Vec<WindowCompositionPass2Candidate>,
 ) {
-    // Shared chains on the members' own finest panes, then, when it
+    // Shared chains on the members' own finest tumbling windows, then, when it
     // groups them differently, on the gcd of their widths.
-    let on_member_panes = nested_window_groups(chosen);
-    let on_gcd_panes = gcd_window_groups(chosen);
-    push_shared_chains(roots, chosen, &on_member_panes, pass2_candidates);
-    if on_gcd_panes != on_member_panes {
-        push_shared_chains(roots, chosen, &on_gcd_panes, pass2_candidates);
+    let on_member_tumbling_windows = nested_window_groups(chosen);
+    let on_gcd_tumbling_windows = gcd_window_groups(chosen);
+    push_shared_chains(roots, chosen, &on_member_tumbling_windows, pass2_candidates);
+    if on_gcd_tumbling_windows != on_member_tumbling_windows {
+        push_shared_chains(roots, chosen, &on_gcd_tumbling_windows, pass2_candidates);
     }
     // Coarser groupings read a finer grouping's chain, rolled up.
     push_shared_chains(
@@ -669,8 +669,8 @@ fn push_every_shared_chain(
 /// each group whose sizing fails. Nothing when no group has a shared size.
 fn push_shared_chains(
     roots: &[QueryRoot],
-    chosen: &[PaneCandidate],
-    groups: &[SharedPaneChain],
+    chosen: &[TumblingWindowCandidate],
+    groups: &[SharedTumblingWindowChain],
     pass2_candidates: &mut Vec<WindowCompositionPass2Candidate>,
 ) {
     // Each group with a size that serves every member, and that build.
@@ -681,29 +681,29 @@ fn push_shared_chains(
             Ok(None) => {}
             Err(error) => pass2_candidates.push(WindowCompositionPass2Candidate {
                 roots: Err(error),
-                pane_candidates: chosen.to_vec(),
+                tumbling_window_candidates: chosen.to_vec(),
                 shared_chains: vec![group.clone()],
             }),
         }
     }
     if !shared.is_empty() {
         pass2_candidates.push(WindowCompositionPass2Candidate {
-            roots: in_panes(roots, chosen, &shared),
-            pane_candidates: chosen.to_vec(),
+            roots: in_tumbling_windows(roots, chosen, &shared),
+            tumbling_window_candidates: chosen.to_vec(),
             shared_chains: shared.into_iter().map(|(group, _)| group).collect(),
         });
     }
 }
 
-/// The pane candidates (positions in `candidates`) that can read one
-/// shared chain at the gcd of their pane widths, each group with its
+/// The tumbling-window candidates (positions in `candidates`) that can read one
+/// shared chain at the gcd of their tumbling-window widths, each group with its
 /// chain: every build over one input ([`same_build_over_one_input`]) in one
-/// group, whatever its pane width, on panes of the gcd of the members'
-/// widths over the longest window. Finer panes than any member builds mean
+/// group, whatever its tumbling-window width, on tumbling windows of the gcd of the members'
+/// widths over the longest window. Finer tumbling windows than any member builds mean
 /// more states and more merges; Stage 3's pricing decides whether sharing
-/// pays. Groups of members with the same panes and window are left to the
+/// pays. Groups of members with the same tumbling windows and window are left to the
 /// other rules.
-fn gcd_window_groups(candidates: &[PaneCandidate]) -> Vec<SharedPaneChain> {
+fn gcd_window_groups(candidates: &[TumblingWindowCandidate]) -> Vec<SharedTumblingWindowChain> {
     let mut groups: Vec<Vec<usize>> = Vec::new();
     for (i, candidate) in candidates.iter().enumerate() {
         match groups
@@ -717,13 +717,16 @@ fn gcd_window_groups(candidates: &[PaneCandidate]) -> Vec<SharedPaneChain> {
     groups
         .into_iter()
         .filter_map(|members| {
-            let panes = |i: usize| {
+            let tumbling_windows = |i: usize| {
                 (
                     candidates[i].tumbling_window_width_ms,
                     candidates[i].tumbling_window_count,
                 )
             };
-            if members.iter().all(|&i| panes(i) == panes(members[0])) {
+            if members
+                .iter()
+                .all(|&i| tumbling_windows(i) == tumbling_windows(members[0]))
+            {
                 return None;
             }
             let tumbling_window_width_ms = members.iter().fold(0, |width, &i| {
@@ -735,7 +738,7 @@ fn gcd_window_groups(candidates: &[PaneCandidate]) -> Vec<SharedPaneChain> {
             let longest = longest(candidates, &members);
             let tumbling_window_count =
                 u32::try_from(candidates[longest].window_ms() / tumbling_window_width_ms).ok()?;
-            Some(SharedPaneChain {
+            Some(SharedTumblingWindowChain {
                 members,
                 tumbling_window_width_ms,
                 tumbling_window_count,
@@ -744,23 +747,23 @@ fn gcd_window_groups(candidates: &[PaneCandidate]) -> Vec<SharedPaneChain> {
         .collect()
 }
 
-/// The pane candidates (positions in `candidates`) that can read one
+/// The tumbling-window candidates (positions in `candidates`) that can read one
 /// shared chain, each group with its chain: builds of one family
 /// ([`same_family`], at any size) that read the same input below their
 /// ranges the same way (item and weight, grouping and filter), with the
 /// same output column names (each reader reads the shared chain's columns
 /// by position). Their windows end at the same time, so each is the newest
-/// panes of the longest. The shared panes are the group's finest member's
-/// own panes: a build joins a group only when that width divides its own
-/// pane width (the gcd of the widths, never finer than a chain some member
+/// tumbling windows of the longest. The shared tumbling windows are the group's finest member's
+/// own tumbling windows: a build joins a group only when that width divides its own
+/// tumbling-window width (the gcd of the widths, never finer than a chain some member
 /// builds anyway), and otherwise starts its own group. Members at different
-/// repeat intervals read the same panes, each at its own cadence. One chain
+/// repeat intervals read the same tumbling windows, each at its own cadence. One chain
 /// over the longest window, sized for every reader
 /// ([`size_for_all_readers`]), serves them all. Groups of members with the
-/// same panes and window are left to the other rules.
-fn nested_window_groups(candidates: &[PaneCandidate]) -> Vec<SharedPaneChain> {
-    // Finest panes first: each build joins the first group over its input
-    // whose (finest) pane width divides its own, so a build whose panes no
+/// same tumbling windows and window are left to the other rules.
+fn nested_window_groups(candidates: &[TumblingWindowCandidate]) -> Vec<SharedTumblingWindowChain> {
+    // Finest tumbling windows first: each build joins the first group over its input
+    // whose (finest) tumbling-window width divides its own, so a build whose tumbling windows no
     // group's divide starts its own group instead of breaking another.
     let mut by_width: Vec<usize> = (0..candidates.len()).collect();
     by_width.sort_by_key(|&i| candidates[i].tumbling_window_width_ms);
@@ -781,13 +784,16 @@ fn nested_window_groups(candidates: &[PaneCandidate]) -> Vec<SharedPaneChain> {
     let mut shared = groups
         .into_iter()
         .filter_map(|mut members| {
-            let panes = |i: usize| {
+            let tumbling_windows = |i: usize| {
                 (
                     candidates[i].tumbling_window_width_ms,
                     candidates[i].tumbling_window_count,
                 )
             };
-            if members.iter().all(|&i| panes(i) == panes(members[0])) {
+            if members
+                .iter()
+                .all(|&i| tumbling_windows(i) == tumbling_windows(members[0]))
+            {
                 return None;
             }
             let tumbling_window_width_ms = candidates[members[0]].tumbling_window_width_ms;
@@ -795,7 +801,7 @@ fn nested_window_groups(candidates: &[PaneCandidate]) -> Vec<SharedPaneChain> {
             let tumbling_window_count =
                 u32::try_from(candidates[longest].window_ms() / tumbling_window_width_ms).ok()?;
             members.sort_unstable();
-            Some(SharedPaneChain {
+            Some(SharedTumblingWindowChain {
                 members,
                 tumbling_window_width_ms,
                 tumbling_window_count,
@@ -810,10 +816,13 @@ fn nested_window_groups(candidates: &[PaneCandidate]) -> Vec<SharedPaneChain> {
 
 /// Whether each of `candidates` may be read rolled up from a finer
 /// grouping's chain: a sketch build over a SQL relation's rows (a PromQL
-/// rollup over newest panes is not offered yet) whose every reader in
+/// rollup over newest tumbling windows is not offered yet) whose every reader in
 /// `roots` is an estimate whose merged readout keeps a guarantee, as for
 /// the rollup rule.
-fn rollable_pane_candidates(roots: &[QueryRoot], candidates: &[PaneCandidate]) -> Vec<bool> {
+fn rollable_tumbling_window_candidates(
+    roots: &[QueryRoot],
+    candidates: &[TumblingWindowCandidate],
+) -> Vec<bool> {
     let mut nodes = Vec::new();
     let mut seen = HashSet::new();
     for node in roots.iter().flat_map(root_operators) {
@@ -843,20 +852,23 @@ fn rollable_pane_candidates(roots: &[QueryRoot], candidates: &[PaneCandidate]) -
         .collect()
 }
 
-/// The pane candidates (positions in `candidates`) that can read one
-/// chain of a finer grouping's panes, each group with its chain: a host,
+/// The tumbling-window candidates (positions in `candidates`) that can read one
+/// chain of a finer grouping's tumbling windows, each group with its chain: a host,
 /// and every candidate whose group keys are the host's or fewer
-/// ([`rolls_up_into`]), whose window is at most the host's and whose pane
-/// width the host's divides. Each member merges the newest panes of its
+/// ([`rolls_up_into`]), whose window is at most the host's and whose tumbling window
+/// width the host's divides. Each member merges the newest tumbling windows of its
 /// window, and a coarser member then rolls the host's groups up into its
 /// own (a regrouping `SummaryMerge`): `p90 per city over 20 minutes` in
-/// 10 s panes serves `p90 over 5 minutes` as the newest 30 panes merged
+/// 10 s tumbling windows serves `p90 over 5 minutes` as the newest 30 tumbling windows merged
 /// across cities. A coarser member is one `rollable[i]` allows
-/// ([`rollable_pane_candidates`]). Hosts are tried by most group keys,
+/// ([`rollable_tumbling_window_candidates`]). Hosts are tried by most group keys,
 /// then longest window, and each candidate joins one group. Only groups
 /// with a coarser member are listed; the others are
 /// [`nested_window_groups`]'s.
-fn rollup_window_groups(candidates: &[PaneCandidate], rollable: &[bool]) -> Vec<SharedPaneChain> {
+fn rollup_window_groups(
+    candidates: &[TumblingWindowCandidate],
+    rollable: &[bool],
+) -> Vec<SharedTumblingWindowChain> {
     let mut hosts: Vec<usize> = (0..candidates.len()).collect();
     hosts.sort_by_key(|&i| {
         (
@@ -892,7 +904,7 @@ fn rollup_window_groups(candidates: &[PaneCandidate], rollable: &[bool]) -> Vec<
         for &i in &members {
             grouped[i] = true;
         }
-        groups.push(SharedPaneChain {
+        groups.push(SharedTumblingWindowChain {
             members,
             tumbling_window_width_ms: candidates[host].tumbling_window_width_ms,
             tumbling_window_count: candidates[host].tumbling_window_count,
@@ -918,7 +930,7 @@ fn group_key_count(build: &OperatorNode) -> usize {
 /// or the same but grouped by fewer of `host`'s keys, of a family whose
 /// states merge across groups ([`FamilyCapability::merges_groups`]), so a
 /// rollup of `host`'s states answers it.
-fn rolls_up_into(member: &PaneCandidate, host: &PaneCandidate) -> bool {
+fn rolls_up_into(member: &TumblingWindowCandidate, host: &TumblingWindowCandidate) -> bool {
     if same_build_over_one_input(member, host) {
         return true;
     }
@@ -957,10 +969,10 @@ fn rolls_up_into(member: &PaneCandidate, host: &PaneCandidate) -> bool {
         && filter == host_filter
 }
 
-/// Whether two pane candidates build one family (at any size) over the
+/// Whether two tumbling-window candidates build one family (at any size) over the
 /// same input below their ranges, read the same way, with the same output
 /// column names.
-fn same_build_over_one_input(a: &PaneCandidate, b: &PaneCandidate) -> bool {
+fn same_build_over_one_input(a: &TumblingWindowCandidate, b: &TumblingWindowCandidate) -> bool {
     let (
         Some(ASAPOp::SummaryAgg {
             child: range,
@@ -1002,7 +1014,7 @@ fn same_build_over_one_input(a: &PaneCandidate, b: &PaneCandidate) -> bool {
 
 /// The member of `group` (positions in `candidates`) with the longest
 /// window.
-fn longest(candidates: &[PaneCandidate], group: &[usize]) -> usize {
+fn longest(candidates: &[TumblingWindowCandidate], group: &[usize]) -> usize {
     *group
         .iter()
         .max_by_key(|&&i| candidates[i].window_ms())
@@ -1013,7 +1025,7 @@ fn longest(candidates: &[PaneCandidate], group: &[usize]) -> usize {
 /// made of: the longest member's, sized for every member
 /// ([`sized_for_all`]); `None` when their sizes have no shared size.
 fn shared_chain_build(
-    candidates: &[PaneCandidate],
+    candidates: &[TumblingWindowCandidate],
     group: &[usize],
 ) -> Result<Option<Rc<OperatorNode>>, PerComputationCandidateError> {
     // Of the longest windows, the finest grouping: a rollup group's host.
@@ -1034,17 +1046,17 @@ fn shared_chain_build(
 }
 
 /// `roots` with the build of each of `candidates` built as its tumbling
-/// panes, and every guarantee composed again. The members of each
-/// [`SharedPaneChain`] (with its [`shared_chain_build`]) read that one
-/// chain: each merges the newest panes covering its own window.
-fn in_panes(
+/// tumbling windows, and every guarantee composed again. The members of each
+/// [`SharedTumblingWindowChain`] (with its [`shared_chain_build`]) read that one
+/// chain: each merges the newest tumbling windows covering its own window.
+fn in_tumbling_windows(
     roots: &[QueryRoot],
-    candidates: &[PaneCandidate],
-    shared_chains: &[(SharedPaneChain, Rc<OperatorNode>)],
+    candidates: &[TumblingWindowCandidate],
+    shared_chains: &[(SharedTumblingWindowChain, Rc<OperatorNode>)],
 ) -> Result<Vec<QueryRoot>, PerComputationCandidateError> {
     let mut replaced: HashMap<*const OperatorNode, Rc<OperatorNode>> = HashMap::new();
     for (shared, build) in shared_chains {
-        let chain = pane_chain(&PaneCandidate {
+        let chain = tumbling_window_chain(&TumblingWindowCandidate {
             build: Rc::clone(build),
             tumbling_window_width_ms: shared.tumbling_window_width_ms,
             tumbling_window_count: shared.tumbling_window_count,
@@ -1063,7 +1075,7 @@ fn in_panes(
                 merge
             } else {
                 regrouped(member, &merge).ok_or(PerComputationCandidateError::Unsupported(
-                    "a coarser pane build whose keys the shared chain does not hold",
+                    "a coarser tumbling-window build whose keys the shared chain does not hold",
                 ))?
             };
             replaced.insert(Rc::as_ptr(member), read);
@@ -1075,7 +1087,7 @@ fn in_panes(
         {
             entry.insert(Rc::new(OperatorNode::new(Operator::ASAP(
                 ASAPOp::SummaryMerge {
-                    children: vec![pane_chain(candidate)?],
+                    children: vec![tumbling_window_chain(candidate)?],
                     newest_tumbling_windows: None,
                     group_by: None,
                 },
@@ -1104,13 +1116,13 @@ fn in_panes(
 }
 
 /// `roots` with the `SummaryMerge` `merge` (over one [`ASAPOp::SummaryTumblingWindowChain`]
-/// of `roots`) reading the newest panes of another chain over the same
-/// input: `tumbling_window_count` panes of `tumbling_window_width_ms` of family `family` (a size
+/// of `roots`) reading the newest tumbling windows of another chain over the same
+/// input: `tumbling_window_count` tumbling windows of `tumbling_window_width_ms` of family `family` (a size
 /// that serves every reader of the chain). The merge reads the newest
-/// panes covering its own window (its newest panes, or its whole chain),
+/// tumbling windows covering its own window (its newest tumbling windows, or its whole chain),
 /// which `tumbling_window_width_ms` divides and the new chain covers; every guarantee
 /// is composed again.
-pub(crate) fn with_pane_chain(
+pub(crate) fn with_tumbling_window_chain(
     roots: &[QueryRoot],
     merge: &Rc<OperatorNode>,
     family: FieldDataType,
@@ -1123,7 +1135,7 @@ pub(crate) fn with_pane_chain(
         ..
     }) = merge.asap()
     else {
-        unreachable!("a merge over a pane chain");
+        unreachable!("a merge over a tumbling-window chain");
     };
     let own = &children[0];
     let Some(ASAPOp::SummaryTumblingWindowChain {
@@ -1137,9 +1149,9 @@ pub(crate) fn with_pane_chain(
         ..
     }) = own.asap()
     else {
-        unreachable!("a merge over a pane chain");
+        unreachable!("a merge over a tumbling-window chain");
     };
-    // The merge's window: its newest panes, or the whole chain.
+    // The merge's window: its newest tumbling windows, or the whole chain.
     let window_ms = own_width * u64::from(own_newest.unwrap_or(*own_count));
     let newest = u32::try_from(window_ms / tumbling_window_width_ms)
         .expect("a reader's window is at most the chain's");
@@ -1237,9 +1249,11 @@ pub(crate) fn with_resized_build(
     Ok(recompose_guarantees(&out)?)
 }
 
-/// The [`ASAPOp::SummaryTumblingWindowChain`] of `candidate`'s panes, with the build's
+/// The [`ASAPOp::SummaryTumblingWindowChain`] of `candidate`'s tumbling windows, with the build's
 /// output names.
-fn pane_chain(candidate: &PaneCandidate) -> Result<Rc<OperatorNode>, PerComputationCandidateError> {
+fn tumbling_window_chain(
+    candidate: &TumblingWindowCandidate,
+) -> Result<Rc<OperatorNode>, PerComputationCandidateError> {
     let Some(ASAPOp::SummaryAgg {
         child: range,
         family,
@@ -1249,7 +1263,7 @@ fn pane_chain(candidate: &PaneCandidate) -> Result<Rc<OperatorNode>, PerComputat
         filter,
     }) = candidate.build.asap()
     else {
-        unreachable!("a pane candidate's build is a SummaryAgg");
+        unreachable!("a tumbling-window candidate's build is a SummaryAgg");
     };
     let mut chain = OperatorNode::new(Operator::ASAP(ASAPOp::SummaryTumblingWindowChain {
         child: Rc::clone(range.children()[0]),
@@ -2351,10 +2365,10 @@ mod tests {
     }
 
     /// A count over a window, read from a Count-Min built in tumbling
-    /// panes, keeps the guarantee of one build over the window: Pass 1
+    /// tumbling windows, keeps the guarantee of one build over the window: Pass 1
     /// offers Count-Min for counts, and its merged counters add.
     #[test]
-    fn a_count_from_count_min_panes_keeps_its_guarantee() {
+    fn a_count_from_count_min_tumbling_windows_keeps_its_guarantee() {
         use crate::pass1::per_computation_candidates::{
             compose_logical_candidate, generate_per_computation_candidates,
         };
@@ -2383,18 +2397,18 @@ mod tests {
             })
             .collect();
         let roots: Vec<QueryRoot> = compose_logical_candidate(&inventory, &choice).unwrap();
-        let candidates = pane_candidates(&roots, &[Some(60_000)]);
+        let candidates = tumbling_window_candidates(&roots, &[Some(60_000)]);
         let pass2_candidates = window_composition_pass2_candidates(&roots, &candidates).unwrap();
         let [pass2_candidate] = pass2_candidates.as_slice() else {
             panic!("one Pass 2 candidate: {pass2_candidates:?}")
         };
-        let (QueryRoot::Operator(whole), QueryRoot::Operator(paned)) =
+        let (QueryRoot::Operator(whole), QueryRoot::Operator(windowed)) =
             (&roots[0], &pass2_candidate.roots.as_ref().unwrap()[0])
         else {
             panic!("operator roots")
         };
         assert!(whole.guarantee.is_some());
-        assert_eq!(paned.guarantee, whole.guarantee);
+        assert_eq!(windowed.guarantee, whole.guarantee);
     }
 
     /// The composed candidate of `queries` (each at its own ε, δ = 0.01)
@@ -2478,9 +2492,9 @@ mod tests {
             .expect("a constant bound")
     }
 
-    /// The pane candidates of `roots` as (pane width, pane count).
-    fn panes(roots: &[QueryRoot], interval_ms: &[Option<u64>]) -> Vec<(u64, u32)> {
-        pane_candidates(roots, interval_ms)
+    /// The tumbling-window candidates of `roots` as (tumbling-window width, tumbling-window count).
+    fn tumbling_windows(roots: &[QueryRoot], interval_ms: &[Option<u64>]) -> Vec<(u64, u32)> {
+        tumbling_window_candidates(roots, interval_ms)
             .iter()
             .map(|rule_candidate| {
                 (
@@ -2491,42 +2505,42 @@ mod tests {
             .collect()
     }
 
-    /// A 5-min window evaluated every 2 min, 90 s or 1 min is built in panes
-    /// of gcd(window, interval). A once-per-window reader has one pane,
-    /// which can reuse the newest pane of a longer chain.
+    /// A 5-min window evaluated every 2 min, 90 s or 1 min is built in tumbling windows
+    /// of gcd(window, interval). A once-per-window reader has one tumbling window,
+    /// which can reuse the newest tumbling window of a longer chain.
     #[test]
-    fn pane_width_is_the_gcd_of_the_window_and_the_interval() {
+    fn tumbling_window_width_is_the_gcd_of_the_window_and_the_interval() {
         let roots = chose(
             &[("quantile_over_time(0.99, m[5m])", 0.01)],
             SketchAlgorithm::Kll,
         );
-        assert_eq!(panes(&roots, &[Some(120_000)]), [(60_000, 5)]);
-        assert_eq!(panes(&roots, &[Some(90_000)]), [(30_000, 10)]);
-        assert_eq!(panes(&roots, &[Some(60_000)]), [(60_000, 5)]);
-        assert_eq!(panes(&roots, &[Some(300_000)]), [(300_000, 1)]);
-        assert!(panes(&roots, &[None]).is_empty());
+        assert_eq!(tumbling_windows(&roots, &[Some(120_000)]), [(60_000, 5)]);
+        assert_eq!(tumbling_windows(&roots, &[Some(90_000)]), [(30_000, 10)]);
+        assert_eq!(tumbling_windows(&roots, &[Some(60_000)]), [(60_000, 5)]);
+        assert_eq!(tumbling_windows(&roots, &[Some(300_000)]), [(300_000, 1)]);
+        assert!(tumbling_windows(&roots, &[None]).is_empty());
     }
 
-    /// Past their caps, the pane rule and the reuse subsets name how many
+    /// Past their caps, the tumbling-window rule and the reuse subsets name how many
     /// candidates they found.
     #[test]
-    fn too_many_pane_or_reuse_candidates_name_the_count_found() {
+    fn too_many_tumbling_window_or_reuse_candidates_name_the_count_found() {
         let roots = chose(
             &[("quantile_over_time(0.99, m[5m])", 0.01)],
             SketchAlgorithm::Kll,
         );
-        let panes: Vec<_> = pane_candidates(&roots, &[Some(60_000)])
+        let tumbling_windows: Vec<_> = tumbling_window_candidates(&roots, &[Some(60_000)])
             .into_iter()
             .cycle()
-            .take(MAX_PANE_CANDIDATES + 1)
+            .take(MAX_TUMBLING_WINDOW_CANDIDATES + 1)
             .collect();
-        let error = window_composition_pass2_candidates(&roots, &panes).unwrap_err();
+        let error = window_composition_pass2_candidates(&roots, &tumbling_windows).unwrap_err();
         assert_eq!(
             error.to_string(),
             format!(
-                "found {} summary builds that could be built in tumbling panes, more than \
-                 {MAX_PANE_CANDIDATES}",
-                MAX_PANE_CANDIDATES + 1
+                "found {} summary builds that could be built in tumbling windows, more than \
+                 {MAX_TUMBLING_WINDOW_CANDIDATES}",
+                MAX_TUMBLING_WINDOW_CANDIDATES + 1
             )
         );
         let error = subsets(&[0u8; MAX_REUSE_CANDIDATES + 1], "rollup").unwrap_err();
@@ -2539,11 +2553,11 @@ mod tests {
         );
     }
 
-    /// A range read at an `@` anchor has no panes, however many shifts
+    /// A range read at an `@` anchor has no tumbling windows, however many shifts
     /// stack above the anchored one: `m[5m] @ 100` with an extra
     /// `offset 1m` shift between the range and the anchor is still anchored.
     #[test]
-    fn an_anchor_below_stacked_shifts_has_no_panes() {
+    fn an_anchor_below_stacked_shifts_has_no_tumbling_windows() {
         use asap_types::ir::operator::TimeShift;
         let roots = chose(
             &[("quantile_over_time(0.99, m[5m] @ 100)", 0.01)],
@@ -2556,7 +2570,7 @@ mod tests {
             .into_iter()
             .find(|n| matches!(n.asap(), Some(ASAPOp::SummaryAgg { .. })))
             .expect("a build");
-        assert_eq!(pane_window_ms(&build), None, "one anchored shift");
+        assert_eq!(splittable_window_ms(&build), None, "one anchored shift");
         // Put an `offset 1m` shift between the range and its anchored shift.
         let restacked = build
             .with_new_children(|range| {
@@ -2580,13 +2594,17 @@ mod tests {
                 )
             })
             .unwrap();
-        assert_eq!(pane_window_ms(&restacked), None, "anchor below an offset");
+        assert_eq!(
+            splittable_window_ms(&restacked),
+            None,
+            "anchor below an offset"
+        );
     }
 
-    /// Exact accumulators whose states merge get panes; IRate, which reads
+    /// Exact accumulators whose states merge get tumbling windows; IRate, which reads
     /// the last two samples of the window, does not.
     #[test]
-    fn exact_accumulators_that_merge_get_panes() {
+    fn exact_accumulators_that_merge_get_tumbling_windows() {
         use asap_types::stages::HowToComputeAggregateMeasure;
         let accumulator = |c: &HowToComputeAggregateMeasure| {
             matches!(c, HowToComputeAggregateMeasure::ExactAccumulator(_))
@@ -2598,10 +2616,14 @@ mod tests {
             "max_over_time(m[5m])",
         ] {
             let roots = chose_where(&[(query, 0.01)], accumulator);
-            assert_eq!(panes(&roots, &[Some(60_000)]), [(60_000, 5)], "{query}");
+            assert_eq!(
+                tumbling_windows(&roots, &[Some(60_000)]),
+                [(60_000, 5)],
+                "{query}"
+            );
         }
         let roots = chose_where(&[("irate(m[5m])", 0.01)], accumulator);
-        assert!(panes(&roots, &[Some(60_000)]).is_empty());
+        assert!(tumbling_windows(&roots, &[Some(60_000)]).is_empty());
     }
 
     /// The rule's candidate reads a `SummaryMerge` over one `SummaryTumblingWindowChain` of
@@ -2609,24 +2631,27 @@ mod tests {
     /// build's output names, and keeps the whole build's guarantee (a KLL
     /// merges into the state of one build over the union).
     #[test]
-    fn panes_replace_the_build_with_a_merged_chain() {
+    fn tumbling_windows_replace_the_build_with_a_merged_chain() {
         let roots = chose(
             &[("quantile_over_time(0.99, m[5m])", 0.01)],
             SketchAlgorithm::Kll,
         );
-        let rule_candidates = pane_candidates(&roots, &[Some(60_000)]);
+        let rule_candidates = tumbling_window_candidates(&roots, &[Some(60_000)]);
         let pass2_candidates =
             window_composition_pass2_candidates(&roots, &rule_candidates).unwrap();
         let [pass2_candidate] = pass2_candidates.as_slice() else {
             panic!("one Pass 2 candidate: {pass2_candidates:?}")
         };
         assert_eq!(
-            positions(&rule_candidates, &pass2_candidate.pane_candidates, |c| &c
-                .build),
+            positions(
+                &rule_candidates,
+                &pass2_candidate.tumbling_window_candidates,
+                |c| &c.build
+            ),
             [0]
         );
-        let panes = pass2_candidate.roots.as_ref().unwrap();
-        let QueryRoot::Operator(root) = &panes[0] else {
+        let tumbling_windows = pass2_candidate.roots.as_ref().unwrap();
+        let QueryRoot::Operator(root) = &tumbling_windows[0] else {
             panic!("operator root")
         };
         root.validate_structure().unwrap();
@@ -2671,9 +2696,9 @@ mod tests {
 
     /// Two builds that could be split give three candidates: each alone and
     /// both, in binary-counter order. Their windows (5 and 2 min) nest on
-    /// 1-min panes, so both together are also offered as one shared chain.
+    /// 1-min tumbling windows, so both together are also offered as one shared chain.
     #[test]
-    fn every_non_empty_subset_of_the_pane_candidates_is_a_pass2_candidate() {
+    fn every_non_empty_subset_of_the_tumbling_window_candidates_is_a_pass2_candidate() {
         let roots = chose(
             &[
                 ("quantile_over_time(0.99, m[5m])", 0.01),
@@ -2681,7 +2706,7 @@ mod tests {
             ],
             SketchAlgorithm::Kll,
         );
-        let rule_candidates = pane_candidates(&roots, &[Some(60_000), Some(60_000)]);
+        let rule_candidates = tumbling_window_candidates(&roots, &[Some(60_000), Some(60_000)]);
         assert_eq!(rule_candidates.len(), 2);
         let subsets: Vec<_> = window_composition_pass2_candidates(&roots, &rule_candidates)
             .unwrap()
@@ -2689,7 +2714,9 @@ mod tests {
             .map(|v| {
                 assert!(v.roots.is_ok());
                 (
-                    positions(&rule_candidates, &v.pane_candidates, |c| &c.build),
+                    positions(&rule_candidates, &v.tumbling_window_candidates, |c| {
+                        &c.build
+                    }),
                     v.shared_chains.clone(),
                 )
             })
@@ -2702,7 +2729,7 @@ mod tests {
                 (vec![0, 1], vec![]),
                 (
                     vec![0, 1],
-                    vec![SharedPaneChain {
+                    vec![SharedTumblingWindowChain {
                         members: vec![0, 1],
                         tumbling_window_width_ms: 60_000,
                         tumbling_window_count: 5
@@ -2712,7 +2739,7 @@ mod tests {
         );
     }
 
-    /// The pane chains in `roots`, one per distinct node.
+    /// The tumbling-window chains in `roots`, one per distinct node.
     fn chains(roots: &[QueryRoot]) -> Vec<Rc<OperatorNode>> {
         let mut found: Vec<Rc<OperatorNode>> = Vec::new();
         for root in roots {
@@ -2742,13 +2769,13 @@ mod tests {
     }
 
     /// A 1-min and a 5-min KLL quantile over one metric, both every 10 s,
-    /// are 6 and 30 panes of 10 s; the 1-min window is the newest 6 of the
+    /// are 6 and 30 tumbling windows of 10 s; the 1-min window is the newest 6 of the
     /// 5-min one. Besides each query's own chain, the rule offers one chain
-    /// of 30 panes read by both: the 5-min query merges every pane, the
+    /// of 30 tumbling windows read by both: the 5-min query merges every tumbling window, the
     /// 1-min one only the newest 6, and each keeps the guarantee of its own
     /// whole-window build (a KLL merges exactly).
     #[test]
-    fn nested_windows_on_equal_panes_share_one_chain() {
+    fn nested_windows_on_equal_tumbling_windows_share_one_chain() {
         let roots = chose(
             &[
                 ("quantile_over_time(0.5, m[1m])", 0.01),
@@ -2756,9 +2783,9 @@ mod tests {
             ],
             SketchAlgorithm::Kll,
         );
-        let rule_candidates = pane_candidates(&roots, &[Some(10_000), Some(10_000)]);
+        let rule_candidates = tumbling_window_candidates(&roots, &[Some(10_000), Some(10_000)]);
         assert_eq!(
-            panes(&roots, &[Some(10_000), Some(10_000)]),
+            tumbling_windows(&roots, &[Some(10_000), Some(10_000)]),
             [(10_000, 6), (10_000, 30)]
         );
         let pass2_candidates =
@@ -2772,7 +2799,7 @@ mod tests {
         };
         assert_eq!(
             shared.shared_chains,
-            [SharedPaneChain {
+            [SharedTumblingWindowChain {
                 members: vec![0, 1],
                 tumbling_window_width_ms: 10_000,
                 tumbling_window_count: 30
@@ -2801,13 +2828,13 @@ mod tests {
         // The per-query chains stay candidates: two chains, each read in full.
         let separate = pass2_candidates
             .iter()
-            .find(|c| c.pane_candidates.len() == 2 && c.shared_chains.is_empty())
-            .expect("both builds in their own panes");
+            .find(|c| c.tumbling_window_candidates.len() == 2 && c.shared_chains.is_empty())
+            .expect("both builds in their own tumbling windows");
         assert_eq!(chains(separate.roots.as_ref().unwrap()).len(), 2);
     }
 
     /// A 15-min quantile every minute and the same quantile every 5 min
-    /// are 15 × 1-min and 3 × 5-min panes. The rule also offers one chain
+    /// are 15 × 1-min and 3 × 5-min tumbling windows. The rule also offers one chain
     /// at the finer width, 15 × 1 min, that both read in full, each at its
     /// own interval; a 1-hour quantile every 5 min (12 × 5 min) reads the
     /// newest 60 of one 60 × 1-min chain with them.
@@ -2821,8 +2848,11 @@ mod tests {
             SketchAlgorithm::Kll,
         );
         let grids = [Some(60_000), Some(300_000)];
-        assert_eq!(panes(&roots, &grids), [(60_000, 15), (300_000, 3)]);
-        let rule_candidates = pane_candidates(&roots, &grids);
+        assert_eq!(
+            tumbling_windows(&roots, &grids),
+            [(60_000, 15), (300_000, 3)]
+        );
+        let rule_candidates = tumbling_window_candidates(&roots, &grids);
         let pass2_candidates =
             window_composition_pass2_candidates(&roots, &rule_candidates).unwrap();
         let shared = pass2_candidates
@@ -2831,7 +2861,7 @@ mod tests {
             .expect("a shared-chain candidate");
         assert_eq!(
             shared.shared_chains,
-            [SharedPaneChain {
+            [SharedTumblingWindowChain {
                 members: vec![0, 1],
                 tumbling_window_width_ms: 60_000,
                 tumbling_window_count: 15
@@ -2863,7 +2893,7 @@ mod tests {
             ],
             SketchAlgorithm::Kll,
         );
-        let rule_candidates = pane_candidates(&roots, &grids);
+        let rule_candidates = tumbling_window_candidates(&roots, &grids);
         let shared = window_composition_pass2_candidates(&roots, &rule_candidates)
             .unwrap()
             .into_iter()
@@ -2882,10 +2912,10 @@ mod tests {
         ));
     }
 
-    /// A build whose panes the group's finest panes do not divide gets its
+    /// A build whose tumbling windows the group's finest tumbling windows do not divide gets its
     /// own chain without breaking the group: 20-min and 10-min quantiles
-    /// every 2 min (2-min panes) share one chain, and a 15-min quantile
-    /// every 3 min (3-min panes) stays apart.
+    /// every 2 min (2-min tumbling windows) share one chain, and a 15-min quantile
+    /// every 3 min (3-min tumbling windows) stays apart.
     #[test]
     fn a_build_on_an_incompatible_grid_does_not_break_a_shared_chain() {
         let roots = chose(
@@ -2898,18 +2928,18 @@ mod tests {
         );
         let grids = [Some(120_000), Some(120_000), Some(180_000)];
         assert_eq!(
-            panes(&roots, &grids),
+            tumbling_windows(&roots, &grids),
             [(120_000, 10), (120_000, 5), (180_000, 5)]
         );
-        let rule_candidates = pane_candidates(&roots, &grids);
+        let rule_candidates = tumbling_window_candidates(&roots, &grids);
         let shared = window_composition_pass2_candidates(&roots, &rule_candidates)
             .unwrap()
             .into_iter()
-            .find(|c| c.pane_candidates.len() == 3 && !c.shared_chains.is_empty())
-            .expect("a shared chain among all three builds in panes");
+            .find(|c| c.tumbling_window_candidates.len() == 3 && !c.shared_chains.is_empty())
+            .expect("a shared chain among all three builds in tumbling windows");
         assert_eq!(
             shared.shared_chains,
-            [SharedPaneChain {
+            [SharedTumblingWindowChain {
                 members: vec![0, 1],
                 tumbling_window_width_ms: 120_000,
                 tumbling_window_count: 10
@@ -2919,15 +2949,15 @@ mod tests {
     }
 
     /// The shared chains (width, count) of every Pass 2 candidate that
-    /// paned all of `rule_candidates`.
+    /// windowed all of `rule_candidates`.
     fn shared_grids(
         roots: &[QueryRoot],
-        rule_candidates: &[PaneCandidate],
+        rule_candidates: &[TumblingWindowCandidate],
     ) -> Vec<Vec<(u64, u32)>> {
         window_composition_pass2_candidates(roots, rule_candidates)
             .unwrap()
             .into_iter()
-            .filter(|c| c.pane_candidates.len() == rule_candidates.len())
+            .filter(|c| c.tumbling_window_candidates.len() == rule_candidates.len())
             .map(|c| {
                 c.shared_chains
                     .iter()
@@ -2942,7 +2972,7 @@ mod tests {
             .collect()
     }
 
-    /// Panes neither member's divide (3-min and 5-min panes of a 15-min
+    /// Tumbling windows neither member's divide (3-min and 5-min tumbling windows of a 15-min
     /// window) are shared at their gcd, 1 min, as one more candidate beside
     /// the per-query chains; no member's own width serves both.
     #[test]
@@ -2955,20 +2985,23 @@ mod tests {
             SketchAlgorithm::Kll,
         );
         let grids = [Some(180_000), Some(300_000)];
-        assert_eq!(panes(&roots, &grids), [(180_000, 5), (300_000, 3)]);
-        let rule_candidates = pane_candidates(&roots, &grids);
+        assert_eq!(
+            tumbling_windows(&roots, &grids),
+            [(180_000, 5), (300_000, 3)]
+        );
+        let rule_candidates = tumbling_window_candidates(&roots, &grids);
         assert_eq!(
             shared_grids(&roots, &rule_candidates),
             [vec![], vec![(60_000, 15)]]
         );
     }
 
-    /// A 15-min quantile every minute (15 × 1-min panes) and a 6-min one
-    /// every 90 s (4 × 90-s panes): one chain of 30-s panes over 15 min
+    /// A 15-min quantile every minute (15 × 1-min tumbling windows) and a 6-min one
+    /// every 90 s (4 × 90-s tumbling windows): one chain of 30-s tumbling windows over 15 min
     /// serves both, the 6-min query merging the newest 12. It comes beside
     /// the per-query chains, and Stage 3 prices which is cheaper.
     #[test]
-    fn queries_at_60_and_90_seconds_share_one_chain_of_30_second_panes() {
+    fn queries_at_60_and_90_seconds_share_one_chain_of_30_second_tumbling_windows() {
         let roots = chose(
             &[
                 ("quantile_over_time(0.5, m[15m])", 0.01),
@@ -2977,8 +3010,11 @@ mod tests {
             SketchAlgorithm::Kll,
         );
         let grids = [Some(60_000), Some(90_000)];
-        assert_eq!(panes(&roots, &grids), [(60_000, 15), (90_000, 4)]);
-        let rule_candidates = pane_candidates(&roots, &grids);
+        assert_eq!(
+            tumbling_windows(&roots, &grids),
+            [(60_000, 15), (90_000, 4)]
+        );
+        let rule_candidates = tumbling_window_candidates(&roots, &grids);
         assert_eq!(
             shared_grids(&roots, &rule_candidates),
             [vec![], vec![(30_000, 30)]]
@@ -2999,7 +3035,7 @@ mod tests {
 
     /// When the members' finest width divides the others, the gcd is that
     /// width: one shared candidate, not two equal ones. With 1-min, 2-min
-    /// and 3-min panes, the divisible group (1 and 2 min, the 3-min build
+    /// and 3-min tumbling windows, the divisible group (1 and 2 min, the 3-min build
     /// joining at 1 min too) is already the gcd grid.
     #[test]
     fn the_gcd_grid_is_not_listed_twice_when_a_member_width_is_the_gcd() {
@@ -3012,7 +3048,7 @@ mod tests {
             SketchAlgorithm::Kll,
         );
         let grids = [Some(60_000), Some(120_000), Some(180_000)];
-        let rule_candidates = pane_candidates(&roots, &grids);
+        let rule_candidates = tumbling_window_candidates(&roots, &grids);
         assert_eq!(
             shared_grids(&roots, &rule_candidates),
             [vec![], vec![(60_000, 12)]]
@@ -3040,7 +3076,7 @@ mod tests {
         };
         let strict = family(&builds(&roots[0])[0]);
         assert_ne!(strict, family(&builds(&roots[1])[0]));
-        let rule_candidates = pane_candidates(&roots, &[Some(10_000), Some(10_000)]);
+        let rule_candidates = tumbling_window_candidates(&roots, &[Some(10_000), Some(10_000)]);
         let pass2_candidates =
             window_composition_pass2_candidates(&roots, &rule_candidates).unwrap();
         let shared = pass2_candidates
@@ -3236,7 +3272,7 @@ mod tests {
 
     /// The rule reuses only a finer computation the workload already has:
     /// keys that are not a superset, another metric, window or measure, or
-    /// a lone query, give no pane candidate.
+    /// a lone query, give no tumbling-window candidate.
     #[test]
     fn rollup_needs_a_finer_computation_of_the_same_rows() {
         for queries in [
diff --git a/crates/logical-asap-optimization/src/pass2/logical_memo_candidates.rs b/crates/logical-asap-optimization/src/pass2/logical_memo_candidates.rs
index de3c2e298..1720253d3 100644
--- a/crates/logical-asap-optimization/src/pass2/logical_memo_candidates.rs
+++ b/crates/logical-asap-optimization/src/pass2/logical_memo_candidates.rs
@@ -9,7 +9,7 @@ use crate::pass2::memo::rules::{
     finer_aggregate, rollup, scan_labels, shared_configuration_readers, summary_inputs,
     summary_results, topk,
 };
-use crate::pass2::memo::shared_configurations::PaneWidthDomain;
+use crate::pass2::memo::shared_configurations::TumblingWindowWidthDomain;
 use crate::pass2::memo::state_groups::{
     add_shared_summary_state_groups, check_unexpanded_memo, StateGroupExpansionError,
 };
@@ -19,18 +19,18 @@ use asap_types::stages::PerComputationLogicalMemoCandidates;
 use asap_types::stages::{CandidateGenerationTimeout, LogicalASAPMemoCandidates};
 use asap_types::workload::QueryWorkloadEntry;
 
-/// What Pass 2 keeps between pane-width rounds: the memo after local
-/// window composition and before the other rules, and the pane widths it
+/// What Pass 2 keeps between tumbling-window-width rounds: the memo after local
+/// window composition and before the other rules, and the tumbling-window widths it
 /// already holds. Each round adds only the newly exposed widths to it,
 /// then reruns the other rules on a copy.
 #[derive(Debug, Clone)]
 pub struct Pass2RoundState {
     unexpanded_memo: MemoCandidates,
-    previous_domain: Option<PaneWidthDomain>,
+    previous_domain: Option<TumblingWindowWidthDomain>,
 }
 
 impl Pass2RoundState {
-    /// The state before the first round: Pass 1's memo, no pane widths.
+    /// The state before the first round: Pass 1's memo, no tumbling-window widths.
     pub fn new(pass1: PerComputationLogicalMemoCandidates) -> Self {
         Self {
             unexpanded_memo: pass1.memo,
@@ -53,21 +53,21 @@ pub enum LogicalASAPMemoCandidatesError {
     #[error(transparent)]
     LocalWindowComposition(CandidateGenerationTimeout),
     /// A later rule or the shared summary-state groups failed. The
-    /// [`Pass2RoundState`] already holds this round's pane widths and stays
+    /// [`Pass2RoundState`] already holds this round's tumbling-window widths and stays
     /// usable for the next round.
     #[error(transparent)]
     Expansion(#[from] StateGroupExpansionError),
 }
 
-/// Stage 1, Pass 2 for one pane-width round: adds to `round`'s memo the
-/// local pane candidates for the widths of `domain` that earlier rounds did
+/// Stage 1, Pass 2 for one tumbling-window-width round: adds to `round`'s memo the
+/// local tumbling-window candidates for the widths of `domain` that earlier rounds did
 /// not generate (rule 1), records `domain` in `round`, then runs rules 2–9
 /// and `add_shared_summary_state_groups` on a copy and returns it.
 /// `entries[i]` is query `i`'s workload entry. Stops once `deadline` passes.
 pub fn generate_logical_asap_memo_candidates(
     round: &mut Pass2RoundState,
     entries: &[QueryWorkloadEntry],
-    domain: PaneWidthDomain,
+    domain: TumblingWindowWidthDomain,
     deadline: Option<Instant>,
 ) -> Result<LogicalASAPMemoCandidates, LogicalASAPMemoCandidatesError> {
     // 1. Local window composition.
@@ -90,7 +90,7 @@ pub fn generate_logical_asap_memo_candidates(
 /// Pass 2's rules 2–9, in order, on a memo after local window composition.
 pub(crate) fn apply_sharing_rules(
     memo: &mut MemoCandidates,
-    domain: PaneWidthDomain,
+    domain: TumblingWindowWidthDomain,
     deadline: Option<Instant>,
 ) -> Result<(), StateGroupExpansionError> {
     check_generation_deadline(deadline)?;
diff --git a/crates/logical-asap-optimization/src/pass2/memo.rs b/crates/logical-asap-optimization/src/pass2/memo.rs
index 2e0fcaee8..79d991c99 100644
--- a/crates/logical-asap-optimization/src/pass2/memo.rs
+++ b/crates/logical-asap-optimization/src/pass2/memo.rs
@@ -14,7 +14,7 @@ pub(crate) mod rules;
 pub(crate) mod shared_configurations;
 /// Concrete summary-state groups exposed by sharing rules.
 pub(crate) mod state_groups;
-/// Local pane candidates with selected-reader grid configurations.
+/// Local tumbling-window candidates with selected-reader grid configurations.
 pub(crate) mod window_candidates;
 
 use std::collections::{HashMap, HashSet};
diff --git a/crates/logical-asap-optimization/src/pass2/memo/rules/rollup.rs b/crates/logical-asap-optimization/src/pass2/memo/rules/rollup.rs
index b34846714..7c871bef3 100644
--- a/crates/logical-asap-optimization/src/pass2/memo/rules/rollup.rs
+++ b/crates/logical-asap-optimization/src/pass2/memo/rules/rollup.rs
@@ -223,7 +223,7 @@ pub(crate) fn add_rollup_candidates(
     Ok(added)
 }
 
-/// Existing pane rollup rules applied to producer pairs on already generated
+/// Existing tumbling window rollup rules applied to producer pairs on already generated
 /// legal local grids. No whole-workload choice combinations are constructed.
 pub(crate) fn add_window_rollup_candidates(
     memo: &mut MemoCandidates,
@@ -231,7 +231,7 @@ pub(crate) fn add_window_rollup_candidates(
 ) -> Result<usize, StateGroupExpansionError> {
     check_generation_deadline(deadline)?;
     use crate::pass2::asap_aware_cse::{
-        pane_candidates, window_composition_shared_chain_candidates,
+        tumbling_window_candidates, window_composition_shared_chain_candidates,
     };
     let mut grids = vec![std::collections::BTreeSet::new(); memo.groups.len()];
     for (group, candidates) in memo.candidates.iter().enumerate() {
@@ -278,11 +278,14 @@ pub(crate) fn add_window_rollup_candidates(
                     QueryRoot::Operator(Rc::clone(&coarse.root_node)),
                     QueryRoot::Operator(Rc::clone(&fine.root_node)),
                 ];
-                let panes = pane_candidates(&roots, &[Some(*grid), Some(*grid)]);
-                if panes.len() != 2 {
+                let tumbling_windows =
+                    tumbling_window_candidates(&roots, &[Some(*grid), Some(*grid)]);
+                if tumbling_windows.len() != 2 {
                     continue;
                 }
-                for rewritten in window_composition_shared_chain_candidates(&roots, &panes) {
+                for rewritten in
+                    window_composition_shared_chain_candidates(&roots, &tumbling_windows)
+                {
                     check_generation_deadline(deadline)?;
                     if rewritten.shared_chains.is_empty() {
                         continue;
@@ -334,7 +337,7 @@ mod tests {
     use crate::pass1::per_computation_candidates::generate_per_computation_candidates;
     use crate::pass2::memo::generate_dag_of_logical_memo_groups;
     use crate::pass2::memo::groups::try_populate_pass1;
-    use crate::pass2::memo::shared_configurations::PaneWidthDomain;
+    use crate::pass2::memo::shared_configurations::TumblingWindowWidthDomain;
     use crate::test_support::{lower_promql, sharing_rules_and_shared_state_groups};
     use asap_types::ir::properties::AccuracyTarget;
     use asap_types::ir::QueryRoot;
@@ -356,7 +359,7 @@ mod tests {
                 .unwrap();
         let memo = sharing_rules_and_shared_state_groups(
             try_populate_pass1(initial, &inventory).unwrap(),
-            PaneWidthDomain::Complete,
+            TumblingWindowWidthDomain::Complete,
         )
         .unwrap();
         let root_of = |query: usize| memo.query_roots[query].as_operator().unwrap().0 as usize;
diff --git a/crates/logical-asap-optimization/src/pass2/memo/rules/shared_configuration_readers.rs b/crates/logical-asap-optimization/src/pass2/memo/rules/shared_configuration_readers.rs
index 99fc7f393..cd975db9e 100644
--- a/crates/logical-asap-optimization/src/pass2/memo/rules/shared_configuration_readers.rs
+++ b/crates/logical-asap-optimization/src/pass2/memo/rules/shared_configuration_readers.rs
@@ -1,4 +1,4 @@
-//! Expand compatible readers at finite shared sizes and pane horizons before
+//! Expand compatible readers at finite shared sizes and tumbling-window horizons before
 //! interning concrete states. Local candidates remain available.
 use crate::pass2::memo::check_generation_deadline;
 use std::collections::{HashMap, HashSet};
@@ -12,10 +12,10 @@ use asap_types::ir::{ASAPOp, Operator, OperatorNode, QueryRoot};
 use super::shared_producer::{
     add_shared_producer_candidates, spans_groups, Reader, SharedProducer,
 };
-use crate::pass2::asap_aware_cse::{with_pane_chain, with_resized_build};
+use crate::pass2::asap_aware_cse::{with_resized_build, with_tumbling_window_chain};
 use crate::pass2::memo::shared_configurations::{
-    pane_configurations_before, shared_size, state_size_configurations, PaneConfiguration,
-    PaneRequirement, PaneWidthDomain,
+    shared_size, state_size_configurations, tumbling_window_configurations_before,
+    TumblingWindowConfiguration, TumblingWindowRequirement, TumblingWindowWidthDomain,
 };
 use crate::pass2::memo::state_groups::{same_range_input, simple_build, StateGroupExpansionError};
 use asap_types::stages::MemoCandidates;
@@ -69,18 +69,18 @@ struct StateNeed {
     /// The reader candidate's `accuracy_budget_parts`: the shares its build
     /// is sized for.
     accuracy_budget_parts: usize,
-    /// The reader's normalized pane layout, when its set shares panes: equal
+    /// The reader's normalized tumbling-window layout, when its set shares tumbling windows: equal
     /// layouts of one set have one index, so a configuration rewrites them once.
     normalized_layout: Option<usize>,
 }
 
-/// A shared build's need: one pane layout (its index among the set's pane
+/// A shared build's need: one tumbling-window layout (its index among the set's tumbling window
 /// configurations, for request deduplication) or one size, with the shares
 /// of the budget its build is sized for ([`covered_parts`]).
 enum StateCovering {
-    Panes {
+    TumblingWindows {
         configuration_index: usize,
-        configuration: PaneConfiguration,
+        configuration: TumblingWindowConfiguration,
         accuracy_budget_parts: usize,
     },
     Size {
@@ -89,13 +89,13 @@ enum StateCovering {
     },
 }
 
-/// Summary builds of one family over one input at different sizes or pane
+/// Summary builds of one family over one input at different sizes or tumbling window
 /// layouts: each reader is rewritten to a build at each covering size or
 /// layout that serves it, and equal concrete builds become one state group
 /// later ([`super::super::state_groups`]).
 struct SummaryStates {
     deduplicate_requests: bool,
-    domain: PaneWidthDomain,
+    domain: TumblingWindowWidthDomain,
     /// Every candidate's graph signature by group, so no rewrite repeats one.
     known: HashMap<(usize, String), Vec<Rc<OperatorNode>>>,
     rewrite_count: usize,
@@ -105,7 +105,7 @@ struct SummaryStates {
 
 pub(crate) fn add_state_configuration_candidates_in_domain(
     memo: &mut MemoCandidates,
-    domain: PaneWidthDomain,
+    domain: TumblingWindowWidthDomain,
     deadline: Option<Instant>,
 ) -> Result<(), StateGroupExpansionError> {
     expand_configurations(memo, true, domain, deadline).map(|_| ())
@@ -114,7 +114,7 @@ pub(crate) fn add_state_configuration_candidates_in_domain(
 fn expand_configurations(
     memo: &mut MemoCandidates,
     deduplicate_requests: bool,
-    domain: PaneWidthDomain,
+    domain: TumblingWindowWidthDomain,
     deadline: Option<Instant>,
 ) -> Result<usize, StateGroupExpansionError> {
     let mut states = SummaryStates {
@@ -168,7 +168,7 @@ impl SharedProducer for SummaryStates {
                         matches!(node.asap(), Some(ASAPOp::SummaryMerge {children, group_by: None, ..})
                             if children.len() == 1 && Rc::ptr_eq(&children[0], &build))
                     }).collect();
-                    // The existing rewrite changes one plain merge. Other pane uses
+                    // The existing rewrite changes one plain merge. Other tumbling window uses
                     // need their own explicit transformation, not guessed semantics.
                     if merges.len() != 1 {
                         continue;
@@ -221,11 +221,11 @@ impl SharedProducer for SummaryStates {
         set: &[Reader<StateNeed>],
         deadline: Option<Instant>,
     ) -> Result<Vec<StateCovering>, StateGroupExpansionError> {
-        let pane_requirements: Option<Vec<_>> = set
+        let tumbling_window_requirements: Option<Vec<_>> = set
             .iter()
-            .map(|reader| pane_requirement(&reader.need))
+            .map(|reader| tumbling_window_requirement(&reader.need))
             .collect();
-        let Some(requirements) = pane_requirements else {
+        let Some(requirements) = tumbling_window_requirements else {
             let requirements = set
                 .iter()
                 .map(|reader| match &reader.need.family {
@@ -254,11 +254,11 @@ impl SharedProducer for SummaryStates {
                 .collect());
         };
         Ok(
-            pane_configurations_before(&requirements, self.domain, deadline)?
+            tumbling_window_configurations_before(&requirements, self.domain, deadline)?
                 .into_iter()
                 .enumerate()
                 .map(
-                    |(configuration_index, configuration)| StateCovering::Panes {
+                    |(configuration_index, configuration)| StateCovering::TumblingWindows {
                         configuration_index,
                         accuracy_budget_parts: covered_parts(&configuration.family, set),
                         configuration,
@@ -276,9 +276,8 @@ impl SharedProducer for SummaryStates {
     ) -> Result<usize, StateGroupExpansionError> {
         let need = &reader.need;
         let serves = match covering {
-            StateCovering::Panes { configuration, .. } => {
-                configuration.serves(&pane_requirement(need).expect("pane set"))
-            }
+            StateCovering::TumblingWindows { configuration, .. } => configuration
+                .serves(&tumbling_window_requirement(need).expect("tumbling window set")),
             StateCovering::Size { family, .. } => serves_size(family, &need.family),
         };
         if !serves {
@@ -287,7 +286,7 @@ impl SharedProducer for SummaryStates {
         let original = memo.candidates[reader.group][need.candidate].clone();
         let roots = [QueryRoot::Operator(Rc::clone(&original.root_node))];
         let result = match covering {
-            StateCovering::Panes {
+            StateCovering::TumblingWindows {
                 configuration_index,
                 configuration,
                 ..
@@ -305,7 +304,7 @@ impl SharedProducer for SummaryStates {
                     return Ok(0);
                 }
                 self.rewrite_count += 1;
-                with_pane_chain(
+                with_tumbling_window_chain(
                     &roots,
                     need.merge.as_ref().unwrap(),
                     configuration.family.clone(),
@@ -352,7 +351,7 @@ impl SharedProducer for SummaryStates {
         // The rewritten build is sized for the covering's shares, at least
         // the reader's own.
         candidate.accuracy_budget_parts = match covering {
-            StateCovering::Panes {
+            StateCovering::TumblingWindows {
                 accuracy_budget_parts,
                 ..
             }
@@ -366,10 +365,10 @@ impl SharedProducer for SummaryStates {
     }
 }
 
-/// Numbers the normalized pane layouts of `set`'s readers, when it shares
-/// panes: different original layouts can produce the same requested
+/// Numbers the normalized tumbling-window layouts of `set`'s readers, when it shares
+/// tumbling windows: different original layouts can produce the same requested
 /// reader/configuration, so each is normalized once and its rewrite made once,
-/// instead of once for every existing pane width. Numbers continue across
+/// instead of once for every existing tumbling-window width. Numbers continue across
 /// sets (`layouts`), so a configuration index of one set never matches
 /// another's.
 fn assign_normalized_layouts(
@@ -380,7 +379,7 @@ fn assign_normalized_layouts(
 ) -> Result<(), StateGroupExpansionError> {
     let Some(requirements) = set
         .iter()
-        .map(|reader| pane_requirement(&reader.need))
+        .map(|reader| tumbling_window_requirement(&reader.need))
         .collect::<Option<Vec<_>>>()
     else {
         return Ok(());
@@ -395,7 +394,7 @@ fn assign_normalized_layouts(
         let need = &reader.need;
         let original = &memo.candidates[reader.group][need.candidate];
         let roots = [QueryRoot::Operator(Rc::clone(&original.root_node))];
-        let normalized = with_pane_chain(
+        let normalized = with_tumbling_window_chain(
             &roots,
             need.merge.as_ref().unwrap(),
             need.family.clone(),
@@ -431,7 +430,7 @@ fn graph_signature(node: &Rc<OperatorNode>) -> Result<String, StateGroupExpansio
         .map_err(|error| StateGroupExpansionError::StateConfiguration(error.to_string()))
 }
 
-fn pane_requirement(reader: &StateNeed) -> Option<PaneRequirement> {
+fn tumbling_window_requirement(reader: &StateNeed) -> Option<TumblingWindowRequirement> {
     let ASAPOp::SummaryTumblingWindowChain {
         tumbling_window_width_ms,
         tumbling_window_count,
@@ -447,7 +446,7 @@ fn pane_requirement(reader: &StateNeed) -> Option<PaneRequirement> {
     else {
         return None;
     };
-    Some(PaneRequirement {
+    Some(TumblingWindowRequirement {
         tumbling_window_width_ms: *tumbling_window_width_ms,
         window_ms: tumbling_window_width_ms.checked_mul(u64::from(
             newest_tumbling_windows.unwrap_or(*tumbling_window_count),
@@ -538,9 +537,9 @@ mod tests {
     use asap_types::workload::{QueryRecurrence, RepeatedDemand, RepetitionInterval};
 
     // Request deduplication preserves the entire declared finite configuration
-    // set while avoiding repeated rewrites through every initial pane layout.
+    // set while avoiding repeated rewrites through every initial tumbling-window layout.
     #[test]
-    fn equivalent_pane_layouts_expand_each_configuration_once() {
+    fn equivalent_tumbling_window_layouts_expand_each_configuration_once() {
         let target = AccuracyTarget::max_error(0.01).failure_probability(0.001);
         let roots: Vec<_> = [0.95, 0.99]
             .into_iter()
@@ -566,10 +565,15 @@ mod tests {
         crate::pass2::memo::window_candidates::add_local_window_composition(&mut memo, &entries);
         let mut unoptimized = memo.clone();
         let optimized_rewrites =
-            expand_configurations(&mut memo, true, PaneWidthDomain::Complete, None).unwrap();
-        let exhaustive_rewrites =
-            expand_configurations(&mut unoptimized, false, PaneWidthDomain::Complete, None)
+            expand_configurations(&mut memo, true, TumblingWindowWidthDomain::Complete, None)
                 .unwrap();
+        let exhaustive_rewrites = expand_configurations(
+            &mut unoptimized,
+            false,
+            TumblingWindowWidthDomain::Complete,
+            None,
+        )
+        .unwrap();
         assert!(
             optimized_rewrites < exhaustive_rewrites,
             "{optimized_rewrites} versus {exhaustive_rewrites}"
@@ -655,7 +659,7 @@ mod tests {
             "{parts_of_size:?}"
         );
         let before = memo.candidates.iter().map(Vec::len).sum::<usize>();
-        expand_configurations(&mut memo, true, PaneWidthDomain::SeedGrids, None).unwrap();
+        expand_configurations(&mut memo, true, TumblingWindowWidthDomain::SeedGrids, None).unwrap();
         assert!(memo.candidates.iter().map(Vec::len).sum::<usize>() > before);
         for candidate in memo.candidates.iter().flatten() {
             for k in kll_sizes(candidate) {
diff --git a/crates/logical-asap-optimization/src/pass2/memo/shared_configurations.rs b/crates/logical-asap-optimization/src/pass2/memo/shared_configurations.rs
index 7a462325d..2a2240572 100644
--- a/crates/logical-asap-optimization/src/pass2/memo/shared_configurations.rs
+++ b/crates/logical-asap-optimization/src/pass2/memo/shared_configurations.rs
@@ -10,7 +10,7 @@ use std::collections::BTreeSet;
 /// Width domain used by the same candidate rules. Seed grids are only a
 /// feasible-plan heuristic; optimality must use the complete domain.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum PaneWidthDomain {
+pub enum TumblingWindowWidthDomain {
     #[default]
     Complete,
     SeedGrids,
@@ -23,17 +23,17 @@ pub enum PaneWidthDomain {
 }
 
 #[cfg(test)]
-pub(crate) fn pane_width_domain(
+pub(crate) fn tumbling_window_width_domain(
     grids: impl IntoIterator<Item = u64>,
-    domain: PaneWidthDomain,
+    domain: TumblingWindowWidthDomain,
 ) -> Vec<u64> {
-    pane_width_domain_before(grids, domain, None)
+    tumbling_window_width_domain_before(grids, domain, None)
         .expect("generation without a deadline cannot time out")
 }
 
-pub(crate) fn pane_width_domain_before(
+pub(crate) fn tumbling_window_width_domain_before(
     grids: impl IntoIterator<Item = u64>,
-    domain: PaneWidthDomain,
+    domain: TumblingWindowWidthDomain,
     deadline: Option<std::time::Instant>,
 ) -> Result<Vec<u64>, asap_types::stages::CandidateGenerationTimeout> {
     super::check_generation_deadline(deadline)?;
@@ -44,10 +44,10 @@ pub(crate) fn pane_width_domain_before(
             widths.insert(width);
         }
     }
-    if domain == PaneWidthDomain::Complete {
+    if domain == TumblingWindowWidthDomain::Complete {
         let mut complete = BTreeSet::new();
         for grid in widths {
-            complete.extend(pane_width_divisors_before(grid, deadline)?);
+            complete.extend(tumbling_window_width_divisors_before(grid, deadline)?);
         }
         return Ok(complete.into_iter().collect());
     }
@@ -68,7 +68,7 @@ pub(crate) fn pane_width_domain_before(
         }
         widths.extend(additional);
     }
-    if let PaneWidthDomain::Expanding { max_parts } = domain {
+    if let TumblingWindowWidthDomain::Expanding { max_parts } = domain {
         // Work is proportional to the requested frontier, not the complete
         // divisor domain. Do not introduce the finest reciprocal width early.
         for grid in grids {
@@ -88,7 +88,7 @@ pub(crate) fn pane_width_domain_before(
 
 /// Integer-domain frontier, independent of expensive candidate graph expansion.
 /// Complete divisor lists are computed once under the caller's deadline.
-pub struct PaneWidthFrontier {
+pub struct TumblingWindowWidthFrontier {
     grids: Vec<u64>,
     complete: Vec<Vec<u64>>,
     previous: Vec<Vec<u64>>,
@@ -96,7 +96,7 @@ pub struct PaneWidthFrontier {
     finished: bool,
 }
 
-impl PaneWidthFrontier {
+impl TumblingWindowWidthFrontier {
     pub fn new(
         grids: impl IntoIterator<Item = u64>,
         deadline: Option<std::time::Instant>,
@@ -109,7 +109,7 @@ impl PaneWidthFrontier {
             .collect();
         let complete = grids
             .iter()
-            .map(|&grid| pane_width_divisors_before(grid, deadline))
+            .map(|&grid| tumbling_window_width_divisors_before(grid, deadline))
             .collect::<Result<Vec<_>, _>>()?;
         let previous = grids.iter().map(|&grid| vec![grid]).collect();
         Ok(Self {
@@ -126,7 +126,8 @@ impl PaneWidthFrontier {
     pub fn next_domain(
         &mut self,
         deadline: Option<std::time::Instant>,
-    ) -> Result<Option<PaneWidthDomain>, asap_types::stages::CandidateGenerationTimeout> {
+    ) -> Result<Option<TumblingWindowWidthDomain>, asap_types::stages::CandidateGenerationTimeout>
+    {
         while !self.finished {
             super::check_generation_deadline(deadline)?;
             let current: Vec<Vec<u64>> = self
@@ -144,11 +145,11 @@ impl PaneWidthFrontier {
             self.max_parts = self.max_parts.saturating_mul(2);
             if current == self.complete {
                 self.finished = true;
-                return Ok(Some(PaneWidthDomain::Complete));
+                return Ok(Some(TumblingWindowWidthDomain::Complete));
             }
             if current != self.previous {
                 self.previous = current;
-                return Ok(Some(PaneWidthDomain::Expanding {
+                return Ok(Some(TumblingWindowWidthDomain::Expanding {
                     max_parts: self.max_parts / 2,
                 }));
             }
@@ -158,19 +159,19 @@ impl PaneWidthFrontier {
 }
 
 #[derive(Debug, Clone)]
-pub(crate) struct PaneRequirement {
+pub(crate) struct TumblingWindowRequirement {
     pub tumbling_window_width_ms: u64,
     pub window_ms: u64,
     pub family: FieldDataType,
 }
 #[derive(Debug, Clone, PartialEq)]
-pub(crate) struct PaneConfiguration {
+pub(crate) struct TumblingWindowConfiguration {
     pub tumbling_window_width_ms: u64,
     pub longest_window_ms: u64,
     pub family: FieldDataType,
 }
-impl PaneConfiguration {
-    pub fn serves(&self, reader: &PaneRequirement) -> bool {
+impl TumblingWindowConfiguration {
+    pub fn serves(&self, reader: &TumblingWindowRequirement) -> bool {
         self.tumbling_window_width_ms > 0
             && reader
                 .tumbling_window_width_ms
@@ -190,12 +191,12 @@ impl PaneConfiguration {
 /// The time representation fixes the search resolution; no representative-width
 /// sampling or arbitrary candidate cap changes this domain.
 #[cfg(test)]
-pub(crate) fn pane_width_divisors(grid_ms: u64) -> Vec<u64> {
-    pane_width_divisors_before(grid_ms, None)
+pub(crate) fn tumbling_window_width_divisors(grid_ms: u64) -> Vec<u64> {
+    tumbling_window_width_divisors_before(grid_ms, None)
         .expect("generation without a deadline cannot time out")
 }
 
-fn pane_width_divisors_before(
+fn tumbling_window_width_divisors_before(
     grid_ms: u64,
     deadline: Option<std::time::Instant>,
 ) -> Result<Vec<u64>, asap_types::stages::CandidateGenerationTimeout> {
@@ -220,24 +221,26 @@ fn pane_width_divisors_before(
 /// Complete divisor grids, distinct required horizons, and joined state sizes.
 /// This enumerates configurations of one compatible producer, not workload plans.
 #[cfg(test)]
-fn pane_configurations(readers: &[PaneRequirement]) -> Vec<PaneConfiguration> {
-    pane_configurations_in_domain(readers, PaneWidthDomain::Complete)
+fn tumbling_window_configurations(
+    readers: &[TumblingWindowRequirement],
+) -> Vec<TumblingWindowConfiguration> {
+    tumbling_window_configurations_in_domain(readers, TumblingWindowWidthDomain::Complete)
 }
 
 #[cfg(test)]
-fn pane_configurations_in_domain(
-    readers: &[PaneRequirement],
-    domain: PaneWidthDomain,
-) -> Vec<PaneConfiguration> {
-    pane_configurations_before(readers, domain, None)
+fn tumbling_window_configurations_in_domain(
+    readers: &[TumblingWindowRequirement],
+    domain: TumblingWindowWidthDomain,
+) -> Vec<TumblingWindowConfiguration> {
+    tumbling_window_configurations_before(readers, domain, None)
         .expect("generation without a deadline cannot time out")
 }
 
-pub(crate) fn pane_configurations_before(
-    readers: &[PaneRequirement],
-    domain: PaneWidthDomain,
+pub(crate) fn tumbling_window_configurations_before(
+    readers: &[TumblingWindowRequirement],
+    domain: TumblingWindowWidthDomain,
     deadline: Option<std::time::Instant>,
-) -> Result<Vec<PaneConfiguration>, asap_types::stages::CandidateGenerationTimeout> {
+) -> Result<Vec<TumblingWindowConfiguration>, asap_types::stages::CandidateGenerationTimeout> {
     super::check_generation_deadline(deadline)?;
     if readers
         .iter()
@@ -245,7 +248,7 @@ pub(crate) fn pane_configurations_before(
     {
         return Ok(Vec::new());
     }
-    let grids = pane_width_domain_before(
+    let grids = tumbling_window_width_domain_before(
         readers.iter().map(|reader| {
             greatest_common_divisor(reader.tumbling_window_width_ms, reader.window_ms)
         }),
@@ -255,7 +258,7 @@ pub(crate) fn pane_configurations_before(
     let mut configurations = Vec::new();
     for &tumbling_window_width_ms in &grids {
         super::check_generation_deadline(deadline)?;
-        let eligible: Vec<&PaneRequirement> = readers
+        let eligible: Vec<&TumblingWindowRequirement> = readers
             .iter()
             .filter(|r| {
                 r.tumbling_window_width_ms
@@ -289,12 +292,12 @@ pub(crate) fn pane_configurations_before(
             super::check_generation_deadline(deadline)?;
             for family in &sizes {
                 super::check_generation_deadline(deadline)?;
-                let configuration = PaneConfiguration {
+                let configuration = TumblingWindowConfiguration {
                     tumbling_window_width_ms,
                     longest_window_ms,
                     family: family.clone(),
                 };
-                let admitted: Vec<&&PaneRequirement> = eligible
+                let admitted: Vec<&&TumblingWindowRequirement> = eligible
                     .iter()
                     .filter(|r| configuration.serves(r))
                     .collect();
@@ -461,20 +464,20 @@ mod tests {
     // Equal physical capacities still carry distinct recorded error contracts;
     // only the joined contract may serve the stricter probability requirement.
     #[test]
-    fn pane_configuration_keeps_failure_probability_contract() {
-        let weaker = PaneConfiguration {
+    fn tumbling_window_configuration_keeps_failure_probability_contract() {
+        let weaker = TumblingWindowConfiguration {
             tumbling_window_width_ms: 1000,
             longest_window_ms: 5000,
             family: kll(None),
         };
-        let strict = PaneRequirement {
+        let strict = TumblingWindowRequirement {
             tumbling_window_width_ms: 1000,
             window_ms: 5000,
             family: kll(Some(0.001)),
         };
         assert!(!weaker.serves(&strict));
-        let configurations = pane_configurations(&[
-            PaneRequirement {
+        let configurations = tumbling_window_configurations(&[
+            TumblingWindowRequirement {
                 family: kll(None),
                 ..strict.clone()
             },
@@ -492,34 +495,40 @@ mod tests {
     // just the coarsest width or GCDs of the readers' original configurations.
     #[test]
     fn width_frontier_skips_empty_rounds_and_detects_actual_completion() {
-        let mut frontier = PaneWidthFrontier::new([97], None).unwrap();
+        let mut frontier = TumblingWindowWidthFrontier::new([97], None).unwrap();
         assert_eq!(
             frontier.next_domain(None).unwrap(),
-            Some(PaneWidthDomain::Complete)
+            Some(TumblingWindowWidthDomain::Complete)
         );
         assert_eq!(frontier.next_domain(None).unwrap(), None);
-        let mut frontier = PaneWidthFrontier::new([12], None).unwrap();
+        let mut frontier = TumblingWindowWidthFrontier::new([12], None).unwrap();
         assert_eq!(
             frontier.next_domain(None).unwrap(),
-            Some(PaneWidthDomain::Expanding { max_parts: 4 })
+            Some(TumblingWindowWidthDomain::Expanding { max_parts: 4 })
         );
         assert_eq!(
             frontier.next_domain(None).unwrap(),
-            Some(PaneWidthDomain::Expanding { max_parts: 8 })
+            Some(TumblingWindowWidthDomain::Expanding { max_parts: 8 })
         );
         assert_eq!(
             frontier.next_domain(None).unwrap(),
-            Some(PaneWidthDomain::Complete)
+            Some(TumblingWindowWidthDomain::Complete)
+        );
+        assert!(
+            TumblingWindowWidthFrontier::new([u64::MAX], Some(std::time::Instant::now())).is_err()
         );
-        assert!(PaneWidthFrontier::new([u64::MAX], Some(std::time::Instant::now())).is_err());
     }
 
     #[test]
     fn expanding_widths_are_nested_and_eventually_complete() {
         let grids = [60, 90];
-        let mut previous = pane_width_domain(grids, PaneWidthDomain::SeedGrids);
+        let mut previous =
+            tumbling_window_width_domain(grids, TumblingWindowWidthDomain::SeedGrids);
         for max_parts in [2, 4, 8, 16, 32, 64, 128] {
-            let next = pane_width_domain(grids, PaneWidthDomain::Expanding { max_parts });
+            let next = tumbling_window_width_domain(
+                grids,
+                TumblingWindowWidthDomain::Expanding { max_parts },
+            );
             assert!(previous.iter().all(|width| next.contains(width)));
             assert!(next
                 .iter()
@@ -528,17 +537,20 @@ mod tests {
         }
         assert_eq!(
             previous,
-            pane_width_domain(grids, PaneWidthDomain::Complete)
+            tumbling_window_width_domain(grids, TumblingWindowWidthDomain::Complete)
         );
     }
 
     #[test]
-    fn expanding_domain_defers_fine_panes_and_obeys_deadline() {
-        let widths = pane_width_domain([60_000], PaneWidthDomain::Expanding { max_parts: 4 });
+    fn expanding_domain_defers_fine_tumbling_windows_and_obeys_deadline() {
+        let widths = tumbling_window_width_domain(
+            [60_000],
+            TumblingWindowWidthDomain::Expanding { max_parts: 4 },
+        );
         assert_eq!(widths, vec![15_000, 20_000, 30_000, 60_000]);
-        assert!(pane_width_domain_before(
+        assert!(tumbling_window_width_domain_before(
             [u64::MAX],
-            PaneWidthDomain::Expanding {
+            TumblingWindowWidthDomain::Expanding {
                 max_parts: u64::MAX
             },
             Some(std::time::Instant::now()),
@@ -547,13 +559,13 @@ mod tests {
     }
 
     #[test]
-    fn pane_width_domain_contains_every_legal_divisor() {
-        let reader = PaneRequirement {
+    fn tumbling_window_width_domain_contains_every_legal_divisor() {
+        let reader = TumblingWindowRequirement {
             tumbling_window_width_ms: 12,
             window_ms: 60,
             family: kll(None),
         };
-        let widths: BTreeSet<_> = pane_configurations(&[reader])
+        let widths: BTreeSet<_> = tumbling_window_configurations(&[reader])
             .into_iter()
             .map(|configuration| configuration.tumbling_window_width_ms)
             .collect();
@@ -567,7 +579,7 @@ mod tests {
             let expected: Vec<_> = (1..=grid)
                 .filter(|width| grid.is_multiple_of(*width))
                 .collect();
-            assert_eq!(pane_width_divisors(grid), expected);
+            assert_eq!(tumbling_window_width_divisors(grid), expected);
         }
     }
 
@@ -577,16 +589,18 @@ mod tests {
     #[ignore = "flaky: depends on a wall-clock deadline (#1067)"]
     fn large_grid_enumeration_honors_deadline() {
         let deadline = std::time::Instant::now() + std::time::Duration::from_millis(2);
-        assert!(
-            pane_width_domain_before([u64::MAX], PaneWidthDomain::Complete, Some(deadline),)
-                .is_err()
-        );
+        assert!(tumbling_window_width_domain_before(
+            [u64::MAX],
+            TumblingWindowWidthDomain::Complete,
+            Some(deadline),
+        )
+        .is_err());
     }
 
     // Public finite enumeration rejects invalid grids instead of dividing by zero.
     #[test]
-    fn invalid_pane_grid_has_no_configurations() {
-        assert!(pane_configurations(&[PaneRequirement {
+    fn invalid_tumbling_window_grid_has_no_configurations() {
+        assert!(tumbling_window_configurations(&[TumblingWindowRequirement {
             tumbling_window_width_ms: 0,
             window_ms: 5000,
             family: kll(None)
diff --git a/crates/logical-asap-optimization/src/pass2/memo/state_groups.rs b/crates/logical-asap-optimization/src/pass2/memo/state_groups.rs
index 103d7d1dc..c58f89d22 100644
--- a/crates/logical-asap-optimization/src/pass2/memo/state_groups.rs
+++ b/crates/logical-asap-optimization/src/pass2/memo/state_groups.rs
@@ -1,7 +1,7 @@
 //! Opt-in concrete summary-state groups for the candidate-connection planner.
 //!
-//! Simple summary builds and pane chains directly over canonical input groups
-//! gain finite compatible sizes and pane horizons before exact state interning.
+//! Simple summary builds and tumbling-window chains directly over canonical input groups
+//! gain finite compatible sizes and tumbling-window horizons before exact state interning.
 //! Concrete state identity includes capacity, guarantee, update/filter semantics,
 //! and materialization. Supported private projections/filters gain explicit input groups.
 
@@ -475,12 +475,12 @@ mod tests {
         added_reader_candidates: usize,
     }
 
-    /// Pass 2 after local window composition, over the complete pane-width
+    /// Pass 2 after local window composition, over the complete tumbling-window-width
     /// domain, as the Pass 2 entry runs it.
     fn expand(memo: MemoCandidates) -> Result<Expanded, StateGroupExpansionError> {
         let memo = crate::test_support::sharing_rules_and_shared_state_groups(
             memo,
-            super::super::shared_configurations::PaneWidthDomain::Complete,
+            super::super::shared_configurations::TumblingWindowWidthDomain::Complete,
         )?;
         Ok(expanded(memo))
     }
@@ -506,7 +506,7 @@ mod tests {
     // linear state lookup and compare every generated candidate and state.
     #[test]
     fn indexed_state_interning_preserves_linear_catalog() {
-        let memo = with_local_panes(
+        let memo = with_local_tumbling_windows(
             workload(&[
                 ("quantile_over_time(0.95, latency[5m])", 0.01),
                 ("quantile_over_time(0.99, latency[15m])", 0.02),
@@ -514,7 +514,7 @@ mod tests {
             ]),
             &[6, 6, 6],
         );
-        let domain = super::super::shared_configurations::PaneWidthDomain::Complete;
+        let domain = super::super::shared_configurations::TumblingWindowWidthDomain::Complete;
         let mut memo = memo;
         crate::pass2::logical_memo_candidates::apply_sharing_rules(&mut memo, domain, None)
             .unwrap();
@@ -561,7 +561,7 @@ mod tests {
         assert!(matches!(
             crate::pass2::logical_memo_candidates::apply_sharing_rules(
                 &mut memo,
-                super::super::shared_configurations::PaneWidthDomain::Complete,
+                super::super::shared_configurations::TumblingWindowWidthDomain::Complete,
                 Some(Instant::now())
             ),
             Err(StateGroupExpansionError::DeadlineExceeded(_))
@@ -685,8 +685,10 @@ mod tests {
         assert_eq!(expanded.memo.groups.len(), count);
     }
 
-    fn with_local_panes(mut memo: MemoCandidates, grids: &[u64]) -> MemoCandidates {
-        use crate::pass2::asap_aware_cse::{pane_candidates, window_composition_pass2_candidates};
+    fn with_local_tumbling_windows(mut memo: MemoCandidates, grids: &[u64]) -> MemoCandidates {
+        use crate::pass2::asap_aware_cse::{
+            tumbling_window_candidates, window_composition_pass2_candidates,
+        };
 
         let boundaries: HashMap<_, _> = memo
             .groups
@@ -698,11 +700,11 @@ mod tests {
             let grid = grids[memo.groups[group].queries[0]];
             for candidate in memo.candidates[group].clone() {
                 let roots = vec![QueryRoot::Operator(Rc::clone(&candidate.root_node))];
-                let panes = pane_candidates(&roots, &[Some(grid)]);
-                if panes.len() != 1 {
+                let tumbling_windows = tumbling_window_candidates(&roots, &[Some(grid)]);
+                if tumbling_windows.len() != 1 {
                     continue;
                 }
-                let rewritten = window_composition_pass2_candidates(&roots, &panes)
+                let rewritten = window_composition_pass2_candidates(&roots, &tumbling_windows)
                     .unwrap()
                     .remove(0)
                     .roots
@@ -710,9 +712,9 @@ mod tests {
                 let QueryRoot::Operator(node) = &rewritten[0] else {
                     unreachable!()
                 };
-                // Pane rewriting recomposes guarantees; restore the original
+                // Tumbling window rewriting recomposes guarantees; restore the original
                 // canonical scan boundary rather than making it a private input.
-                let input = panes[0].build.children()[0].children()[0].clone();
+                let input = tumbling_windows[0].build.children()[0].children()[0].clone();
                 let chain = OperatorNode::reachable(node)
                     .into_iter()
                     .find(|node| {
@@ -720,21 +722,21 @@ mod tests {
                     })
                     .unwrap();
                 let node = replace_node(node, chain.children()[0], &input);
-                let mut pane = candidate;
-                pane.root_node = Rc::clone(&node);
-                pane.input_groups = boundary_groups(&node, &boundaries);
-                pane.origin = OriginOfCandidateForMemoGroup::TumblingWindows;
-                memo.candidates[group].push(pane);
+                let mut tumbling_window = candidate;
+                tumbling_window.root_node = Rc::clone(&node);
+                tumbling_window.input_groups = boundary_groups(&node, &boundaries);
+                tumbling_window.origin = OriginOfCandidateForMemoGroup::TumblingWindows;
+                memo.candidates[group].push(tumbling_window);
             }
         }
         memo
     }
 
-    // Different label projections can consume one wider pane state through
+    // Different label projections can consume one wider tumbling-window state through
     // typed reader projections; no original scan needs to contain the union.
     #[test]
-    fn disjoint_scan_labels_share_a_union_pane_state_with_typed_readers() {
-        let original = with_local_panes(
+    fn disjoint_scan_labels_share_a_union_tumbling_window_state_with_typed_readers() {
+        let original = with_local_tumbling_windows(
             workload(&[
                 ("avg by (job) (quantile_over_time(0.95, latency[5m]))", 0.01),
                 (
@@ -824,8 +826,8 @@ mod tests {
     // Widening shifts identity's position but must retain its full typed field
     // and remap the source's unique key rather than treating it as a plain label.
     #[test]
-    fn widened_pane_inputs_preserve_series_identity_and_keys() {
-        let memo = with_local_panes(
+    fn widened_tumbling_window_inputs_preserve_series_identity_and_keys() {
+        let memo = with_local_tumbling_windows(
             workload_with_identity(
                 &[
                     ("avg by (job) (quantile_over_time(0.95, latency[5m]))", 0.01),
@@ -857,7 +859,7 @@ mod tests {
                             .any(|field| field.name == *name)
                     })
             })
-            .expect("identity-carrying union pane state");
+            .expect("identity-carrying union tumbling-window state");
         let input = state.logical_node.children()[0];
         assert!(input.schema.has_promql_series_identity());
         let identity = input
@@ -928,7 +930,7 @@ mod tests {
             let mut memo = workload_with_identity(&queries, true);
             crate::pass2::logical_memo_candidates::apply_sharing_rules(
                 &mut memo,
-                super::super::shared_configurations::PaneWidthDomain::Complete,
+                super::super::shared_configurations::TumblingWindowWidthDomain::Complete,
                 None,
             )
             .unwrap();
@@ -973,7 +975,7 @@ mod tests {
     // Label widening must not erase source predicates in order to create reuse.
     #[test]
     fn scan_label_widening_keeps_different_filters_separate() {
-        let original = with_local_panes(
+        let original = with_local_tumbling_windows(
             workload(&[
                 (
                     "avg by (job) (quantile_over_time(0.95, latency{env=\"a\"}[5m]))",
@@ -993,23 +995,23 @@ mod tests {
             .all(|id| expanded.memo.groups[id.0 as usize].queries.len() == 1));
     }
 
-    // Real pane rewrites expose one identical chain to distinct quantile readers.
+    // Real tumbling window rewrites expose one identical chain to distinct quantile readers.
     #[test]
-    fn identical_local_pane_chains_share_state_without_removing_local_choices() {
-        let original = with_local_panes(
+    fn identical_local_tumbling_window_chains_share_state_without_removing_local_choices() {
+        let original = with_local_tumbling_windows(
             workload(&[
                 ("quantile_over_time(0.95, latency[5m])", 0.01),
                 ("quantile_over_time(0.99, latency[5m])", 0.01),
             ]),
             &[60_000, 60_000],
         );
-        let local_panes = original
+        let local_tumbling_windows = original
             .candidates
             .iter()
             .flatten()
             .filter(|candidate| candidate.origin == OriginOfCandidateForMemoGroup::TumblingWindows)
             .count();
-        assert!(local_panes >= 2);
+        assert!(local_tumbling_windows >= 2);
         let expanded = expand(original.clone()).unwrap();
         let chains: Vec<_> = expanded
             .state_groups
@@ -1050,8 +1052,8 @@ mod tests {
 
     // A finer grid and longer horizon serves a shorter reader through newest_tumbling_windows.
     #[test]
-    fn different_pane_grids_and_horizons_gain_explicit_newest_pane_readers() {
-        let original = with_local_panes(
+    fn different_tumbling_window_grids_and_horizons_gain_explicit_newest_tumbling_window_readers() {
+        let original = with_local_tumbling_windows(
             workload(&[
                 ("quantile_over_time(0.95, latency[5m])", 0.01),
                 ("quantile_over_time(0.99, latency[15m])", 0.02),
@@ -1279,7 +1281,7 @@ mod tests {
                 .any(|after| Rc::ptr_eq(&before.root_node, &after.root_node))));
     }
 
-    // A global SQL-window quantile can consume newest panes of a longer,
+    // A global SQL-window quantile can consume newest tumbling windows of a longer,
     // finer-grouped chain through the existing regrouping rule.
     #[test]
     fn grouped_window_rollup_exposes_one_finer_chain() {
@@ -1323,7 +1325,7 @@ mod tests {
         let generated =
             generate_per_computation_candidates(&generate_dag_of_logical_memo_groups(&roots))
                 .unwrap();
-        let memo = with_local_panes(
+        let memo = with_local_tumbling_windows(
             try_populate_pass1(initial, &generated).unwrap(),
             &[10_000, 10_000],
         );
diff --git a/crates/logical-asap-optimization/src/pass2/memo/window_candidates.rs b/crates/logical-asap-optimization/src/pass2/memo/window_candidates.rs
index 154e14002..ef505371d 100644
--- a/crates/logical-asap-optimization/src/pass2/memo/window_candidates.rs
+++ b/crates/logical-asap-optimization/src/pass2/memo/window_candidates.rs
@@ -1,10 +1,14 @@
-//! Local pane candidates generated from compatible reader grids. Selected
+//! Local tumbling-window candidates generated from compatible reader grids. Selected
 //! connections, not the union of potential consumers, determine eligibility.
 #[cfg(test)]
-use super::shared_configurations::pane_width_divisors;
-use super::shared_configurations::{pane_width_domain_before, PaneWidthDomain};
+use super::shared_configurations::tumbling_window_width_divisors;
+use super::shared_configurations::{
+    tumbling_window_width_domain_before, TumblingWindowWidthDomain,
+};
 use super::{check_generation_deadline, CandidateGenerationTimeout};
-use crate::pass2::asap_aware_cse::{pane_candidates, window_composition_pass2_candidates};
+use crate::pass2::asap_aware_cse::{
+    tumbling_window_candidates, window_composition_pass2_candidates,
+};
 use asap_types::ir::flat::flatten;
 use asap_types::ir::{OperatorNode, QueryRoot};
 use asap_types::stages::{
@@ -22,14 +26,14 @@ use std::time::Instant;
 /// chosen consumers, including ingestion alignment and range evaluation steps.
 #[cfg(any(test, feature = "test-support"))]
 pub fn add_local_window_composition(memo: &mut Memo, entries: &[QueryWorkloadEntry]) {
-    add_local_window_composition_in_domain(memo, entries, PaneWidthDomain::Complete);
+    add_local_window_composition_in_domain(memo, entries, TumblingWindowWidthDomain::Complete);
 }
 
 #[cfg(any(test, feature = "test-support"))]
 pub fn add_local_window_composition_in_domain(
     memo: &mut Memo,
     entries: &[QueryWorkloadEntry],
-    domain: PaneWidthDomain,
+    domain: TumblingWindowWidthDomain,
 ) {
     try_add_local_window_composition_in_domain(memo, entries, domain, None)
         .expect("generation without a deadline cannot time out");
@@ -40,24 +44,24 @@ pub fn add_local_window_composition_in_domain(
 pub(crate) fn try_add_local_window_composition_in_domain(
     memo: &mut Memo,
     entries: &[QueryWorkloadEntry],
-    domain: PaneWidthDomain,
+    domain: TumblingWindowWidthDomain,
     deadline: Option<Instant>,
 ) -> Result<(), CandidateGenerationTimeout> {
     extend_local_window_composition(memo, entries, None, domain, deadline)
 }
 
-/// Extend a pre-state-expansion memo with only newly exposed pane widths.
+/// Extend a pre-state-expansion memo with only newly exposed tumbling-window widths.
 /// `previous` must describe widths already generated for this memo.
 pub(crate) fn extend_local_window_composition(
     memo: &mut Memo,
     entries: &[QueryWorkloadEntry],
-    previous: Option<PaneWidthDomain>,
-    domain: PaneWidthDomain,
+    previous: Option<TumblingWindowWidthDomain>,
+    domain: TumblingWindowWidthDomain,
     deadline: Option<Instant>,
 ) -> Result<(), CandidateGenerationTimeout> {
     check_generation_deadline(deadline)?;
     // Flatten each existing/generated graph once. Repeatedly flattening the
-    // growing candidate list makes a complete pane-width domain quadratic.
+    // growing candidate list makes a complete tumbling-window-width domain quadratic.
     let mut known: HashMap<(usize, String), Vec<usize>> = HashMap::new();
     for (group, candidates) in memo.candidates.iter().enumerate() {
         check_generation_deadline(deadline)?;
@@ -69,7 +73,7 @@ pub(crate) fn extend_local_window_composition(
         }
     }
     for (group, candidate) in
-        local_pane_candidates_delta(memo, entries, previous, domain, deadline)?
+        local_tumbling_window_candidates_delta(memo, entries, previous, domain, deadline)?
     {
         check_generation_deadline(deadline)?;
         let Ok(signature) = candidate_signature(&candidate) else {
@@ -93,31 +97,36 @@ pub(crate) fn extend_local_window_composition(
     Ok(())
 }
 
-/// Expand legal pane widths while preserving canonical memo inputs.
+/// Expand legal tumbling-window widths while preserving canonical memo inputs.
 #[cfg(test)]
-fn local_pane_candidates(
+fn local_tumbling_window_candidates(
     memo: &Memo,
     entries: &[QueryWorkloadEntry],
 ) -> Vec<(usize, CandidateForMemoGroup)> {
-    local_pane_candidates_before(memo, entries, PaneWidthDomain::Complete, None)
-        .expect("generation without a deadline cannot time out")
+    local_tumbling_window_candidates_before(
+        memo,
+        entries,
+        TumblingWindowWidthDomain::Complete,
+        None,
+    )
+    .expect("generation without a deadline cannot time out")
 }
 
 #[cfg(test)]
-fn local_pane_candidates_before(
+fn local_tumbling_window_candidates_before(
     memo: &Memo,
     entries: &[QueryWorkloadEntry],
-    domain: PaneWidthDomain,
+    domain: TumblingWindowWidthDomain,
     deadline: Option<Instant>,
 ) -> Result<Vec<(usize, CandidateForMemoGroup)>, CandidateGenerationTimeout> {
-    local_pane_candidates_delta(memo, entries, None, domain, deadline)
+    local_tumbling_window_candidates_delta(memo, entries, None, domain, deadline)
 }
 
-fn local_pane_candidates_delta(
+fn local_tumbling_window_candidates_delta(
     memo: &Memo,
     entries: &[QueryWorkloadEntry],
-    previous: Option<PaneWidthDomain>,
-    domain: PaneWidthDomain,
+    previous: Option<TumblingWindowWidthDomain>,
+    domain: TumblingWindowWidthDomain,
     deadline: Option<Instant>,
 ) -> Result<Vec<(usize, CandidateForMemoGroup)>, CandidateGenerationTimeout> {
     check_generation_deadline(deadline)?;
@@ -125,7 +134,7 @@ fn local_pane_candidates_delta(
     let mut own: Vec<(usize, CandidateForMemoGroup)> = Vec::new();
     for (g, group) in memo.groups.iter().enumerate() {
         check_generation_deadline(deadline)?;
-        let grids = pane_width_domain_before(
+        let grids = tumbling_window_width_domain_before(
             group
                 .queries
                 .iter()
@@ -135,7 +144,7 @@ fn local_pane_candidates_delta(
         )?;
         let previous_widths = previous
             .map(|previous| {
-                pane_width_domain_before(
+                tumbling_window_width_domain_before(
                     group
                         .queries
                         .iter()
@@ -170,11 +179,12 @@ fn local_pane_candidates_delta(
                     })
                     .collect::<Vec<_>>();
                 let roots = [QueryRoot::Operator(Rc::clone(&candidate.root_node))];
-                let panes = pane_candidates(&roots, &[Some(grid)]);
-                if panes.is_empty() {
+                let tumbling_windows = tumbling_window_candidates(&roots, &[Some(grid)]);
+                if tumbling_windows.is_empty() {
                     continue;
                 }
-                let Ok(pass2_candidates) = window_composition_pass2_candidates(&roots, &panes)
+                let Ok(pass2_candidates) =
+                    window_composition_pass2_candidates(&roots, &tumbling_windows)
                 else {
                     continue;
                 };
@@ -189,7 +199,7 @@ fn local_pane_candidates_delta(
                     // Guarantee recomposition can clone unchanged source scans.
                     // Restore only an unambiguous original scan with the same full
                     // source/schema/execution contract; scans have intrinsic exact
-                    // semantics. Otherwise the pane's canonical input disappears.
+                    // semantics. Otherwise the tumbling window's canonical input disappears.
                     let mut restored = HashMap::new();
                     for rewritten in OperatorNode::reachable(node) {
                         check_generation_deadline(deadline)?;
@@ -258,15 +268,15 @@ fn restore_scan_boundaries(
 
 // Union of complete divisor domains covers individual readers and every
 // compatible subset: common widths belong to each reader's divisor domain.
-// Nongridded potential consumers do not veto a repeated reader's panes.
+// Nongridded potential consumers do not veto a repeated reader's tumbling windows.
 #[cfg(test)]
 fn compatible_reader_grids(group: &MemoGroup, entries: &[QueryWorkloadEntry]) -> Vec<u64> {
-    super::shared_configurations::pane_width_domain(
+    super::shared_configurations::tumbling_window_width_domain(
         group
             .queries
             .iter()
             .filter_map(|&query| entries.get(query)?.evaluation_grid_ms()),
-        PaneWidthDomain::Complete,
+        TumblingWindowWidthDomain::Complete,
     )
 }
 
@@ -358,7 +368,7 @@ mod tests {
         assert!(try_add_local_window_composition_in_domain(
             &mut memo,
             &entries,
-            PaneWidthDomain::Complete,
+            TumblingWindowWidthDomain::Complete,
             Some(Instant::now())
         )
         .is_err());
@@ -374,14 +384,14 @@ mod tests {
         let mut incremental = base.clone();
         let mut previous = None;
         for domain in [
-            PaneWidthDomain::SeedGrids,
-            PaneWidthDomain::Expanding { max_parts: 4 },
-            PaneWidthDomain::Expanding { max_parts: 8 },
-            PaneWidthDomain::Complete,
+            TumblingWindowWidthDomain::SeedGrids,
+            TumblingWindowWidthDomain::Expanding { max_parts: 4 },
+            TumblingWindowWidthDomain::Expanding { max_parts: 8 },
+            TumblingWindowWidthDomain::Complete,
         ] {
             extend_local_window_composition(&mut incremental, &entries, previous, domain, None)
                 .unwrap();
-            assert!(local_pane_candidates_delta(
+            assert!(local_tumbling_window_candidates_delta(
                 &incremental,
                 &entries,
                 Some(domain),
@@ -431,11 +441,11 @@ mod tests {
         (memo, entries)
     }
 
-    // A nongridded potential reader cannot eliminate another reader's panes.
+    // A nongridded potential reader cannot eliminate another reader's tumbling windows.
     #[test]
-    fn nongridded_potential_reader_preserves_local_pane_candidates() {
+    fn nongridded_potential_reader_preserves_local_tumbling_window_candidates() {
         let (memo, entries) = fixture(&[repeated(60_000), QueryRecurrence::Unknown]);
-        let candidates = local_pane_candidates(&memo, &entries);
+        let candidates = local_tumbling_window_candidates(&memo, &entries);
         assert!(!candidates.is_empty());
         assert!(candidates.iter().all(
             |(_, candidate)| candidate.origin == OriginOfCandidateForMemoGroup::TumblingWindows
@@ -453,9 +463,9 @@ mod tests {
         let group = &memo.groups[memo.query_roots[0].as_operator().unwrap().0 as usize];
         assert_eq!(
             compatible_reader_grids(group, &entries),
-            pane_width_divisors(120_000)
+            tumbling_window_width_divisors(120_000)
                 .into_iter()
-                .chain(pane_width_divisors(180_000))
+                .chain(tumbling_window_width_divisors(180_000))
                 .collect::<BTreeSet<_>>()
                 .into_iter()
                 .collect::<Vec<_>>()
diff --git a/crates/logical-asap-optimization/src/test_support.rs b/crates/logical-asap-optimization/src/test_support.rs
index 2114b1a3c..64115fbd7 100644
--- a/crates/logical-asap-optimization/src/test_support.rs
+++ b/crates/logical-asap-optimization/src/test_support.rs
@@ -11,7 +11,7 @@ pub use crate::pass1::per_computation_candidates::{
     compose_logical_candidate, generate_per_computation_candidates, PerComputationCandidates,
 };
 pub use crate::pass2::asap_aware_cse::{
-    pane_candidates, rollup_candidates, rollup_pass2_candidates,
+    rollup_candidates, rollup_pass2_candidates, tumbling_window_candidates,
     window_composition_pass2_candidates, window_composition_shared_chain_candidates,
     with_union_scan_labels,
 };
@@ -35,7 +35,7 @@ use asap_types::workload::{
 /// [`generate_logical_asap_memo_candidates`](crate::pass2::logical_memo_candidates::generate_logical_asap_memo_candidates).
 pub fn sharing_rules_and_shared_state_groups(
     mut memo: asap_types::stages::MemoCandidates,
-    domain: crate::pass2::memo::shared_configurations::PaneWidthDomain,
+    domain: crate::pass2::memo::shared_configurations::TumblingWindowWidthDomain,
 ) -> Result<
     asap_types::stages::MemoCandidates,
     crate::pass2::memo::state_groups::StateGroupExpansionError,
diff --git a/crates/physical-asap-optimization/Cargo.toml b/crates/physical-asap-optimization/Cargo.toml
index 49acbe7e7..5baeb003a 100644
--- a/crates/physical-asap-optimization/Cargo.toml
+++ b/crates/physical-asap-optimization/Cargo.toml
@@ -13,7 +13,7 @@ edition = "2021"
 [dependencies]
 asap-accuracy = { path = "../accuracy" }
 asap-types = { path = "../types" }
-# The pane retention of a realized plan (`AssignmentRealizer::realize`).
+# The tumbling-window retention of a realized plan (`AssignmentRealizer::realize`).
 asap-cost = { path = "../cost" }
 rmp-serde = "1"
 serde = { version = "1", features = ["derive"] }
@@ -22,7 +22,7 @@ thiserror = "2"
 
 [features]
 # Exposes `test_support` (single-candidate realization, operator
-# implementation, pane coverage, and `test_support::catalog`: catalog
+# implementation, tumbling window coverage, and `test_support::catalog`: catalog
 # internals plan selection's unit tests exercise with its solver), for other
 # crates' tests. Tests also enumerate whole workloads with the reference pricer.
 test-support = ["reference-pricer"]
diff --git a/crates/physical-asap-optimization/src/catalog/configurations.rs b/crates/physical-asap-optimization/src/catalog/configurations.rs
index a778334f0..3bc3cca9b 100644
--- a/crates/physical-asap-optimization/src/catalog/configurations.rs
+++ b/crates/physical-asap-optimization/src/catalog/configurations.rs
@@ -27,7 +27,7 @@ use asap_types::stages::{
 /// [`PhysicalCandidate::may_keep_across_evaluations_per_sole_reader_query`] for `node` configured
 /// with `materialization`: for each query in `entries`, whether
 /// `summary_materialization_eligibility` with that query as the only reader
-/// allows keeping it across evaluations. Empty unless `node` is a pane chain,
+/// allows keeping it across evaluations. Empty unless `node` is a tumbling-window chain,
 /// `materialization` is `MatAtQueryKeptAcrossEvaluations(Memory)` and the
 /// deployment keeps query-time results.
 pub fn may_keep_across_evaluations_per_sole_reader_query(
diff --git a/crates/physical-asap-optimization/src/catalog/realize.rs b/crates/physical-asap-optimization/src/catalog/realize.rs
index dbbc14bb6..81d7c39a0 100644
--- a/crates/physical-asap-optimization/src/catalog/realize.rs
+++ b/crates/physical-asap-optimization/src/catalog/realize.rs
@@ -243,7 +243,7 @@ mod tests {
     use asap_logical_asap_optimization::test_support::{
         entry, lower_promql, sharing_rules_and_shared_state_groups,
     };
-    use asap_logical_asap_optimization::PaneWidthDomain;
+    use asap_logical_asap_optimization::TumblingWindowWidthDomain;
     use asap_types::ir::properties::AccuracyTarget;
     use asap_types::stages::{
         LogicalASAPMemoCandidates, PhysicalCandidateId, SelectedEdge, SelectedNodeId,
@@ -299,7 +299,8 @@ mod tests {
             .unwrap();
         let memo = try_populate_pass1(initial, &per_computation).unwrap();
         let logical = LogicalASAPMemoCandidates {
-            memo: sharing_rules_and_shared_state_groups(memo, PaneWidthDomain::Complete).unwrap(),
+            memo: sharing_rules_and_shared_state_groups(memo, TumblingWindowWidthDomain::Complete)
+                .unwrap(),
         };
         let entries = vec![entry(QueryRecurrence::Unknown)];
         let data = DataWorkload::default();
diff --git a/crates/physical-asap-optimization/src/lib.rs b/crates/physical-asap-optimization/src/lib.rs
index 01c25bf83..d80a6654f 100644
--- a/crates/physical-asap-optimization/src/lib.rs
+++ b/crates/physical-asap-optimization/src/lib.rs
@@ -34,9 +34,9 @@
 //!   kept across evaluations (#509 Example 4's B3), offered when the
 //!   deployment keeps query-time results (the caller's
 //!   `query_time_results_retained`) for a
-//!   tumbling-pane chain that builds one new pane per evaluation
-//!   (`builds_one_pane_per_evaluation`): each evaluation builds the
-//!   newest pane and reuses the others. Both query-time options are offered
+//!   tumbling-window chain that builds one new tumbling window per evaluation
+//!   (`builds_one_tumbling_window_per_evaluation`): each evaluation builds the
+//!   newest tumbling window and reuses the others. Both query-time options are offered
 //!   when both apply, and Stage 3 prices each.
 //!
 //! A build at ingestion time needs every build below it at ingestion time too
@@ -61,9 +61,9 @@
 //!   as Prometheus assumes (it rejects out-of-order samples). Table (SQL)
 //!   sources and mixed data, whose at-rest part may load in any order, are
 //!   not taken to be ordered;
-//! * it is a tumbling-pane chain whose readers all evaluate on its pane
+//! * it is a tumbling-window chain whose readers all evaluate on its tumbling window
 //!   boundaries, anchored at the epoch (each fixed interval a multiple of the
-//!   pane width, and each known phase on that grid), or a whole-window build whose readers
+//!   tumbling-window width, and each known phase on that grid), or a whole-window build whose readers
 //!   all run at one fixed interval with agreeing declared phases, over a
 //!   window that is not shifted and whose evaluations all end on the grid
 //!   of its width anchored at the epoch (the interval and a declared phase
@@ -81,11 +81,11 @@
 //! [`RangeEvaluation`](asap_types::workload::RangeEvaluation) evaluates at
 //! every `step_ms` from `end − span_ms` forward to each request's end.
 //! Every step reads the
-//! panes of a tumbling-pane chain, so each pane width must divide the step
+//! tumbling windows of a tumbling-window chain, so each tumbling-window width must divide the step
 //! of every range-evaluated reader. Stage 1 offers only such widths
 //! (`QueryWorkloadEntry::evaluation_grid_ms`); a candidate with a chain off
 //! a reader's step grid fails with
-//! [`PhysicalASAPOptimizationError::PaneWidthOffRangeStep`] and the caller
+//! [`PhysicalASAPOptimizationError::TumblingWindowWidthOffRangeStep`] and the caller
 //! prunes it with that reason.
 //!
 //! ## Physical operator implementation
@@ -140,7 +140,10 @@ use asap_types::workload::{
     DataArrival, DataWorkload, Predictability, QueryRecurrence, QueryWorkloadEntry, RepeatedDemand,
 };
 use split_by_timing::split_shared_by_timing;
-use summary_window::{plan_pane_phase, validate_pane_coverage, PaneLayout, WindowEdgeCoverage};
+use summary_window::{
+    plan_tumbling_window_phase, validate_tumbling_window_coverage, TumblingWindowLayout,
+    WindowEdgeCoverage,
+};
 use thiserror::Error;
 
 #[derive(Debug, Error)]
@@ -153,17 +156,17 @@ pub enum PhysicalASAPOptimizationError {
     Timing(#[from] ExecutionDataStateError),
     #[error("exact top-k has no Sort + Limit implementation: {0}")]
     ExactTopK(String),
-    /// Bad candidate for the workload: a tumbling-pane chain whose pane
+    /// Bad candidate for the workload: a tumbling-window chain whose tumbling window
     /// width does not divide the step of a query that reads it as a range
-    /// request, so some step would end inside a pane and could not read
-    /// the panes. Stage 1 offers only panes on every reader's step grid;
+    /// request, so some step would end inside a tumbling window and could not read
+    /// the tumbling windows. Stage 1 offers only tumbling windows on every reader's step grid;
     /// the candidate is pruned with this reason.
     #[error(
-        "pane width {tumbling_window_width_ms} ms does not divide the {step_ms} ms step of \
+        "tumbling-window width {tumbling_window_width_ms} ms does not divide the {step_ms} ms step of \
          a range evaluation that reads it"
     )]
-    PaneWidthOffRangeStep {
-        /// The chain's pane width.
+    TumblingWindowWidthOffRangeStep {
+        /// The chain's tumbling-window width.
         tumbling_window_width_ms: u64,
         /// The reader's range-evaluation step.
         step_ms: u64,
@@ -192,21 +195,21 @@ pub(crate) enum IngestionPruneReason {
     /// A whole-window build whose evaluations do not all end on the grid of
     /// its window's width anchored at the epoch, where the backend builds
     /// it (e.g. `m[20s]` every 20 s at phase 5 s, every 30 s, or `m[15m]`
-    /// every 5 minutes, which panes serve): the interval or the declared
+    /// every 5 minutes, which tumbling windows serve): the interval or the declared
     /// phase is not a multiple of the window.
     WindowOffEpochGrid,
     /// A whole-window build read by a range evaluation of more than one
     /// step per request: it keeps one window per request, not one per step.
     RangeEvaluatedWholeWindow,
-    /// A tumbling-pane chain read at a known phase off its pane boundaries,
-    /// which are anchored at the epoch (e.g. 20 s panes read at phase 5 s):
-    /// built once each, its panes cannot end at every evaluation.
-    PanesOffPhase,
+    /// A tumbling-window chain read at a known phase off its tumbling-window boundaries,
+    /// which are anchored at the epoch (e.g. 20 s tumbling windows read at phase 5 s):
+    /// built once each, its tumbling windows cannot end at every evaluation.
+    TumblingWindowsOffPhase,
     /// A tumbling-window chain read at a fixed interval that its width does
     /// not divide (e.g. 15 s tumbling windows read every 10 s): built once
     /// each on the grid anchored at the epoch, its tumbling windows cannot
     /// end at every evaluation.
-    PanesOffInterval,
+    TumblingWindowsOffInterval,
     /// Something below it can only run at query time.
     UpstreamAtQueryTime(String),
     /// It is not a summary build (e.g. a shared `Scan`): only a summary's
@@ -221,7 +224,7 @@ pub(crate) enum IngestionPruneReason {
 pub(crate) struct SummaryMaterializationEligibility {
     pub(crate) at_ingestion: Result<(), IngestionPruneReason>,
     pub(crate) may_keep_across_evaluations: bool,
-    /// A pane's selected readers must also meet their range-step grids.
+    /// A tumbling window's selected readers must also meet their range-step grids.
     pub(crate) range_compatibility: Result<(), PhysicalASAPOptimizationError>,
 }
 
@@ -229,11 +232,11 @@ pub(crate) struct SummaryMaterializationEligibility {
 pub(crate) enum SummaryEligibilityError {
     #[error("selected reader {query} has no workload entry")]
     UnknownReader { query: usize },
-    #[error("materialization eligibility requires a summary build or pane chain")]
+    #[error("materialization eligibility requires a summary build or tumbling-window chain")]
     NotSummary,
     #[error("materialization eligibility requires at least one selected reader")]
     NoSelectedReaders,
-    #[error("pane width must be positive")]
+    #[error("tumbling-window width must be positive")]
     ZeroPaneWidth,
 }
 
@@ -301,7 +304,7 @@ fn summary_reader_eligibility(
                     ..
                 }),
                 Some(recurrences),
-            ) => builds_one_pane_per_evaluation(*tumbling_window_width_ms, recurrences),
+            ) => builds_one_tumbling_window_per_evaluation(*tumbling_window_width_ms, recurrences),
             _ => false,
         };
     SummaryMaterializationEligibility {
@@ -323,13 +326,13 @@ fn summary_reader_eligibility(
 /// q2: max_over_time(latency[5m])              every 1m
 /// ```
 ///
-/// If Stage 1 chose KLL panes for q1 and exact max panes for q2, Stage 2
+/// If Stage 1 chose KLL tumbling windows for q1 and exact max tumbling windows for q2, Stage 2
 /// finds two materialization candidates:
 ///
-/// | materialization candidate | readers | options                         |
-/// |---------------------------|---------|---------------------------------|
-/// | Kll ×5 panes (q1)         | q1      | NotMaterialized, MatAtIngestion |
-/// | Max acc ×5 panes (q2)     | q2      | NotMaterialized, MatAtIngestion |
+/// | materialization candidate        | readers | options                         |
+/// |----------------------------------|---------|---------------------------------|
+/// | Kll ×5 tumbling windows (q1)     | q1      | NotMaterialized, MatAtIngestion |
+/// | Max acc ×5 tumbling windows (q2) | q2      | NotMaterialized, MatAtIngestion |
 ///
 /// One read by two or more queries also gets `MatAtQuery` (built once per
 /// evaluation and reused), and so does the highest node of a shared
@@ -349,8 +352,8 @@ pub(crate) struct MaterializationCandidate {
     /// `Ok` when `MatAtIngestion` is an option.
     pub(crate) at_ingestion: Result<(), IngestionPruneReason>,
     /// Whether `MatAtQueryKeptAcrossEvaluations` is an option: the
-    /// deployment keeps query-time results and it is a tumbling-pane chain
-    /// that builds one new pane per evaluation.
+    /// deployment keeps query-time results and it is a tumbling-window chain
+    /// that builds one new tumbling window per evaluation.
     pub(crate) may_keep_across_evaluations: bool,
 }
 
@@ -376,11 +379,11 @@ impl MaterializationCandidate {
     }
 }
 
-/// Whether a tumbling-pane chain of `tumbling_window_width_ms`-wide panes read by
-/// queries repeating as `readers` builds exactly one new pane per
+/// Whether a tumbling-window chain of `tumbling_window_width_ms`-wide tumbling windows read by
+/// queries repeating as `readers` builds exactly one new tumbling window per
 /// evaluation: there is a reader, every reader repeats at a fixed interval
-/// equal to the pane width, and the readers whose evaluation phase is known
-/// share one phase (modulo the interval). Its other panes are the previous
+/// equal to the tumbling-window width, and the readers whose evaluation phase is known
+/// share one phase (modulo the interval). Its other tumbling windows are the previous
 /// evaluations' newest, so a deployment that keeps query-time results
 /// reuses them (#509 Example 4's B3).
 ///
@@ -388,8 +391,8 @@ impl MaterializationCandidate {
 /// phase run at the same instants as each other and as the readers with a
 /// known phase, as plan selection (`asap-plan-selection`) assumes when it counts
 /// one evaluation per interval. Readers at different known phases would
-/// each need their own newest pane, so they do not share one kept chain.
-pub(crate) fn builds_one_pane_per_evaluation<'a>(
+/// each need their own newest tumbling window, so they do not share one kept chain.
+pub(crate) fn builds_one_tumbling_window_per_evaluation<'a>(
     tumbling_window_width_ms: u64,
     readers: impl IntoIterator<Item = &'a QueryRecurrence>,
 ) -> bool {
@@ -441,7 +444,7 @@ pub fn optimize_physical_asap(
     let implemented = map_roots(roots, &mut |node| implement(node, &mut cache))?;
     let mat_candidates =
         materialization_candidates(&implemented, entries, data, query_time_results_retained);
-    check_panes_on_range_steps(&mat_candidates, entries)?;
+    check_tumbling_windows_on_range_steps(&mat_candidates, entries)?;
     materialization_assignments(&mat_candidates)
         .map(|assignment| {
             assigned_candidate(from_logical, &implemented, &mat_candidates, assignment)
@@ -471,7 +474,7 @@ pub fn optimize_physical_asap_assigned(
     let implemented = map_roots(roots, &mut |node| implement(node, &mut cache))?;
     let mat_candidates =
         materialization_candidates(&implemented, entries, data, query_time_results_retained);
-    check_panes_on_range_steps(&mat_candidates, entries)?;
+    check_tumbling_windows_on_range_steps(&mat_candidates, entries)?;
     let mut assignment = Vec::with_capacity(mat_candidates.len());
     for mat_candidate in &mat_candidates {
         match choose(&mat_candidate.readers) {
@@ -517,7 +520,7 @@ pub(crate) fn optimize_physical_asap_chosen(
         .collect();
     let mat_candidates =
         materialization_candidates(&implemented, entries, data, query_time_results_retained);
-    check_panes_on_range_steps(&mat_candidates, entries)?;
+    check_tumbling_windows_on_range_steps(&mat_candidates, entries)?;
     let mut assignment = Vec::with_capacity(mat_candidates.len());
     for mat_candidate in &mat_candidates {
         let logical = logical_of
@@ -610,15 +613,15 @@ fn physical_candidate_count(
     let implemented = map_roots(roots, &mut |node| implement(node, &mut cache))?;
     let mat_candidates =
         materialization_candidates(&implemented, entries, data, query_time_results_retained);
-    check_panes_on_range_steps(&mat_candidates, entries)?;
+    check_tumbling_windows_on_range_steps(&mat_candidates, entries)?;
     Ok(materialization_assignments(&mat_candidates).count())
 }
 
-/// `Err` for the first tumbling-pane chain whose pane width does not
+/// `Err` for the first tumbling-window chain whose tumbling-window width does not
 /// divide the step of a reader's range evaluation
-/// ([`PhysicalASAPOptimizationError::PaneWidthOffRangeStep`]): that step
-/// would end inside a pane.
-fn check_panes_on_range_steps(
+/// ([`PhysicalASAPOptimizationError::TumblingWindowWidthOffRangeStep`]): that step
+/// would end inside a tumbling window.
+fn check_tumbling_windows_on_range_steps(
     mat_candidates: &[MaterializationCandidate],
     entries: &[QueryWorkloadEntry],
 ) -> Result<(), PhysicalASAPOptimizationError> {
@@ -649,10 +652,12 @@ fn check_summary_range_steps(
             continue;
         };
         if range.step_ms % tumbling_window_width_ms.max(&1) != 0 {
-            return Err(PhysicalASAPOptimizationError::PaneWidthOffRangeStep {
-                tumbling_window_width_ms: *tumbling_window_width_ms,
-                step_ms: range.step_ms,
-            });
+            return Err(
+                PhysicalASAPOptimizationError::TumblingWindowWidthOffRangeStep {
+                    tumbling_window_width_ms: *tumbling_window_width_ms,
+                    step_ms: range.step_ms,
+                },
+            );
         }
     }
     Ok(())
@@ -798,7 +803,7 @@ fn ingestion_eligibility(
     if is_filtered_build(node) {
         return Err(Why::Filtered);
     }
-    let (family, chain_pane_width_ms) = match node.asap() {
+    let (family, chain_tumbling_window_width_ms) = match node.asap() {
         Some(ASAPOp::SummaryAgg { family, .. }) => (family, None),
         Some(ASAPOp::SummaryTumblingWindowChain {
             family,
@@ -819,17 +824,17 @@ fn ingestion_eligibility(
             return Err(Why::CounterNeedsTimeOrder);
         }
     }
-    if let Some(tumbling_window_width_ms) = chain_pane_width_ms {
-        // A chain's panes are built once each, on the grid anchored at the
-        // epoch (the plan carries no pane origin): every reader must
+    if let Some(tumbling_window_width_ms) = chain_tumbling_window_width_ms {
+        // A chain's tumbling windows are built once each, on the grid anchored at the
+        // epoch (the plan carries no tumbling-window origin): every reader must
         // evaluate on its boundaries. A reader at a fixed interval needs an
         // interval the width divides, whatever its phase; a reader of known
         // phase also needs that phase on the grid. A reader of unknown phase
         // is taken to run at multiples of its interval (phase 0), as for a
         // whole-window build below.
-        let epoch_panes = PaneLayout {
+        let epoch_tumbling_windows = TumblingWindowLayout {
             tumbling_window_width_ms,
-            pane_origin_ms: Some(0),
+            tumbling_window_origin_ms: Some(0),
         };
         for d in demands.iter().flatten() {
             let QueryRecurrence::Repeated(demand) = &d.recurrence else {
@@ -839,23 +844,23 @@ fn ingestion_eligibility(
                 .fixed_interval_ms()
                 .is_some_and(|interval_ms| !interval_ms.is_multiple_of(tumbling_window_width_ms))
             {
-                return Err(Why::PanesOffInterval);
+                return Err(Why::TumblingWindowsOffInterval);
             }
-            let reader = plan_pane_phase(demand, tumbling_window_width_ms)
-                .map_err(|_| Why::PanesOffPhase)?;
-            let Some(phase_ms) = reader.pane_origin_ms else {
+            let reader = plan_tumbling_window_phase(demand, tumbling_window_width_ms)
+                .map_err(|_| Why::TumblingWindowsOffPhase)?;
+            let Some(phase_ms) = reader.tumbling_window_origin_ms else {
                 if matches!(demand, RepeatedDemand::Scheduled(_)) {
-                    // A schedule whose times are not all on one pane phase.
-                    return Err(Why::PanesOffPhase);
+                    // A schedule whose times are not all on one tumbling-window phase.
+                    return Err(Why::TumblingWindowsOffPhase);
                 }
                 continue;
             };
-            validate_pane_coverage(
-                &epoch_panes,
+            validate_tumbling_window_coverage(
+                &epoch_tumbling_windows,
                 Some(phase_ms),
-                &WindowEdgeCoverage::PaneAligned,
+                &WindowEdgeCoverage::TumblingWindowAligned,
             )
-            .map_err(|_| Why::PanesOffPhase)?;
+            .map_err(|_| Why::TumblingWindowsOffPhase)?;
         }
         return Ok(());
     }
@@ -866,7 +871,7 @@ fn ingestion_eligibility(
         return Err(Why::RangeEvaluatedWholeWindow);
     }
     // A whole-window build: one tumbling window per evaluation, built (like
-    // a chain's panes) on the grid of its width anchored at the epoch, so
+    // a chain's tumbling windows) on the grid of its width anchored at the epoch, so
     // every evaluation must end on that grid. The readers share one fixed
     // interval and their declared phases agree; a reader with no declared
     // phase is taken to evaluate at multiples of its interval (phase 0), as
@@ -1179,7 +1184,7 @@ fn rebuilt(
 
 /// Stage 2 internals that other crates' tests call: building one physical
 /// candidate for a chosen assignment, implementing one candidate's
-/// operators, and the pane-coverage check.
+/// operators, and the tumbling-window-coverage check.
 #[cfg(feature = "test-support")]
 pub mod test_support {
     use std::rc::Rc;
@@ -1192,7 +1197,8 @@ pub mod test_support {
     pub use crate::catalog::test_support as catalog;
     pub use crate::split_by_timing::split_shared_by_timing;
     pub use crate::summary_window::{
-        validate_pane_coverage, PaneCoverageError, PaneLayout, WindowEdgeCoverage,
+        validate_tumbling_window_coverage, TumblingWindowCoverageError, TumblingWindowLayout,
+        WindowEdgeCoverage,
     };
 
     /// See `optimize_physical_asap_chosen` in this crate.
@@ -1587,11 +1593,14 @@ mod tests {
             .remove(0)
     }
 
-    /// `root` with its summary build in 1-min tumbling panes.
-    fn in_panes(root: QueryRoot) -> QueryRoot {
+    /// `root` with its summary build in 1-min tumbling windows.
+    fn in_tumbling_windows(root: QueryRoot) -> QueryRoot {
         let roots = [root];
         let rule_candidates =
-            asap_logical_asap_optimization::test_support::pane_candidates(&roots, &[Some(MINUTE)]);
+            asap_logical_asap_optimization::test_support::tumbling_window_candidates(
+                &roots,
+                &[Some(MINUTE)],
+            );
         assert_eq!(rule_candidates.len(), 1, "{rule_candidates:?}");
         let mut pass2_candidates =
             asap_logical_asap_optimization::test_support::window_composition_pass2_candidates(
@@ -1617,7 +1626,7 @@ mod tests {
     // An unselected unpredictable query must not restrict an ingestion candidate.
     #[test]
     fn selected_reader_eligibility_ignores_optional_unpredictable_consumers() {
-        let root = in_panes(summary_root("quantile_over_time(0.99, m[5m])"));
+        let root = in_tumbling_windows(summary_root("quantile_over_time(0.99, m[5m])"));
         let node = root_operators(&root)
             .into_iter()
             .flat_map(OperatorNode::reachable)
@@ -1680,7 +1689,7 @@ mod tests {
     #[test]
     fn selected_reader_eligibility_checks_phase_and_range_compatibility() {
         use asap_types::workload::RangeEvaluation;
-        let root = in_panes(summary_root("quantile_over_time(0.99, m[5m])"));
+        let root = in_tumbling_windows(summary_root("quantile_over_time(0.99, m[5m])"));
         let node = root_operators(&root)
             .into_iter()
             .flat_map(OperatorNode::reachable)
@@ -1727,7 +1736,7 @@ mod tests {
         assert!(!different_phase.may_keep_across_evaluations);
         assert_eq!(
             different_phase.at_ingestion,
-            Err(IngestionPruneReason::PanesOffPhase)
+            Err(IngestionPruneReason::TumblingWindowsOffPhase)
         );
         let off_grid = summary_materialization_eligibility(
             &node,
@@ -1739,7 +1748,7 @@ mod tests {
         .unwrap();
         assert!(matches!(
             off_grid.range_compatibility,
-            Err(PhysicalASAPOptimizationError::PaneWidthOffRangeStep { .. })
+            Err(PhysicalASAPOptimizationError::TumblingWindowWidthOffRangeStep { .. })
         ));
         assert!(matches!(
             summary_materialization_eligibility(
@@ -1786,14 +1795,14 @@ mod tests {
         nodes
     }
 
-    /// #509 Example 4, B1 and B2: a tumbling-pane chain read by a repeating,
+    /// #509 Example 4, B1 and B2: a tumbling-window chain read by a repeating,
     /// predictable query over arriving data is either rebuilt at query time
     /// or maintained at ingestion time. Maintained, the chain and the scan
     /// below it run at ingestion time, and the merge and estimate at query
     /// time.
     #[test]
-    fn a_pane_chain_over_arriving_data_may_be_maintained_at_ingestion_time() {
-        let root = in_panes(summary_root("quantile_over_time(0.99, m[5m])"));
+    fn a_tumbling_window_chain_over_arriving_data_may_be_maintained_at_ingestion_time() {
+        let root = in_tumbling_windows(summary_root("quantile_over_time(0.99, m[5m])"));
         let candidates =
             optimize_physical_asap("L1", &[root], &[every_minute()], &arriving(), false).unwrap();
         assert_eq!(candidates.len(), 2);
@@ -1824,15 +1833,15 @@ mod tests {
         }
     }
 
-    /// A chain of 1-min panes, anchored at the epoch, read by two queries
+    /// A chain of 1-min tumbling windows, anchored at the epoch, read by two queries
     /// every minute is maintained at ingestion time when they evaluate on
-    /// its pane boundaries (phases 0 and 2 min, or one phase unknown), not
-    /// when one is at phase 30 s: each pane is built once, so it would read
-    /// panes 30 s off.
+    /// its tumbling-window boundaries (phases 0 and 2 min, or one phase unknown), not
+    /// when one is at phase 30 s: each tumbling window is built once, so it would read
+    /// tumbling windows 30 s off.
     #[test]
-    fn a_pane_chain_is_maintained_only_on_its_readers_phases() {
+    fn a_tumbling_window_chain_is_maintained_only_on_its_readers_phases() {
         use IngestionPruneReason as Why;
-        let root = in_panes(summary_root("quantile_over_time(0.99, m[5m])"));
+        let root = in_tumbling_windows(summary_root("quantile_over_time(0.99, m[5m])"));
         let at = |phase_ms: u64| QueryWorkloadEntry {
             recurrence: QueryRecurrence::Repeated(RepeatedDemand::FixedIntervalAt {
                 interval: RepetitionInterval(MINUTE as u32),
@@ -1860,10 +1869,13 @@ mod tests {
         };
         assert_eq!(at_ingestion([at(0), at(2 * MINUTE)]), Ok(()));
         assert_eq!(at_ingestion([at(0), every_minute()]), Ok(()));
-        assert_eq!(at_ingestion([at(0), at(30_000)]), Err(Why::PanesOffPhase));
+        assert_eq!(
+            at_ingestion([at(0), at(30_000)]),
+            Err(Why::TumblingWindowsOffPhase)
+        );
         assert_eq!(
             at_ingestion([at(30_000), every_minute()]),
-            Err(Why::PanesOffPhase)
+            Err(Why::TumblingWindowsOffPhase)
         );
     }
 
@@ -1874,7 +1886,7 @@ mod tests {
     #[test]
     fn a_tumbling_window_chain_is_maintained_only_on_its_readers_intervals() {
         use IngestionPruneReason as Why;
-        let root = in_panes(summary_root("quantile_over_time(0.99, m[5m])"));
+        let root = in_tumbling_windows(summary_root("quantile_over_time(0.99, m[5m])"));
         let every = |interval_ms: u64| QueryWorkloadEntry {
             recurrence: QueryRecurrence::Repeated(RepeatedDemand::FixedInterval(
                 RepetitionInterval(interval_ms as u32),
@@ -1909,11 +1921,11 @@ mod tests {
         assert_eq!(at_ingestion([every_minute(), every(2 * MINUTE)]), Ok(()));
         assert_eq!(
             at_ingestion([every_minute(), every(90_000)]),
-            Err(Why::PanesOffInterval)
+            Err(Why::TumblingWindowsOffInterval)
         );
         assert_eq!(
             at_ingestion([every_minute(), every_at_phase_0(90_000)]),
-            Err(Why::PanesOffInterval)
+            Err(Why::TumblingWindowsOffInterval)
         );
     }
 
@@ -1923,7 +1935,7 @@ mod tests {
     #[test]
     fn ingestion_time_needs_arriving_data_and_repeated_predictable_queries() {
         use IngestionPruneReason as Why;
-        let root = in_panes(summary_root("quantile_over_time(0.99, m[5m])"));
+        let root = in_tumbling_windows(summary_root("quantile_over_time(0.99, m[5m])"));
         let at_rest = DataWorkload {
             arrival: DataArrival::AtRest,
             ..Default::default()
@@ -1960,12 +1972,12 @@ mod tests {
 
     /// A counter state (`rate`, `increase`) needs each series' samples in
     /// time order. Continuously ingesting time-series (PromQL) data is taken
-    /// to arrive in that order, as Prometheus assumes, so its counter panes
+    /// to arrive in that order, as Prometheus assumes, so its counter tumbling windows
     /// may be maintained at ingestion time.
     #[test]
-    fn counter_panes_over_ingesting_promql_data_run_at_ingestion_time() {
+    fn counter_tumbling_windows_over_ingesting_promql_data_run_at_ingestion_time() {
         for query in ["rate(m[5m])", "increase(m[5m])"] {
-            let roots = [in_panes(summary_root(query))];
+            let roots = [in_tumbling_windows(summary_root(query))];
             let mut cache = HashMap::new();
             let implemented = map_roots(&roots, &mut |n| implement(n, &mut cache)).unwrap();
             let mat_candidates =
@@ -1982,9 +1994,9 @@ mod tests {
     /// time order: a counter over a table source, or over mixed data (whose
     /// at-rest part may be loaded in any order), stays at query time.
     #[test]
-    fn counter_panes_over_other_sources_stay_at_query_time() {
+    fn counter_tumbling_windows_over_other_sources_stay_at_query_time() {
         use IngestionPruneReason as Why;
-        let root = in_panes(summary_root("rate(m[5m])"));
+        let root = in_tumbling_windows(summary_root("rate(m[5m])"));
         let QueryRoot::Operator(node) = &root else {
             panic!("{root:?}")
         };
@@ -2186,13 +2198,13 @@ mod tests {
         assert_eq!(at_ingestion(at_minute(0)), Ok(()));
     }
 
-    /// A pane chain whose width does not divide a range-evaluated reader's
+    /// A tumbling-window chain whose width does not divide a range-evaluated reader's
     /// step is not offered: the candidate fails with the widths, and the
-    /// caller prunes it. 1-min panes serve 2-min steps.
+    /// caller prunes it. 1-min tumbling windows serve 2-min steps.
     #[test]
-    fn a_pane_chain_off_the_range_step_grid_is_rejected() {
+    fn a_tumbling_window_chain_off_the_range_step_grid_is_rejected() {
         use asap_types::workload::RangeEvaluation;
-        let root = in_panes(summary_root("quantile_over_time(0.99, m[5m])"));
+        let root = in_tumbling_windows(summary_root("quantile_over_time(0.99, m[5m])"));
         let stepping = |step_ms: u64| QueryWorkloadEntry {
             range_evaluation: Some(RangeEvaluation {
                 step_ms,
@@ -2213,7 +2225,7 @@ mod tests {
         assert!(
             matches!(
                 error,
-                PhysicalASAPOptimizationError::PaneWidthOffRangeStep {
+                PhysicalASAPOptimizationError::TumblingWindowWidthOffRangeStep {
                     tumbling_window_width_ms: MINUTE,
                     step_ms: 30_000,
                 }
@@ -2222,7 +2234,7 @@ mod tests {
         );
         assert_eq!(
             error.to_string(),
-            "pane width 60000 ms does not divide the 30000 ms step of a range \
+            "tumbling-window width 60000 ms does not divide the 30000 ms step of a range \
              evaluation that reads it"
         );
         assert!(physical_candidate_count(
@@ -2280,19 +2292,20 @@ mod tests {
         );
     }
 
-    /// Two queries share one scan: one reads it through panes maintained at
+    /// Two queries share one scan: one reads it through tumbling windows maintained at
     /// ingestion time, the other at query time. The scan is split, one copy
     /// per timing; with nothing materialized it stays one node. The shared
     /// scan may also be built once per evaluation (`MatAtQuery`), but not
-    /// under ingestion-time panes, where only one query reads it at query
+    /// under ingestion-time tumbling windows, where only one query reads it at query
     /// time.
     #[test]
     fn a_scan_two_queries_read_at_two_timings_is_split() {
-        let QueryRoot::Operator(panes) = in_panes(summary_root("quantile_over_time(0.99, m[5m])"))
+        let QueryRoot::Operator(tumbling_windows) =
+            in_tumbling_windows(summary_root("quantile_over_time(0.99, m[5m])"))
         else {
             unreachable!()
         };
-        let scan = OperatorNode::reachable(&panes)
+        let scan = OperatorNode::reachable(&tumbling_windows)
             .into_iter()
             .find(|n| matches!(n.non_asap(), Some(NonASAPOp::Scan { .. })))
             .unwrap();
@@ -2309,7 +2322,10 @@ mod tests {
             None,
             ranged,
         );
-        let roots = [QueryRoot::Operator(panes), QueryRoot::Operator(exact)];
+        let roots = [
+            QueryRoot::Operator(tumbling_windows),
+            QueryRoot::Operator(exact),
+        ];
         let candidates = optimize_physical_asap(
             "L1",
             &roots,
@@ -2407,13 +2423,13 @@ mod tests {
         );
     }
 
-    /// Readers share one kept pane chain only when they evaluate at the
+    /// Readers share one kept tumbling-window chain only when they evaluate at the
     /// same instants: two readers every minute at phases 0 and 2 min do,
     /// at phases 0 and 30 s they do not (each would need its own newest
-    /// pane). A reader with no known phase is assumed to run with the
+    /// tumbling window). A reader with no known phase is assumed to run with the
     /// others.
     #[test]
-    fn readers_at_different_phases_do_not_build_one_pane_per_evaluation() {
+    fn readers_at_different_phases_do_not_build_one_tumbling_window_per_evaluation() {
         let at = |phase_ms: u64| {
             QueryRecurrence::Repeated(RepeatedDemand::FixedIntervalAt {
                 interval: RepetitionInterval(MINUTE as u32),
@@ -2421,19 +2437,19 @@ mod tests {
             })
         };
         let unknown_phase = every_minute().recurrence;
-        assert!(builds_one_pane_per_evaluation(
+        assert!(builds_one_tumbling_window_per_evaluation(
             MINUTE,
             [&at(0), &at(2 * MINUTE)]
         ));
-        assert!(!builds_one_pane_per_evaluation(
+        assert!(!builds_one_tumbling_window_per_evaluation(
             MINUTE,
             [&at(0), &at(30_000)]
         ));
-        assert!(builds_one_pane_per_evaluation(
+        assert!(builds_one_tumbling_window_per_evaluation(
             MINUTE,
             [&at(30_000), &unknown_phase]
         ));
-        assert!(!builds_one_pane_per_evaluation(
+        assert!(!builds_one_tumbling_window_per_evaluation(
             MINUTE,
             [&at(0), &unknown_phase, &at(30_000)]
         ));
diff --git a/crates/physical-asap-optimization/src/summary_window.rs b/crates/physical-asap-optimization/src/summary_window.rs
index 70c941bd8..64a5aa468 100644
--- a/crates/physical-asap-optimization/src/summary_window.rs
+++ b/crates/physical-asap-optimization/src/summary_window.rs
@@ -1,6 +1,6 @@
-//! Planner-level summary-window pane primitives.
+//! Planner-level tumbling-window layout and window-edge coverage.
 //!
-//! These values describe pane layout and window-edge coverage. They do not
+//! These values describe tumbling-window layout and window-edge coverage. They do not
 //! identify a runtime library, process, placement, shard layout, storage
 //! backend, or deployment instance; those choices belong to downstream
 //! physical compilation.
@@ -8,51 +8,55 @@
 use asap_types::workload::RepeatedDemand;
 use serde::{Deserialize, Serialize};
 
-/// Concrete pane phase recorded in a catalog layout or inventory snapshot.
+/// Concrete tumbling-window phase recorded in a catalog layout or inventory snapshot.
 /// Milliseconds are canonical throughout the shared contract.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct PaneLayout {
-    // Named `pane_width_ms` before #1163.
-    #[serde(alias = "pane_width_ms")]
+pub struct TumblingWindowLayout {
+    // The deployed wire contract keeps the names from before #1163.
+    #[serde(rename = "pane_width_ms", alias = "tumbling_window_width_ms")]
     pub tumbling_window_width_ms: u64,
-    /// Unix timestamp of a pane edge. `None` means the runtime has not
+    /// Unix timestamp of a tumbling-window edge. `None` means the runtime has not
     /// established an origin and therefore cannot claim full coverage.
-    pub pane_origin_ms: Option<i64>,
+    #[serde(rename = "pane_origin_ms")]
+    pub tumbling_window_origin_ms: Option<i64>,
 }
 
-/// How a query obtains exact values for partial panes at its two window edges.
+/// How a query obtains exact values for partial tumbling windows at its two window edges.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(tag = "kind", rename_all = "snake_case")]
 pub enum WindowEdgeCoverage {
-    PaneAligned,
+    // Wire name kept from before #1163.
+    #[serde(rename = "pane_aligned")]
+    TumblingWindowAligned,
     #[serde(rename = "exact_boundary_residual")]
-    ExactWindowEdgeResidual {
-        executor: String,
-        source: String,
-    },
+    ExactWindowEdgeResidual { executor: String, source: String },
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub enum PaneCoverageError {
-    ZeroPaneWidth,
-    UnknownPaneOrigin,
+// Wire names kept from before #1163.
+pub enum TumblingWindowCoverageError {
+    #[serde(rename = "ZeroPaneWidth")]
+    ZeroTumblingWindowWidth,
+    #[serde(rename = "UnknownPaneOrigin")]
+    UnknownTumblingWindowOrigin,
     UnknownEvaluationPhase,
     PhaseMismatch {
-        pane_phase_ms: u64,
+        #[serde(rename = "pane_phase_ms")]
+        tumbling_window_phase_ms: u64,
         query_phase_ms: u64,
     },
 }
 
-/// Validate that a pane-only evaluation covers a query exactly. A mismatched
+/// Validate that a tumbling-window-only evaluation covers a query exactly. A mismatched
 /// phase is sound only when the physical plan explicitly supplies an exact
-/// residual for the partial edge panes.
-pub fn validate_pane_coverage(
-    layout: &PaneLayout,
+/// residual for the partial edge tumbling windows.
+pub fn validate_tumbling_window_coverage(
+    layout: &TumblingWindowLayout,
     evaluation_time_ms: Option<i64>,
     edge_coverage: &WindowEdgeCoverage,
-) -> Result<(), PaneCoverageError> {
+) -> Result<(), TumblingWindowCoverageError> {
     if layout.tumbling_window_width_ms == 0 {
-        return Err(PaneCoverageError::ZeroPaneWidth);
+        return Err(TumblingWindowCoverageError::ZeroTumblingWindowWidth);
     }
     if matches!(
         edge_coverage,
@@ -61,32 +65,33 @@ pub fn validate_pane_coverage(
         return Ok(());
     }
     let origin = layout
-        .pane_origin_ms
-        .ok_or(PaneCoverageError::UnknownPaneOrigin)?;
-    let evaluation = evaluation_time_ms.ok_or(PaneCoverageError::UnknownEvaluationPhase)?;
+        .tumbling_window_origin_ms
+        .ok_or(TumblingWindowCoverageError::UnknownTumblingWindowOrigin)?;
+    let evaluation =
+        evaluation_time_ms.ok_or(TumblingWindowCoverageError::UnknownEvaluationPhase)?;
     let width = layout.tumbling_window_width_ms as i64;
-    let pane_phase_ms = origin.rem_euclid(width) as u64;
+    let tumbling_window_phase_ms = origin.rem_euclid(width) as u64;
     let query_phase_ms = evaluation.rem_euclid(width) as u64;
-    if pane_phase_ms == query_phase_ms {
+    if tumbling_window_phase_ms == query_phase_ms {
         Ok(())
     } else {
-        Err(PaneCoverageError::PhaseMismatch {
-            pane_phase_ms,
+        Err(TumblingWindowCoverageError::PhaseMismatch {
+            tumbling_window_phase_ms,
             query_phase_ms,
         })
     }
 }
 
-/// Select a query-aligned pane origin from workload recurrence. A plain fixed
+/// Select a query-aligned tumbling-window origin from workload recurrence. A plain fixed
 /// interval has cadence but no phase, so it remains unknown. Every timestamp
-/// in an explicit schedule must have the same phase for one pane layout to
+/// in an explicit schedule must have the same phase for one tumbling-window layout to
 /// serve all occurrences.
-pub(crate) fn plan_pane_phase(
+pub(crate) fn plan_tumbling_window_phase(
     demand: &RepeatedDemand,
     tumbling_window_width_ms: u64,
-) -> Result<PaneLayout, PaneCoverageError> {
+) -> Result<TumblingWindowLayout, TumblingWindowCoverageError> {
     if tumbling_window_width_ms == 0 {
-        return Err(PaneCoverageError::ZeroPaneWidth);
+        return Err(TumblingWindowCoverageError::ZeroTumblingWindowWidth);
     }
     let phase = match demand {
         RepeatedDemand::FixedIntervalAt {
@@ -102,9 +107,9 @@ pub(crate) fn plan_pane_phase(
         }
         RepeatedDemand::FixedInterval(_) | RepeatedDemand::EstimatedRate(_) => None,
     };
-    Ok(PaneLayout {
+    Ok(TumblingWindowLayout {
         tumbling_window_width_ms,
-        pane_origin_ms: phase.and_then(|value| i64::try_from(value).ok()),
+        tumbling_window_origin_ms: phase.and_then(|value| i64::try_from(value).ok()),
     })
 }
 
@@ -113,19 +118,23 @@ mod tests {
     use super::*;
 
     #[test]
-    fn pane_only_evaluation_rejects_source_and_query_phase_mismatch() {
-        let layout = PaneLayout {
+    fn tumbling_window_only_evaluation_rejects_source_and_query_phase_mismatch() {
+        let layout = TumblingWindowLayout {
             tumbling_window_width_ms: 60_000,
-            pane_origin_ms: Some(26_000),
+            tumbling_window_origin_ms: Some(26_000),
         };
         assert_eq!(
-            validate_pane_coverage(&layout, Some(56_000), &WindowEdgeCoverage::PaneAligned),
-            Err(PaneCoverageError::PhaseMismatch {
-                pane_phase_ms: 26_000,
+            validate_tumbling_window_coverage(
+                &layout,
+                Some(56_000),
+                &WindowEdgeCoverage::TumblingWindowAligned
+            ),
+            Err(TumblingWindowCoverageError::PhaseMismatch {
+                tumbling_window_phase_ms: 26_000,
                 query_phase_ms: 56_000,
             })
         );
-        assert!(validate_pane_coverage(
+        assert!(validate_tumbling_window_coverage(
             &layout,
             Some(56_000),
             &WindowEdgeCoverage::ExactWindowEdgeResidual {
@@ -143,30 +152,61 @@ mod tests {
             evaluation_phase: asap_types::workload::TimestampMs(56_000),
         };
         assert_eq!(
-            plan_pane_phase(&demand, 60_000).unwrap(),
-            PaneLayout {
+            plan_tumbling_window_phase(&demand, 60_000).unwrap(),
+            TumblingWindowLayout {
                 tumbling_window_width_ms: 60_000,
-                pane_origin_ms: Some(56_000),
+                tumbling_window_origin_ms: Some(56_000),
             }
         );
         assert_eq!(
-            plan_pane_phase(
+            plan_tumbling_window_phase(
                 &RepeatedDemand::FixedInterval(asap_types::workload::RepetitionInterval(60_000)),
                 60_000,
             )
             .unwrap()
-            .pane_origin_ms,
+            .tumbling_window_origin_ms,
             None
         );
     }
 
-    // Renamed pane APIs still read and emit the deployed wire contract.
+    // Renamed tumbling window APIs still read and emit the deployed wire contract.
     #[test]
     fn window_edge_names_preserve_wire_values() {
-        let layout: PaneLayout = serde_json::from_value(serde_json::json!({
-            "tumbling_window_width_ms": 1000, "pane_origin_ms": 0
+        let layout: TumblingWindowLayout = serde_json::from_value(serde_json::json!({
+            "pane_width_ms": 1000, "pane_origin_ms": 0
         }))
         .unwrap();
+        assert_eq!(
+            serde_json::to_value(&layout).unwrap(),
+            serde_json::json!({"pane_width_ms": 1000, "pane_origin_ms": 0})
+        );
+        assert_eq!(
+            serde_json::to_value(WindowEdgeCoverage::TumblingWindowAligned).unwrap(),
+            serde_json::json!({"kind": "pane_aligned"})
+        );
+        for (error, wire) in [
+            (
+                TumblingWindowCoverageError::ZeroTumblingWindowWidth,
+                serde_json::json!("ZeroPaneWidth"),
+            ),
+            (
+                TumblingWindowCoverageError::UnknownTumblingWindowOrigin,
+                serde_json::json!("UnknownPaneOrigin"),
+            ),
+            (
+                TumblingWindowCoverageError::PhaseMismatch {
+                    tumbling_window_phase_ms: 1,
+                    query_phase_ms: 2,
+                },
+                serde_json::json!({"PhaseMismatch": {"pane_phase_ms": 1, "query_phase_ms": 2}}),
+            ),
+        ] {
+            assert_eq!(serde_json::to_value(&error).unwrap(), wire);
+            assert_eq!(
+                serde_json::from_value::<TumblingWindowCoverageError>(wire).unwrap(),
+                error
+            );
+        }
         let json = serde_json::json!({
             "kind": "exact_boundary_residual", "executor": "runtime", "source": "raw"
         });
@@ -176,6 +216,6 @@ mod tests {
             WindowEdgeCoverage::ExactWindowEdgeResidual { .. }
         ));
         assert_eq!(serde_json::to_value(&coverage).unwrap(), json);
-        assert!(validate_pane_coverage(&layout, Some(1500), &coverage).is_ok());
+        assert!(validate_tumbling_window_coverage(&layout, Some(1500), &coverage).is_ok());
     }
 }
diff --git a/crates/plan-selection/src/lib.rs b/crates/plan-selection/src/lib.rs
index a4cf7a76f..3a0c858e0 100644
--- a/crates/plan-selection/src/lib.rs
+++ b/crates/plan-selection/src/lib.rs
@@ -44,11 +44,11 @@
 //!   the queries whose sub-DAG reaches it and the materialized nodes above
 //!   it, counted without looking through a materialized node: a node below
 //!   one is computed when that node is. The `MatAtIngestion` consumers of
-//!   one refresh window (`PhysicalASAPDAG::refresh_window`: for a pane
-//!   chain, its pane width) are refreshed in one ingestion run and count as
+//!   one refresh window (`PhysicalASAPDAG::refresh_window`: for a tumbling window
+//!   chain, its tumbling-window width) are refreshed in one ingestion run and count as
 //!   one consumer: a `Scan` under a KLL chain and a DDSketch chain of 10 s
-//!   panes is computed once per second of arriving data, under chains of
-//!   10 s and 60 s panes twice. Stage 2 keeps a shared node one
+//!   tumbling windows is computed once per second of arriving data, under chains of
+//!   10 s and 60 s tumbling windows twice. Stage 2 keeps a shared node one
 //!   node (it copies it only for readers at two timings). A shared
 //!   `NotMaterialized` input costs what reading it separately does (#509
 //!   Example 4) only when every consumer reads the same window: a query-time `Scan` is priced over the longest window
@@ -61,8 +61,8 @@
 //!   evaluated together, so each distinct interval counts once.
 //! * A `MatAtIngestion` node runs as data arrives: it is priced over one
 //!   second of arriving rows, once per second, whatever its readers' rates.
-//!   A tumbling-pane chain maintained this way updates only its newest
-//!   pane: each arriving row is placed in it and updates it.
+//!   A tumbling-window chain maintained this way updates only its newest
+//!   tumbling window: each arriving row is placed in it and updates it.
 //! * A query repeating every `I` ms runs `1000 / I` times per second, and an
 //!   estimated rate runs at that rate. One-off, scheduled and unknown
 //!   queries are spread over the settings' `non_repeating_query_horizon_seconds`
@@ -72,7 +72,7 @@
 //! ([`ResourceUsage::average_memory_bytes`](asap_cost::ResourceUsage::average_memory_bytes)), at
 //! `cost_per_memory_byte_second` per byte per second. A `MatAtIngestion`
 //! node keeps its state every second: twice for a whole window (the window
-//! being built and the completed one queries read) and `N + 1` panes for a
+//! being built and the completed one queries read) and `N + 1` tumbling windows for a
 //! chain of `N` (the `N` the query merges and the one being built). A
 //! `MatAtQuery` node's state is reused only within one evaluation, so it is
 //! held only while that evaluation runs: its bytes times the latency of the
@@ -83,11 +83,11 @@
 //! materialized node reading it (directly or through other
 //! `NotMaterialized` nodes), its bytes times the latency of the longest
 //! query reading that node, at the node's rate, as a `MatAtQuery` state is.
-//! A `MatAtQueryKeptAcrossEvaluations` tumbling-pane chain (#509 Example
+//! A `MatAtQueryKeptAcrossEvaluations` tumbling-window chain (#509 Example
 //! 4's B3, offered by Stage 2 when the deployment keeps query-time results,
 //! `DeploymentCapabilities::query_time_results_retained`) is kept across
-//! evaluations: each evaluation scans one pane of raw data and builds the
-//! newest pane, and the `N − 1` older panes, which complete the readers'
+//! evaluations: each evaluation scans one tumbling window of raw data and builds the
+//! newest tumbling window, and the `N − 1` older tumbling windows, which complete the readers'
 //! look-back, are kept every second (in memory, all `N` at the peak). When
 //! Stage 2 offers both query-time options for a chain, plan selection
 //! prices each and the cheaper wins.
@@ -103,14 +103,14 @@
 //!   request; a `MatAtIngestion` state is maintained as before, and the
 //!   merge and estimate over it run once per step;
 //! * a chain kept across evaluations is built once per request: Stage 2
-//!   offers it only when the requests repeat at its pane width, so in the
-//!   steady state each request builds its newest pane and every other pane
+//!   offers it only when the requests repeat at its tumbling-window width, so in the
+//!   steady state each request builds its newest tumbling window and every other tumbling window
 //!   any of its steps reads was built by an earlier request or step;
-//! * a pane chain kept beyond one evaluation (ingestion time or kept
+//! * a tumbling-window chain kept beyond one evaluation (ingestion time or kept
 //!   across evaluations) retains its input's offset plus its window plus
 //!   the longest `span_ms` among its readers (`RealizedPlan::tumbling_window_retention_ms`),
-//!   so the earliest step of the next request still finds its panes: that
-//!   many more panes are kept every second.
+//!   so the earliest step of the next request still finds its tumbling windows: that
+//!   many more tumbling windows are kept every second.
 //!
 //! Latency stays per evaluation (one step). Without a range evaluation
 //! `S = 1` and the retention is the window, so every price is as above.
@@ -125,9 +125,9 @@
 //! count; summary build and estimation are priced as rows × sketch depth and
 //! groups × k. A query-time scan reads the longest window above it (a time
 //! shift moves a window without widening it); a time shift is free, and a
-//! time range is priced by the rows it keeps. A tumbling-pane chain is
+//! time range is priced by the rows it keeps. A tumbling-window chain is
 //! priced as one build over its whole window plus one operation per row to
-//! place it in its pane, and keeps one state per group and pane; a merge
+//! place it in its tumbling window, and keeps one state per group and tumbling window; a merge
 //! costs one operation per state it reads. Kept state is sized by its bytes: a sketch by its parameters, a
 //! fixed-size exact accumulator (sum, count, min, max, rate, ...) as one
 //! value per group, and exact state that grows with the data (quantile,
@@ -322,7 +322,7 @@ mod tests {
     use asap_accuracy::estimators::hll;
     use asap_accuracy::propagation::root_guarantee;
     use asap_cost::execution_demand::evaluation_rate;
-    use asap_cost::{kept_pane_chains, node_map, plan_cost, NodeMap};
+    use asap_cost::{kept_tumbling_window_chains, node_map, plan_cost, NodeMap};
     use asap_cost::{
         CalibrationFit, ClusterLimits, ClusterObjective, CostInputs, CostModel, NodePriceSource,
         OperatorKind, PlanCost, ResourceUsage, COST_SOURCE, MEASURED_COST_SOURCE,
@@ -377,7 +377,7 @@ mod tests {
         Ok(at(fit.factor())?.0)
     }
 
-    /// [`self_calibrated_cost`] with `dag`'s node map and kept pane chains.
+    /// [`self_calibrated_cost`] with `dag`'s node map and kept tumbling-window chains.
     fn price(
         dag: &PhysicalASAPDAG,
         recurrence: &[QueryRecurrence],
@@ -387,7 +387,7 @@ mod tests {
         self_calibrated_cost(
             dag,
             &node_map(dag),
-            &kept_pane_chains(dag),
+            &kept_tumbling_window_chains(dag),
             recurrence,
             &[],
             data,
@@ -3871,7 +3871,7 @@ mod tests {
     /// read is not checked.
     #[test]
     fn invalid_settings_are_rejected() {
-        let candidates = pane_candidates(10_000.0);
+        let candidates = tumbling_window_candidates(10_000.0);
         let select = |settings: &CostInputs| {
             select_among_plans(
                 &candidates,
@@ -3914,7 +3914,7 @@ mod tests {
 
     const MINUTE: u32 = 60_000;
 
-    /// The p99 target [`pane_candidates`] are sized for.
+    /// The p99 target [`tumbling_window_candidates`] are sized for.
     fn p99_target() -> AccuracyTarget {
         AccuracyTarget::max_error(0.01)
             .failure_probability(0.001)
@@ -3941,19 +3941,20 @@ mod tests {
     }
 
     /// The physical candidates of a per-series p99 over 5 min with its KLL
-    /// in five 1-min tumbling panes, every minute over data arriving at
+    /// in five 1-min tumbling windows, every minute over data arriving at
     /// `rows_per_s`: rebuilt at query time (B2), then maintained at
     /// ingestion time (B1).
-    fn pane_candidates(rows_per_s: f64) -> Vec<PhysicalWorkloadPlan> {
-        let candidates = pane_candidates_for(rows_per_s, &DeploymentCapabilities::default());
+    fn tumbling_window_candidates(rows_per_s: f64) -> Vec<PhysicalWorkloadPlan> {
+        let candidates =
+            tumbling_window_candidates_for(rows_per_s, &DeploymentCapabilities::default());
         assert_eq!(candidates.len(), 2);
         candidates
     }
 
-    /// [`pane_candidates`] for a deployment with `deployment`'s
+    /// [`tumbling_window_candidates`] for a deployment with `deployment`'s
     /// capabilities: B2, B1, then, when it keeps query-time results, B3
     /// (built at query time and kept across evaluations).
-    fn pane_candidates_for(
+    fn tumbling_window_candidates_for(
         rows_per_s: f64,
         deployment: &DeploymentCapabilities,
     ) -> Vec<PhysicalWorkloadPlan> {
@@ -3982,10 +3983,11 @@ mod tests {
             )
             .unwrap();
         let roots = sized_as_pass1(&roots, &[p99_target()], &arriving(rows_per_s));
-        let rule_candidates = asap_logical_asap_optimization::test_support::pane_candidates(
-            &roots,
-            &[Some(u64::from(MINUTE))],
-        );
+        let rule_candidates =
+            asap_logical_asap_optimization::test_support::tumbling_window_candidates(
+                &roots,
+                &[Some(u64::from(MINUTE))],
+            );
         let roots =
             asap_logical_asap_optimization::test_support::window_composition_pass2_candidates(
                 &roots,
@@ -4031,18 +4033,18 @@ mod tests {
 
     /// `query_time_results_retained` gates keeping a query-time result across
     /// evaluations, and only that. Without it, Stage 2 offers the 1-min
-    /// panes of a query repeating every minute rebuilt (B2) or maintained
+    /// tumbling windows of a query repeating every minute rebuilt (B2) or maintained
     /// (B1); with it, also built at query time and kept (B3,
     /// `MatAtQueryKeptAcrossEvaluations`). B3 is computed once per
-    /// evaluation, reads one pane (1 min) of raw data, keeps that much raw
-    /// data on disk, and holds its 4 older panes in memory between
+    /// evaluation, reads one tumbling window (1 min) of raw data, keeps that much raw
+    /// data on disk, and holds its 4 older tumbling windows in memory between
     /// evaluations (on disk, if it were placed there). The same chain
     /// `MatAtQuery` is reused only within one evaluation: the scan reads the
     /// 5-min window and nothing is kept between evaluations.
     #[test]
-    fn query_time_results_retained_keeps_a_pane_chain_across_evaluations() {
-        assert_eq!(pane_candidates(10_000.0).len(), 2);
-        let candidates = pane_candidates_for(10_000.0, &keeping_query_time_results());
+    fn query_time_results_retained_keeps_a_tumbling_window_chain_across_evaluations() {
+        assert_eq!(tumbling_window_candidates(10_000.0).len(), 2);
+        let candidates = tumbling_window_candidates_for(10_000.0, &keeping_query_time_results());
         assert_eq!(candidates.len(), 3);
         let b2 = &candidates[0].dag;
         let b3 = &candidates[2].dag;
@@ -4076,7 +4078,7 @@ mod tests {
         else {
             unreachable!()
         };
-        // Each pane sees its series' 60 samples: the one minute of 10 000
+        // Each tumbling window sees its series' 60 samples: the one minute of 10 000
         // rows per second over 10 000 series it reads.
         let samples = StateInputRows {
             rows_per_state: Some(60),
@@ -4090,7 +4092,7 @@ mod tests {
         assert!(chain_cost
             .detail
             .contains(&format!("keeps {between} bytes across evaluations")));
-        // On disk, the same N − 1 older panes are kept.
+        // On disk, the same N − 1 older tumbling windows are kept.
         let on_disk = with_chain(Materialization::MatAtQueryKeptAcrossEvaluations(
             Medium::Disk,
         ));
@@ -4117,13 +4119,14 @@ mod tests {
         )
     }
 
-    /// #509 Example 4, B1: maintained at ingestion time, a chain of N panes
-    /// pays the update of the newest pane only, one second of arriving rows
-    /// once per second, and keeps N + 1 panes (the N the query merges and
+    /// #509 Example 4, B1: maintained at ingestion time, a chain of N tumbling windows
+    /// pays the update of the newest tumbling window only, one second of arriving rows
+    /// once per second, and keeps N + 1 tumbling windows (the N the query merges and
     /// the one being built) per series.
     #[test]
-    fn a_chain_at_ingestion_pays_the_newest_pane_and_keeps_n_plus_one_panes() {
-        let candidates = pane_candidates(10_000.0);
+    fn a_chain_at_ingestion_pays_the_newest_tumbling_window_and_keeps_n_plus_one_tumbling_windows()
+    {
+        let candidates = tumbling_window_candidates(10_000.0);
         let dag = &candidates[1].dag;
         let chain = node_of(dag, is_chain);
         let Payload::ASAP(ASAPOp::SummaryTumblingWindowChain {
@@ -4135,7 +4138,7 @@ mod tests {
             unreachable!()
         };
         assert_eq!(*tumbling_window_count, 5);
-        // Each pane sees its series' 60 samples: one minute of 10 000 rows
+        // Each tumbling window sees its series' 60 samples: one minute of 10 000 rows
         // per second over 10 000 series.
         let samples = StateInputRows {
             rows_per_state: Some(60),
@@ -4175,13 +4178,13 @@ mod tests {
     }
 
     /// The latency check (S6, sketch-bench cost model §5): a query's
-    /// latency is its query-time work on one core. Rebuilding the panes at
+    /// latency is its query-time work on one core. Rebuilding the tumbling windows at
     /// query time (B2) takes longer than merging the maintained ones (B1);
     /// with a bound between the two, B2 is rejected as invalid with its
     /// latency and B1 is selected.
     #[test]
     fn a_candidate_over_a_querys_latency_bound_is_rejected_with_its_latency() {
-        let candidates = pane_candidates(10_000.0);
+        let candidates = tumbling_window_candidates(10_000.0);
         let latency = |c: &PhysicalWorkloadPlan| {
             let cost = price(
                 &c.dag,
@@ -4225,13 +4228,13 @@ mod tests {
     /// A query evaluated every minute whose evaluation takes longer than a
     /// minute never keeps up, so even without a latency bound the
     /// candidate is invalid. Over data fast enough that rebuilding the
-    /// panes at query time (B2) takes over a minute while merging the
+    /// tumbling windows at query time (B2) takes over a minute while merging the
     /// maintained ones (B1) does not, B2 is rejected with its latency and
     /// the interval, and B1 is selected.
     #[test]
     fn a_candidate_slower_than_a_querys_repeat_interval_is_rejected_without_a_bound() {
         let rows_per_s = 1e9;
-        let candidates = pane_candidates(rows_per_s);
+        let candidates = tumbling_window_candidates(rows_per_s);
         let latency = |c: &PhysicalWorkloadPlan| {
             price(
                 &c.dag,
@@ -4281,7 +4284,7 @@ mod tests {
     #[test]
     fn a_one_time_query_has_no_repeat_interval_to_keep_up_with() {
         let rows_per_s = 1e9;
-        let candidates = pane_candidates(rows_per_s);
+        let candidates = tumbling_window_candidates(rows_per_s);
         let once = QueryWorkloadEntry {
             recurrence: QueryRecurrence::OneTime {
                 invocations: 1,
@@ -4310,7 +4313,7 @@ mod tests {
     #[test]
     fn a_broken_latency_bound_is_reported_before_the_repeat_interval() {
         let rows_per_s = 1e9;
-        let candidates = pane_candidates(rows_per_s);
+        let candidates = tumbling_window_candidates(rows_per_s);
         let mut bounded = QueryWorkloadEntry {
             recurrence: QueryRecurrence::Repeated(RepeatedDemand::FixedIntervalAt {
                 interval: asap_types::workload::RepetitionInterval(MINUTE),
@@ -4349,7 +4352,7 @@ mod tests {
     #[test]
     fn ingestion_work_over_one_core_adds_the_newest_windows_compaction() {
         let latency = |rows_per_s: f64| {
-            let candidates = pane_candidates(rows_per_s);
+            let candidates = tumbling_window_candidates(rows_per_s);
             price(
                 &candidates[1].dag,
                 &[repeating(MINUTE)],
@@ -4376,7 +4379,7 @@ mod tests {
     /// instead of one operation.
     #[test]
     fn compaction_prices_merges_from_the_measured_merge() {
-        let candidates = pane_candidates(1e10);
+        let candidates = tumbling_window_candidates(1e10);
         let dag = &candidates[1].dag;
         let kll = dag
             .nodes
@@ -4460,7 +4463,7 @@ mod tests {
                 |u| u.disk_bytes as f64,
             ),
         ];
-        for candidate in pane_candidates(10_000.0) {
+        for candidate in tumbling_window_candidates(10_000.0) {
             for (set, used) in resources {
                 let cost = price(
                     &candidate.dag,
@@ -4487,7 +4490,7 @@ mod tests {
 
     /// Cost model 2 prices the candidate's peaks per second: provisioned
     /// memory, cores and disk; its nodes carry no price. B1 (maintained
-    /// panes) needs a core for ingestion and one for the query; B2 (rebuilt
+    /// tumbling windows) needs a core for ingestion and one for the query; B2 (rebuilt
     /// at query time) one.
     #[test]
     fn provisioned_capacity_prices_peak_memory_cores_and_disk() {
@@ -4496,7 +4499,7 @@ mod tests {
             ..ResourceUnitCost::illustrative()
         };
         let settings = under(CostModel::ProvisionedCapacity(prices.clone()));
-        let candidates = pane_candidates(10_000.0);
+        let candidates = tumbling_window_candidates(10_000.0);
         let cores: Vec<u32> = candidates
             .iter()
             .map(|candidate| {
@@ -4530,7 +4533,7 @@ mod tests {
             cpu_cores,
             objective: ClusterObjective::LowestLatency,
         };
-        let candidates = pane_candidates(10_000.0);
+        let candidates = tumbling_window_candidates(10_000.0);
         let select = |cpu_cores| {
             let settings = under(CostModel::ClusterCapacity(limits(cpu_cores)));
             select_among_plans(
@@ -4587,7 +4590,7 @@ mod tests {
     /// less disk than B2's raw data leaves only B1.
     #[test]
     fn cluster_capacity_rejects_a_candidate_over_its_disk() {
-        let candidates = pane_candidates(10_000.0);
+        let candidates = tumbling_window_candidates(10_000.0);
         let select = |disk_bytes| {
             let settings = under(CostModel::ClusterCapacity(ClusterLimits {
                 memory_bytes: u64::MAX,
@@ -4679,7 +4682,7 @@ mod tests {
     /// Under the Pareto front neither dominates the other: both are on it.
     #[test]
     fn cluster_objectives_keep_the_earlier_of_tied_candidates() {
-        let b2 = pane_candidates(10_000.0).remove(0);
+        let b2 = tumbling_window_candidates(10_000.0).remove(0);
         let twin = PhysicalWorkloadPlan {
             id: format!("{}-twin", b2.id),
             ..b2.clone()
@@ -4719,8 +4722,8 @@ mod tests {
 
     /// Every Pass 2 window-composition candidate of a per-series p50 over
     /// 2 min and a p99 over 5 min, both every minute, with both builds in
-    /// 1-min panes: `shared` picks one chain read by both (the 2-min query
-    /// merging its newest 2 panes) or a chain each. Its physical candidate
+    /// 1-min tumbling windows: `shared` picks one chain read by both (the 2-min query
+    /// merging its newest 2 tumbling windows) or a chain each. Its physical candidate
     /// with every chain maintained at ingestion time.
     fn nested_windows_at_ingestion(shared: bool, rows_per_s: f64) -> PhysicalWorkloadPlan {
         let queries = [
@@ -4765,10 +4768,11 @@ mod tests {
             })
             .collect();
         let roots: Vec<_> = pcc::compose_logical_candidate(&inventory, &kll).unwrap();
-        let rule_candidates = asap_logical_asap_optimization::test_support::pane_candidates(
-            &roots,
-            &queries.map(|(_, interval_ms)| Some(u64::from(interval_ms))),
-        );
+        let rule_candidates =
+            asap_logical_asap_optimization::test_support::tumbling_window_candidates(
+                &roots,
+                &queries.map(|(_, interval_ms)| Some(u64::from(interval_ms))),
+            );
         let roots =
             asap_logical_asap_optimization::test_support::window_composition_pass2_candidates(
                 &roots,
@@ -4776,7 +4780,9 @@ mod tests {
             )
             .unwrap()
             .into_iter()
-            .find(|c| c.pane_candidates.len() == 2 && c.shared_chains.is_empty() != shared)
+            .find(|c| {
+                c.tumbling_window_candidates.len() == 2 && c.shared_chains.is_empty() != shared
+            })
             .unwrap()
             .roots
             .unwrap();
@@ -4805,12 +4811,12 @@ mod tests {
         .unwrap()
     }
 
-    /// One chain of 5 panes maintained at ingestion time serves a 5-min and
-    /// a 2-min window: the 2-min query's merge reads its newest 2 panes per
+    /// One chain of 5 tumbling windows maintained at ingestion time serves a 5-min and
+    /// a 2-min window: the 2-min query's merge reads its newest 2 tumbling windows per
     /// series, the 5-min query's all 5, and the plan costs less than a chain
-    /// per query, since each arriving row updates one pane instead of two.
+    /// per query, since each arriving row updates one tumbling window instead of two.
     #[test]
-    fn a_merge_of_the_newest_panes_is_priced_by_the_panes_it_reads() {
+    fn a_merge_of_the_newest_tumbling_windows_is_priced_by_the_tumbling_windows_it_reads() {
         let rows_per_s = 10_000.0;
         let shared = nested_windows_at_ingestion(true, rows_per_s);
         let chains: Vec<_> = shared
@@ -4854,9 +4860,9 @@ mod tests {
         );
     }
 
-    /// A 10-min quantile every minute (10 × 1-min panes) and one every 5
-    /// min (2 × 5-min panes), maintained at ingestion time: one chain of
-    /// 1-min panes serves both, the 5-min query merging all 10 panes once
+    /// A 10-min quantile every minute (10 × 1-min tumbling windows) and one every 5
+    /// min (2 × 5-min tumbling windows), maintained at ingestion time: one chain of
+    /// 1-min tumbling windows serves both, the 5-min query merging all 10 tumbling windows once
     /// per 5 min, and costs less than a chain per query.
     #[test]
     fn queries_at_different_intervals_share_one_chain_at_ingestion_time() {
@@ -4894,7 +4900,7 @@ mod tests {
             separate_cost.cost_per_second
         );
         assert!(cost.usage.average_memory_bytes < separate_cost.usage.average_memory_bytes);
-        // Each query merges all 10 panes per series at its own rate: once
+        // Each query merges all 10 tumbling windows per series at its own rate: once
         // a minute and once per 5 min.
         let mut merges: Vec<(u64, String)> = shared
             .dag
@@ -4919,9 +4925,9 @@ mod tests {
         assert!(merges[1].1.starts_with("0.0167/s"), "{merges:?}");
     }
 
-    /// A 1-hour quantile every minute (60 × 1-min panes) and every 45 s
-    /// (80 × 45-s panes) can share only a chain at their gcd, 240 × 15-s
-    /// panes. Maintained at ingestion time it keeps more states than both
+    /// A 1-hour quantile every minute (60 × 1-min tumbling windows) and every 45 s
+    /// (80 × 45-s tumbling windows) can share only a chain at their gcd, 240 × 15-s
+    /// tumbling windows. Maintained at ingestion time it keeps more states than both
     /// per-query chains together, so it is priced higher than the
     /// per-query chains maintained at ingestion time.
     #[test]
@@ -4966,12 +4972,12 @@ mod tests {
 
     /// With more than one ingest worker, each worker beyond the first holds
     /// its own partial copy of a maintained state's newest window: B1's
-    /// peak memory grows by (k − 1) panes of states, its average memory
+    /// peak memory grows by (k − 1) tumbling windows of states, its average memory
     /// (and so cost model 1's price) does not.
     #[test]
     fn partial_copies_of_the_newest_window_add_to_peak_memory() {
         let rows_per_s = 1e9;
-        let b1 = pane_candidates(rows_per_s).remove(1);
+        let b1 = tumbling_window_candidates(rows_per_s).remove(1);
         let chain = node_of(&b1.dag, is_chain);
         let cost = price(
             &b1.dag,
@@ -4983,7 +4989,7 @@ mod tests {
         let detail = &cost.per_node[&chain].detail;
         let workers = cost.usage.peak_cpu_cores - 1;
         assert!(workers > 1, "{workers}");
-        // The chain keeps 6 panes (5 read and the one being built).
+        // The chain keeps 6 tumbling windows (5 read and the one being built).
         let kept: u64 = detail
             .split("; keeps ")
             .nth(1)
@@ -5258,8 +5264,8 @@ mod tests {
         })
     }
 
-    /// The exact rebuild of [`quantile_candidates`] and the KLL pane
-    /// candidates ([`pane_candidates`]: B2 rebuilt at query time, B1
+    /// The exact rebuild of [`quantile_candidates`] and the KLL tumbling window
+    /// candidates ([`tumbling_window_candidates`]: B2 rebuilt at query time, B1
     /// maintained at ingestion time), with the KLL's parameters.
     fn exact_and_kll() -> (Vec<PhysicalWorkloadPlan>, SketchParams) {
         let mut candidates: Vec<_> = quantile_candidates()
@@ -5268,7 +5274,7 @@ mod tests {
             .collect();
         assert_eq!(candidates.len(), 1);
         candidates[0].id = "EXACT".to_string();
-        candidates.extend(pane_candidates(10_000.0));
+        candidates.extend(tumbling_window_candidates(10_000.0));
         let kll = candidates[2]
             .dag
             .nodes
@@ -5280,7 +5286,7 @@ mod tests {
                 }) => Some(kind.params().clone()),
                 _ => None,
             })
-            .expect("a KLL pane chain");
+            .expect("a KLL tumbling-window chain");
         (candidates, kll)
     }
 
@@ -5319,7 +5325,7 @@ mod tests {
             plan_cost(
                 &candidate.dag,
                 &node_map(&candidate.dag),
-                &kept_pane_chains(&candidate.dag),
+                &kept_tumbling_window_chains(&candidate.dag),
                 &[repeating(MINUTE)],
                 &[],
                 &arriving(10_000.0),
@@ -5550,7 +5556,7 @@ mod tests {
             let cost = self_calibrated_cost(
                 &candidate.dag,
                 &node_map(&candidate.dag),
-                &kept_pane_chains(&candidate.dag),
+                &kept_tumbling_window_chains(&candidate.dag),
                 std::slice::from_ref(&recurrence),
                 &[range],
                 &data(),
@@ -5605,7 +5611,7 @@ mod tests {
     /// in place of the bytes the formulas derive from its parameters.
     #[test]
     fn measured_state_bytes_size_the_kept_state() {
-        let candidates = pane_candidates(10_000.0);
+        let candidates = tumbling_window_candidates(10_000.0);
         let maintained = &candidates[1];
         let kll = maintained
             .dag
@@ -5635,7 +5641,7 @@ mod tests {
             .average_memory_bytes
         };
         let formula = memory(None);
-        // The formula's state: each pane sees its series' 60 samples (one
+        // The formula's state: each tumbling window sees its series' 60 samples (one
         // minute of 10 000 rows per second over 10 000 series).
         let samples = StateInputRows {
             rows_per_state: Some(60),
@@ -5646,10 +5652,10 @@ mod tests {
     }
 
     // Oversized state configurations must be rejected as unrepresentable,
-    // never wrap to a cheap candidate or panic while pricing pane choices.
+    // never wrap to a cheap candidate or panic while pricing tumbling window choices.
     #[test]
-    fn pane_state_byte_overflow_returns_a_cost_error() {
-        for candidate in pane_candidates(10_000.0) {
+    fn tumbling_window_state_byte_overflow_returns_a_cost_error() {
+        for candidate in tumbling_window_candidates(10_000.0) {
             let kll = candidate
                 .dag
                 .nodes
diff --git a/crates/plan-selection/src/report.rs b/crates/plan-selection/src/report.rs
index 504cbd443..fbd7668c9 100644
--- a/crates/plan-selection/src/report.rs
+++ b/crates/plan-selection/src/report.rs
@@ -192,7 +192,7 @@ pub struct WholePlanSelection {
     /// For each valid candidate, per query, the accuracy Stage 3 accepted.
     pub accepted: BTreeMap<String, Vec<AcceptedAccuracy>>,
     pub rejected: Vec<Rejection>,
-    /// The selected plan's pane retention, by node id in its physical DAG
+    /// The selected plan's tumbling-window retention, by node id in its physical DAG
     /// ([`RealizedPlan::tumbling_window_retention_ms`](asap_types::stages::RealizedPlan::tumbling_window_retention_ms)).
     pub tumbling_window_retention_ms: BTreeMap<PhysicalASAPNodeId, u64>,
     /// The physical candidates checked, valid or not.
diff --git a/crates/plan-selection/src/search/candidates/configurations.rs b/crates/plan-selection/src/search/candidates/configurations.rs
index 0f1fa213c..1525b2bd3 100644
--- a/crates/plan-selection/src/search/candidates/configurations.rs
+++ b/crates/plan-selection/src/search/candidates/configurations.rs
@@ -174,7 +174,7 @@ mod tests {
     use asap_logical_asap_optimization::test_support::lower_promql;
     use asap_logical_asap_optimization::test_support::sharing_rules_and_shared_state_groups;
     use asap_logical_asap_optimization::test_support::try_populate_pass1;
-    use asap_logical_asap_optimization::PaneWidthDomain;
+    use asap_logical_asap_optimization::TumblingWindowWidthDomain;
     use asap_types::ir::properties::AccuracyTarget;
     use asap_types::ir::schema::{FieldDataType, SketchAlgorithm};
     use asap_types::ir::QueryRoot;
@@ -221,7 +221,7 @@ mod tests {
                 .unwrap();
         let memo = sharing_rules_and_shared_state_groups(
             try_populate_pass1(initial, &candidates).unwrap(),
-            PaneWidthDomain::Complete,
+            TumblingWindowWidthDomain::Complete,
         )
         .unwrap();
         let source = build_candidate_inventory(&memo, &outputs, |_| Ok(7.0)).unwrap();
diff --git a/crates/plan-selection/src/search/candidates/inventory.rs b/crates/plan-selection/src/search/candidates/inventory.rs
index b621c2cc0..bb3210929 100644
--- a/crates/plan-selection/src/search/candidates/inventory.rs
+++ b/crates/plan-selection/src/search/candidates/inventory.rs
@@ -125,7 +125,7 @@ mod tests {
     use asap_logical_asap_optimization::test_support::lower_promql;
     use asap_logical_asap_optimization::test_support::sharing_rules_and_shared_state_groups;
     use asap_logical_asap_optimization::test_support::try_populate_pass1;
-    use asap_logical_asap_optimization::PaneWidthDomain;
+    use asap_logical_asap_optimization::TumblingWindowWidthDomain;
     use asap_types::ir::properties::AccuracyTarget;
     use asap_types::ir::schema::{FieldDataType, SketchAlgorithm};
     use asap_types::ir::{ASAPOp, NonASAPOp, QueryRoot};
@@ -149,7 +149,8 @@ mod tests {
                 .unwrap();
         let memo = try_populate_pass1(initial, &candidates).unwrap();
         (
-            sharing_rules_and_shared_state_groups(memo, PaneWidthDomain::Complete).unwrap(),
+            sharing_rules_and_shared_state_groups(memo, TumblingWindowWidthDomain::Complete)
+                .unwrap(),
             output_groups,
         )
     }
@@ -315,11 +316,11 @@ mod tests {
         assert_eq!(physical.roots.len(), 2);
     }
 
-    // Union-label pane sharing survives typed connection selection and real
+    // Union-label tumbling window sharing survives typed connection selection and real
     // Stage 2, while each query receives only its original output columns.
     #[test]
-    fn widened_label_readers_materialize_one_shared_pane_chain() {
-        check_shared_pane_plan(
+    fn widened_label_readers_materialize_one_shared_tumbling_window_chain() {
+        check_shared_tumbling_window_plan(
             [
                 "avg by (job) (quantile_over_time(0.95, latency[5m]))",
                 "avg by (region) (quantile_over_time(0.99, latency[5m]))",
@@ -331,10 +332,10 @@ mod tests {
     }
 
     // Different capacities and windows can share a larger chain while the short
-    // query reads only its newest panes; Stage 2, accuracy and pricing all validate.
+    // query reads only its newest tumbling windows; Stage 2, accuracy and pricing all validate.
     #[test]
-    fn different_capacity_and_horizon_readers_share_one_validated_pane_chain() {
-        check_shared_pane_plan(
+    fn different_capacity_and_horizon_readers_share_one_validated_tumbling_window_chain() {
+        check_shared_tumbling_window_plan(
             [
                 "avg by (job) (quantile_over_time(0.95, latency[5m]))",
                 "avg by (job) (quantile_over_time(0.99, latency[15m]))",
@@ -345,7 +346,7 @@ mod tests {
         );
     }
 
-    fn check_shared_pane_plan(
+    fn check_shared_tumbling_window_plan(
         queries: [&str; 2],
         errors: [f64; 2],
         labels: &[&str],
@@ -391,7 +392,8 @@ mod tests {
         asap_logical_asap_optimization::test_support::add_local_window_composition(
             &mut memo, &entries,
         );
-        let memo = sharing_rules_and_shared_state_groups(memo, PaneWidthDomain::Complete).unwrap();
+        let memo = sharing_rules_and_shared_state_groups(memo, TumblingWindowWidthDomain::Complete)
+            .unwrap();
         let source = build_candidate_inventory(&memo, &outputs, |_| Ok(0.0)).unwrap();
         let deployment = asap_logical_asap_optimization::DeploymentCapabilities {
             raw_data_retained: false,
@@ -477,7 +479,7 @@ mod tests {
             else {
                 unreachable!("selected chain checked above")
             };
-            // The complete width domain permits different pane counts. Verify
+            // The complete width domain permits different tumbling-window counts. Verify
             // the short reader's coverage, not one traversal-dependent width.
             assert!(physical.plan.dag.nodes.iter().any(|node| matches!(
                 node.payload, asap_types::ir::Operator::ASAP(ASAPOp::SummaryMerge {newest_tumbling_windows: Some(count), ..})
@@ -488,7 +490,7 @@ mod tests {
         assert!(selected.node_of(*chains[0]).is_some());
         // Validate this exact selected shared graph. Bounded search incumbents
         // need not choose it, and synthetic activation prices are never bills.
-        physical.plan.id = "shared-pane-regression".into();
+        physical.plan.id = "shared-tumbling-window-regression".into();
         let mut evaluator = crate::PlanSelector::new(
             &entries,
             &data,
@@ -501,7 +503,7 @@ mod tests {
         evaluator.offer(&physical.plan).unwrap();
         let (selection, physical) = evaluator
             .finish()
-            .expect("shared pane graph must pass accuracy and cost validation");
+            .expect("shared tumbling window graph must pass accuracy and cost validation");
         assert!(selection.costs[&selection.selected]
             .cost_per_second
             .unwrap()
@@ -565,7 +567,7 @@ mod tests {
             .unwrap();
             let memo = sharing_rules_and_shared_state_groups(
                 try_populate_pass1(initial, &generated).unwrap(),
-                PaneWidthDomain::Complete,
+                TumblingWindowWidthDomain::Complete,
             )
             .unwrap();
             let mut inventory = build_candidate_inventory(&memo, &outputs, |node| {
@@ -742,7 +744,8 @@ mod tests {
             fused.accuracy_budget_parts = 2;
             memo.candidates[owner].push(fused);
             let memo =
-                sharing_rules_and_shared_state_groups(memo, PaneWidthDomain::Complete).unwrap();
+                sharing_rules_and_shared_state_groups(memo, TumblingWindowWidthDomain::Complete)
+                    .unwrap();
             let mut inventory = build_candidate_inventory(&memo, &outputs, |node| {
                 Ok(if matches!(node.asap(), Some(ASAPOp::SummaryAgg { .. })) {
                     1000.0
diff --git a/crates/plan-selection/src/search/candidates/physical.rs b/crates/plan-selection/src/search/candidates/physical.rs
index 4a5870241..0a4a7c844 100644
--- a/crates/plan-selection/src/search/candidates/physical.rs
+++ b/crates/plan-selection/src/search/candidates/physical.rs
@@ -23,7 +23,7 @@ mod tests {
     use asap_logical_asap_optimization::test_support::sharing_rules_and_shared_state_groups;
     use asap_logical_asap_optimization::test_support::try_populate_pass1;
     use asap_logical_asap_optimization::DeploymentCapabilities;
-    use asap_logical_asap_optimization::PaneWidthDomain;
+    use asap_logical_asap_optimization::TumblingWindowWidthDomain;
     use asap_types::ir::properties::AccuracyTarget;
     use asap_types::ir::schema::{FieldDataType, SketchAlgorithm};
     use asap_types::ir::{ASAPOp, NonASAPOp};
@@ -64,7 +64,7 @@ mod tests {
         .unwrap();
         let memo = sharing_rules_and_shared_state_groups(
             try_populate_pass1(initial, &candidates).unwrap(),
-            PaneWidthDomain::Complete,
+            TumblingWindowWidthDomain::Complete,
         )
         .unwrap();
         let inventory = build_candidate_inventory(&memo, &output_groups, |node| {
diff --git a/crates/plan-selection/src/search/candidates/scopes.rs b/crates/plan-selection/src/search/candidates/scopes.rs
index ae88d9674..1982758f0 100644
--- a/crates/plan-selection/src/search/candidates/scopes.rs
+++ b/crates/plan-selection/src/search/candidates/scopes.rs
@@ -366,7 +366,7 @@ mod tests {
     }
 
     // Fix the producer catalog independently of planning budgets and progressive
-    // pane domains. Root-only readers need one optional binding per output;
+    // tumbling-window domains. Root-only readers need one optional binding per output;
     // producers stay constant and producer connections grow exactly linearly.
     // Output-to-copy assignment choices are intentionally N*N, not claimed linear.
     #[test]
diff --git a/crates/plan-selection/src/search/costing/direct_price_options_tests.rs b/crates/plan-selection/src/search/costing/direct_price_options_tests.rs
index 9d88e1957..c8ee50398 100644
--- a/crates/plan-selection/src/search/costing/direct_price_options_tests.rs
+++ b/crates/plan-selection/src/search/costing/direct_price_options_tests.rs
@@ -378,7 +378,8 @@ fn producer_worker_buckets_remain_joint_choices_and_match_evaluator() {
         let ingestion = ingestion
             || (matches!(node.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. }))
                 && mode == Materialization::MatAtIngestion(Medium::Memory));
-        let pane = matches!(node.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. }));
+        let tumbling_window =
+            matches!(node.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. }));
         let mut inputs = Vec::new();
         node.operator
             .map_children(|child| inputs.push(append(child.clone(), configured, ingestion, mode)));
@@ -390,7 +391,7 @@ fn producer_worker_buckets_remain_joint_choices_and_match_evaluator() {
             } else {
                 ExecutionTiming::QueryTime
             },
-            if pane {
+            if tumbling_window {
                 mode
             } else {
                 Materialization::NotMaterialized
@@ -427,11 +428,14 @@ fn producer_worker_buckets_remain_joint_choices_and_match_evaluator() {
         })
         .unwrap();
     let roots: Vec<_> = compose_logical_candidate(&generated, &[choice]).unwrap();
-    let pane_rules =
-        asap_logical_asap_optimization::test_support::pane_candidates(&roots, &[Some(60_000)]);
+    let tumbling_window_rules =
+        asap_logical_asap_optimization::test_support::tumbling_window_candidates(
+            &roots,
+            &[Some(60_000)],
+        );
     let roots = asap_logical_asap_optimization::test_support::window_composition_pass2_candidates(
         &roots,
-        &pane_rules,
+        &tumbling_window_rules,
     )
     .unwrap()
     .pop()
@@ -472,7 +476,7 @@ fn producer_worker_buckets_remain_joint_choices_and_match_evaluator() {
         Some(NonASAPOp::Scan { .. })
     ));
     // This tests the pricing kernel, not executor installation of a projection
-    // below a pane. Both producers return exactly the same stream. The identity projection
+    // below a tumbling window. Both producers return exactly the same stream. The identity projection
     // adds ingestion CPU without changing rows, values, or source identity.
     let source = configured.node(raw_producer.0).clone();
     let projected = OperatorNode::new_shared(Operator::NonASAP(NonASAPOp::Project {
diff --git a/crates/plan-selection/src/search/costing/direct_profile.rs b/crates/plan-selection/src/search/costing/direct_profile.rs
index 942ad5324..68c6a72f1 100644
--- a/crates/plan-selection/src/search/costing/direct_profile.rs
+++ b/crates/plan-selection/src/search/costing/direct_profile.rs
@@ -71,9 +71,9 @@ pub(in crate::search) fn extract(
     extract_scan_class(configured, context, false)
 }
 
-/// A second restricted proposal keeps the newest-pane scan class separate from
+/// A second restricted proposal keeps the newest-tumbling-window scan class separate from
 /// ordinary full-window scans. The full candidate graph is never changed.
-pub(in crate::search) fn extract_latest_panes(
+pub(in crate::search) fn extract_latest_tumbling_windows(
     configured: &PhysicalCandidatesWithCosts,
     context: &CandidatePlanningContext<'_>,
 ) -> Result<Option<DirectProfileExtraction>, DirectProfileError> {
@@ -93,7 +93,7 @@ struct PreparedProfile {
 fn prepare_profile(
     configured: &PhysicalCandidatesWithCosts,
     context: &CandidatePlanningContext<'_>,
-    prefer_latest_pane: bool,
+    prefer_latest_tumbling_window: bool,
 ) -> Result<Option<PreparedProfile>, DirectProfileError> {
     let settings = context.models.cost_inputs;
     let CostModel::UsageOverTime(_prices) = &settings.cost_model else {
@@ -300,7 +300,7 @@ fn prepare_profile(
         if raw_output {
             lookbacks[id] = None;
         } else {
-            let choices = if prefer_latest_pane && !kept.is_empty() {
+            let choices = if prefer_latest_tumbling_window && !kept.is_empty() {
                 &kept
             } else if !ordinary.is_empty() {
                 &ordinary
@@ -310,7 +310,7 @@ fn prepare_profile(
             if choices.is_empty() {
                 nodes[id] = None;
             } else if choices.contains(&None)
-                && !(prefer_latest_pane && choices.iter().any(Option::is_some))
+                && !(prefer_latest_tumbling_window && choices.iter().any(Option::is_some))
             {
                 lookbacks[id] = None;
             } else {
@@ -332,7 +332,7 @@ fn prepare_profile(
 fn extract_scan_class(
     configured: &PhysicalCandidatesWithCosts,
     context: &CandidatePlanningContext<'_>,
-    prefer_latest_pane: bool,
+    prefer_latest_tumbling_window: bool,
 ) -> Result<Option<DirectProfileExtraction>, DirectProfileError> {
     // The fixed adapter has no selected-reader retention tiers. The joint
     // option extractor carries those decisions instead.
@@ -351,7 +351,8 @@ fn extract_scan_class(
     {
         return Ok(None);
     }
-    let Some(prepared) = prepare_profile(configured, context, prefer_latest_pane)? else {
+    let Some(prepared) = prepare_profile(configured, context, prefer_latest_tumbling_window)?
+    else {
         return Ok(None);
     };
     let PreparedProfile {
@@ -486,8 +487,8 @@ fn profile_for_priced(
         }),
         materialized: node.materialization != Materialization::NotMaterialized,
         raw_retention,
-        // A chain maintained at ingestion refreshes its newest pane. The
-        // profile admits no `TimeShift` at ingestion, so that pane ends at
+        // A chain maintained at ingestion refreshes its newest tumbling window. The
+        // profile admits no `TimeShift` at ingestion, so that tumbling window ends at
         // the evaluation time: phase 0.
         refresh_window: match &node.payload {
             asap_types::ir::Operator::ASAP(ASAPOp::SummaryTumblingWindowChain {
@@ -669,7 +670,7 @@ fn price<'a>(
         if sketches > 1 && input_override.is_none() {
             continue;
         }
-        let (retained_panes, ingestion_window) = match &node.payload {
+        let (retained_tumbling_windows, ingestion_window) = match &node.payload {
             asap_types::ir::Operator::ASAP(ASAPOp::SummaryTumblingWindowChain {
                 tumbling_window_count,
                 tumbling_window_width_ms,
@@ -700,7 +701,7 @@ fn price<'a>(
             &views,
             (1, 1.0),
             asap_cost::trailing_window(lookbacks[id]),
-            retained_panes,
+            retained_tumbling_windows,
             ingestion_window,
             context.data,
             context.models.cost_inputs,
@@ -1016,7 +1017,7 @@ fn state_compaction_seconds(
         settings.resource_speed.ms_per_cpu_op * context.calibration.factor(),
         |unit| (unit.ns_per_unit + unit.ns_per_invocation) * 1e-6,
     );
-    let states = priced.output.rows / asap_cost::panes_of(node);
+    let states = priced.output.rows / asap_cost::tumbling_windows_of(node);
     (workers - 1) as f64 * states as f64 * merge_ms / 1000.0
 }
 
@@ -1415,29 +1416,29 @@ mod tests {
     }
 
     #[test]
-    fn ingestion_pane_profiles_match_the_real_evaluator() {
-        check_pane_profile(Materialization::MatAtIngestion(Medium::Memory));
+    fn ingestion_tumbling_window_profiles_match_the_real_evaluator() {
+        check_tumbling_window_profile(Materialization::MatAtIngestion(Medium::Memory));
     }
 
     #[test]
-    fn rebuilt_pane_profiles_match_the_real_evaluator() {
-        check_pane_profile(Materialization::NotMaterialized);
-        check_pane_profile(Materialization::MatAtQuery(Medium::Memory));
+    fn rebuilt_tumbling_window_profiles_match_the_real_evaluator() {
+        check_tumbling_window_profile(Materialization::NotMaterialized);
+        check_tumbling_window_profile(Materialization::MatAtQuery(Medium::Memory));
     }
 
     #[test]
-    fn kept_pane_profiles_and_scan_classes_match_the_real_evaluator() {
-        check_pane_profile(Materialization::MatAtQueryKeptAcrossEvaluations(
+    fn kept_tumbling_window_profiles_and_scan_classes_match_the_real_evaluator() {
+        check_tumbling_window_profile(Materialization::MatAtQueryKeptAcrossEvaluations(
             Medium::Memory,
         ));
     }
 
-    fn check_pane_profile(mode: Materialization) {
-        check_pane_profile_with_range(mode, None);
+    fn check_tumbling_window_profile(mode: Materialization) {
+        check_tumbling_window_profile_with_range(mode, None);
     }
 
     #[test]
-    fn identical_range_pane_profiles_match_the_real_evaluator() {
+    fn identical_range_tumbling_window_profiles_match_the_real_evaluator() {
         let range = Some(asap_types::workload::RangeEvaluation {
             span_ms: 3_600_000,
             step_ms: 60_000,
@@ -1447,11 +1448,11 @@ mod tests {
             Materialization::MatAtQuery(Medium::Memory),
             Materialization::MatAtIngestion(Medium::Memory),
         ] {
-            check_pane_profile_with_range(mode, range);
+            check_tumbling_window_profile_with_range(mode, range);
         }
     }
 
-    fn check_pane_profile_with_range(
+    fn check_tumbling_window_profile_with_range(
         mode: Materialization,
         range_evaluation: Option<asap_types::workload::RangeEvaluation>,
     ) {
@@ -1470,7 +1471,8 @@ mod tests {
             let ingestion = ingestion
                 || (matches!(node.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. }))
                     && mode == Materialization::MatAtIngestion(Medium::Memory));
-            let pane = matches!(node.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. }));
+            let tumbling_window =
+                matches!(node.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. }));
             let mut inputs = Vec::new();
             node.operator.map_children(|child| {
                 inputs.push(append(child.clone(), configured, ingestion, mode))
@@ -1483,7 +1485,7 @@ mod tests {
                 } else {
                     ExecutionTiming::QueryTime
                 },
-                if pane {
+                if tumbling_window {
                     mode
                 } else {
                     Materialization::NotMaterialized
@@ -1534,11 +1536,12 @@ mod tests {
                     let choice = generated.targets[0].ways_to_compute.iter().position(|candidate|
                     matches!(candidate, HowToComputeAggregateMeasure::Summary(found) if *found == algorithm)).unwrap();
                     let roots: Vec<_> = compose_logical_candidate(&generated, &[choice]).unwrap();
-                    let pane_rules = asap_logical_asap_optimization::test_support::pane_candidates(
-                        &roots,
-                        &[Some(width)],
-                    );
-                    let roots = asap_logical_asap_optimization::test_support::window_composition_pass2_candidates(&roots, &pane_rules).unwrap().pop().unwrap().roots.unwrap();
+                    let tumbling_window_rules =
+                        asap_logical_asap_optimization::test_support::tumbling_window_candidates(
+                            &roots,
+                            &[Some(width)],
+                        );
+                    let roots = asap_logical_asap_optimization::test_support::window_composition_pass2_candidates(&roots, &tumbling_window_rules).unwrap().pop().unwrap().roots.unwrap();
                     let data: DataWorkload = serde_json::from_value(serde_json::json!({
                     "arrival":{"ingesting":{"rows_per_second":rows_per_second}},
                     "sources":{"latency":{"series_count":series_count,"rows_held":rows_per_second * 300,"values_non_negative":true,"max_distinct_per_evaluation":1000}}
@@ -1799,7 +1802,7 @@ mod tests {
                     }
                     if mode == Materialization::MatAtQueryKeptAcrossEvaluations(Medium::Memory) {
                         // The same physical scan may feed either a full-window
-                        // rebuild or a newest-pane refresh. Keep these priced
+                        // rebuild or a newest-tumbling-window refresh. Keep these priced
                         // domains distinct, and validate each selected binding.
                         let normal_chain =
                             PhysicalCandidateId(configured.physical.candidates.len());
@@ -1821,7 +1824,7 @@ mod tests {
                         }
                         configured.sync_physical_for_tests();
                         let normal = extract(&configured, &context).unwrap().unwrap();
-                        let latest = extract_latest_panes(&configured, &context)
+                        let latest = extract_latest_tumbling_windows(&configured, &context)
                             .unwrap()
                             .unwrap();
                         assert!(!normal.supported[chain] && normal.supported[normal_chain.0]);
@@ -1926,23 +1929,23 @@ mod tests {
     }
 
     /// A KLL chain (p90 over a minute) and a DDSketch chain (p99 over five
-    /// minutes) kept at ingestion over one `Scan`, each in panes of its
-    /// query's interval. With equal pane widths, one ingestion run per pane
+    /// minutes) kept at ingestion over one `Scan`, each in tumbling windows of its
+    /// query's interval. With equal tumbling-window widths, one ingestion run per tumbling window
     /// computes the `Scan` for both chains, and the old Stage 3 engine's
     /// modeled cost equals the real evaluator's with the `Scan` computed
     /// once, for one schedule (both every 10 s) and for mixed schedules
-    /// (every 20 s and every 40 s, 20 s panes). With 10 s and 60 s panes the
+    /// (every 20 s and every 40 s, 20 s tumbling windows). With 10 s and 60 s tumbling windows the
     /// chains run apart and both count the `Scan` twice (#1151).
     #[test]
     fn chains_of_one_refresh_window_share_their_scan_in_the_direct_profile() {
-        // ((p90 interval, its pane width), (p99 interval, its pane width), Scan computations)
+        // ((p90 interval, its tumbling-window width), (p99 interval, its tumbling-window width), Scan computations)
         for (kll, dd, scan_computations) in [
             ((10_000, 10_000), (10_000, 10_000), 1),
             ((20_000, 20_000), (40_000, 20_000), 1),
             ((10_000, 10_000), (60_000, 60_000), 2),
         ] {
             let (modeled, evaluated, multiplier) = two_chains_over_one_scan(kll, dd);
-            let case = format!("p90 (every, panes) {kll:?} ms, p99 {dd:?} ms");
+            let case = format!("p90 (every, tumbling windows) {kll:?} ms, p99 {dd:?} ms");
             assert!(
                 (evaluated - modeled).abs() <= 1e-9 * evaluated.max(1e-15),
                 "{case}: direct {modeled}, evaluator {evaluated}"
@@ -1952,20 +1955,20 @@ mod tests {
     }
 
     /// [`chains_of_one_refresh_window_share_their_scan_in_the_direct_profile`]
-    /// with the p90 and the p99 each `(interval in ms, pane width in ms)`:
+    /// with the p90 and the p99 each `(interval in ms, tumbling-window width in ms)`:
     /// the direct profile's modeled cost of the selected plan, the
     /// evaluator's cost of it, and the evaluator's multiplier of the `Scan`.
     fn two_chains_over_one_scan(kll: (u64, u64), dd: (u64, u64)) -> (f64, f64, u64) {
         use asap_logical_asap_optimization::test_support::{
-            compose_logical_candidate, generate_per_computation_candidates, pane_candidates,
-            window_composition_pass2_candidates,
+            compose_logical_candidate, generate_per_computation_candidates,
+            tumbling_window_candidates, window_composition_pass2_candidates,
         };
         use asap_types::ir::schema::SketchAlgorithm;
         use asap_types::stages::HowToComputeAggregateMeasure;
         use std::collections::HashMap;
         use std::rc::Rc;
         /// `node` and every node below it as candidates of `configured`, one
-        /// per node (`seen`, by address), at ingestion below a pane chain.
+        /// per node (`seen`, by address), at ingestion below a tumbling-window chain.
         fn append(
             node: &Rc<OperatorNode>,
             configured: &mut PhysicalCandidatesWithCosts,
@@ -2007,7 +2010,7 @@ mod tests {
         let target = AccuracyTarget::max_error(0.05)
             .failure_probability(0.01)
             .accuracy_scope(AccuracyScope::PerValue);
-        // (query, interval in ms, sketch, pane width in ms)
+        // (query, interval in ms, sketch, tumbling-window width in ms)
         let queries = [
             (
                 "quantile_over_time(0.9, latency[1m])",
@@ -2050,20 +2053,27 @@ mod tests {
             .iter()
             .map(|(_, interval, ..)| Some(*interval))
             .collect();
-        // Each build in its query's pane width.
-        let panes: Vec<_> = pane_candidates(&roots, &grid)
+        // Each build in its query's tumbling-window width.
+        let tumbling_windows: Vec<_> = tumbling_window_candidates(&roots, &grid)
             .into_iter()
-            .filter(|pane| {
-                (pane.window_ms(), pane.tumbling_window_width_ms) == (60_000, kll.1)
-                    || (pane.window_ms(), pane.tumbling_window_width_ms) == (300_000, dd.1)
+            .filter(|tumbling_window| {
+                (
+                    tumbling_window.window_ms(),
+                    tumbling_window.tumbling_window_width_ms,
+                ) == (60_000, kll.1)
+                    || (
+                        tumbling_window.window_ms(),
+                        tumbling_window.tumbling_window_width_ms,
+                    ) == (300_000, dd.1)
             })
             .collect();
-        assert_eq!(panes.len(), 2, "{panes:?}");
-        let roots = window_composition_pass2_candidates(&roots, &panes)
+        assert_eq!(tumbling_windows.len(), 2, "{tumbling_windows:?}");
+        let roots = window_composition_pass2_candidates(&roots, &tumbling_windows)
             .unwrap()
             .into_iter()
             .find(|candidate| {
-                candidate.pane_candidates.len() == 2 && candidate.shared_chains.is_empty()
+                candidate.tumbling_window_candidates.len() == 2
+                    && candidate.shared_chains.is_empty()
             })
             .unwrap()
             .roots
diff --git a/crates/plan-selection/src/search/costing/lower_bounds.rs b/crates/plan-selection/src/search/costing/lower_bounds.rs
index 09e54c12e..cb9eada14 100644
--- a/crates/plan-selection/src/search/costing/lower_bounds.rs
+++ b/crates/plan-selection/src/search/costing/lower_bounds.rs
@@ -19,7 +19,7 @@ pub(in crate::search) struct LowerBoundMetrics {
     pub priced_candidates: usize,
     pub rounded_down_candidates: usize,
     pub ingestion_scans: usize,
-    pub ingestion_pane_chains: usize,
+    pub ingestion_tumbling_window_chains: usize,
     pub query_readers: usize,
     pub ingestion_transforms: usize,
 }
@@ -252,7 +252,7 @@ pub(in crate::search) fn apply(
                             }
                             asap_types::ir::Operator::ASAP(
                                 ASAPOp::SummaryTumblingWindowChain { .. },
-                            ) => metrics.ingestion_pane_chains += 1,
+                            ) => metrics.ingestion_tumbling_window_chains += 1,
                             _ => metrics.ingestion_transforms += 1,
                         }
                     }
@@ -260,7 +260,7 @@ pub(in crate::search) fn apply(
             }
         }
     }
-    // The solver's coefficient range is narrower than the full pane domain.
+    // The solver's coefficient range is narrower than the full tumbling-window domain.
     // Zero is still a certified lower bound for omitted tiny local charges;
     // the evaluator continues to charge their complete actual cost.
     metrics.rounded_down_candidates = round_down_small_bounds(&mut costs);
@@ -274,8 +274,8 @@ pub(in crate::search) fn apply(
 
 /// Each candidate's common reader window: the window every candidate that
 /// may read it (through time shifts) reads, as the evaluator's
-/// `windows_read` counts windows (a time range's range, a pane chain's
-/// panes). A query-time scan reads its readers' longest window, or every
+/// `windows_read` counts windows (a time range's range, a tumbling-window chain's
+/// tumbling windows). A query-time scan reads its readers' longest window, or every
 /// row held when no reader has one; both are at least the rows of this
 /// window capped by the rows held. `None` when no reader has a window, or
 /// when readers' windows differ: which window the scan reads then depends on
@@ -311,7 +311,7 @@ fn common_reader_windows(configured: &PhysicalCandidatesWithCosts) -> Vec<Option
                             pending.push(reader);
                             None
                         }
-                        // A chain kept across evaluations reads one pane;
+                        // A chain kept across evaluations reads one tumbling window;
                         // its scans are never certified (retained ancestors).
                         asap_types::ir::Operator::ASAP(ASAPOp::SummaryTumblingWindowChain {
                             tumbling_window_width_ms,
@@ -588,9 +588,9 @@ fn certified_price<'a>(
                         asap_types::workload::bounds::declared_non_negative(context.data, source)
                     })
                 });
-                // Producer pane counts, family, schema fields, statistics and
+                // Producer tumbling-window counts, family, schema fields, statistics and
                 // provenance must agree; upstream work is charged separately.
-                let panes = match producer.payload {
+                let tumbling_windows = match producer.payload {
                     asap_types::ir::Operator::ASAP(ASAPOp::SummaryTumblingWindowChain {
                         tumbling_window_count,
                         ..
@@ -606,7 +606,7 @@ fn certified_price<'a>(
                 schema.closed = false;
                 let current = serde_json::to_string(&(
                     raw_nonnegative,
-                    panes,
+                    tumbling_windows,
                     family,
                     schema,
                     priced.output,
@@ -653,7 +653,7 @@ fn certified_price<'a>(
         // One ingestion boundary executes once per accounted second; additional
         // unmaterialized consumers can only add executions. A summary build is
         // priced at its template's size, its final size
-        // ([`template_price_is_a_floor`]). Retention above its own pane count
+        // ([`template_price_is_a_floor`]). Retention above its own tumbling-window count
         // and all whole-plan charges are deliberately omitted.
         Ok(node_usage(
             node,
@@ -686,7 +686,7 @@ fn certified_price<'a>(
 #[cfg(test)]
 mod tests {
     use asap_logical_asap_optimization::generate_dag_of_logical_memo_groups;
-    // Fine panes may widen the bound range; round down only the relaxation,
+    // Fine tumbling windows may widen the bound range; round down only the relaxation,
     // preserving a valid lower bound and the core solver's numeric contract.
     #[test]
     fn tiny_certificates_are_rounded_down_without_inflating_other_costs() {
@@ -710,7 +710,7 @@ mod tests {
     use asap_logical_asap_optimization::test_support::try_populate_pass1;
     use asap_logical_asap_optimization::test_support::{entry_with, lower_promql};
     use asap_logical_asap_optimization::test_support::{
-        pane_candidates, window_composition_pass2_candidates,
+        tumbling_window_candidates, window_composition_pass2_candidates,
     };
     use asap_physical_asap_optimization::test_support::catalog::materialize_selected_candidates;
     use asap_types::ir::properties::AccuracyTarget;
@@ -783,9 +783,9 @@ mod tests {
                 } else { matches!(node.asap(), Some(ASAPOp::SummaryAgg { family: FieldDataType::Sketch(kind, _), .. }) if matches!(kind.params(), SketchParams::DDSketch { .. })) })
             ).unwrap();
             let input = vec![QueryRoot::Operator(Rc::clone(&candidate.root_node))];
-            let panes = pane_candidates(&input, &[Some(60_000)]);
+            let tumbling_windows = tumbling_window_candidates(&input, &[Some(60_000)]);
             roots.push(
-                window_composition_pass2_candidates(&input, &panes)
+                window_composition_pass2_candidates(&input, &tumbling_windows)
                     .unwrap()
                     .remove(0)
                     .roots
@@ -809,16 +809,17 @@ mod tests {
             });
             let id = configured.nodes_for_tests().len();
             ids.insert(Rc::as_ptr(node), id);
-            let pane = matches!(node.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. }));
+            let tumbling_window =
+                matches!(node.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. }));
             let scan = matches!(node.non_asap(), Some(NonASAPOp::Scan { .. }));
             configured.push_for_tests(
                 Rc::clone(node),
-                if pane || scan {
+                if tumbling_window || scan {
                     ExecutionTiming::IngestionTime
                 } else {
                     ExecutionTiming::QueryTime
                 },
-                if pane {
+                if tumbling_window {
                     Materialization::MatAtIngestion(Medium::Memory)
                 } else {
                     Materialization::NotMaterialized
@@ -1088,7 +1089,7 @@ mod tests {
     // Fixed exact accumulator state is not resized by failure-probability rules;
     // every sharing/independent plan must have positive certified state pricing.
     #[test]
-    fn exact_accumulator_panes_and_finalizers_have_certified_bounds() {
+    fn exact_accumulator_tumbling_windows_and_finalizers_have_certified_bounds() {
         check_tiny_bounds(true, false, false);
     }
 
@@ -1101,10 +1102,10 @@ mod tests {
         check_tiny_bounds(true, true, false);
     }
 
-    // Grouped ingestion state uses its own exact pane horizon, matching the
+    // Grouped ingestion state uses its own exact tumbling-window horizon, matching the
     // complete evaluator's maintained_window_ms rather than an unknown window.
     #[test]
-    fn grouped_exact_panes_use_their_declared_maintenance_horizon() {
+    fn grouped_exact_tumbling_windows_use_their_declared_maintenance_horizon() {
         check_tiny_bounds(true, false, true);
     }
 
@@ -1180,7 +1181,7 @@ mod tests {
                 calibration,
             };
             let metrics = apply(&mut configured, &context).unwrap();
-            assert_eq!(metrics.ingestion_pane_chains, 2);
+            assert_eq!(metrics.ingestion_tumbling_window_chains, 2);
             assert!(metrics.ingestion_scans > 0);
             assert!(metrics.query_readers > 0);
             if exact {
@@ -1276,7 +1277,7 @@ mod tests {
         };
         let metrics = apply(&mut configured, &context).unwrap();
         assert_eq!(metrics.query_readers, 0);
-        assert!(metrics.ingestion_pane_chains > 0);
+        assert!(metrics.ingestion_tumbling_window_chains > 0);
         for (candidate, config) in configured
             .dag
             .candidates
@@ -1290,7 +1291,7 @@ mod tests {
     }
     // Equal row counts do not certify different sources as interchangeable cost inputs.
     #[test]
-    fn differing_producer_metadata_leaves_pane_bounds_zero() {
+    fn differing_producer_metadata_leaves_tumbling_window_bounds_zero() {
         let (mut configured, roots, entries, mut data) = fixture();
         let scans: Vec<_> = configured
             .nodes_for_tests()
@@ -1333,7 +1334,7 @@ mod tests {
             calibration: CalibrationFit::default(),
         };
         let metrics = apply(&mut configured, &context).unwrap();
-        assert_eq!(metrics.ingestion_pane_chains, 0);
+        assert_eq!(metrics.ingestion_tumbling_window_chains, 0);
         assert_eq!(metrics.ingestion_scans, 2);
     }
 
diff --git a/crates/plan-selection/src/search/costing/proposals.rs b/crates/plan-selection/src/search/costing/proposals.rs
index 441338bd8..82659fad9 100644
--- a/crates/plan-selection/src/search/costing/proposals.rs
+++ b/crates/plan-selection/src/search/costing/proposals.rs
@@ -125,8 +125,8 @@ impl TemplateCatalog {
             _ => lookback,
         };
         let lookback = match node.asap() {
-            // Query-time construction reads all panes' source rows. Reuse the
-            // compact SummaryTumblingWindowChain formula in asap_cost::node_usage without expanding panes.
+            // Query-time construction reads all tumbling windows' source rows. Reuse the
+            // compact SummaryTumblingWindowChain formula in asap_cost::node_usage without expanding tumbling windows.
             Some(ASAPOp::SummaryTumblingWindowChain {
                 tumbling_window_width_ms,
                 tumbling_window_count,
@@ -287,10 +287,10 @@ mod tests {
             .candidates
             .iter()
             .all(|candidate| candidate.local_cost == 0.0));
-        // A query-time pane chain reads its full window, not an unbounded
+        // A query-time tumbling-window chain reads its full window, not an unbounded
         // source. Price it compactly; a missing horizon previously made every
-        // pane estimate zero and wrongly favored it over priced whole builds.
-        let pane_id = configured
+        // tumbling-window estimate zero and wrongly favored it over priced whole builds.
+        let tumbling_window_id = configured
             .nodes_for_tests()
             .iter()
             .enumerate()
@@ -300,7 +300,7 @@ mod tests {
                 .then_some(id)
             })
             .unwrap();
-        let build = configured.node(pane_id);
+        let build = configured.node(tumbling_window_id);
         let Some(ASAPOp::SummaryAgg {
             child,
             family,
@@ -315,7 +315,7 @@ mod tests {
         let Some(NonASAPOp::TimeRange { child: source, .. }) = child.non_asap() else {
             unreachable!()
         };
-        let pane = OperatorNode::new_shared(asap_types::ir::Operator::ASAP(
+        let tumbling_window = OperatorNode::new_shared(asap_types::ir::Operator::ASAP(
             ASAPOp::SummaryTumblingWindowChain {
                 child: Rc::clone(source),
                 family: family.clone(),
@@ -328,13 +328,16 @@ mod tests {
             },
         ))
         .unwrap();
-        configured.set_node_for_tests(pane_id, pane);
-        let pane_estimates = estimate_costs(&configured, &context);
+        configured.set_node_for_tests(tumbling_window_id, tumbling_window);
+        let tumbling_window_estimates = estimate_costs(&configured, &context);
         assert!(
-            pane_estimates[pane_id] > 0.0,
-            "query-time pane build must not look free"
+            tumbling_window_estimates[tumbling_window_id] > 0.0,
+            "query-time tumbling-window build must not look free"
+        );
+        assert_eq!(
+            configured.dag.candidates[tumbling_window_id].local_cost,
+            0.0
         );
-        assert_eq!(configured.dag.candidates[pane_id].local_cost, 0.0);
 
         // Deadline cancellation merely omits advisory priorities; no inventory
         // or feasibility fact is changed by incomplete heuristic work.
diff --git a/crates/plan-selection/src/search/costing/range_price_options_tests.rs b/crates/plan-selection/src/search/costing/range_price_options_tests.rs
index 5809f1c81..e21a6041c 100644
--- a/crates/plan-selection/src/search/costing/range_price_options_tests.rs
+++ b/crates/plan-selection/src/search/costing/range_price_options_tests.rs
@@ -17,7 +17,7 @@ use asap_types::workload::{
 use std::rc::Rc;
 
 #[test]
-fn shared_pane_range_tiers_match_evaluator_for_ingestion_and_kept_refresh() {
+fn shared_tumbling_window_range_tiers_match_evaluator_for_ingestion_and_kept_refresh() {
     fn append(
         node: Rc<OperatorNode>,
         configured: &mut PhysicalCandidatesWithCosts,
@@ -27,7 +27,8 @@ fn shared_pane_range_tiers_match_evaluator_for_ingestion_and_kept_refresh() {
         let ingestion = ingestion
             || (matches!(node.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. }))
                 && mode == Materialization::MatAtIngestion(Medium::Memory));
-        let pane = matches!(node.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. }));
+        let tumbling_window =
+            matches!(node.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. }));
         let mut inputs = Vec::new();
         node.operator
             .map_children(|child| inputs.push(append(child.clone(), configured, ingestion, mode)));
@@ -39,7 +40,7 @@ fn shared_pane_range_tiers_match_evaluator_for_ingestion_and_kept_refresh() {
             } else {
                 ExecutionTiming::QueryTime
             },
-            if pane {
+            if tumbling_window {
                 mode
             } else {
                 Materialization::NotMaterialized
@@ -80,8 +81,10 @@ fn shared_pane_range_tiers_match_evaluator_for_ingestion_and_kept_refresh() {
             })
             .unwrap();
         let roots: Vec<_> = compose_logical_candidate(&generated, &[choice]).unwrap();
-        let rules =
-            asap_logical_asap_optimization::test_support::pane_candidates(&roots, &[Some(10_000)]);
+        let rules = asap_logical_asap_optimization::test_support::tumbling_window_candidates(
+            &roots,
+            &[Some(10_000)],
+        );
         let roots =
             asap_logical_asap_optimization::test_support::window_composition_pass2_candidates(
                 &roots, &rules,
diff --git a/crates/plan-selection/src/search/refinement/planner.rs b/crates/plan-selection/src/search/refinement/planner.rs
index 75b7ca950..12d14ec95 100644
--- a/crates/plan-selection/src/search/refinement/planner.rs
+++ b/crates/plan-selection/src/search/refinement/planner.rs
@@ -455,7 +455,7 @@ fn direct_cost_seed(
     configured: &PhysicalCandidatesWithCosts,
     context: &CandidatePlanningContext<'_>,
     seed_exclusions: &[asap_types::stages::PhysicalCandidateId],
-    latest_panes: bool,
+    latest_tumbling_windows: bool,
 ) -> Result<
     Option<(
         crate::search::candidates::dag::DagOfPhysicalCandidatesWithCosts,
@@ -465,11 +465,11 @@ fn direct_cost_seed(
 > {
     use crate::search::candidates::dag::ReaderConstraint;
     use crate::search::costing::direct_profile::{
-        extract, extract_latest_panes, DirectProfileError,
+        extract, extract_latest_tumbling_windows, DirectProfileError,
     };
     use asap_types::stages::PhysicalCandidateId;
-    let extracted = if latest_panes {
-        extract_latest_panes(configured, context)
+    let extracted = if latest_tumbling_windows {
+        extract_latest_tumbling_windows(configured, context)
     } else {
         extract(configured, context)
     };
@@ -751,18 +751,17 @@ fn accuracy_baseline(
         .iter()
         .enumerate()
         .map(|(id, candidate)| {
-            candidate
-                .local_cost
-                .max(estimated_costs[id])
-                .max(retained_pane_priority_cost(
+            candidate.local_cost.max(estimated_costs[id]).max(
+                retained_tumbling_window_priority_cost(
                     configured.node(id),
                     &configured.physical.candidates[id],
                     context,
-                ))
+                ),
+            )
         })
         .collect();
     // Feasibility seeds compare retained states; cost-only seeds compare query
-    // work. Large unrelated pane residency must not make CPU savings smaller
+    // work. Large unrelated tumbling window residency must not make CPU savings smaller
     // than the structural node-count tie-break when accuracy is ignored.
     let mut positive_costs: Vec<_> = proposal_costs
         .iter()
@@ -797,7 +796,7 @@ fn accuracy_baseline(
             let cost_priority = if reference_cost > 0.0 {
                 let relative = proposal_costs[id] / reference_cost;
                 // Preserve ordering beyond the normal linear range, without
-                // letting a very fine unused pane destroy numerical scaling.
+                // letting a very fine unused tumbling window destroy numerical scaling.
                 preference
                     * if relative <= 1000.0 {
                         relative
@@ -839,7 +838,7 @@ fn accuracy_baseline(
                 }) || (node.guarantee.is_none()
                     && matches!(node.asap(), Some(ASAPOp::SummaryEstimate { .. }))));
             // Highest-shared-node eligibility depends on chosen consumers.
-            // Start with explicit build/pane materialization; optional shared
+            // Start with explicit build/tumbling window materialization; optional shared
             // non-summary materializations remain in the complete search.
             let contextual_materialization =
                 !context.models.accuracy.may_accept_regardless_of_guarantee()
@@ -855,9 +854,9 @@ fn accuracy_baseline(
                     node.non_asap(),
                     Some(asap_types::ir::NonASAPOp::Project { .. })
                 );
-            // Unpriced pane pipelines are not free. Prefer candidates whose
+            // Unpriced tumbling window pipelines are not free. Prefer candidates whose
             // local query work can be priced for the initial proposal; the
-            // complete search retains every legal pane and its certified bound.
+            // complete search retains every legal tumbling window and its certified bound.
             let unknown_work_priority = if context.models.accuracy.may_accept_regardless_of_guarantee()
                 && configured.physical.candidates[id].timing
                     == asap_types::ir::properties::ExecutionTiming::QueryTime
@@ -904,7 +903,7 @@ fn raw_scan_with_shifts(node: &asap_types::ir::OperatorNode) -> bool {
 
 // A heuristic memory charge, never a lower bound or an evaluator replacement.
 // Group/cardinality and producer choices remain authoritative after selection.
-fn retained_pane_priority_cost(
+fn retained_tumbling_window_priority_cost(
     node: &std::rc::Rc<asap_types::ir::OperatorNode>,
     configuration: &asap_types::stages::PhysicalCandidate,
     context: &CandidatePlanningContext<'_>,
@@ -1156,7 +1155,7 @@ mod tests {
     use asap_logical_asap_optimization::test_support::sharing_rules_and_shared_state_groups;
     use asap_logical_asap_optimization::test_support::try_populate_pass1;
     use asap_logical_asap_optimization::test_support::{entry_with, lower_promql};
-    use asap_logical_asap_optimization::PaneWidthDomain;
+    use asap_logical_asap_optimization::TumblingWindowWidthDomain;
     use asap_types::ir::properties::AccuracyTarget;
     use asap_types::ir::schema::{FieldDataType, SketchAlgorithm};
     use asap_types::ir::{ASAPOp, OperatorNode};
@@ -1194,7 +1193,7 @@ mod tests {
         .unwrap();
         let mut memo = sharing_rules_and_shared_state_groups(
             try_populate_pass1(initial, &generated).unwrap(),
-            PaneWidthDomain::Complete,
+            TumblingWindowWidthDomain::Complete,
         )
         .unwrap();
         // Keep the real generated shared KLL readers to bound this evaluator
@@ -1334,10 +1333,12 @@ mod tests {
             .unwrap()
             .is_none());
         assert!(!reasons.is_empty());
-        for latest_panes in [false, true] {
-            assert!(direct_cost_seed(&configured, &context, &[], latest_panes)
-                .unwrap()
-                .is_none());
+        for latest_tumbling_windows in [false, true] {
+            assert!(
+                direct_cost_seed(&configured, &context, &[], latest_tumbling_windows)
+                    .unwrap()
+                    .is_none()
+            );
         }
         // Malformed demand is a real input error, not an unsupported model.
         let mut invalid_entries = entries.clone();
@@ -1349,15 +1350,18 @@ mod tests {
             ..context
         };
         assert!(joint_cost_seed(&configured, &invalid_context, &[], &mut reasons).is_err());
-        for latest_panes in [false, true] {
-            assert!(direct_cost_seed(&configured, &invalid_context, &[], latest_panes).is_err());
+        for latest_tumbling_windows in [false, true] {
+            assert!(
+                direct_cost_seed(&configured, &invalid_context, &[], latest_tumbling_windows)
+                    .is_err()
+            );
         }
     }
 
-    // One logical group can serve a repeated reader through panes and an
-    // unpredictable reader locally; only selected pane consumers need eligibility.
+    // One logical group can serve a repeated reader through tumbling windows and an
+    // unpredictable reader locally; only selected tumbling window consumers need eligibility.
     #[test]
-    fn nongridded_reader_does_not_veto_another_readers_ingestion_panes() {
+    fn nongridded_reader_does_not_veto_another_readers_ingestion_tumbling_windows() {
         use crate::search::milp::model::select_candidates;
         use asap_types::ir::properties::ExecutionTiming;
         let (_, original, mut entries, mut data) = fixture();
@@ -1379,7 +1383,7 @@ mod tests {
         asap_logical_asap_optimization::test_support::add_local_window_composition_in_domain(
             &mut memo,
             &entries,
-            asap_logical_asap_optimization::PaneWidthDomain::SeedGrids,
+            asap_logical_asap_optimization::TumblingWindowWidthDomain::SeedGrids,
         );
         let source = build_candidate_inventory(&memo, &[output, output], |_| Ok(0.0)).unwrap();
         let models = SelectionModels::builtin();
@@ -1391,7 +1395,7 @@ mod tests {
             &asap_logical_asap_optimization::DeploymentCapabilities::default(),
         )
         .unwrap();
-        let has_panes: Vec<_> = configured
+        let has_tumbling_windows: Vec<_> = configured
             .nodes_for_tests()
             .iter()
             .map(|node| {
@@ -1402,10 +1406,10 @@ mod tests {
             .collect();
         configured.dag.query_roots[0]
             .candidates
-            .retain(|id| has_panes[id.0]);
+            .retain(|id| has_tumbling_windows[id.0]);
         configured.dag.query_roots[1]
             .candidates
-            .retain(|id| !has_panes[id.0]);
+            .retain(|id| !has_tumbling_windows[id.0]);
         assert!(!configured.dag.query_roots[0].candidates.is_empty());
         let allowed: Vec<_> = configured
             .nodes_for_tests()
@@ -1423,7 +1427,7 @@ mod tests {
         }
         let selected = select_candidates(&configured.dag)
             .unwrap()
-            .expect("repeated reader still has an ingestion pane plan");
+            .expect("repeated reader still has an ingestion tumbling window plan");
         let context = CandidatePlanningContext {
             deadline: None,
             refine_materialization: false,
@@ -1447,7 +1451,7 @@ mod tests {
         configured.dag.query_roots[1].candidates = configured.dag.query_roots[0].candidates.clone();
         assert!(
             select_candidates(&configured.dag).unwrap().is_none(),
-            "unpredictable reader cannot bind to ingestion-only panes"
+            "unpredictable reader cannot bind to ingestion-only tumbling windows"
         );
     }
 
@@ -1466,7 +1470,7 @@ mod tests {
                 .unwrap();
         let memo = sharing_rules_and_shared_state_groups(
             try_populate_pass1(initial, &generated).unwrap(),
-            PaneWidthDomain::Complete,
+            TumblingWindowWidthDomain::Complete,
         )
         .unwrap();
         let source = build_candidate_inventory(&memo, &[output], |_| Ok(0.0)).unwrap();
@@ -1571,7 +1575,8 @@ mod tests {
         asap_logical_asap_optimization::test_support::add_local_window_composition(
             &mut memo, &entries,
         );
-        let memo = sharing_rules_and_shared_state_groups(memo, PaneWidthDomain::Complete).unwrap();
+        let memo = sharing_rules_and_shared_state_groups(memo, TumblingWindowWidthDomain::Complete)
+            .unwrap();
         let source = build_candidate_inventory(&memo, &outputs, |_| Ok(0.0)).unwrap();
         let deployment = asap_logical_asap_optimization::DeploymentCapabilities {
             raw_data_retained: false,
@@ -1862,7 +1867,7 @@ mod tests {
         assert_eq!(configured.dag.candidates[0].local_cost, 100.0);
     }
 
-    // An irrelevant extremely fine pane must not erase the cost distinction
+    // An irrelevant extremely fine tumbling window must not erase the cost distinction
     // between ordinary state configurations in the feasible-plan heuristic.
     #[test]
     fn baseline_cost_scale_is_not_diluted_by_an_outlier() {
@@ -1885,10 +1890,10 @@ mod tests {
         assert!(weighted[0] > original[0] + 2.0);
     }
 
-    // Uncertified memory is not free: a 1200-pane shared state must not beat
+    // Uncertified memory is not free: a 1200-tumbling-window shared state must not beat
     // two much smaller same-family states solely by saving one activation.
     #[test]
-    fn baseline_prices_uncertified_pane_storage_without_changing_bounds() {
+    fn baseline_prices_uncertified_tumbling_window_storage_without_changing_bounds() {
         use asap_types::ir::{NonASAPOp, Operator};
         use asap_types::physical::Medium;
         let (mut configured, roots, entries, data) = fixture();
diff --git a/crates/plan-selection/src/selector.rs b/crates/plan-selection/src/selector.rs
index eaa6a9a01..d1a289bc7 100644
--- a/crates/plan-selection/src/selector.rs
+++ b/crates/plan-selection/src/selector.rs
@@ -18,7 +18,9 @@ use crate::report::{
     AcceptedAccuracy, ErrorSelectingPlan, Rejection, RejectionCause, WholePlanSelection,
 };
 use crate::SelectionModels;
-use asap_cost::{kept_pane_chains, node_map, plan_cost, query_reach, tumbling_window_retention_ms};
+use asap_cost::{
+    kept_tumbling_window_chains, node_map, plan_cost, query_reach, tumbling_window_retention_ms,
+};
 
 type Ranking = PlanRanking;
 use asap_types::workload::bounds::with_confirmed_weights;
@@ -157,7 +159,7 @@ impl<'a> PlanSelector<'a> {
             return Ok(CalibrationFit::default());
         }
         let nodes = node_map(&candidate.dag);
-        let kept_chains = kept_pane_chains(&candidate.dag);
+        let kept_chains = kept_tumbling_window_chains(&candidate.dag);
         let (_, fit) = plan_cost(
             &candidate.dag,
             &nodes,
@@ -224,7 +226,7 @@ impl<'a> PlanSelector<'a> {
                 }
             };
         let nodes = node_map(&candidate.dag);
-        let kept_chains = kept_pane_chains(&candidate.dag);
+        let kept_chains = kept_tumbling_window_chains(&candidate.dag);
         let settings = self.models.cost_inputs;
         let (cost, _) = plan_cost(
             &candidate.dag,
diff --git a/crates/planner/src/installable.rs b/crates/planner/src/installable.rs
index 855398f5f..0ba1079fb 100644
--- a/crates/planner/src/installable.rs
+++ b/crates/planner/src/installable.rs
@@ -19,9 +19,9 @@
 //! buffers; a SQL table is read as is) and its stored views, and the
 //! DAG's own `TimeRange`s apply each window, an instant selector's lookback
 //! and Prometheus stale markers. How the Planner represents the plan
-//! internally (e.g. a tumbling-pane chain, which the stage export keeps for
+//! internally (e.g. a tumbling-window chain, which the stage export keeps for
 //! costing and display) is not the runtime's concern: the installable DAG
-//! has every chain expanded into the panes the executor runs.
+//! has every chain expanded into the tumbling windows the executor runs.
 
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::rc::Rc;
@@ -32,7 +32,7 @@ use asap_plan_selection::{SearchReport, Selection};
 use asap_types::ir::materialized_view::{
     IngestionRefreshGroup, InstallableDagError, MaterializedView, RawDataRetention,
 };
-use asap_types::ir::operator::pane_chain::expand_pane_chains_in_workload;
+use asap_types::ir::operator::tumbling_window_chain::expand_tumbling_window_chains_in_workload;
 use asap_types::ir::physical_export::{
     PhysicalASAPDAG, PhysicalASAPDAGEdge, PhysicalASAPDAGNode, PhysicalASAPDAGValidationError,
     PhysicalASAPNodeId, ReferencePlanError,
@@ -60,7 +60,7 @@ pub struct InstallablePlan {
     /// [`INSTALLABLE_PLAN_WIRE_VERSION`] of the planner that wrote it.
     pub wire_version: u32,
     /// The selected physical ASAP DAG with Stage 3's timings and
-    /// materialization, every pane chain expanded into its panes, each
+    /// materialization, every tumbling-window chain expanded into its tumbling windows, each
     /// materialized view and query-time `Scan` carrying its `retention_ms`;
     /// the executor compiles it as is.
     pub dag: PhysicalASAPDAG,
@@ -115,18 +115,18 @@ pub struct PredictedUsage {
 }
 
 /// One operator node's predicted usage. The node is one of the physical
-/// DAG Stage 3 priced, where a tumbling-pane chain is one node; `dag` has
-/// it expanded into its panes, so `installed_node_ids` says which of
+/// DAG Stage 3 priced, where a tumbling-window chain is one node; `dag` has
+/// it expanded into its tumbling windows, so `installed_node_ids` says which of
 /// `dag`'s nodes run it.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct PredictedNodeUsage {
     /// Its id in Stage 3's physical DAG of the selected candidate.
     pub stage3_node_id: PhysicalASAPNodeId,
-    /// The ids in `dag` that run it: a tumbling-pane chain's panes, newest
+    /// The ids in `dag` that run it: a tumbling-window chain's tumbling windows, newest
     /// first; for every other node, the one node it is installed as. Empty
     /// for a node `dag` has no copy of: one the expansion rebuilds once per
-    /// pane below a chain (e.g. the chain's input window).
+    /// tumbling window below a chain (e.g. the chain's input window).
     pub installed_node_ids: Vec<PhysicalASAPNodeId>,
     /// Its operator, as the measured cost table names it.
     pub operator: OperatorKind,
@@ -161,9 +161,9 @@ pub enum InstallablePlanError {
     /// cannot run at query time.
     #[error("timing: {0}")]
     Timing(#[from] ExecutionDataStateError),
-    /// Internal bug: a pane chain of the selected plan does not expand.
-    #[error("pane chain expansion: {0}")]
-    PaneChainExpansion(#[from] SchemaDerivationError),
+    /// Internal bug: a tumbling-window chain of the selected plan does not expand.
+    #[error("tumbling-window chain expansion: {0}")]
+    TumblingWindowChainExpansion(#[from] SchemaDerivationError),
     /// Bad input (a plan file): written for another plan-file format; `None`
     /// for a file without `wire_version`, written before version 11.
     #[error("unsupported installable plan wire version {0:?}")]
@@ -188,10 +188,10 @@ pub enum InstallablePlanError {
     /// [`InstallableDagError`]).
     #[error("{0}")]
     Uninstallable(InstallableDagError),
-    /// Internal bug: Stage 3 records a pane retention for node `node_id`
-    /// of the selected plan, which is not one of its pane chains.
-    #[error("pane retention for node {node_id}, which is not a pane chain of the selected plan")]
-    PaneRetentionOfUnknownChain { node_id: PhysicalASAPNodeId },
+    /// Internal bug: Stage 3 records a tumbling-window retention for node `node_id`
+    /// of the selected plan, which is not one of its tumbling-window chains.
+    #[error("tumbling-window retention for node {node_id}, which is not a tumbling-window chain of the selected plan")]
+    TumblingWindowRetentionOfUnknownChain { node_id: PhysicalASAPNodeId },
     /// Unsatisfiable request: the executor cannot refresh materialized view
     /// `node_id` from its inputs (`reason`); for a refresh group, `node_id`
     /// is its first view and `reason` names every view compiled with it.
@@ -262,7 +262,7 @@ pub async fn plan_installable(
 /// The installable plan of `roots`, the selected roots of a workload whose
 /// entries are `entries` (in `QueryWorkload::entries()` order), with
 /// Stage 3's report of its `selection` of them when there is one, and the
-/// pane retention of the selected plan's kept chains
+/// tumbling-window retention of the selected plan's kept chains
 /// (`RealizedPlan::tumbling_window_retention_ms`, by node id in the DAG `roots`
 /// export): what [`plan_installable`] returns after planning. A caller that
 /// runs the planning stages itself (e.g. a developer tool) uses it to see
@@ -283,7 +283,10 @@ pub fn installable_plan_of(
     // Every node keeps the timing Stage 3 gave it.
     let timed =
         apply_materialization_timings_to_roots(roots, &MaterializationAssignment::default())?;
-    let expanded = pane_retention_of_expanded_panes(&timed, tumbling_window_retention_ms)?;
+    let expanded = tumbling_window_retention_of_expanded_tumbling_windows(
+        &timed,
+        tumbling_window_retention_ms,
+    )?;
     let report = selection.map(|selection| report_of(selection, &expanded.installed_node_ids));
     let reader_span_ms_by_node = reader_span_ms_by_node(&expanded.dag, &range_spans_ms);
     let plan = InstallablePlan::of_dag(
@@ -361,10 +364,14 @@ impl InstallablePlan {
     pub(crate) fn of_dag(
         mut dag: PhysicalASAPDAG,
         query_texts: Vec<String>,
-        pane_retention_ms_by_node: &HashMap<PhysicalASAPNodeId, u64>,
+        tumbling_window_retention_ms_by_node: &HashMap<PhysicalASAPNodeId, u64>,
         reader_span_ms_by_node: &HashMap<PhysicalASAPNodeId, u64>,
     ) -> Result<Self, InstallablePlanError> {
-        let views = dag.set_retention(pane_retention_ms_by_node, reader_span_ms_by_node, None)?;
+        let views = dag.set_retention(
+            tumbling_window_retention_ms_by_node,
+            reader_span_ms_by_node,
+            None,
+        )?;
         check_queries(&dag, &query_texts)?;
         executor_compiles(&dag, &views)?;
         let plan = InstallablePlan {
@@ -632,7 +639,7 @@ fn executor_refreshes(
 }
 
 /// The installable DAG of the timed selected plan, with each expanded
-/// pane's retention by node id.
+/// tumbling window's retention by node id.
 struct ExpandedWithRetention {
     dag: PhysicalASAPDAG,
     retention_ms_by_node: HashMap<PhysicalASAPNodeId, u64>,
@@ -642,18 +649,18 @@ struct ExpandedWithRetention {
     installed_node_ids: HashMap<PhysicalASAPNodeId, Vec<PhysicalASAPNodeId>>,
 }
 
-/// Expand the pane chains of `timed` and export it; each pane takes the
+/// Expand the tumbling-window chains of `timed` and export it; each tumbling window takes the
 /// retention Stage 2 gives its chain (`RealizedPlan::tumbling_window_retention_ms`, by
 /// node id in the selected candidate's physical DAG, which is `timed`
 /// exported).
-fn pane_retention_of_expanded_panes(
+fn tumbling_window_retention_of_expanded_tumbling_windows(
     timed: &[QueryRoot],
     tumbling_window_retention_ms: &BTreeMap<PhysicalASAPNodeId, u64>,
 ) -> Result<ExpandedWithRetention, InstallablePlanError> {
     use asap_types::ir::physical_export::compile_physical_asap_workload_with_node_ids;
     let selected = compile_physical_asap_workload_with_node_ids(timed)?;
     // Reject unsupported raw-source shapes before expanding possibly thousands
-    // of panes. The complete expanded-plan validation remains authoritative.
+    // of tumbling windows. The complete expanded-plan validation remains authoritative.
     selected.dag.check_raw_data_windows()?;
     let mut retention_by_chain: Vec<(Rc<OperatorNode>, u64)> = Vec::new();
     for (&node_id, &retention_ms) in tumbling_window_retention_ms {
@@ -661,14 +668,14 @@ fn pane_retention_of_expanded_panes(
             .node_ids
             .operator_node(node_id)
             .filter(|node| matches!(node.asap(), Some(ASAPOp::SummaryTumblingWindowChain { .. })))
-            .ok_or(InstallablePlanError::PaneRetentionOfUnknownChain { node_id })?;
+            .ok_or(InstallablePlanError::TumblingWindowRetentionOfUnknownChain { node_id })?;
         retention_by_chain.push((Rc::clone(chain), retention_ms));
     }
-    let expansion =
-        expand_pane_chains_in_workload(timed).map_err(InstallablePlanError::PaneChainExpansion)?;
+    let expansion = expand_tumbling_window_chains_in_workload(timed)
+        .map_err(InstallablePlanError::TumblingWindowChainExpansion)?;
     let compiled = compile_physical_asap_workload_with_node_ids(&expansion.roots)?;
-    // Index physical identity once. Looking up every expanded pane through
-    // the identity map's linear search makes this phase quadratic in panes.
+    // Index physical identity once. Looking up every expanded tumbling window through
+    // the identity map's linear search makes this phase quadratic in tumbling windows.
     let mut installed_ids_by_pointer = HashMap::with_capacity(compiled.dag.nodes.len());
     for node in &compiled.dag.nodes {
         if let Some(operator) = compiled.node_ids.operator_node(node.id) {
@@ -685,13 +692,13 @@ fn pane_retention_of_expanded_panes(
         else {
             continue;
         };
-        for pane in &expanded.panes {
-            if let Some(node_id) = installed_id(pane) {
+        for tumbling_window in &expanded.tumbling_windows {
+            if let Some(node_id) = installed_id(tumbling_window) {
                 retention_ms_by_node.insert(node_id, *retention_ms);
             }
         }
     }
-    // A chain runs as its panes; every other node as the node replacing it
+    // A chain runs as its tumbling windows; every other node as the node replacing it
     // (itself when nothing below it changed).
     let mut installed_node_ids = HashMap::new();
     for node in &selected.dag.nodes {
@@ -704,9 +711,9 @@ fn pane_retention_of_expanded_panes(
             .find(|expanded| Rc::ptr_eq(&expanded.chain, input))
         {
             Some(expanded) => {
-                let mut ids = Vec::with_capacity(expanded.panes.len());
-                for pane in &expanded.panes {
-                    if let Some(id) = installed_id(pane) {
+                let mut ids = Vec::with_capacity(expanded.tumbling_windows.len());
+                for tumbling_window in &expanded.tumbling_windows {
+                    if let Some(id) = installed_id(tumbling_window) {
                         ids.push(id);
                     }
                 }
@@ -799,9 +806,9 @@ mod tests {
     }
 
     /// A p99 panel over a 300 s window every second, with no raw data kept:
-    /// one DDSketch per series in each of 300 one-second panes built at
+    /// one DDSketch per series in each of 300 one-second tumbling windows built at
     /// ingestion, about 300 materialized views in a DAG of about 900 nodes.
-    /// Each refresh (here one refresh group of all the panes) is compiled
+    /// Each refresh (here one refresh group of all the tumbling windows) is compiled
     /// over the nodes below its views, and the whole plan's checks run once,
     /// so the nodes handed to the executor grow with the plan, not with the
     /// plan times its views (before, every refresh compiled the whole
@@ -1010,10 +1017,10 @@ mod tests {
             )) => assert_eq!(end_offsets_ms, [0, 60_000]),
             other => panic!("{other:?}"),
         }
-        // A merge stored at ingestion time over two panes stored at
+        // A merge stored at ingestion time over two tumbling windows stored at
         // ingestion time, one a minute older: an ingestion run would read
-        // both panes for the window ending at its end, so it is refused too.
-        let pane = |offset_ms: i64| {
+        // both tumbling windows for the window ending at its end, so it is refused too.
+        let tumbling_window = |offset_ms: i64| {
             OperatorNode::new_shared(Operator::ASAP(ASAPOp::SummaryAgg {
                 child: window(offset_ms),
                 family: FieldDataType::ExactAggregate(ExactKind::Sum, ExactParams::Sum),
@@ -1024,15 +1031,15 @@ mod tests {
             }))
             .unwrap()
         };
-        let panes = [pane(0), pane(60_000)];
+        let tumbling_windows = [tumbling_window(0), tumbling_window(60_000)];
         let merge = OperatorNode::new_shared(Operator::ASAP(ASAPOp::SummaryMerge {
-            children: panes.to_vec(),
+            children: tumbling_windows.to_vec(),
             newest_tumbling_windows: None,
             group_by: None,
         }))
         .unwrap();
         let mut assignment = MaterializationAssignment::default();
-        for node in panes.iter().chain([&merge]) {
+        for node in tumbling_windows.iter().chain([&merge]) {
             assignment.set(node, Materialization::MatAtIngestion(Medium::Memory));
         }
         let timed =
diff --git a/crates/planner/src/lib.rs b/crates/planner/src/lib.rs
index d0937d125..f4c3b9c3e 100644
--- a/crates/planner/src/lib.rs
+++ b/crates/planner/src/lib.rs
@@ -6,7 +6,7 @@
 //! ```
 //!
 //! The default pass, [`Stage1ToStage3Pass`], orchestrates the stages
-//! ([`run_planning`]): Stage 0 and Pass 1, then per pane-width round Pass 2,
+//! ([`run_planning`]): Stage 0 and Pass 1, then per tumbling-window-width round Pass 2,
 //! Stage 2 (`generate_physical_asap_memo_candidates`) and Stage 3
 //! (`asap_plan_selection::select_plan`), and builds the selected plan through
 //! Stage 2's realizer. The stages never call each other.
diff --git a/crates/planner/src/pass.rs b/crates/planner/src/pass.rs
index 0e7511a80..9d699cfc9 100644
--- a/crates/planner/src/pass.rs
+++ b/crates/planner/src/pass.rs
@@ -217,9 +217,9 @@ pub struct PlanOutput {
     /// How plan selection chose the plan, when the pass selects among priced
     /// candidates.
     pub selection: Option<Selection>,
-    /// For each tumbling-pane chain of the selected plan kept beyond one
+    /// For each tumbling-window chain of the selected plan kept beyond one
     /// evaluation, by node id in its physical DAG, how long its completed
-    /// panes are kept ([`RealizedPlan::tumbling_window_retention_ms`](asap_types::stages::RealizedPlan::tumbling_window_retention_ms));
+    /// tumbling windows are kept ([`RealizedPlan::tumbling_window_retention_ms`](asap_types::stages::RealizedPlan::tumbling_window_retention_ms));
     /// empty for a pass that does not set it.
     pub tumbling_window_retention_ms: BTreeMap<PhysicalASAPNodeId, u64>,
 }
@@ -301,7 +301,7 @@ impl PlanOutput {
     /// The workload as one physical ASAP DAG, with shared sub-DAGs exported
     /// once. A node keeps the timing and materialization its pass gave it:
     /// for [`Stage1ToStage3Pass`] that is Stage 3's selected plan as
-    /// selected (e.g. ingestion-time panes), the document a deployment
+    /// selected (e.g. ingestion-time tumbling windows), the document a deployment
     /// runtime executes. Only a node the pass left untimed takes the default
     /// [`MaterializationAssignment`] (not materialized, computed when its
     /// consumer runs). Operator queries become its `roots` and standalone scalar
diff --git a/crates/planner/src/run.rs b/crates/planner/src/run.rs
index 1db50da32..36ee974b6 100644
--- a/crates/planner/src/run.rs
+++ b/crates/planner/src/run.rs
@@ -1,5 +1,5 @@
 //! The facade's orchestration of the planning stages (#1047): Stage 0
-//! (the memo of logical groups), Pass 1, then per pane-width round Pass 2 →
+//! (the memo of logical groups), Pass 1, then per tumbling-window-width round Pass 2 →
 //! Stage 2 → Stage 3, and finally the selected plan built through Stage 2's
 //! realizer. No stage calls another; the facade owns the deadline and splits
 //! it per round (#1048).
@@ -20,7 +20,7 @@ use asap_logical_asap_optimization::{
     generate_per_computation_logical_memo_candidates, PerComputationCandidateError,
     PerComputationLogicalMemoCandidatesError,
 };
-use asap_logical_asap_optimization::{PaneWidthDomain, PaneWidthFrontier};
+use asap_logical_asap_optimization::{TumblingWindowWidthDomain, TumblingWindowWidthFrontier};
 use asap_physical_asap_optimization::{
     generate_physical_asap_memo_candidates, Stage2AssignmentRealizer,
 };
@@ -46,7 +46,7 @@ const DEFAULT_TIME_LIMIT_MS: u64 = 30_000;
 /// The seed-width round's share of the remaining budget, and its cap.
 const SEED_ROUND_SHARE: u32 = 4;
 const SEED_ROUND_MAX: Duration = Duration::from_secs(5);
-/// An intermediate pane-width round's budget cap.
+/// An intermediate tumbling-window-width round's budget cap.
 const INTERMEDIATE_ROUND_MAX: Duration = Duration::from_secs(5);
 /// The least budget left after Pass 1 for the seed round to run first.
 const SEED_ROUND_MIN_REMAINING: Duration = Duration::from_secs(1);
@@ -55,7 +55,7 @@ const SEED_ROUND_MIN_REMAINING: Duration = Duration::from_secs(1);
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub struct PlanSearchSettings {
     /// The whole planning budget, Pass 1 included, in milliseconds; default
-    /// 30 s. The facade splits it over the pane-width rounds, and each
+    /// 30 s. The facade splits it over the tumbling-window-width rounds, and each
     /// stage stops at its round's deadline (an evaluation in progress may
     /// overrun it).
     pub time_limit_ms: Option<u64>,
@@ -72,7 +72,7 @@ pub struct PlanSearchSettings {
 /// [`PlanningRun::per_computation_candidates`], without candidates.
 #[derive(Debug, Clone)]
 pub struct MemoSteps {
-    /// After local window composition (pane candidates).
+    /// After local window composition (tumbling-window candidates).
     pub pass2: MemoCandidates,
     /// After concrete summary-state group expansion: the memo Stage 2
     /// implements.
@@ -114,11 +114,11 @@ pub enum SelectionError {
     DeadlineReached,
 }
 
-/// One pane-width round, as the facade ran it.
+/// One tumbling-window-width round, as the facade ran it.
 #[derive(Debug, Clone, PartialEq, serde::Serialize)]
 pub struct PlanningRoundReport {
-    /// The round's pane-width domain (`SeedGrids`, `Complete`, ...).
-    pub pane_width_domain: String,
+    /// The round's tumbling-window-width domain (`SeedGrids`, `Complete`, ...).
+    pub tumbling_window_width_domain: String,
     /// Pass 2's output: memo groups and their candidates.
     pub memo_groups: usize,
     pub logical_candidates: usize,
@@ -147,9 +147,9 @@ pub struct PlanningReport {
     pub rounds: Vec<PlanningRoundReport>,
     /// The round whose selection is the plan (index into `rounds`).
     pub selected_round: Option<usize>,
-    /// Some legal pane widths were not searched: the plan is the best over
+    /// Some legal tumbling-window widths were not searched: the plan is the best over
     /// the widths searched, not over all of them.
-    pub pane_widths_pending: bool,
+    pub tumbling_window_widths_pending: bool,
     /// The whole budget, in milliseconds.
     pub time_limit_ms: u64,
 }
@@ -169,7 +169,7 @@ pub struct PlanningRun {
     pub physical_asap_candidates: Option<PhysicalASAPMemoCandidates>,
     /// Stage 3's selection.
     pub selection: Result<Selection, SelectionError>,
-    /// The selected plan as Stage 2 built it, with its pane retention.
+    /// The selected plan as Stage 2 built it, with its tumbling-window retention.
     pub selected_physical_plan: Option<RealizedPlan>,
     /// The plan to run: the selected plan's roots with the weight proofs
     /// Stage 3 made applied.
@@ -208,7 +208,7 @@ pub fn run_planning(
     }
     // Stage 0: the memo of logical groups.
     let initial = generate_dag_of_logical_memo_groups(&roots);
-    let has_pane_window = has_pane_window(&initial);
+    let has_splittable_window = has_splittable_window(&initial);
     let has_groups = !initial.groups.is_empty();
     // Pass 1: the per-computation candidates the deployment can run and
     // some query can use.
@@ -282,7 +282,7 @@ pub fn run_planning(
     let mut last: Option<Round> = None;
     let mut final_error: Option<SelectionError> = None;
     let mut completed_full_domain = false;
-    let mut run_round = |domain: PaneWidthDomain,
+    let mut run_round = |domain: TumblingWindowWidthDomain,
                          deadline: Option<Instant>,
                          state: &mut Option<Pass2RoundState>,
                          report: &mut PlanningReport|
@@ -325,12 +325,12 @@ pub fn run_planning(
             deadline.saturating_duration_since(Instant::now())
         })
     };
-    let seed_enabled = has_pane_window
+    let seed_enabled = has_splittable_window
         && calibration_is_frozen(models.cost_inputs)
         && remaining() >= SEED_ROUND_MIN_REMAINING;
     if !seed_enabled {
         let end = run_round(
-            PaneWidthDomain::Complete,
+            TumblingWindowWidthDomain::Complete,
             global_deadline,
             &mut state,
             &mut report,
@@ -343,7 +343,7 @@ pub fn run_planning(
         let seed_deadline =
             Instant::now().checked_add((remaining() / SEED_ROUND_SHARE).min(SEED_ROUND_MAX));
         let end = run_round(
-            PaneWidthDomain::SeedGrids,
+            TumblingWindowWidthDomain::SeedGrids,
             seed_deadline,
             &mut state,
             &mut report,
@@ -351,13 +351,13 @@ pub fn run_planning(
         if let Some(error) = end.fatal {
             final_error = Some(error);
         }
-        // A literal-only workload has no computation in which pane rules
+        // A literal-only workload has no computation in which tumbling-window rules
         // can fire.
         let grids = entries
             .iter()
             .filter_map(|entry| entry.evaluation_grid_ms())
             .filter(|_| has_groups);
-        let mut frontier = PaneWidthFrontier::new(grids, global_deadline);
+        let mut frontier = TumblingWindowWidthFrontier::new(grids, global_deadline);
         while final_error.is_none() && state.is_some() && !remaining().is_zero() {
             let domain = match frontier
                 .as_mut()
@@ -366,7 +366,7 @@ pub fn run_planning(
                 Ok(Ok(Some(domain))) => domain,
                 Ok(Ok(None)) | Ok(Err(_)) | Err(_) => break,
             };
-            let complete = domain == PaneWidthDomain::Complete;
+            let complete = domain == TumblingWindowWidthDomain::Complete;
             let deadline = if complete {
                 global_deadline
             } else {
@@ -382,7 +382,7 @@ pub fn run_planning(
             }
         }
     }
-    report.pane_widths_pending = !completed_full_domain;
+    report.tumbling_window_widths_pending = !completed_full_domain;
 
     let (chosen, selected) = match (final_error, best) {
         (Some(error), best) => {
@@ -467,14 +467,14 @@ struct RoundOutcome {
     end: RoundEnd,
 }
 
-/// One pane-width round: Pass 2 over `state` for `domain`, Stage 2, then
+/// One tumbling-window-width round: Pass 2 over `state` for `domain`, Stage 2, then
 /// Stage 3, each stopping at `deadline`. A Pass 2 timeout in local window
 /// composition leaves `state` unusable, so it is dropped. With `inspect`,
 /// the round keeps a copy of the memo after local window composition.
 #[allow(clippy::too_many_arguments)]
 fn plan_round(
     state: &mut Option<Pass2RoundState>,
-    domain: PaneWidthDomain,
+    domain: TumblingWindowWidthDomain,
     deadline: Option<Instant>,
     entries: &[QueryWorkloadEntry],
     data: &DataWorkload,
@@ -484,7 +484,7 @@ fn plan_round(
     inspect: bool,
 ) -> RoundOutcome {
     let mut report = PlanningRoundReport {
-        pane_width_domain: format!("{domain:?}"),
+        tumbling_window_width_domain: format!("{domain:?}"),
         memo_groups: 0,
         logical_candidates: 0,
         operator_nodes: 0,
@@ -581,7 +581,9 @@ fn plan_round(
                 | ErrorSelectingPlan::EvaluationDeadlineExceeded => None,
                 // An infeasible restricted catalog does not make the complete
                 // one infeasible.
-                ErrorSelectingPlan::NoValidCandidate(_) if domain != PaneWidthDomain::Complete => {
+                ErrorSelectingPlan::NoValidCandidate(_)
+                    if domain != TumblingWindowWidthDomain::Complete =>
+                {
                     None
                 }
                 error => Some(SelectionError::Selection(clone_error(error))),
@@ -633,10 +635,10 @@ fn calibration_is_frozen(cost_inputs: &asap_cost::CostInputs) -> bool {
         || cost_inputs.measured_operation_costs.operators.is_empty()
 }
 
-/// Pane rules require a temporal range below a summary build: a positive
-/// `Range` window, or an existing pane chain. Instant lookback selectors are
-/// not splittable panes.
-fn has_pane_window(initial: &DagOfLogicalMemoGroups) -> bool {
+/// Tumbling-window rules require a temporal range below a summary build: a positive
+/// `Range` window, or an existing tumbling-window chain. Instant lookback selectors
+/// have no range to split into tumbling windows.
+fn has_splittable_window(initial: &DagOfLogicalMemoGroups) -> bool {
     initial.groups.iter().any(|group| {
         matches!(
             group.logical_node.non_asap(),
@@ -728,7 +730,7 @@ fn selected_chosen_candidates(
 /// runtime; a root with no such representation is planned over its labels
 /// alone), through [`run_planning`] with every entry's accuracy target. The
 /// output is the selected plan's roots, with the weight proofs plan
-/// selection made applied, and its pane retention.
+/// selection made applied, and its tumbling-window retention.
 #[derive(Debug, Default, Clone, Copy)]
 pub struct Stage1ToStage3Pass;
 
diff --git a/crates/planner/tests/columnar_batches.rs b/crates/planner/tests/columnar_batches.rs
index 6f124e4a9..658dee91b 100644
--- a/crates/planner/tests/columnar_batches.rs
+++ b/crates/planner/tests/columnar_batches.rs
@@ -1,5 +1,5 @@
 //! A runtime's samples reach the executor as Arrow columns (issue #762):
-//! the planner-layering #509 Example 4b plan, one pane built by the
+//! the planner-layering #509 Example 4b plan, one tumbling window built by the
 //! executor from a time series' raw data whose batch the runtime built as
 //! Arrow columns, each series' identity stored once, through the public
 //! batch API only.
@@ -30,7 +30,7 @@ use time_series::{series_identity, RawDataSample};
 const EVALUATION_MS: i64 = 3_600_000;
 
 #[tokio::test]
-async fn a_pane_is_built_from_arrow_columns_with_one_label_entry_per_series() {
+async fn a_tumbling_window_is_built_from_arrow_columns_with_one_label_entry_per_series() {
     // What the user writes: p99 of `latency_ms` over the last hour, every
     // 10 minutes, at rank error 0.01, over 1,000 series sampled every second.
     let workload: PlanningWorkload = serde_json::from_str(
@@ -45,14 +45,14 @@ async fn a_pane_is_built_from_arrow_columns_with_one_label_entry_per_series() {
               "sources": {"latency_ms": {"series_count": 1000, "sample_interval": 1000}}}}"#,
     )
     .unwrap();
-    // The deployment keeps no raw data samples, so every pane is built at
+    // The deployment keeps no raw data samples, so every tumbling window is built at
     // ingestion and materialized.
     let capabilities = DeploymentCapabilities {
         raw_data_retained: false,
         ..DeploymentCapabilities::default()
     };
-    // The installable plan: the selected DAG and its materialized KLL panes.
-    // Pane width is chosen by the optimizer.
+    // The installable plan: the selected DAG and its materialized KLL tumbling windows.
+    // Tumbling-window width is chosen by the optimizer.
     let plan = plan_installable(UserInput::new(
         &workload,
         FrontendInput::Promql,
@@ -61,7 +61,7 @@ async fn a_pane_is_built_from_arrow_columns_with_one_label_entry_per_series() {
     .await
     .unwrap()
     .0;
-    // The newest pane: its node, and the raw-data window it reads.
+    // The newest tumbling window: its node, and the raw-data window it reads.
     let views = plan.materialized_views().unwrap();
     let output = views
         .iter()
@@ -71,10 +71,10 @@ async fn a_pane_is_built_from_arrow_columns_with_one_label_entry_per_series() {
                 .1
         })
         .unwrap();
-    // The pane's window at this evaluation, `(start_ms, end_ms]`.
+    // The time range the tumbling window covers at this evaluation, `(start_ms, end_ms]`.
     let (start_ms, end_ms) = output.inputs.raw_data_windows()[0].bounds_ms(EVALUATION_MS);
-    // Feed both series within the selected pane, whose width is an optimizer
-    // decision. Keep distinct millisecond timestamps even for very fine panes.
+    // Feed both series within the selected tumbling window, whose width is an optimizer
+    // decision. Keep distinct millisecond timestamps even for very fine tumbling windows.
     let width_ms = end_ms - start_ms;
     assert!(width_ms > 0);
     let samples_per_series = width_ms.min(60);
@@ -135,8 +135,8 @@ async fn a_pane_is_built_from_arrow_columns_with_one_label_entry_per_series() {
     let input = Batch::try_from_columns(schema.clone(), columns).unwrap();
     assert_eq!(input.num_rows(), expected_rows);
 
-    // The executor's pane build over the `latency_ms` raw data bound at
-    // the `Scan`; its `TimeRange` keeps the pane's window.
+    // The executor's tumbling-window build over the `latency_ms` raw data bound at
+    // the `Scan`; its `TimeRange` keeps the time range the tumbling window covers.
     let compiled = compile(&plan.dag, &[], &[output.node_id as u64]).unwrap();
     let store = InMemoryDataStore::default()
         .with_raw_data(
@@ -147,7 +147,7 @@ async fn a_pane_is_built_from_arrow_columns_with_one_label_entry_per_series() {
             vec![input],
         )
         .unwrap();
-    // The build, ready to run in the pane's ingestion window.
+    // The build, ready to run in the tumbling window's ingestion window.
     let build = compiled.instantiate(Arc::new(store)).unwrap();
     let context = RunContext::new(
         Scope::Ingestion {
@@ -157,8 +157,8 @@ async fn a_pane_is_built_from_arrow_columns_with_one_label_entry_per_series() {
         Limits::default(),
     )
     .unwrap();
-    // The built pane: one row per series, its KLL in a state column.
-    let pane = build
+    // The built tumbling window: one row per series, its KLL in a state column.
+    let tumbling_window = build
         .execute(compiled.roots(), context)
         .unwrap()
         .remove(0)
@@ -166,12 +166,12 @@ async fn a_pane_is_built_from_arrow_columns_with_one_label_entry_per_series() {
         .await
         .unwrap()
         .unwrap();
-    let state_column = pane
+    let state_column = tumbling_window
         .schema()
         .fields
         .iter()
         .position(|field| !field.is_plain())
         .unwrap();
-    assert_eq!(pane.num_rows(), 2);
-    assert_eq!(pane.state_column(state_column).unwrap().len(), 2);
+    assert_eq!(tumbling_window.num_rows(), 2);
+    assert_eq!(tumbling_window.state_column(state_column).unwrap().len(), 2);
 }
diff --git a/crates/planner/tests/per_sample_updater.rs b/crates/planner/tests/per_sample_updater.rs
index 67e619c8a..b8f83f1e5 100644
--- a/crates/planner/tests/per_sample_updater.rs
+++ b/crates/planner/tests/per_sample_updater.rs
@@ -1,6 +1,6 @@
-//! A runtime that ingests sample by sample refreshes a materialized pane's states
+//! A runtime that ingests sample by sample refreshes a materialized tumbling window's states
 //! with `StateColumnUpdater`, the code the plan's `SummaryAgg` runs on a
-//! batch (issue #762): the same states as the executor's pane build.
+//! batch (issue #762): the same states as the executor's tumbling-window build.
 
 use std::collections::BTreeMap;
 use std::sync::Arc;
@@ -24,7 +24,7 @@ use time_series::{series_identity, series_labels, time_series_tables, RawDataSam
 const EVALUATION_MS: i64 = 3_600_000;
 
 #[tokio::test]
-async fn per_sample_updates_build_the_materialized_pane_the_plan_refreshes() {
+async fn per_sample_updates_build_the_materialized_tumbling_window_the_plan_refreshes() {
     // What the user writes: the 5-minute rate of a counter, every minute,
     // exactly, over 1,000 series sampled every 15 s.
     let workload: PlanningWorkload = serde_json::from_str(
@@ -37,7 +37,7 @@ async fn per_sample_updates_build_the_materialized_pane_the_plan_refreshes() {
               "sources": {"http_requests_total": {"series_count": 1000, "sample_interval": 15000}}}}"#,
     )
     .unwrap();
-    // No raw data samples retained: the plan stores rate panes built at ingestion.
+    // No raw data samples retained: the plan stores rate tumbling windows built at ingestion.
     let capabilities = DeploymentCapabilities {
         raw_data_retained: false,
         ..DeploymentCapabilities::default()
@@ -52,7 +52,7 @@ async fn per_sample_updates_build_the_materialized_pane_the_plan_refreshes() {
     .unwrap()
     .0;
     let dag = &plan.dag;
-    // The newest pane view and its window at this evaluation.
+    // The newest tumbling window view and its window at this evaluation.
     let views = plan.materialized_views().unwrap();
     let output = views
         .iter()
@@ -63,7 +63,7 @@ async fn per_sample_updates_build_the_materialized_pane_the_plan_refreshes() {
         })
         .unwrap();
     let (start_ms, end_ms) = output.inputs.raw_data_windows()[0].bounds_ms(EVALUATION_MS);
-    // Five one-minute panes, the newest (59 min, 60 min].
+    // Five one-minute tumbling windows, the newest (59 min, 60 min].
     assert_eq!(views.len(), 5);
     assert_eq!((start_ms, end_ms), (3_540_000, 3_600_000));
     // The view node's summary family, as the plan declares it: the
@@ -83,7 +83,7 @@ async fn per_sample_updates_build_the_materialized_pane_the_plan_refreshes() {
                 .producer;
         }
     };
-    // What the runtime received in the pane: 3 series, one counter sample
+    // What the runtime received in the tumbling window: 3 series, one counter sample
     // every 15 s, one series with a reset.
     assert_eq!(
         family,
@@ -114,8 +114,8 @@ async fn per_sample_updates_build_the_materialized_pane_the_plan_refreshes() {
         })
         .collect();
 
-    // The executor's pane build: the samples bound at the plan's `Scan`,
-    // its `TimeRange` keeping the pane's window.
+    // The executor's tumbling-window build: the samples bound at the plan's `Scan`,
+    // its `TimeRange` keeping the time range the tumbling window covers.
     let compiled = compile(dag, &[], &[output.node_id as u64]).unwrap();
     let build = compiled
         .instantiate(Arc::new(time_series_tables(dag, &samples)))
@@ -128,7 +128,7 @@ async fn per_sample_updates_build_the_materialized_pane_the_plan_refreshes() {
         Limits::default(),
     )
     .unwrap();
-    let pane = build
+    let tumbling_window = build
         .execute(compiled.roots(), context)
         .unwrap()
         .remove(0)
@@ -137,13 +137,13 @@ async fn per_sample_updates_build_the_materialized_pane_the_plan_refreshes() {
         .unwrap()
         .unwrap();
     // Its states, by series labels.
-    let state_column = pane
+    let state_column = tumbling_window
         .schema()
         .fields
         .iter()
         .position(|field| !field.is_plain())
         .unwrap();
-    let from_dag: BTreeMap<BTreeMap<String, String>, String> = pane
+    let from_dag: BTreeMap<BTreeMap<String, String>, String> = tumbling_window
         .to_rows()
         .iter()
         .map(|row| {
@@ -152,13 +152,13 @@ async fn per_sample_updates_build_the_materialized_pane_the_plan_refreshes() {
             };
             let exact = state.as_any().downcast_ref::<ExactAccumulator>().unwrap();
             (
-                series_labels(pane.schema(), row),
+                series_labels(tumbling_window.schema(), row),
                 serde_json::to_string(exact).unwrap(),
             )
         })
         .collect();
 
-    // The per-sample build: one updater for the pane, a group per series.
+    // The per-sample build: one updater for the tumbling window, a group per series.
     let mut updater = StateColumnUpdater::new(&family).unwrap();
     let mut groups: BTreeMap<BTreeMap<String, String>, u32> = BTreeMap::new();
     for sample in &samples {
@@ -174,7 +174,7 @@ async fn per_sample_updates_build_the_materialized_pane_the_plan_refreshes() {
             .update(group, sample.value, sample.timestamp_ms)
             .unwrap();
     }
-    // Sealed at pane close: one state per group.
+    // Sealed at tumbling window close: one state per group.
     let states = updater.seal();
     let per_sample: BTreeMap<BTreeMap<String, String>, String> = groups
         .into_iter()
@@ -243,12 +243,12 @@ async fn answers(
     results
 }
 
-/// A runtime builds every materialized pane sample by sample, installs each as a
+/// A runtime builds every materialized tumbling window sample by sample, installs each as a
 /// batch with `Batch::try_from_columns` (no DAG run), and answers the query
 /// from them: the same answers as the plan's query-time reference over the
 /// raw data samples.
 #[tokio::test]
-async fn panes_installed_from_per_sample_states_answer_the_query() {
+async fn tumbling_windows_installed_from_per_sample_states_answer_the_query() {
     use asap_executor::arrow::array::{DictionaryArray, TimestampMillisecondArray, UInt32Array};
     use asap_executor::arrow::datatypes::UInt32Type;
     use asap_executor::values::{Batch, BatchColumn};
@@ -265,7 +265,7 @@ async fn panes_installed_from_per_sample_states_answer_the_query() {
               "sources": {"http_requests_total": {"series_count": 1000, "sample_interval": 15000}}}}"#,
     )
     .unwrap();
-    // No raw data samples retained: five one-minute rate panes built at ingestion.
+    // No raw data samples retained: five one-minute rate tumbling windows built at ingestion.
     let capabilities = DeploymentCapabilities {
         raw_data_retained: false,
         ..DeploymentCapabilities::default()
@@ -302,10 +302,10 @@ async fn panes_installed_from_per_sample_states_answer_the_query() {
             })
         })
         .collect();
-    // Every materialized pane, built sample by sample and installed as a batch.
-    let mut panes = BTreeMap::new();
+    // Every materialized tumbling window, built sample by sample and installed as a batch.
+    let mut tumbling_windows = BTreeMap::new();
     for output in &plan.materialized_views().unwrap() {
-        // The pane's window, `(start_ms, end_ms]`, at this evaluation.
+        // The time range the tumbling window covers, `(start_ms, end_ms]`, at this evaluation.
         let (start_ms, end_ms) = output.inputs.raw_data_windows()[0].bounds_ms(EVALUATION_MS);
         // The view node's family and output schema, from the plan.
         let node = dag.nodes.iter().find(|n| n.id == output.node_id).unwrap();
@@ -343,9 +343,9 @@ async fn panes_installed_from_per_sample_states_answer_the_query() {
                 .update(group, sample.value, sample.timestamp_ms)
                 .unwrap();
         }
-        // ... sealed at pane close: one rate record per series.
+        // ... sealed at tumbling window close: one rate record per series.
         let states = Arc::new(updater.seal());
-        // The pane's columns, in the view node's schema: the pane end as
+        // The tumbling window's columns, in the view node's schema: the tumbling window end as
         // its time, each series' state, and its identity.
         let schema = Arc::new(node.output_schema.clone());
         let groups = identities.len();
@@ -375,18 +375,19 @@ async fn panes_installed_from_per_sample_states_answer_the_query() {
             })
             .collect();
         // Installed without running the DAG.
-        panes.insert(
+        tumbling_windows.insert(
             output.node_id as u64,
             Batch::try_from_columns(schema, columns).unwrap(),
         );
     }
-    assert_eq!(panes.len(), 5);
+    assert_eq!(tumbling_windows.len(), 5);
     let query = Scope::Query {
         evaluation_time_ms: EVALUATION_MS,
     };
     let roots: Vec<u64> = plan.dag.roots.iter().map(|&r| r as u64).collect();
-    // The query's answers from the installed panes.
-    let from_panes = answers(dag, panes, &samples, &roots, query.clone()).await;
+    // The query's answers from the installed tumbling windows.
+    let from_tumbling_windows =
+        answers(dag, tumbling_windows, &samples, &roots, query.clone()).await;
     // The plan's query-time reference over the raw data samples.
     let reference = query_time_reference(&plan).unwrap();
     let reference_roots: Vec<u64> = reference.dag.roots.iter().map(|&r| r as u64).collect();
@@ -399,6 +400,6 @@ async fn panes_installed_from_per_sample_states_answer_the_query() {
     )
     .await;
     // One rate per series, equal to the reference.
-    assert_eq!(from_panes[0].len(), 3);
-    assert_eq!(from_panes, expected);
+    assert_eq!(from_tumbling_windows[0].len(), 3);
+    assert_eq!(from_tumbling_windows, expected);
 }
diff --git a/crates/planner/tests/runtime_install.rs b/crates/planner/tests/runtime_install.rs
index 67abf04d6..5dd7913a4 100644
--- a/crates/planner/tests/runtime_install.rs
+++ b/crates/planner/tests/runtime_install.rs
@@ -82,22 +82,22 @@ fn sample(metric: &str, instance: &str, timestamp_ms: i64, value: f64) -> RawDat
 
 /// Raw `latency_ms` samples of series `a` and `b`, one every 10 s from 70
 /// minutes before `EVALUATION_MS` to a minute after it (for a second
-/// evaluation), off the pane boundaries, and one
+/// evaluation), off the tumbling-window boundaries, and one
 /// sample of another metric the plan never reads. A sample's value says
-/// which 10-minute pane before `EVALUATION_MS` it falls in: `1000 × pane +
-/// base + 0..=100`, with base 100 for `a` and 300 for `b` (pane 0 is the
-/// newest), so an answer read from the wrong panes is visibly off.
+/// which 10-minute tumbling window before `EVALUATION_MS` it falls in: `1000 × tumbling_window +
+/// base + 0..=100`, with base 100 for `a` and 300 for `b` (tumbling window 0 is the
+/// newest), so an answer read from the wrong tumbling windows is visibly off.
 fn remote_write_samples() -> Vec<RawDataSample> {
     let mut samples = Vec::new();
     for (instance, base) in [("a", 100.0), ("b", 300.0)] {
         for step in 0..426 {
             let timestamp_ms = EVALUATION_MS - 4_195_000 + step * 10_000;
-            let pane = (EVALUATION_MS - timestamp_ms) / 600_000;
+            let tumbling_window = (EVALUATION_MS - timestamp_ms) / 600_000;
             samples.push(sample(
                 "latency_ms",
                 instance,
                 timestamp_ms,
-                (1000 * pane) as f64 + base + (step * 37 % 101) as f64,
+                (1000 * tumbling_window) as f64 + base + (step * 37 % 101) as f64,
             ));
         }
     }
@@ -206,19 +206,19 @@ fn answers(batches: &[Batch]) -> Vec<Answer> {
     answers
 }
 
-/// Each answer is a p99 read from pane `pane` of its series
-/// ([`remote_write_samples`]): within `1000 × pane + base + 0..=100`.
-fn assert_answers_from_pane(answers: &[Answer], pane: i64) {
+/// Each answer is a p99 read from tumbling window `tumbling_window` of its series
+/// ([`remote_write_samples`]): within `1000 × tumbling_window + base + 0..=100`.
+fn assert_answers_from_tumbling_window(answers: &[Answer], tumbling_window: i64) {
     for (labels, value) in answers {
         let base = if labels["instance"] == "a" {
             100.0
         } else {
             300.0
         };
-        let low = (1000 * pane) as f64 + base;
+        let low = (1000 * tumbling_window) as f64 + base;
         assert!(
             (low..=low + 100.0).contains(value),
-            "{labels:?}: {value} is not from pane {pane}"
+            "{labels:?}: {value} is not from tumbling window {tumbling_window}"
         );
     }
 }
@@ -374,9 +374,9 @@ fn run_data_plane(
 enum IngestionBuilds {
     /// For each evaluation, over windows ending at that evaluation.
     PerEvaluation,
-    /// Tumbling, as a runtime that maintains panes as samples arrive: each
+    /// Tumbling, as a runtime that maintains tumbling windows as samples arrive: each
     /// once, over windows ending on the grid of its window's width anchored
-    /// at the epoch (pane end ≡ 0 mod width, as the backend data plane
+    /// at the epoch (tumbling window end ≡ 0 mod width, as the backend data plane
     /// builds them); an evaluation reads the newest one at or before it.
     Tumbling,
 }
@@ -589,8 +589,8 @@ fn run_data_plane_on(
     }
 }
 
-/// The sketch algorithm of the panes view `id` of `plan` builds.
-fn pane_sketch(plan: &InstallablePlan, id: usize) -> SketchAlgorithm {
+/// The sketch algorithm of the tumbling windows view `id` of `plan` builds.
+fn tumbling_window_sketch(plan: &InstallablePlan, id: usize) -> SketchAlgorithm {
     let node = plan.dag.nodes.iter().find(|node| node.id == id).unwrap();
     match &node.payload {
         asap_executor::planner::ir::physical_export::PhysicalASAPOperatorPayload::ASAP(
@@ -599,7 +599,7 @@ fn pane_sketch(plan: &InstallablePlan, id: usize) -> SketchAlgorithm {
                 ..
             },
         ) => *kind.algorithm(),
-        other => panic!("not a sketch pane: {other:?}"),
+        other => panic!("not a sketch tumbling window: {other:?}"),
     }
 }
 
@@ -607,14 +607,14 @@ fn pane_sketch(plan: &InstallablePlan, id: usize) -> SketchAlgorithm {
 /// at relative error 0.01 over five minutes, both every 10 s, over 1,000
 /// ingesting non-negative `latency_ms` gauges sampled every 10 s, on a
 /// deployment that keeps no raw data: a KLL chain and a DDSketch chain,
-/// both of 10 s panes, kept at ingestion over one `Scan`. Their panes are one refresh group, so each
+/// both of 10 s tumbling windows, kept at ingestion over one `Scan`. Their tumbling windows are one refresh group, so each
 /// 10 s window is read from raw data once, in one ingestion run that builds
-/// both panes ending there: 30 reads for the 30 pane windows of the first
-/// evaluation (36 when each pane view had its own run). Each state equals
+/// both tumbling windows ending there: 30 reads for the 30 tumbling window windows of the first
+/// evaluation (36 when each tumbling window view had its own run). Each state equals
 /// the one a run of its view alone builds, and both queries answer as the
 /// query-time reference.
 #[tokio::test]
-async fn panes_of_one_refresh_window_read_each_raw_window_once() {
+async fn tumbling_windows_of_one_refresh_window_read_each_raw_window_once() {
     let entry = |query: &str, metric: &str| {
         format!(
             r#"{{"query": {query:?}, "demand": {{"fixed_interval": 10000}},
@@ -639,8 +639,8 @@ async fn panes_of_one_refresh_window_read_each_raw_window_once() {
     let plan_json = plan_json_for(workload, &capabilities).await;
     let installed: InstallablePlan = serde_json::from_str(&plan_json).unwrap();
     installed.check_compiles().unwrap();
-    // One refresh group: the six 10 s KLL panes and the thirty 10 s
-    // DDSketch panes.
+    // One refresh group: the six 10 s KLL tumbling windows and the thirty 10 s
+    // DDSketch tumbling windows.
     let groups = installed.ingestion_refresh_groups().unwrap();
     assert_eq!(groups.len(), 1, "{groups:#?}");
     assert_eq!(
@@ -653,7 +653,7 @@ async fn panes_of_one_refresh_window_read_each_raw_window_once() {
     let sketches: Vec<SketchAlgorithm> = groups[0]
         .views
         .iter()
-        .map(|view| pane_sketch(&installed, view.node_id))
+        .map(|view| tumbling_window_sketch(&installed, view.node_id))
         .collect();
     let count = |algorithm| sketches.iter().filter(|a| **a == algorithm).count();
     assert_eq!(count(SketchAlgorithm::Kll), 6, "{sketches:?}");
@@ -670,7 +670,7 @@ async fn panes_of_one_refresh_window_read_each_raw_window_once() {
     );
     assert_eq!(evaluated.answers_per_query[0].len(), 2);
 
-    // Each pane's state equals the one an ingestion run of its view alone
+    // Each tumbling window's state equals the one an ingestion run of its view alone
     // builds.
     for view in &groups[0].views {
         let span = view.inputs.raw_data_windows()[0].bounds_ms(EVALUATION_MS);
@@ -705,8 +705,8 @@ async fn panes_of_one_refresh_window_read_each_raw_window_once() {
 }
 
 /// #509 Example 4b, as a runtime runs it: one `plan_installable` call,
-/// `plan.json`, then each pane view refreshed in an ingestion run and merged
-/// in the query run. One p99 per series, read from the hour's oldest pane,
+/// `plan.json`, then each tumbling window view refreshed in an ingestion run and merged
+/// in the query run. One p99 per series, read from the hour's oldest tumbling window,
 /// equal to the query-time reference; the other metric is not read.
 #[tokio::test]
 async fn a_runtime_installs_and_runs_the_plan_from_one_facade_call() {
@@ -721,15 +721,15 @@ async fn a_runtime_installs_and_runs_the_plan_from_one_facade_call() {
     let views = installed.materialized_views().unwrap();
     assert!(!views.is_empty());
     assert_eq!(run.outputs_built, views.len());
-    // The p99 of the hour comes from its oldest pane, pane 5.
-    assert_answers_from_pane(&run.answers_per_query[0], 5);
+    // The p99 of the hour comes from its oldest tumbling window, tumbling window 5.
+    assert_answers_from_tumbling_window(&run.answers_per_query[0], 5);
     assert_eq!(run.answers_per_query[0][0].0["instance"], "a");
     assert_eq!(run.answers_per_query, run.reference_answers_per_query);
 }
 
 /// The plan file carries Stage 3's predicted usage of the selected plan, so
 /// a runtime reports it against what it measures without planning again:
-/// for Example 4b's panes maintained at ingestion time, its nodes' prices
+/// for Example 4b's tumbling windows maintained at ingestion time, its nodes' prices
 /// add up to Stage 3's selection cost and their CPU to the plan's, with
 /// one latency per query, each node naming the installed nodes that run it.
 #[tokio::test]
@@ -737,10 +737,10 @@ async fn the_plan_carries_stage3s_predicted_usage() {
     let (plan, selection) =
         planned_with_report(&["quantile_over_time(0.99, latency_ms[60m])"]).await;
     let views = plan.materialized_views().unwrap();
-    assert!(!views.is_empty(), "a pane-only plan");
+    assert!(!views.is_empty(), "a tumbling-window-only plan");
     assert!(
         plan.raw_data_retention().unwrap().is_empty(),
-        "a pane-only plan"
+        "a tumbling-window-only plan"
     );
     let selection = selection.as_ref().expect("Stage 3's report");
     let usage = &selection.predicted_usage;
@@ -766,8 +766,8 @@ async fn the_plan_carries_stage3s_predicted_usage() {
         && node.timing == asap_planner::ExecutionTiming::IngestionTime));
     assert_eq!(usage.per_query.len(), 1);
     assert!(usage.peak_memory_bytes > 0);
-    // Each prediction names the installed nodes that run it: the pane
-    // chain its selected panes, the query's root its own node.
+    // Each prediction names the installed nodes that run it: the tumbling window
+    // chain its selected tumbling windows, the query's root its own node.
     let installed: BTreeSet<_> = plan.dag.nodes.iter().map(|node| node.id).collect();
     for node in &usage.per_node {
         assert!(
@@ -798,7 +798,7 @@ async fn the_plan_carries_stage3s_predicted_usage() {
 /// The query's label matcher selects series `a` only: the runtime feeds
 /// every sample, and the window's selector applies the plan's `Scan`.
 #[tokio::test]
-async fn label_matchers_select_the_series_a_pane_reads() {
+async fn label_matchers_select_the_series_a_tumbling_window_reads() {
     let plan_json =
         plan_json(&[r#"quantile_over_time(0.99, latency_ms{instance="a"}[60m])"#]).await;
     let run = run_data_plane(
@@ -810,13 +810,13 @@ async fn label_matchers_select_the_series_a_pane_reads() {
     let answered = &run.answers_per_query[0];
     assert_eq!(answered.len(), 1, "{answered:?}");
     assert_eq!(answered[0].0["instance"], "a");
-    assert_answers_from_pane(answered, 5);
+    assert_answers_from_tumbling_window(answered, 5);
     assert_eq!(run.answers_per_query, run.reference_answers_per_query);
 }
 
 /// The p99 over the last hour and over the hour before the last 10
-/// minutes may share selected pane windows. The runtime refreshes each distinct
-/// state key once, independent of the optimizer's pane widths. Both answers
+/// minutes may share selected tumbling windows. The runtime refreshes each distinct
+/// state key once, independent of the optimizer's tumbling-window widths. Both answers
 /// equal the reference.
 #[tokio::test]
 async fn an_hour_and_its_offset_twin_both_equal_the_reference() {
@@ -841,33 +841,33 @@ async fn an_hour_and_its_offset_twin_both_equal_the_reference() {
     );
     assert_eq!(run.outputs_built, distinct_states.len());
     assert_eq!(run.answers_per_query.len(), 2);
-    // The last hour's p99 comes from pane 5, the offset hour's from pane 6.
-    assert_answers_from_pane(&run.answers_per_query[0], 5);
-    assert_answers_from_pane(&run.answers_per_query[1], 6);
+    // The last hour's p99 comes from tumbling window 5, the offset hour's from tumbling window 6.
+    assert_answers_from_tumbling_window(&run.answers_per_query[0], 5);
+    assert_answers_from_tumbling_window(&run.answers_per_query[1], 6);
     assert_eq!(run.answers_per_query, run.reference_answers_per_query);
 }
 
 /// Two copies of `sum by (job) (sum_over_time(m[10m]))`, each every 20 s,
 /// one at phase 0 and one at phase 5 s, over 6 ingesting series of `m`
-/// sampled every second. Panes shared by both must end on both schedules:
-/// 20 s panes end only on the first's, so the second would read
+/// sampled every second. Tumbling windows shared by both must end on both schedules:
+/// 20 s tumbling windows end only on the first's, so the second would read
 /// `(t − 605 s, t − 5 s]` instead of `(t − 600 s, t]`.
 #[tokio::test]
-async fn queries_at_two_phases_read_panes_on_both_schedules() {
+async fn queries_at_two_phases_read_tumbling_windows_on_both_schedules() {
     assert_phased_copies_answer_as_reference(&[0, 5_000]).await;
 }
 
-/// The same two copies, both at phase 5 s. A runtime anchors panes at the
-/// epoch and the plan carries no pane origin, so 20 s panes would end 5 s
-/// before every evaluation: the panes must also end on the phase itself.
+/// The same two copies, both at phase 5 s. A runtime anchors tumbling windows at the
+/// epoch and the plan carries no tumbling-window origin, so 20 s tumbling windows would end 5 s
+/// before every evaluation: the tumbling windows must also end on the phase itself.
 #[tokio::test]
-async fn queries_at_one_nonzero_phase_read_panes_anchored_at_the_epoch() {
+async fn queries_at_one_nonzero_phase_read_tumbling_windows_anchored_at_the_epoch() {
     assert_phased_copies_answer_as_reference(&[5_000, 5_000]).await;
 }
 
 /// Copies of `sum by (job) (sum_over_time(m[10m]))`, each every 20 s, copy
 /// `q` at phase `phases_ms[q]`, over 6 ingesting series of `m` sampled
-/// every second. Run by a runtime that refreshes each ingestion pane once, on
+/// every second. Run by a runtime that refreshes each ingestion tumbling window once, on
 /// the grid of its width anchored at the epoch, each answers as the
 /// query-time reference at its own evaluation.
 async fn assert_phased_copies_answer_as_reference(phases_ms: &[i64]) {
@@ -923,10 +923,10 @@ async fn assert_phased_copies_answer_as_reference(phases_ms: &[i64]) {
             })
         })
         .collect();
-    // The panes stored across every evaluation.
+    // The tumbling windows stored across every evaluation.
     let mut store = SummaryStore::new();
     // Copy `q` evaluates `phases_ms[q]` after `EVALUATION_MS` (on the
-    // 20 s grid); each reads the panes the store holds by then.
+    // 20 s grid); each reads the tumbling windows the store holds by then.
     for (query, phase_ms) in phases_ms.iter().enumerate() {
         let evaluation_ms = EVALUATION_MS + phase_ms;
         let run = run_data_plane_on(
@@ -1221,12 +1221,12 @@ async fn an_instant_selector_reads_the_latest_sample_per_series() {
 /// evaluations (#509 Example 4's B3), with a dashboard panel
 /// (`max_over_time(latency_ms[5m])` every minute over 1M series sampled
 /// every 1.5 s, answered as the last hour at 1-minute steps): Stage 3
-/// keeps five 1-minute panes refreshed at query time, and keeps raw data
-/// for refreshing the oldest pane at the oldest step (5 min + 1 h). The first
+/// keeps five 1-minute tumbling windows refreshed at query time, and keeps raw data
+/// for refreshing the oldest tumbling window at the oldest step (5 min + 1 h). The first
 /// evaluation, with an empty store, refreshes all five in its query run; the
 /// next, a minute later, reuses the four still in its window and refreshes
 /// only the newest. Each
-/// evaluation's answers (each series' newest-pane maximum) equal the
+/// evaluation's answers (each series' newest-tumbling-window maximum) equal the
 /// reference.
 #[tokio::test]
 async fn query_time_results_kept_across_evaluations_are_built_in_query_runs() {
@@ -1253,15 +1253,15 @@ async fn query_time_results_kept_across_evaluations_are_built_in_query_runs() {
         .iter()
         .all(|v| v.refresh() == MaterializedViewRefresh::OnFirstRead
             && v.inputs.raw_data_windows()[0].width_ms() == 60_000));
-    // Raw data is kept for refreshing the oldest pane at the oldest step:
-    // the five panes' 5 minutes plus the hour of steps, as long as the panes
+    // Raw data is kept for refreshing the oldest tumbling window at the oldest step:
+    // the five tumbling windows' 5 minutes plus the hour of steps, as long as the tumbling windows
     // themselves are kept.
-    let pane_lookback_ms = views
+    let tumbling_window_lookback_ms = views
         .iter()
         .flat_map(|v| v.inputs.raw_data_windows())
         .map(asap_types::test_support::lookback_ms)
         .max();
-    assert_eq!(pane_lookback_ms, Some(300_000));
+    assert_eq!(tumbling_window_lookback_ms, Some(300_000));
     assert!(views.iter().all(|v| v.retention_ms() == 3_900_000));
     let retention = installed.raw_data_retention().unwrap();
     assert_eq!(
@@ -1272,7 +1272,7 @@ async fn query_time_results_kept_across_evaluations_are_built_in_query_runs() {
         vec![Some(3_900_000)],
         "{retention:?}"
     );
-    // The pane cache the data plane keeps across evaluations.
+    // The tumbling window cache the data plane keeps across evaluations.
     let mut store = SummaryStore::new();
     let first = run_data_plane(
         &plan_json,
@@ -1281,7 +1281,7 @@ async fn query_time_results_kept_across_evaluations_are_built_in_query_runs() {
         &mut store,
     );
     assert_eq!(first.outputs_built, 5);
-    assert_answers_from_pane(&first.answers_per_query[0], 0);
+    assert_answers_from_tumbling_window(&first.answers_per_query[0], 0);
     assert_eq!(first.answers_per_query, first.reference_answers_per_query);
     let next = run_data_plane(
         &plan_json,
@@ -1289,7 +1289,10 @@ async fn query_time_results_kept_across_evaluations_are_built_in_query_runs() {
         EVALUATION_MS + 60_000,
         &mut store,
     );
-    assert_eq!(next.outputs_built, 1, "four panes reused from the cache");
+    assert_eq!(
+        next.outputs_built, 1,
+        "four tumbling windows reused from the cache"
+    );
     assert_eq!(next.answers_per_query, next.reference_answers_per_query);
 }
 
@@ -1421,7 +1424,7 @@ fn promql_quantile(q: f64, values: &mut [f64]) -> f64 {
 /// The p90/p50 ratio of an hour (W-RangeHeavy template 8) on a deployment
 /// that keeps no raw data samples: both quantiles come from DDSketches
 /// sized for a share of the target (α = 1 − 1.05^{−1/2} ≈ 0.0241, so
-/// `(a + b)/(1 − b) ≤ 0.05`), maintained in panes; nothing is read from
+/// `(a + b)/(1 − b) ≤ 0.05`), maintained in tumbling windows; nothing is read from
 /// raw data at query time. Run on data, each series' ratio is within 0.05
 /// of the exact ratio of its hour's samples.
 #[tokio::test]
@@ -1816,12 +1819,12 @@ async fn a_summary_across_series_from_per_series_summaries_is_listed_and_built()
 }
 
 /// A dashboard's 5-minute max over the last hour at 1-minute steps (#509
-/// Example 4's B3) keeps five 1-minute panes; with its merge kept too, the
-/// merge is listed after the panes it reads, with their definition and the
+/// Example 4's B3) keeps five 1-minute tumbling windows; with its merge kept too, the
+/// merge is listed after the tumbling windows it reads, with their definition and the
 /// union of their times, refreshed in the query run and kept for its window
-/// plus the hour of steps; its panes are kept at least that long. Built
-/// from the stored panes it answers as the reference, and a minute later
-/// only the newest pane and the new merge are refreshed.
+/// plus the hour of steps; its tumbling windows are kept at least that long. Built
+/// from the stored tumbling windows it answers as the reference, and a minute later
+/// only the newest tumbling window and the new merge are refreshed.
 #[tokio::test]
 async fn a_kept_sliding_window_merge_is_listed_and_built() {
     let capabilities = DeploymentCapabilities {
@@ -1832,7 +1835,7 @@ async fn a_kept_sliding_window_merge_is_listed_and_built() {
         &["max_over_time(m[5m])"],
         r#", "range_evaluation": {"step_ms": 60000, "span_ms": 3600000}"#,
     );
-    // Declared as sampled every second, so that keeping the panes is
+    // Declared as sampled every second, so that keeping the tumbling windows is
     // cheaper than rebuilding the window at every step; the samples the
     // run reads are every 10 s, and exact answers do not depend on it.
     let facts = workload
@@ -1844,27 +1847,30 @@ async fn a_kept_sliding_window_merge_is_listed_and_built() {
     let plan_json = forced_plan_json(&workload, &capabilities, merges_kept).await;
     let plan: InstallablePlan = serde_json::from_str(&plan_json).unwrap();
     let views = plan.materialized_views().unwrap();
-    let (merge, panes) = views.split_last().unwrap();
-    assert_eq!(panes.len(), 5);
+    let (merge, tumbling_windows) = views.split_last().unwrap();
+    assert_eq!(tumbling_windows.len(), 5);
     assert_eq!(
         merge.inputs.materialized_views,
-        panes.iter().map(|pane| pane.node_id).collect::<Vec<_>>()
+        tumbling_windows
+            .iter()
+            .map(|tumbling_window| tumbling_window.node_id)
+            .collect::<Vec<_>>()
     );
     assert!(merge.inputs.raw_data_windows().is_empty());
     assert_eq!(merge.refresh(), MaterializedViewRefresh::OnFirstRead);
     assert_eq!(merge.coverage().selection(), relative_time(-300_000, 0));
     assert_eq!(merge.retention_ms(), 300_000 + 3_600_000);
-    for (i, pane) in panes.iter().enumerate() {
+    for (i, tumbling_window) in tumbling_windows.iter().enumerate() {
         let i = i as i64;
         assert_eq!(
-            pane.coverage().definition_id(),
+            tumbling_window.coverage().definition_id(),
             merge.coverage().definition_id()
         );
         assert_eq!(
-            pane.coverage().selection(),
+            tumbling_window.coverage().selection(),
             relative_time(-(i + 1) * 60_000, -i * 60_000)
         );
-        assert!(pane.retention_ms() >= merge.retention_ms());
+        assert!(tumbling_window.retention_ms() >= merge.retention_ms());
     }
     let mut store = SummaryStore::new();
     let first = run_data_plane(&plan_json, &job_samples(), EVALUATION_MS, &mut store);
@@ -1876,45 +1882,48 @@ async fn a_kept_sliding_window_merge_is_listed_and_built() {
         EVALUATION_MS + 60_000,
         &mut store,
     );
-    assert_eq!(next.outputs_built, 2, "the newest pane and the new merge");
+    assert_eq!(
+        next.outputs_built, 2,
+        "the newest tumbling window and the new merge"
+    );
     assert_eq!(next.answers_per_query, next.reference_answers_per_query);
 }
 
-/// Example 4b's selected panes cover the hour and share one definition id,
-/// each with its own time selection; each reads its pane of
+/// Example 4b's selected tumbling windows cover the hour and share one definition id,
+/// each with its own time selection; each reads its tumbling window of
 /// raw data samples and nothing stored.
 #[tokio::test]
-async fn panes_of_an_hour_share_one_definition_with_distinct_times() {
+async fn tumbling_windows_of_an_hour_share_one_definition_with_distinct_times() {
     let plan: InstallablePlan =
         serde_json::from_str(&plan_json(&["quantile_over_time(0.99, latency_ms[60m])"]).await)
             .unwrap();
     let views = plan.materialized_views().unwrap();
     assert!(!views.is_empty());
-    let mut panes: Vec<&MaterializedView> = views.iter().collect();
-    panes.sort_by_key(|o| o.inputs.raw_data_windows()[0].end_offset_ms());
-    let width_ms = panes[0].inputs.raw_data_windows()[0].width_ms();
+    let mut tumbling_windows: Vec<&MaterializedView> = views.iter().collect();
+    tumbling_windows.sort_by_key(|o| o.inputs.raw_data_windows()[0].end_offset_ms());
+    let width_ms = tumbling_windows[0].inputs.raw_data_windows()[0].width_ms();
     assert!(width_ms > 0);
     assert_eq!(
-        width_ms * panes.len() as i64,
+        width_ms * tumbling_windows.len() as i64,
         3_600_000,
         "complete hour coverage"
     );
-    for (i, pane) in panes.iter().enumerate() {
+    for (i, tumbling_window) in tumbling_windows.iter().enumerate() {
         let i = i as i64;
-        let [window] = pane.inputs.raw_data_windows() else {
-            panic!("{pane:?}");
+        let [window] = tumbling_window.inputs.raw_data_windows() else {
+            panic!("{tumbling_window:?}");
         };
         assert_eq!(
             (window.width_ms(), window.end_offset_ms()),
             (width_ms, i * width_ms)
         );
-        assert!(pane.inputs.materialized_views.is_empty());
+        assert!(tumbling_window.inputs.materialized_views.is_empty());
         assert_eq!(
-            pane.coverage().definition_id(),
-            panes[0].coverage().definition_id()
+            tumbling_window.coverage().definition_id(),
+            tumbling_windows[0].coverage().definition_id()
         );
         assert_eq!(
-            pane.coverage().selection(),
+            tumbling_window.coverage().selection(),
             relative_time(-(i + 1) * width_ms, -i * width_ms)
         );
     }
@@ -2075,19 +2084,20 @@ async fn plan_p99_avg(
 }
 
 /// Without raw data samples, the only valid plan of the p99 query keeps one
-/// DDSketch per series in one-second panes built at ingestion and merges
-/// the window's panes at query time. A quantile
-/// of merged panes is still one of the samples, so a declared non-negative
+/// DDSketch per series in one-second tumbling windows built at ingestion and merges
+/// the window's tumbling windows at query time. A quantile
+/// of merged tumbling windows is still one of the samples, so a declared non-negative
 /// gauge carries the sketch's relative bound through `avg`: that plan is
 /// selected, its answers equal the query-time reference's and are within
 /// 5% of the exact averages.
 #[tokio::test]
-async fn a_non_negative_gauges_merged_ddsketch_panes_carry_the_relative_bound_through_avg() {
+async fn a_non_negative_gauges_merged_ddsketch_tumbling_windows_carry_the_relative_bound_through_avg(
+) {
     let (plan, selection) = plan_p99_avg(true).await.expect("a valid plan");
     let selection = selection.as_ref().expect("Stage 3's report");
     let views = plan.materialized_views().unwrap();
     assert!(selection.cost_per_second.is_some());
-    assert!(!views.is_empty(), "panes built at ingestion");
+    assert!(!views.is_empty(), "tumbling windows built at ingestion");
     assert_eq!(
         stored_definitions(&plan, "DDSketch").len(),
         1,
@@ -2202,7 +2212,7 @@ async fn a_non_negative_gauges_merged_ddsketch_panes_carry_the_relative_bound_th
 /// which scan raw data at query time.
 #[tokio::test]
 #[ignore = "flaky: depends on wall-clock search budgets (#1067)"]
-async fn an_undeclared_gauges_merged_ddsketch_panes_get_no_relative_bound_through_avg() {
+async fn an_undeclared_gauges_merged_ddsketch_tumbling_windows_get_no_relative_bound_through_avg() {
     let error = plan_p99_avg(false).await.expect_err("no valid plan");
     assert_plan_selection_selected_none(&error);
     // Pass 1 prunes both quantile sketches for that reason: DDSketch's
@@ -2673,7 +2683,7 @@ fn assert_p99s_within_alpha(
 }
 
 /// A non-negative gauge that reports exactly 0 is still summarized by the
-/// selected DDSketch panes (zero has its own bucket): each series' window
+/// selected DDSketch tumbling windows (zero has its own bucket): each series' window
 /// holds the samples 0, 0, 3 and 5 scaled by the series, and every answer
 /// equals the query-time reference's and is within the relative error 0.05
 /// of the exact average of PromQL's interpolated p99s.
@@ -2681,7 +2691,7 @@ fn assert_p99s_within_alpha(
 async fn a_ddsketch_over_a_gauge_reporting_zero_runs_within_alpha() {
     let (plan, _) = plan_p99("avg", true, false).await;
     let views = plan.materialized_views().unwrap();
-    assert!(!views.is_empty(), "panes built at ingestion");
+    assert!(!views.is_empty(), "tumbling windows built at ingestion");
     let (samples, per_group) = data_samples(8, 4, 20_000, |s, step| {
         (s + 1) as f64 * [0.0, 0.0, 3.0, 5.0][step as usize]
     });
@@ -2696,7 +2706,7 @@ async fn a_ddsketch_over_a_gauge_reporting_zero_runs_within_alpha() {
 }
 
 /// Signed samples (negative, zero and positive) are summarized by the
-/// selected DDSketch panes, through their negative store and zero bucket:
+/// selected DDSketch tumbling windows, through their negative store and zero bucket:
 /// Signed interpolation has no general relative guarantee, so this kernel
 /// fixture explicitly bypasses accuracy admission. Every answer equals the
 /// query-time reference's and is
@@ -2714,7 +2724,7 @@ async fn a_ddsketch_over_signed_samples_runs_within_alpha() {
         report.as_ref().unwrap().queries_accepted_without_guarantee,
         vec![0]
     );
-    assert!(!views.is_empty(), "panes built at ingestion");
+    assert!(!views.is_empty(), "tumbling windows built at ingestion");
     let max = |p99s: &[f64]| p99s.iter().copied().fold(f64::NEG_INFINITY, f64::max);
     // Series 0..4 cross zero; series 4..8 are all negative.
     let (samples, per_group) = data_samples(8, 1_100, 100, |s, step| {
@@ -2777,7 +2787,7 @@ fn counter_raw_data_samples() -> Vec<RawDataSample> {
 }
 
 /// Issue: with guarantees ignored and no raw data samples, the counter top-k
-/// queries selected exact per-series panes followed by a query-time
+/// queries selected exact per-series tumbling windows followed by a query-time
 /// CountSketchWithHeap top-k the executor cannot compile ("invalid keyed
 /// evaluation shape or capacity"). The selected plan must be one the
 /// executor compiles; it runs, equal to its query-time reference and to the
diff --git a/crates/planner/tests/sql_table_scans.rs b/crates/planner/tests/sql_table_scans.rs
index 4ba558369..69dd65cf4 100644
--- a/crates/planner/tests/sql_table_scans.rs
+++ b/crates/planner/tests/sql_table_scans.rs
@@ -3,9 +3,9 @@
 //! the plan compiles with the table's scans (`check_compiles` sees them),
 //! `now()` is the evaluation time, `COUNT(DISTINCT)` over an `Int64` id
 //! column answers with the type the Planner gives it, from a distinct-count
-//! sketch or exactly. A plan that keeps panes at ingestion time runs as a
-//! runtime runs it: each pane built in an ingestion run over its window from
-//! the table bound at the plan's `Scan`, the queries answered from the panes.
+//! sketch or exactly. A plan that keeps tumbling windows at ingestion time runs as a
+//! runtime runs it: each tumbling window built in an ingestion run over its window from
+//! the table bound at the plan's `Scan`, the queries answered from the tumbling windows.
 
 use std::collections::BTreeMap;
 use std::sync::Arc;
@@ -366,15 +366,18 @@ async fn an_exact_global_sql_percentile_of_no_row_is_null() {
 }
 
 /// A 5 and a 15 minute distinct count over one table: the plan builds them
-/// in tumbling panes, each pane a `TimeRange` over a shifted table `Scan`,
+/// in tumbling windows, each tumbling window a `TimeRange` over a shifted table `Scan`,
 /// which the executor runs as filters on `ts`. Both answer exactly (the
 /// sketch is exact below its capacity).
 #[tokio::test]
-async fn distinct_counts_over_5_and_15_minute_windows_run_from_panes() {
+async fn distinct_counts_over_5_and_15_minute_windows_run_from_tumbling_windows() {
     let fifteen = DISTINCT_USERS_LAST_5_MINUTES.replace("5 minutes", "15 minutes");
     let plan = plan_all(&[DISTINCT_USERS_LAST_5_MINUTES, &fifteen], APPROXIMATE).await;
     let selected = format!("{:?}", plan.dag.nodes);
-    assert!(selected.contains("TimeShift"), "panes: {selected}");
+    assert!(
+        selected.contains("TimeShift"),
+        "tumbling windows: {selected}"
+    );
     assert_eq!(by_key(run_query(&plan, 0).1), expected_distinct_users());
     // The last 15 minutes (i >= 300): every user `i % 50` of each service
     // (3 and 50 are coprime) and its 7 recent ones.
@@ -385,8 +388,8 @@ async fn distinct_counts_over_5_and_15_minute_windows_run_from_panes() {
 }
 
 /// Exact row counts over 5 and 15 minutes: a count tells a row read twice
-/// or missed at a pane's edge, which a distinct count cannot. Each pane is
-/// `(T - s - w, T - s]`, so the 15-minute panes read every row after
+/// or missed at a tumbling window's edge, which a distinct count cannot. Each tumbling window is
+/// `(T - s - w, T - s]`, so the 15-minute tumbling windows read every row after
 /// `T - 15m` exactly once: 300 per service (the row at `T - 15m` is not
 /// read), and 100 in the last 5 minutes.
 #[tokio::test]
@@ -396,7 +399,10 @@ async fn row_counts_over_5_and_15_minute_windows_read_each_row_once() {
     let fifteen = five.replace("5 minutes", "15 minutes");
     let plan = plan_all(&[five, &fifteen], EXACT).await;
     let selected = format!("{:?}", plan.dag.nodes);
-    assert!(selected.contains("TimeShift"), "panes: {selected}");
+    assert!(
+        selected.contains("TimeShift"),
+        "tumbling windows: {selected}"
+    );
     for (query, rows_per_service) in [(0, 100), (1, 300)] {
         let expected: BTreeMap<String, String> = (0..3)
             .map(|s| (format!("s{s}"), shown(&Value::Int64(rows_per_service))))
@@ -540,12 +546,12 @@ fn run_data_plane(plan: &InstallablePlan) -> Vec<Vec<Vec<Value>>> {
         .collect()
 }
 
-/// A 5 and a 15 minute distinct count kept in tumbling panes at ingestion
-/// time (the deployment keeps no raw data): each pane is built in an ingestion run from the table rows of its
-/// window, and both queries answer exactly from the panes (the sketch is
+/// A 5 and a 15 minute distinct count kept in tumbling windows at ingestion
+/// time (the deployment keeps no raw data): each tumbling window is built in an ingestion run from the table rows of its
+/// window, and both queries answer exactly from the tumbling windows (the sketch is
 /// exact below its capacity), as the query-time reference does.
 #[tokio::test]
-async fn ingestion_time_panes_built_from_table_rows_answer_exactly() {
+async fn ingestion_time_tumbling_windows_built_from_table_rows_answer_exactly() {
     let fifteen = DISTINCT_USERS_LAST_5_MINUTES.replace("5 minutes", "15 minutes");
     let plan = plan_without_raw_data(&[DISTINCT_USERS_LAST_5_MINUTES, &fifteen], APPROXIMATE).await;
     let views = plan.materialized_views().unwrap();
@@ -554,10 +560,10 @@ async fn ingestion_time_panes_built_from_table_rows_answer_exactly() {
             .iter()
             .any(|v| v.refresh() == MaterializedViewRefresh::AtIngestion
                 && !v.inputs.raw_data_windows().is_empty()),
-        "panes built at ingestion time from table rows: {:?}",
+        "tumbling windows built at ingestion time from table rows: {:?}",
         views
     );
-    // Older panes read windows that end before the evaluation.
+    // Older tumbling windows read windows that end before the evaluation.
     assert!(views
         .iter()
         .flat_map(|v| v.inputs.raw_data_windows())
diff --git a/crates/types/src/ir/materialized_view.rs b/crates/types/src/ir/materialized_view.rs
index 0c932c78c..bbbd1a32f 100644
--- a/crates/types/src/ir/materialized_view.rs
+++ b/crates/types/src/ir/materialized_view.rs
@@ -47,12 +47,12 @@
 //! own). A runtime refreshes a group with one ingestion run per window
 //! `(e - W, e]`, `e ≡ p (mod W)`. The run's roots are the views of the group
 //! whose state for the window ending at `e` is not stored yet: in steady
-//! state the newest pane of each chain, since older panes are the same
+//! state the newest tumbling window of each chain, since older tumbling windows are the same
 //! states, stored by earlier runs. A view of the group that a root reads is
 //! computed in the run; views of other groups are materialized view slots.
 //! A node several roots share runs once per run, so a `Scan` below a KLL
-//! pane chain and a DDSketch pane chain of equal pane width reads each
-//! pane's raw data once. Stage 3's cost assumes this grouping; a runtime
+//! tumbling-window chain and a DDSketch tumbling-window chain of equal tumbling-window width reads each
+//! tumbling window's raw data once. Stage 3's cost assumes this grouping; a runtime
 //! that splits a group computes the same states at a higher cost than
 //! priced.
 //!
@@ -281,7 +281,7 @@ impl RefreshWindow {
 /// ([`PhysicalASAPDAG::ingestion_refresh_groups`]). A runtime refreshes
 /// them with one ingestion run per window `(e - W, e]`; each run's roots are
 /// the views whose state for the window ending at `e` is not stored yet (in
-/// steady state the newest pane of each chain), and a view of the group a
+/// steady state the newest tumbling window of each chain), and a view of the group a
 /// root reads is computed in the run.
 #[derive(Debug, Clone, PartialEq)]
 pub struct IngestionRefreshGroup {
@@ -519,11 +519,11 @@ impl PhysicalASAPDAG {
     }
 
     /// The refresh window of `node` ([`RefreshWindow::of_window`]): for a
-    /// `SummaryTumblingWindowChain` (a DAG with its chains unexpanded), its newest pane's,
-    /// `(pane_width, s mod pane_width)` with `s` the sum of the offsets of
+    /// `SummaryTumblingWindowChain` (a DAG with its chains unexpanded), its newest tumbling window's,
+    /// `(tumbling_window_width, s mod tumbling_window_width)` with `s` the sum of the offsets of
     /// the `TimeShift`s below it; for any other node, that of its window
     /// ([`Self::view_windows`], which counts a chain below it as all its
-    /// panes). A chain and each of its expanded panes have the same one.
+    /// tumbling windows). A chain and each of its expanded tumbling windows have the same one.
     /// `None` when the window is unbounded or empty. O(nodes + edges).
     pub fn refresh_window(&self, node: PhysicalASAPNodeId) -> Option<RefreshWindow> {
         self.refresh_windows([node])[&node]
@@ -565,7 +565,7 @@ impl PhysicalASAPDAG {
             else {
                 continue;
             };
-            // The newest pane ends at the offsets of the shifts below the chain.
+            // The newest tumbling window ends at the offsets of the shifts below the chain.
             let end_offset_ms = offset_below(*child, |id| payloads.get(&id).copied());
             let width_ms = i64::try_from(*tumbling_window_width_ms).unwrap_or(0);
             windows.insert(
@@ -577,11 +577,11 @@ impl PhysicalASAPDAG {
     }
 
     /// Sets `retention_ms` on every materialized view and every query-time
-    /// `Scan` of an installed DAG (pane chains expanded), and returns the
+    /// `Scan` of an installed DAG (tumbling-window chains expanded), and returns the
     /// views ([`Self::materialized_views`]); `Err` when `deadline` passes.
     ///
-    /// A view takes `pane_retention_ms_by_node`'s value (Stage 3's retention
-    /// of a pane's chain: its offset plus its window plus the longest
+    /// A view takes `tumbling_window_retention_ms_by_node`'s value (Stage 3's retention
+    /// of a tumbling window's chain: its offset plus its window plus the longest
     /// range-evaluation span of its readers); otherwise how far back its
     /// data reaches, plus, for a view built from other views, its readers'
     /// longest range-evaluation span (`reader_span_ms_by_node`). Then each
@@ -597,14 +597,14 @@ impl PhysicalASAPDAG {
     /// range-evaluation span, and at least the retention of every view
     /// refreshed on first read from it (which may be refreshed for its
     /// oldest step); `None` when its window is unbounded. In an installed
-    /// DAG a chain kept across evaluations is its expanded panes, so its
-    /// scan keeps the reach of all of them: reusing a pane refreshed at an
+    /// DAG a chain kept across evaluations is its expanded tumbling windows, so its
+    /// scan keeps the reach of all of them: reusing a tumbling window refreshed at an
     /// earlier evaluation is optional, and a restart or an older range step
-    /// refreshes older panes from raw data. (Stage 3 prices a kept chain on
-    /// the unexpanded DAG as reading its newest pane.)
+    /// refreshes older tumbling windows from raw data. (Stage 3 prices a kept chain on
+    /// the unexpanded DAG as reading its newest tumbling window.)
     pub fn set_retention(
         &mut self,
-        pane_retention_ms_by_node: &HashMap<PhysicalASAPNodeId, u64>,
+        tumbling_window_retention_ms_by_node: &HashMap<PhysicalASAPNodeId, u64>,
         reader_span_ms_by_node: &HashMap<PhysicalASAPNodeId, u64>,
         deadline: Option<Instant>,
     ) -> Result<Vec<MaterializedView>, InstallableDagError> {
@@ -623,7 +623,7 @@ impl PhysicalASAPDAG {
                     .copied()
                     .unwrap_or(0),
             };
-            view.retention_ms = pane_retention_ms_by_node
+            view.retention_ms = tumbling_window_retention_ms_by_node
                 .get(&view.node_id)
                 .copied()
                 .unwrap_or(reach_ms + span_ms);
@@ -728,7 +728,7 @@ impl PhysicalASAPDAG {
     }
 
     /// Checks that every raw-data window the DAG reads (each `TimeRange`,
-    /// and each `SummaryTumblingWindowChain`'s pane, reading a `Scan` without passing another
+    /// and each `SummaryTumblingWindowChain`'s tumbling window, reading a `Scan` without passing another
     /// `TimeRange`) has a supported shape
     /// ([`InstallableDagError::UnsupportedRawDataWindow`]). O(nodes + edges)
     /// plus the depth below each window.
@@ -997,9 +997,9 @@ impl<'a> ViewIndex<'a> {
     }
 
     /// The window of width `width_ms` that `time_range` (a `TimeRange`, or
-    /// a `SummaryTumblingWindowChain`'s pane) reads from the `Scan` below it, and that
+    /// a `SummaryTumblingWindowChain`'s tumbling window) reads from the `Scan` below it, and that
     /// `Scan`, or why its shape is unsupported. It does not allocate or
-    /// compile every pane in a chain.
+    /// compile every tumbling window in a chain.
     fn raw_window_below(
         &self,
         time_range: PhysicalASAPNodeId,
diff --git a/crates/types/src/ir/operator/asap.rs b/crates/types/src/ir/operator/asap.rs
index 4c213bbc6..707ab4add 100644
--- a/crates/types/src/ir/operator/asap.rs
+++ b/crates/types/src/ir/operator/asap.rs
@@ -55,11 +55,11 @@ pub enum ASAPOp<C = Rc<OperatorNode>> {
         evaluation: PopulationStatistic,
     },
     /// Merge compatible partial states of one family: every input state of
-    /// a group, including each pane of a [`SummaryTumblingWindowChain`](ASAPOp::SummaryTumblingWindowChain),
+    /// a group, including each tumbling window of a [`SummaryTumblingWindowChain`](ASAPOp::SummaryTumblingWindowChain),
     /// into one state per group.
     SummaryMerge {
         children: Vec<C>,
-        /// Merge only the newest `n` panes of the one `SummaryTumblingWindowChain` this
+        /// Merge only the newest `n` tumbling windows of the one `SummaryTumblingWindowChain` this
         /// merge reads, `1 ≤ n <` its `tumbling_window_count`: the state of one build
         /// over the newest `n · tumbling_window_width_ms` of the chain's window, so a
         /// query over a shorter window reads a chain kept for a longer one.
@@ -78,19 +78,19 @@ pub enum ASAPOp<C = Rc<OperatorNode>> {
         #[serde(default, skip_serializing_if = "Option::is_none")]
         group_by: Option<Vec<ColumnId>>,
     },
-    /// A tumbling-pane window summary (#509 Pass 2, window-composition
+    /// A tumbling-window summary (#509 Pass 2, window-composition
     /// rule): the `SummaryAgg` with these `family`, `input`, `reduction`,
     /// `grouping` and `filter`, built over each of `tumbling_window_count` back-to-back
     /// range windows of `tumbling_window_width_ms` that end at `child`'s evaluation
     /// time, newest first. `child` is the input a range selector would
-    /// read, so pane `i` covers `(-(i+1)·w, -i·w]` relative to it. Output:
-    /// the `SummaryAgg` schema, one state per group and pane; a
+    /// read, so tumbling window `i` covers `(-(i+1)·w, -i·w]` relative to it. Output:
+    /// the `SummaryAgg` schema, one state per group and tumbling window; a
     /// `SummaryMerge` over the chain gives the state of one build over the
     /// whole `tumbling_window_count · tumbling_window_width_ms` window
     /// (`whole_window_build`).
-    /// One compact node whatever the pane count: costs and guarantees come
-    /// from formulas, and the executor expands the panes
-    /// (`expand_pane_chains`).
+    /// One compact node whatever the tumbling-window count: costs and guarantees come
+    /// from formulas, and the executor expands the tumbling windows
+    /// (`expand_tumbling_window_chains`).
     // Written as `PaneChain` before #1163; the aliases read those documents.
     #[serde(alias = "PaneChain")]
     SummaryTumblingWindowChain {
@@ -370,10 +370,10 @@ impl ASAPOp {
                 if let Some(build) = rolled_up_build(child) {
                     return FinalizeExactAccumulator { child: build }.output_schema();
                 }
-                // Merged panes finalize as one build over their window.
-                if super::pane_chain::merged_chain(child).is_some() {
+                // Merged tumbling windows finalize as one build over their window.
+                if super::tumbling_window_chain::merged_chain(child).is_some() {
                     return FinalizeExactAccumulator {
-                        child: Rc::new(super::pane_chain::merged_window_build(child)?),
+                        child: Rc::new(super::tumbling_window_chain::merged_window_build(child)?),
                     }
                     .output_schema();
                 }
@@ -576,7 +576,7 @@ impl ASAPOp {
             } => {
                 if newest_tumbling_windows.is_some() && group_by.is_some() {
                     return Err(SchemaDerivationError::InvalidScalarSignature(
-                        "a rollup merges every input state, not the newest panes".into(),
+                        "a rollup merges every input state, not the newest tumbling windows".into(),
                     ));
                 }
                 if let Some(n) = newest_tumbling_windows {
@@ -592,8 +592,8 @@ impl ASAPOp {
                     };
                     if !tumbling_window_count.is_some_and(|count| (1..count).contains(n)) {
                         return Err(SchemaDerivationError::InvalidScalarSignature(
-                            "a merge of the newest panes reads one pane chain, and fewer \
-                             panes than it has"
+                            "a merge of the newest tumbling windows reads one tumbling-window chain, and fewer \
+                             tumbling windows than it has"
                                 .into(),
                         ));
                     }
@@ -692,7 +692,7 @@ impl ASAPOp {
             } => {
                 if *tumbling_window_width_ms == 0 || *tumbling_window_count == 0 {
                     return Err(SchemaDerivationError::InvalidScalarSignature(
-                        "a pane chain needs a positive pane width and pane count".into(),
+                        "a tumbling-window chain needs a positive tumbling-window width and tumbling-window count".into(),
                     ));
                 }
                 // The chain is the range selector: it reads the series the
@@ -702,7 +702,7 @@ impl ASAPOp {
                     OperatorResultKind::InstantVector | OperatorResultKind::Relation
                 ) {
                     return Err(SchemaDerivationError::InvalidScalarSignature(format!(
-                        "a pane chain reads an instant vector or a relation, got {:?}",
+                        "a tumbling-window chain reads an instant vector or a relation, got {:?}",
                         child.result_kind
                     )));
                 }
@@ -799,8 +799,8 @@ fn rolled_up_build(state: &OperatorNode) -> Option<Rc<OperatorNode>> {
     let input = selected_from(input).unwrap_or(input);
     let build = match input.asap()? {
         ASAPOp::SummaryAgg { .. } => (**input).clone(),
-        _ if super::pane_chain::merged_chain(input).is_some() => {
-            super::pane_chain::merged_window_build(input).ok()?
+        _ if super::tumbling_window_chain::merged_chain(input).is_some() => {
+            super::tumbling_window_chain::merged_window_build(input).ok()?
         }
         _ => return None,
     };
diff --git a/crates/types/src/ir/operator/mod.rs b/crates/types/src/ir/operator/mod.rs
index a08372ae2..5adc9322b 100644
--- a/crates/types/src/ir/operator/mod.rs
+++ b/crates/types/src/ir/operator/mod.rs
@@ -8,7 +8,7 @@
 //!   [`Reduction`], [`Source`], …).
 //! - [`agg_intent`] — the aggregation-intent vocabulary ([`AggIntent`]).
 //! - [`maintained_population`] — maintained populations and their evaluations.
-//! - [`pane_chain`] — what a tumbling-pane chain computes.
+//! - [`tumbling_window_chain`] — what a tumbling-window chain computes.
 //! - [`query`] — a query root: an operator result or a standalone scalar.
 pub mod agg_intent;
 pub mod asap;
@@ -16,8 +16,8 @@ pub mod maintained_population;
 pub mod node;
 pub mod non_asap;
 pub mod operator_properties;
-pub mod pane_chain;
 pub mod query;
+pub mod tumbling_window_chain;
 
 pub use agg_intent::{
     agg_has_exact_per_entity_kernel, default_cardinality, default_quantile, AggIntent, MathFunc,
diff --git a/crates/types/src/ir/operator/non_asap.rs b/crates/types/src/ir/operator/non_asap.rs
index 354d98178..b29247310 100644
--- a/crates/types/src/ir/operator/non_asap.rs
+++ b/crates/types/src/ir/operator/non_asap.rs
@@ -1184,7 +1184,7 @@ impl NonASAPOp {
             }
             TimeShift { child, .. } => {
                 // A relation is a SQL table's rows, shifted under a trailing
-                // window's tumbling pane.
+                // window's tumbling window.
                 if !matches!(
                     child.result_kind,
                     OperatorResultKind::InstantVector
diff --git a/crates/types/src/ir/operator/pane_chain.rs b/crates/types/src/ir/operator/tumbling_window_chain.rs
similarity index 71%
rename from crates/types/src/ir/operator/pane_chain.rs
rename to crates/types/src/ir/operator/tumbling_window_chain.rs
index 3356dc710..1df8b6a7e 100644
--- a/crates/types/src/ir/operator/pane_chain.rs
+++ b/crates/types/src/ir/operator/tumbling_window_chain.rs
@@ -1,15 +1,15 @@
-//! Tumbling-pane window summaries: what an [`ASAPOp::SummaryTumblingWindowChain`] computes,
+//! Tumbling-window summaries: what an [`ASAPOp::SummaryTumblingWindowChain`] computes,
 //! as the plain `SummaryAgg` nodes it stands for.
 //!
-//! A chain of `n` panes of width `w` over `child` is pane `i` (newest first,
+//! A chain of `n` tumbling windows of width `w` over `child` is tumbling window `i` (newest first,
 //! `0 ≤ i < n`): the chain's `SummaryAgg` over a range `TimeRange(w)` over
 //! `child` shifted back by `i·w`. A `SummaryMerge` over the chain is the
 //! state of one build over `TimeRange(n·w)` (`whole_window_build`) when
 //! the family merges (the family-capability table), and the executor runs
-//! the chain as its panes (`expand_pane_chains`). A merge of only the
-//! newest `m < n` panes (`SummaryMerge::newest_tumbling_windows`) is the state of one
+//! the chain as its tumbling windows (`expand_tumbling_window_chains`). A merge of only the
+//! newest `m < n` tumbling windows (`SummaryMerge::newest_tumbling_windows`) is the state of one
 //! build over `TimeRange(m·w)` ([`merged_window_build`]): one chain kept for
-//! the longest window serves every query whose window, on the same panes,
+//! the longest window serves every query whose window, on the same tumbling windows,
 //! ends at the same time and is shorter.
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -29,7 +29,7 @@ fn invalid(message: &str) -> SchemaDerivationError {
 
 /// The `SummaryTumblingWindowChain` a summary-state node carries merged: the chain itself,
 /// or the one chain a `SummaryMerge` that keeps its groups reads, in full
-/// or its newest panes (`merged_pane_count`). `None` for any other node,
+/// or its newest tumbling windows (`merged_tumbling_window_count`). `None` for any other node,
 /// a rollup (regrouping merge) included.
 pub fn merged_chain(state: &OperatorNode) -> Option<&OperatorNode> {
     match state.asap()? {
@@ -53,10 +53,10 @@ pub fn merged_chain(state: &OperatorNode) -> Option<&OperatorNode> {
     }
 }
 
-/// How many of its chain's panes, newest first, a summary-state node with
+/// How many of its chain's tumbling windows, newest first, a summary-state node with
 /// a [`merged_chain`] merges: the merge's `newest_tumbling_windows`, otherwise the
 /// chain's `tumbling_window_count`. `None` for any other node.
-fn merged_pane_count(state: &OperatorNode) -> Option<u32> {
+fn merged_tumbling_window_count(state: &OperatorNode) -> Option<u32> {
     let Some(ASAPOp::SummaryTumblingWindowChain {
         tumbling_window_count,
         ..
@@ -74,7 +74,7 @@ fn merged_pane_count(state: &OperatorNode) -> Option<u32> {
 }
 
 /// The `SummaryAgg` over `TimeRange(tumbling_window_count · tumbling_window_width_ms)` over the
-/// chain's input whose state the merged panes of `chain` equal.
+/// chain's input whose state the merged tumbling windows of `chain` equal.
 pub(crate) fn whole_window_build(
     chain: &OperatorNode,
 ) -> Result<OperatorNode, SchemaDerivationError> {
@@ -83,26 +83,28 @@ pub(crate) fn whole_window_build(
         ..
     }) = chain.asap()
     else {
-        return Err(invalid("expected a pane chain"));
+        return Err(invalid("expected a tumbling-window chain"));
     };
-    newest_panes_build(chain, *tumbling_window_count)
+    newest_tumbling_windows_build(chain, *tumbling_window_count)
 }
 
 /// The `SummaryAgg` whose state a summary-state node with a
-/// [`merged_chain`] carries: one build over the window of the panes it
-/// merges (`merged_pane_count`).
+/// [`merged_chain`] carries: one build over the window of the tumbling windows it
+/// merges (`merged_tumbling_window_count`).
 pub fn merged_window_build(state: &OperatorNode) -> Result<OperatorNode, SchemaDerivationError> {
     let (Some(chain), Some(tumbling_window_count)) =
-        (merged_chain(state), merged_pane_count(state))
+        (merged_chain(state), merged_tumbling_window_count(state))
     else {
-        return Err(invalid("expected merged panes of one pane chain"));
+        return Err(invalid(
+            "expected merged tumbling windows of one tumbling-window chain",
+        ));
     };
-    newest_panes_build(chain, tumbling_window_count)
+    newest_tumbling_windows_build(chain, tumbling_window_count)
 }
 
 /// The `SummaryAgg` over `TimeRange(tumbling_window_count · tumbling_window_width_ms)` over the
-/// chain's input: the state of the chain's newest `tumbling_window_count` panes.
-fn newest_panes_build(
+/// chain's input: the state of the chain's newest `tumbling_window_count` tumbling windows.
+fn newest_tumbling_windows_build(
     chain: &OperatorNode,
     tumbling_window_count: u32,
 ) -> Result<OperatorNode, SchemaDerivationError> {
@@ -112,18 +114,18 @@ fn newest_panes_build(
         ..
     }) = chain.asap()
     else {
-        return Err(invalid("expected a pane chain"));
+        return Err(invalid("expected a tumbling-window chain"));
     };
     let window = tumbling_window_width_ms
         .checked_mul(u64::from(tumbling_window_count))
-        .ok_or_else(|| invalid("pane chain window overflows"))?;
+        .ok_or_else(|| invalid("tumbling-window chain window overflows"))?;
     build_over(chain, range(Rc::clone(child), window)?)
 }
 
-/// Pane `index` (0 = newest) of `chain`: its `SummaryAgg` over the range
+/// Tumbling window `index` (0 = newest) of `chain`: its `SummaryAgg` over the range
 /// `TimeRange(tumbling_window_width_ms)` ending `index · tumbling_window_width_ms` before the
 /// chain's input.
-pub(crate) fn pane(
+pub(crate) fn tumbling_window(
     chain: &OperatorNode,
     index: u32,
 ) -> Result<OperatorNode, SchemaDerivationError> {
@@ -133,10 +135,10 @@ pub(crate) fn pane(
         ..
     }) = chain.asap()
     else {
-        return Err(invalid("expected a pane chain"));
+        return Err(invalid("expected a tumbling-window chain"));
     };
     let back = i64::try_from(tumbling_window_width_ms.saturating_mul(u64::from(index)))
-        .map_err(|_| invalid("pane offset overflows"))?;
+        .map_err(|_| invalid("tumbling window offset overflows"))?;
     build_over(
         chain,
         range(shifted(child, back)?, *tumbling_window_width_ms)?,
@@ -161,7 +163,7 @@ fn shifted(
                 offset_ms: shift
                     .offset_ms
                     .checked_add(back_ms)
-                    .ok_or_else(|| invalid("pane offset overflows"))?,
+                    .ok_or_else(|| invalid("tumbling window offset overflows"))?,
                 at: shift.at,
             },
             input,
@@ -205,7 +207,7 @@ fn build_over(
         ..
     }) = chain.asap()
     else {
-        return Err(invalid("expected a pane chain"));
+        return Err(invalid("expected a tumbling-window chain"));
     };
     let mut build = OperatorNode::new(Operator::ASAP(ASAPOp::SummaryAgg {
         child: input,
@@ -224,48 +226,48 @@ fn build_over(
 
 /// Expansion failure distinguishes invalid IR from an interrupted valid plan.
 #[derive(Debug, thiserror::Error)]
-pub enum PaneChainExpansionError {
+pub enum TumblingWindowChainExpansionError {
     #[error(transparent)]
     Invalid(#[from] SchemaDerivationError),
-    #[error("planning deadline exceeded expanding pane chains")]
+    #[error("planning deadline exceeded expanding tumbling-window chains")]
     DeadlineExceeded,
 }
 
-fn without_deadline(error: PaneChainExpansionError) -> SchemaDerivationError {
+fn without_deadline(error: TumblingWindowChainExpansionError) -> SchemaDerivationError {
     match error {
-        PaneChainExpansionError::Invalid(error) => error,
-        PaneChainExpansionError::DeadlineExceeded => {
+        TumblingWindowChainExpansionError::Invalid(error) => error,
+        TumblingWindowChainExpansionError::DeadlineExceeded => {
             unreachable!("no expansion deadline was supplied")
         }
     }
 }
 
-/// `root` with every `SummaryTumblingWindowChain` expanded into its panes: a `SummaryMerge`
-/// reads each pane of each chain it read, newest first, as plain
-/// `SummaryAgg` nodes the executor runs; a merge of the newest `n` panes
+/// `root` with every `SummaryTumblingWindowChain` expanded into its tumbling windows: a `SummaryMerge`
+/// reads each tumbling window of each chain it read, newest first, as plain
+/// `SummaryAgg` nodes the executor runs; a merge of the newest `n` tumbling windows
 /// reads the first `n`, the same nodes a merge of the whole chain reads. Every other node keeps its
-/// guarantee, timing and materialization. Each pane takes its chain's
+/// guarantee, timing and materialization. Each tumbling window takes its chain's
 /// timing and materialization, and the range and shift it reads take the
 /// chain's timing: a chain materialized at ingestion time expands into
-/// panes each built and stored at ingestion time. Expanding before timings
-/// are applied leaves the panes untimed. A chain read by anything but a
+/// tumbling windows each built and stored at ingestion time. Expanding before timings
+/// are applied leaves the tumbling windows untimed. A chain read by anything but a
 /// `SummaryMerge` is an error.
 #[cfg(any(test, feature = "test-support"))]
-pub fn expand_pane_chains(
+pub fn expand_tumbling_window_chains(
     root: &Rc<OperatorNode>,
 ) -> Result<Rc<OperatorNode>, SchemaDerivationError> {
     expand(root, &mut NodeToExpandedNodeCache::default()).map_err(without_deadline)
 }
 
-/// A workload with its pane chains expanded
-/// ([`expand_pane_chains_in_workload`]).
+/// A workload with its tumbling-window chains expanded
+/// ([`expand_tumbling_window_chains_in_workload`]).
 #[derive(Debug, Clone)]
-pub struct PaneChainExpansion {
+pub struct TumblingWindowChainExpansion {
     /// The workload's roots, in order, with every chain expanded.
     pub roots: Vec<QueryRoot>,
-    /// Each expanded chain with its panes some merge reads, newest first,
+    /// Each expanded chain with its tumbling windows some merge reads, newest first,
     /// in the order the chains were first reached.
-    pub chains: Vec<ExpandedPaneChain>,
+    pub chains: Vec<ExpandedTumblingWindowChain>,
     /// Every other node of the input workload the expansion reached, with
     /// the node that replaces it (itself when nothing below it changed),
     /// so a caller can carry what it knows about a node to the expanded
@@ -274,33 +276,33 @@ pub struct PaneChainExpansion {
 }
 
 /// One expanded chain: the `SummaryTumblingWindowChain` node of the input workload and the
-/// `SummaryAgg` panes that replace it.
+/// `SummaryAgg` tumbling windows that replace it.
 #[derive(Debug, Clone)]
-pub struct ExpandedPaneChain {
+pub struct ExpandedTumblingWindowChain {
     /// The chain node, as the input workload holds it.
     pub chain: Rc<OperatorNode>,
-    /// Its panes in the expanded workload that some merge reads, newest
+    /// Its tumbling windows in the expanded workload that some merge reads, newest
     /// first.
-    pub panes: Vec<Rc<OperatorNode>>,
+    pub tumbling_windows: Vec<Rc<OperatorNode>>,
 }
 
-/// `expand_pane_chains` over every root of one workload, with one cache, so
+/// `expand_tumbling_window_chains` over every root of one workload, with one cache, so
 /// a node several roots share stays one node and a chain several merges
-/// read expands into one set of panes. A standalone scalar root has the
-/// operators it reads expanded. Also returns each chain's panes, so a
+/// read expands into one set of tumbling windows. A standalone scalar root has the
+/// operators it reads expanded. Also returns each chain's tumbling windows, so a
 /// caller can carry what it knows about a chain (e.g. its retention) to
 /// them.
-pub fn expand_pane_chains_in_workload(
+pub fn expand_tumbling_window_chains_in_workload(
     roots: &[QueryRoot],
-) -> Result<PaneChainExpansion, SchemaDerivationError> {
-    expand_pane_chains_in_workload_before(roots, None).map_err(without_deadline)
+) -> Result<TumblingWindowChainExpansion, SchemaDerivationError> {
+    expand_tumbling_window_chains_in_workload_before(roots, None).map_err(without_deadline)
 }
 
-/// Expand the same legal pane domain, abandoning partial expansion on timeout.
-pub(crate) fn expand_pane_chains_in_workload_before(
+/// Expand the same legal tumbling-window domain, abandoning partial expansion on timeout.
+pub(crate) fn expand_tumbling_window_chains_in_workload_before(
     roots: &[QueryRoot],
     deadline: Option<Instant>,
-) -> Result<PaneChainExpansion, PaneChainExpansionError> {
+) -> Result<TumblingWindowChainExpansion, TumblingWindowChainExpansionError> {
     let mut cache = NodeToExpandedNodeCache {
         deadline,
         ..Default::default()
@@ -336,17 +338,25 @@ pub(crate) fn expand_pane_chains_in_workload_before(
                 }) => *tumbling_window_count,
                 _ => unreachable!("only chains are recorded"),
             };
-            let panes = (0..tumbling_window_count)
-                .map_while(|index| cache.pane_of.get(&(Rc::as_ptr(&chain), index)).cloned())
+            let tumbling_windows = (0..tumbling_window_count)
+                .map_while(|index| {
+                    cache
+                        .tumbling_window_of
+                        .get(&(Rc::as_ptr(&chain), index))
+                        .cloned()
+                })
                 .collect();
-            ExpandedPaneChain { chain, panes }
+            ExpandedTumblingWindowChain {
+                chain,
+                tumbling_windows,
+            }
         })
         .collect();
     // Catalog assembly follows expansion and is part of the same budget.
     if deadline.is_some_and(|deadline| Instant::now() >= deadline) {
-        return Err(PaneChainExpansionError::DeadlineExceeded);
+        return Err(TumblingWindowChainExpansionError::DeadlineExceeded);
     }
-    Ok(PaneChainExpansion {
+    Ok(TumblingWindowChainExpansion {
         roots,
         chains,
         expanded_nodes: cache.expanded,
@@ -354,7 +364,7 @@ pub(crate) fn expand_pane_chains_in_workload_before(
 }
 
 /// The untimed `node` with `timing` written into it and into every untimed
-/// node below it: the nodes [`pane`] created, over the chain's input, which
+/// node below it: the nodes [`tumbling_window`] created, over the chain's input, which
 /// the timing pass already timed.
 fn timed_like(node: &Rc<OperatorNode>, timing: ExecutionTiming) -> OperatorNode {
     OperatorNode::with_schema(
@@ -370,13 +380,13 @@ fn timed_like(node: &Rc<OperatorNode>, timing: ExecutionTiming) -> OperatorNode
 }
 
 /// What one expansion has built: each expanded node by its input's
-/// address, and each pane by its chain's address and index, so a chain two
-/// merges read expands into one set of panes.
+/// address, and each tumbling window by its chain's address and index, so a chain two
+/// merges read expands into one set of tumbling windows.
 #[derive(Default)]
 struct NodeToExpandedNodeCache {
     deadline: Option<Instant>,
     expanded_node_of: HashMap<*const OperatorNode, Rc<OperatorNode>>,
-    pane_of: HashMap<(*const OperatorNode, u32), Rc<OperatorNode>>,
+    tumbling_window_of: HashMap<(*const OperatorNode, u32), Rc<OperatorNode>>,
     /// Each chain expanded, in the order first reached.
     chains: Vec<Rc<OperatorNode>>,
     /// Each expanded node with its input, in the order expanded.
@@ -384,12 +394,12 @@ struct NodeToExpandedNodeCache {
 }
 
 impl NodeToExpandedNodeCache {
-    fn check_deadline(&self) -> Result<(), PaneChainExpansionError> {
+    fn check_deadline(&self) -> Result<(), TumblingWindowChainExpansionError> {
         if self
             .deadline
             .is_some_and(|deadline| Instant::now() >= deadline)
         {
-            Err(PaneChainExpansionError::DeadlineExceeded)
+            Err(TumblingWindowChainExpansionError::DeadlineExceeded)
         } else {
             Ok(())
         }
@@ -399,14 +409,16 @@ impl NodeToExpandedNodeCache {
 fn expand(
     node: &Rc<OperatorNode>,
     cache: &mut NodeToExpandedNodeCache,
-) -> Result<Rc<OperatorNode>, PaneChainExpansionError> {
+) -> Result<Rc<OperatorNode>, TumblingWindowChainExpansionError> {
     cache.check_deadline()?;
     if let Some(done) = cache.expanded_node_of.get(&Rc::as_ptr(node)) {
         return Ok(Rc::clone(done));
     }
     let out = match &node.operator {
         Operator::ASAP(ASAPOp::SummaryTumblingWindowChain { .. }) => {
-            return Err(invalid("a pane chain is read only through a summary merge").into())
+            return Err(
+                invalid("a tumbling-window chain is read only through a summary merge").into(),
+            )
         }
         Operator::ASAP(ASAPOp::SummaryMerge {
             children,
@@ -423,23 +435,25 @@ fn expand(
                         for index in 0..newest_tumbling_windows.unwrap_or(*tumbling_window_count) {
                             cache.check_deadline()?;
                             let key = (Rc::as_ptr(child), index);
-                            if let Some(done) = cache.pane_of.get(&key) {
+                            if let Some(done) = cache.tumbling_window_of.get(&key) {
                                 inputs.push(Rc::clone(done));
                                 continue;
                             }
-                            let pane = Rc::new(pane(child, index)?);
-                            let pane = match child.timing {
+                            let tumbling_window = Rc::new(tumbling_window(child, index)?);
+                            let tumbling_window = match child.timing {
                                 Some(timing) => Rc::new(
-                                    timed_like(&pane, timing)
+                                    timed_like(&tumbling_window, timing)
                                         .with_materialization(child.materialization),
                                 ),
-                                None => pane,
+                                None => tumbling_window,
                             };
                             if index == 0 {
                                 cache.chains.push(Rc::clone(child));
                             }
-                            cache.pane_of.insert(key, Rc::clone(&pane));
-                            inputs.push(pane);
+                            cache
+                                .tumbling_window_of
+                                .insert(key, Rc::clone(&tumbling_window));
+                            inputs.push(tumbling_window);
                         }
                     }
                     _ => inputs.push(expand(child, cache)?),
diff --git a/crates/types/src/ir/physical_export.rs b/crates/types/src/ir/physical_export.rs
index 03263faf9..ec5dcc6dd 100644
--- a/crates/types/src/ir/physical_export.rs
+++ b/crates/types/src/ir/physical_export.rs
@@ -55,10 +55,10 @@ pub enum GroupingEdgeCompatibility {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub enum WindowEdgeCompatibility {
-    /// Physical lowering must prove equal pane/query phase or install an
+    /// Physical lowering must prove equal tumbling-window and query phases or install an
     /// exact boundary residual. The logical DAG alone cannot make that claim.
     #[serde(rename = "RequiresAlignedPanePhaseOrExactBoundaryResidual")]
-    RequiresAlignedPanePhaseOrExactWindowEdgeResidual,
+    RequiresAlignedTumblingWindowPhaseOrExactWindowEdgeResidual,
     NotApplicable,
 }
 
@@ -294,7 +294,7 @@ impl ScanWindow {
 /// counts for it. `Unbounded` when one of those shifts has an `@` anchor,
 /// or `time_range` is not a `TimeRange`. `payload_of` gives each node's
 /// operator by id; an indexed lookup keeps this O(shifts), so a caller
-/// asking for every `TimeRange` of a pane-expanded DAG stays linear.
+/// asking for every `TimeRange` of a tumbling-window-expanded DAG stays linear.
 pub fn time_range_window<'a>(
     time_range: PhysicalASAPNodeId,
     payload_of: impl Fn(PhysicalASAPNodeId) -> Option<&'a PhysicalASAPOperatorPayload>,
@@ -409,10 +409,10 @@ impl PhysicalASAPDAG {
     /// reaches the `Scan` through `TimeShift`s without an `@` anchor
     /// (offsets summing to `s`) and is
     /// - a `TimeRange(w)`, range or instant: `(T - s - w, T - s]`;
-    /// - a `SummaryTumblingWindowChain` of `n` panes of width `w`: its whole window `(T - s -
-    ///   n·w, T - s]`, or only its newest pane `(T - s - w, T - s]` for a
+    /// - a `SummaryTumblingWindowChain` of `n` tumbling windows of width `w`: its whole window `(T - s -
+    ///   n·w, T - s]`, or only its newest tumbling window `(T - s - w, T - s]` for a
     ///   chain in `kept_chains` (kept across evaluations, so each
-    ///   evaluation builds one pane).
+    ///   evaluation builds one tumbling window).
     ///
     /// `Unbounded` when a root, any other reader, or a shift with an `@`
     /// anchor reads the `Scan` or one of those shifts, or nothing reads it.
@@ -492,8 +492,8 @@ impl PhysicalASAPDAG {
     /// The interval of data the output of `node` summarizes, back from the
     /// evaluation time `T`: the union of the windows
     /// ([`time_range_window`]) of every `TimeRange` below it, and of every
-    /// unexpanded `SummaryTumblingWindowChain` (all its panes). For an expanded pane, its
-    /// pane; for a view built from panes, all of them. `Unbounded` when no
+    /// unexpanded `SummaryTumblingWindowChain` (all its tumbling windows). For an expanded tumbling window, its
+    /// tumbling window; for a view built from tumbling windows, all of them. `Unbounded` when no
     /// `TimeRange` or chain is below it or one of them is unbounded (a whole
     /// SQL table, an `@` anchor). O(nodes + edges).
     #[cfg(any(test, feature = "test-support"))]
@@ -679,7 +679,7 @@ impl PhysicalASAPDAG {
         // the role of each input's position, so a swapped `Left`/`Right`
         // cannot reorder the inputs of a binary operator.
         // Count input occurrences instead of scanning a vector for each edge.
-        // Pane merges can have tens of thousands of distinct inputs; linear
+        // Tumbling-window merges can have tens of thousands of distinct inputs; linear
         // searches made validation quadratic in that fan-in. Multiplicities
         // still matter when the same producer occupies several input slots.
         let mut expected: HashMap<_, HashMap<_, usize>> = self
@@ -923,7 +923,7 @@ pub(crate) fn compile_physical_asap_workload_with_node_ids_before(
                 data_state: producer_state,
                 grouping: grouping_compatibility(&nodes[producer].payload, &flat_node.operator),
                 window: if ingestion_dependency {
-                    WindowEdgeCompatibility::RequiresAlignedPanePhaseOrExactWindowEdgeResidual
+                    WindowEdgeCompatibility::RequiresAlignedTumblingWindowPhaseOrExactWindowEdgeResidual
                 } else {
                     WindowEdgeCompatibility::NotApplicable
                 },
diff --git a/crates/types/src/ir/properties/summary_coverage.rs b/crates/types/src/ir/properties/summary_coverage.rs
index 61e80e188..5cf1812ed 100644
--- a/crates/types/src/ir/properties/summary_coverage.rs
+++ b/crates/types/src/ir/properties/summary_coverage.rs
@@ -226,8 +226,8 @@ pub enum CoverageError {
     /// A `SummaryTumblingWindowChain` that does not expand to one build over its whole
     /// window (its window overflows, or the build does not derive): bad
     /// input.
-    #[error("pane chain does not expand to one build over its whole window: {reason}")]
-    PaneChainExpansion { reason: String },
+    #[error("tumbling-window chain does not expand to one build over its whole window: {reason}")]
+    TumblingWindowChainExpansion { reason: String },
     /// A `SummaryMerge` without inputs: bad input.
     #[error("summary merge requires at least one input")]
     EmptyMerge,
@@ -269,7 +269,7 @@ pub(crate) type NodeToSummaryCoverageCache = HashMap<*const OperatorNode, Summar
 impl SummaryCoverage {
     /// Coverage of a `SummaryAgg`, `SummaryTumblingWindowChain` or `SummaryMerge`. A chain
     /// covers what one build over its whole window does, and a merge of its
-    /// newest panes what one build over their window does. A merge fails unless
+    /// newest tumbling windows what one build over their window does. A merge fails unless
     /// every input has the same definition and their selections are
     /// pairwise disjoint; a family whose merge is idempotent
     /// ([`MergeInputRule::MayOverlap`] in the family-capability
@@ -310,27 +310,27 @@ impl SummaryCoverage {
         }
         let coverage = match node.asap() {
             Some(ASAPOp::SummaryAgg { .. }) => of_summary_agg(node),
-            // Back-to-back panes cover the whole window one build over it
+            // Back-to-back tumbling windows cover the whole window one build over it
             // would.
             Some(ASAPOp::SummaryTumblingWindowChain { .. }) => of_summary_agg(
-                &crate::ir::operator::pane_chain::whole_window_build(node).map_err(|error| {
-                    CoverageError::PaneChainExpansion {
+                &crate::ir::operator::tumbling_window_chain::whole_window_build(node).map_err(
+                    |error| CoverageError::TumblingWindowChainExpansion {
                         reason: error.to_string(),
-                    }
-                })?,
+                    },
+                )?,
             ),
-            // The newest panes of one chain cover what one build over their
+            // The newest tumbling windows of one chain cover what one build over their
             // window does.
             Some(ASAPOp::SummaryMerge {
                 newest_tumbling_windows: Some(_),
                 group_by: None,
                 ..
             }) => of_summary_agg(
-                &crate::ir::operator::pane_chain::merged_window_build(node).map_err(|error| {
-                    CoverageError::PaneChainExpansion {
+                &crate::ir::operator::tumbling_window_chain::merged_window_build(node).map_err(
+                    |error| CoverageError::TumblingWindowChainExpansion {
                         reason: error.to_string(),
-                    }
-                })?,
+                    },
+                )?,
             ),
             Some(ASAPOp::SummaryMerge {
                 children, group_by, ..
@@ -1170,9 +1170,9 @@ fn union_general(mut boxes: Vec<SelectionBox>) -> Vec<SelectionBox> {
     boxes
 }
 
-/// Pane coverage has identical column predicates and pairwise disjoint time
+/// Tumbling-window coverage has identical column predicates and pairwise disjoint time
 /// intervals. Sort once and join adjacent intervals, rather than removing one
-/// element from a large vector for every pane. General multidimensional or
+/// element from a large vector for every tumbling window. General multidimensional or
 /// overlapping coverage continues through the existing exact union algorithm.
 fn union_ordered_time_boxes(boxes: &[SelectionBox]) -> Option<Vec<SelectionBox>> {
     let first = boxes.first()?;
@@ -1299,10 +1299,10 @@ fn touching<T: Clone>(
 }
 
 #[cfg(test)]
-mod pane_union_tests {
+mod tumbling_window_union_tests {
     use super::*;
 
-    fn pane(start: i64, end: i64) -> SelectionBox {
+    fn tumbling_window(start: i64, end: i64) -> SelectionBox {
         SelectionBox {
             relative_time: Some((Bound::Excluded(start), Bound::Included(end))),
             ..Default::default()
@@ -1310,9 +1310,12 @@ mod pane_union_tests {
     }
 
     #[test]
-    fn large_reverse_ordered_pane_union_is_one_exact_interval() {
-        let panes: Vec<_> = (0..75_000).rev().map(|i| pane(i, i + 1)).collect();
-        assert_eq!(union(panes), vec![pane(0, 75_000)]);
+    fn large_reverse_ordered_tumbling_window_union_is_one_exact_interval() {
+        let tumbling_windows: Vec<_> = (0..75_000)
+            .rev()
+            .map(|i| tumbling_window(i, i + 1))
+            .collect();
+        assert_eq!(union(tumbling_windows), vec![tumbling_window(0, 75_000)]);
     }
 
     #[test]
@@ -1362,20 +1365,28 @@ mod pane_union_tests {
     #[test]
     fn sorted_union_preserves_gaps_boundaries_and_original_group_order() {
         assert_eq!(
-            union(vec![pane(10, 11), pane(1, 2), pane(0, 1), pane(11, 12)]),
-            vec![pane(10, 12), pane(0, 2)]
+            union(vec![
+                tumbling_window(10, 11),
+                tumbling_window(1, 2),
+                tumbling_window(0, 1),
+                tumbling_window(11, 12)
+            ]),
+            vec![tumbling_window(10, 12), tumbling_window(0, 2)]
         );
         let missing_endpoint = SelectionBox {
             relative_time: Some((Bound::Excluded(0), Bound::Excluded(1))),
             ..Default::default()
         };
         assert_eq!(
-            union(vec![missing_endpoint.clone(), pane(1, 2)]),
-            vec![missing_endpoint, pane(1, 2)]
+            union(vec![missing_endpoint.clone(), tumbling_window(1, 2)]),
+            vec![missing_endpoint, tumbling_window(1, 2)]
         );
-        let overlaps = vec![pane(0, 2), pane(1, 3)];
+        let overlaps = vec![tumbling_window(0, 2), tumbling_window(1, 3)];
         assert!(union_ordered_time_boxes(&overlaps).is_none());
         assert_eq!(union(overlaps.clone()), overlaps);
-        assert_eq!(union(vec![pane(0, 1), pane(0, 1)]), vec![pane(0, 1)]);
+        assert_eq!(
+            union(vec![tumbling_window(0, 1), tumbling_window(0, 1)]),
+            vec![tumbling_window(0, 1)]
+        );
     }
 }
diff --git a/crates/types/src/ir/properties/timing.rs b/crates/types/src/ir/properties/timing.rs
index 2695eee6b..af8bbc152 100644
--- a/crates/types/src/ir/properties/timing.rs
+++ b/crates/types/src/ir/properties/timing.rs
@@ -8,7 +8,7 @@
 //! `MatAtQueryKeptAcrossEvaluations(medium)`.
 //! [`MaterializationAssignment`] records that option per sub-DAG, named by
 //! the node whose output would be stored (any node: a summary state, a
-//! population, or e.g. the tumbling-window panes of #509 Example 4), and
+//! population, or e.g. the tumbling windows of #509 Example 4), and
 //! [`apply_materialization_timings`] expands it into a timing on every node:
 //!
 //! - `SummaryEstimate` and `EvaluatePopulation` run at query time;
@@ -1218,10 +1218,10 @@ mod tests {
     /// can only run at query time cannot be stored at ingestion time.
     #[test]
     fn any_node_may_be_materialized() {
-        let panes = max(scan());
-        let root = max(Rc::clone(&panes));
+        let tumbling_windows = max(scan());
+        let root = max(Rc::clone(&tumbling_windows));
         let mut assignment = MaterializationAssignment::default();
-        assignment.set(&panes, AT_INGESTION);
+        assignment.set(&tumbling_windows, AT_INGESTION);
         let timed =
             apply_materialization_timings(&root, &assignment, &mut NodeToTimedNodeCache::new())
                 .unwrap();
diff --git a/crates/types/src/ir/schema/family_capability.rs b/crates/types/src/ir/schema/family_capability.rs
index 0a79b6a81..6af62d919 100644
--- a/crates/types/src/ir/schema/family_capability.rs
+++ b/crates/types/src/ir/schema/family_capability.rs
@@ -159,7 +159,7 @@ impl FamilyCapability {
                 // reset handling (`IncreaseAccumulator::merge_pair`).
                 E::Rate | E::Increase => (Some(DisjointInTime), &[]),
                 // IRate reads the last two samples of the window, which a
-                // pane does not keep across its boundary.
+                // tumbling window does not keep across its boundary.
                 E::IRate => (None, &[]),
             },
             // A Hydra answers per subpopulation from a shared grid of the
diff --git a/crates/types/src/physical/materialization.rs b/crates/types/src/physical/materialization.rs
index b6da9e367..e30e192b3 100644
--- a/crates/types/src/physical/materialization.rs
+++ b/crates/types/src/physical/materialization.rs
@@ -28,8 +28,8 @@ pub enum Materialization {
     /// queries of the same evaluation and discarded after it.
     MatAtQuery(Medium),
     /// Runs at query time and keeps its output across evaluations: a
-    /// tumbling-pane chain whose readers evaluate together every pane
-    /// width builds its newest pane at each evaluation and keeps the older
+    /// tumbling-window chain whose readers evaluate together every tumbling window
+    /// width builds its newest tumbling window at each evaluation and keeps the older
     /// ones for the next (#509 Example 4's B3). Offered only when the
     /// deployment keeps query-time results.
     MatAtQueryKeptAcrossEvaluations(Medium),
diff --git a/crates/types/src/stages/candidates.rs b/crates/types/src/stages/candidates.rs
index 99af7d4c3..6ccf47f87 100644
--- a/crates/types/src/stages/candidates.rs
+++ b/crates/types/src/stages/candidates.rs
@@ -54,7 +54,7 @@ pub enum OriginOfCandidateForMemoGroup {
     SummaryResult,
     /// Canonical value preprocessing feeding a summary build.
     SummaryInput,
-    /// Tumbling panes, or the newest panes of another group's chain.
+    /// Tumbling windows, or the newest tumbling windows of another group's chain.
     TumblingWindows,
     /// A coarse group regrouping a finer group.
     Rollup,
diff --git a/crates/types/src/stages/physical/memo_candidates.rs b/crates/types/src/stages/physical/memo_candidates.rs
index 6c253837e..454e6e49c 100644
--- a/crates/types/src/stages/physical/memo_candidates.rs
+++ b/crates/types/src/stages/physical/memo_candidates.rs
@@ -78,9 +78,9 @@ pub struct PhysicalCandidate {
     /// query time whose output matches its group's logical node, in a group
     /// some query's root reads.
     pub may_produce_query_output: bool,
-    /// One entry per workload query: whether this pane chain may be kept
+    /// One entry per workload query: whether this tumbling-window chain may be kept
     /// across evaluations when that query is its only reader. Filled only
-    /// for a `MatAtQueryKeptAcrossEvaluations(Memory)` pane chain in a
+    /// for a `MatAtQueryKeptAcrossEvaluations(Memory)` tumbling-window chain in a
     /// deployment that keeps query-time results; empty otherwise.
     pub may_keep_across_evaluations_per_sole_reader_query: Vec<bool>,
 }
diff --git a/crates/types/src/stages/realizer.rs b/crates/types/src/stages/realizer.rs
index 7b0fa8582..8c2ff17d6 100644
--- a/crates/types/src/stages/realizer.rs
+++ b/crates/types/src/stages/realizer.rs
@@ -33,23 +33,23 @@ impl From<&str> for PhysicalCandidateError {
 }
 
 /// A realized selection (was `SelectedPhysicalCandidate`): the physical
-/// plan Stage 2 built for it, how long each kept pane chain of that plan
-/// keeps its panes, and the operator node each selected node became.
+/// plan Stage 2 built for it, how long each kept tumbling-window chain of that plan
+/// keeps its tumbling windows, and the operator node each selected node became.
 #[derive(Debug, Clone)]
 pub struct RealizedPlan {
     /// The selection rebuilt as one physical plan, one operator node per
     /// selected node, each with its candidate's timing and materialization.
     pub plan: PhysicalWorkloadPlan,
-    /// For each tumbling-pane chain of `plan` kept beyond one evaluation
+    /// For each tumbling-window chain of `plan` kept beyond one evaluation
     /// (maintained at ingestion time, or built at query time and kept
     /// across evaluations), by node id in `plan.dag`: how far back from the
-    /// newest evaluation the runtime must keep its completed panes, in
-    /// milliseconds. It is how far its panes reach back: the offset its
-    /// newest pane ends before the evaluation (`[60m] offset 10m`: 10 min),
+    /// newest evaluation the runtime must keep its completed tumbling windows, in
+    /// milliseconds. It is how far its tumbling windows reach back: the offset its
+    /// newest tumbling window ends before the evaluation (`[60m] offset 10m`: 10 min),
     /// plus the chain's window, plus the longest range-evaluation span of
     /// its readers, so the earliest step of the next request still finds
-    /// its panes; without an offset or range evaluations, just the window.
-    /// Empty when the plan keeps no panes.
+    /// its tumbling windows; without an offset or range evaluations, just the window.
+    /// Empty when the plan keeps no tumbling windows.
     pub tumbling_window_retention_ms: BTreeMap<PhysicalASAPNodeId, u64>,
     /// The operator node of `plan` each selected node became, indexed by
     /// [`SelectedNodeId`](super::SelectedNodeId).
diff --git a/crates/types/src/test_support.rs b/crates/types/src/test_support.rs
index 755bb2326..14b13add4 100644
--- a/crates/types/src/test_support.rs
+++ b/crates/types/src/test_support.rs
@@ -8,7 +8,9 @@ use std::time::Instant;
 use crate::ir::materialized_view::RawDataWindow;
 use crate::ir::operator::maintained_population::CurrentSeriesInput;
 use crate::ir::operator::node::Operator;
-use crate::ir::operator::pane_chain::{PaneChainExpansion, PaneChainExpansionError};
+use crate::ir::operator::tumbling_window_chain::{
+    TumblingWindowChainExpansion, TumblingWindowChainExpansionError,
+};
 use crate::ir::physical_export::{PhysicalASAPCompilationError, PhysicalASAPDAGCompilation};
 use crate::ir::properties::summary_coverage::SummaryCoverage;
 use crate::ir::properties::timing::NodeToTimedNodeCache;
@@ -23,22 +25,27 @@ pub fn definition_id(coverage: &SummaryCoverage) -> String {
     coverage.definition_id()
 }
 
-/// `pane_chain::whole_window_build`.
+/// `tumbling_window_chain::whole_window_build`.
 pub fn whole_window_build(chain: &OperatorNode) -> Result<OperatorNode, SchemaDerivationError> {
-    crate::ir::operator::pane_chain::whole_window_build(chain)
+    crate::ir::operator::tumbling_window_chain::whole_window_build(chain)
 }
 
-/// `pane_chain::pane`.
-pub fn pane(chain: &OperatorNode, index: u32) -> Result<OperatorNode, SchemaDerivationError> {
-    crate::ir::operator::pane_chain::pane(chain, index)
+/// `tumbling_window_chain::tumbling_window`.
+pub fn tumbling_window(
+    chain: &OperatorNode,
+    index: u32,
+) -> Result<OperatorNode, SchemaDerivationError> {
+    crate::ir::operator::tumbling_window_chain::tumbling_window(chain, index)
 }
 
-/// `pane_chain::expand_pane_chains_in_workload_before`.
-pub fn expand_pane_chains_in_workload_before(
+/// `tumbling_window_chain::expand_tumbling_window_chains_in_workload_before`.
+pub fn expand_tumbling_window_chains_in_workload_before(
     roots: &[QueryRoot],
     deadline: Option<Instant>,
-) -> Result<PaneChainExpansion, PaneChainExpansionError> {
-    crate::ir::operator::pane_chain::expand_pane_chains_in_workload_before(roots, deadline)
+) -> Result<TumblingWindowChainExpansion, TumblingWindowChainExpansionError> {
+    crate::ir::operator::tumbling_window_chain::expand_tumbling_window_chains_in_workload_before(
+        roots, deadline,
+    )
 }
 
 /// `physical_export::compile_physical_asap_dag_with_node_ids`.
diff --git a/crates/types/src/workload/bounds.rs b/crates/types/src/workload/bounds.rs
index 4b61a6257..a50afb0ed 100644
--- a/crates/types/src/workload/bounds.rs
+++ b/crates/types/src/workload/bounds.rs
@@ -364,7 +364,7 @@ fn at_most_one_row(node: &OperatorNode) -> bool {
             group_by: Some(keys),
             ..
         }) => keys.is_empty(),
-        // A merge gives one state per group, whatever the panes it merges.
+        // A merge gives one state per group, whatever the tumbling windows it merges.
         Operator::ASAP(ASAPOp::SummaryMerge { .. }) => matches!(
             node.summary_build(),
             Some(
diff --git a/crates/types/src/workload/mod.rs b/crates/types/src/workload/mod.rs
index aeb1d4299..fe7dec720 100644
--- a/crates/types/src/workload/mod.rs
+++ b/crates/types/src/workload/mod.rs
@@ -363,7 +363,7 @@ pub struct QueryWorkloadEntry {
     pub recurrence: QueryRecurrence,
     /// How each run is answered as a range request, one evaluation per
     /// step; `None` (the default) for one evaluation per run. Stage 1 and
-    /// Stage 2 keep pane widths on its step grid, and Stage 3 prices
+    /// Stage 2 keep tumbling-window widths on its step grid, and Stage 3 prices
     /// [`RangeEvaluation::evaluations_per_request`] evaluations per run.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub range_evaluation: Option<RangeEvaluation>,
@@ -561,7 +561,7 @@ pub struct SourceFacts {
     pub stream_norms: Option<StreamNorms>,
     /// Upper bound on the distinct items any one distinct-count summary over
     /// the source's own rows counts in one complete evaluation, including
-    /// every merged pane. One bound serves every query over the source, so
+    /// every merged tumbling window. One bound serves every query over the source, so
     /// it must hold for the longest evaluation window any of them uses; a
     /// filter or a shorter window only lowers it. Each group's own items
     /// count separately: the bound is per output row. The deployment must
diff --git a/crates/types/tests/main.rs b/crates/types/tests/main.rs
index efea99601..e95aeb9cf 100644
--- a/crates/types/tests/main.rs
+++ b/crates/types/tests/main.rs
@@ -3,11 +3,11 @@
 //! One file: `cargo test -p asap-types --test types <file>::`.
 
 mod materialized_view;
-mod pane_chain;
 mod physical_export;
 mod planner_vocabulary;
 mod schema_rebuilding;
 mod structure_contract;
 mod summary_coverage;
 mod summary_merge_structure;
+mod tumbling_window_chain;
 mod workload_compatibility;
diff --git a/crates/types/tests/materialized_view.rs b/crates/types/tests/materialized_view.rs
index 40e58273d..2e51ec49f 100644
--- a/crates/types/tests/materialized_view.rs
+++ b/crates/types/tests/materialized_view.rs
@@ -1,5 +1,5 @@
 //! A DAG's materialized views and their retention
-//! (`asap_types::ir::materialized_view`): two one-minute KLL panes of `m`
+//! (`asap_types::ir::materialized_view`): two one-minute KLL tumbling windows of `m`
 //! kept at ingestion, merged into a view refreshed on first read.
 
 use std::collections::HashMap;
@@ -10,7 +10,7 @@ use asap_types::ir::materialized_view::{
     InstallableDagError, MaterializedViewRefresh, RefreshWindow,
 };
 use asap_types::ir::operator::operator_properties::{Reduction, Source};
-use asap_types::ir::operator::pane_chain::expand_pane_chains_in_workload;
+use asap_types::ir::operator::tumbling_window_chain::expand_tumbling_window_chains_in_workload;
 use asap_types::ir::operator::TimeShift;
 use asap_types::ir::physical_export::{
     compile_physical_asap_dag, compile_physical_asap_workload, PhysicalASAPDAG,
@@ -28,7 +28,7 @@ use asap_types::ir::{
 use asap_types::physical::{Materialization, Medium};
 
 /// A KLL of `m`'s values over `(T - shift - 1 min, T - shift]`.
-fn pane(scan: &Rc<OperatorNode>, shift_ms: i64) -> Rc<OperatorNode> {
+fn tumbling_window(scan: &Rc<OperatorNode>, shift_ms: i64) -> Rc<OperatorNode> {
     let shifted = OperatorNode::new_shared(Operator::NonASAP(NonASAPOp::TimeShift {
         shift: TimeShift {
             offset_ms: shift_ms,
@@ -81,20 +81,23 @@ fn scan_m() -> Rc<OperatorNode> {
     .unwrap()
 }
 
-/// The panes at offsets 0 and 1 min kept at ingestion, their merge kept
+/// The tumbling windows at offsets 0 and 1 min kept at ingestion, their merge kept
 /// across evaluations, exported: `(dag, merge's node id)`.
-fn panes_and_kept_merge() -> (PhysicalASAPDAG, usize) {
+fn tumbling_windows_and_kept_merge() -> (PhysicalASAPDAG, usize) {
     let scan = scan_m();
-    let panes = [pane(&scan, 0), pane(&scan, 60_000)];
+    let tumbling_windows = [tumbling_window(&scan, 0), tumbling_window(&scan, 60_000)];
     let merge = OperatorNode::new_shared(Operator::ASAP(ASAPOp::SummaryMerge {
-        children: panes.to_vec(),
+        children: tumbling_windows.to_vec(),
         newest_tumbling_windows: None,
         group_by: None,
     }))
     .unwrap();
     let mut assignment = MaterializationAssignment::default();
-    for pane in &panes {
-        assignment.set(pane, Materialization::MatAtIngestion(Medium::Memory));
+    for tumbling_window in &tumbling_windows {
+        assignment.set(
+            tumbling_window,
+            Materialization::MatAtIngestion(Medium::Memory),
+        );
     }
     assignment.set(
         &merge,
@@ -112,7 +115,7 @@ fn panes_and_kept_merge() -> (PhysicalASAPDAG, usize) {
 /// materialized views to list.
 #[test]
 fn a_view_without_retention_is_refused() {
-    let (dag, _) = panes_and_kept_merge();
+    let (dag, _) = tumbling_windows_and_kept_merge();
     assert!(matches!(
         dag.materialized_views(),
         Err(InstallableDagError::ViewWithoutRetention { .. })
@@ -120,34 +123,41 @@ fn a_view_without_retention_is_refused() {
 }
 
 /// The merge, refreshed on first read for each step of a one-hour range,
-/// is kept for its two minutes plus the hour; each pane it reads is kept
+/// is kept for its two minutes plus the hour; each tumbling window it reads is kept
 /// that long too, since the merge may be refreshed for its oldest step.
-/// The panes read `m` at ingestion, so no raw data is kept for queries.
+/// The tumbling windows read `m` at ingestion, so no raw data is kept for queries.
 #[test]
 fn retention_propagates_from_a_view_refreshed_on_first_read_to_its_inputs() {
-    let (mut dag, merge_id) = panes_and_kept_merge();
+    let (mut dag, merge_id) = tumbling_windows_and_kept_merge();
     let spans = HashMap::from([(merge_id, 3_600_000)]);
     dag.set_retention(&HashMap::new(), &spans, None).unwrap();
     let views = dag.materialized_views().unwrap();
-    let (merge, panes) = views.split_last().unwrap();
+    let (merge, tumbling_windows) = views.split_last().unwrap();
     assert_eq!(merge.node_id, merge_id);
     assert_eq!(merge.refresh(), MaterializedViewRefresh::OnFirstRead);
     assert_eq!(merge.retention_ms(), 120_000 + 3_600_000);
-    assert_eq!(panes.len(), 2);
-    for pane in panes {
-        assert_eq!(pane.refresh(), MaterializedViewRefresh::AtIngestion);
-        assert_eq!(pane.retention_ms(), merge.retention_ms());
-        let node = dag.nodes.iter().find(|n| n.id == pane.node_id).unwrap();
-        assert_eq!(node.retention_ms, Some(pane.retention_ms()));
+    assert_eq!(tumbling_windows.len(), 2);
+    for tumbling_window in tumbling_windows {
+        assert_eq!(
+            tumbling_window.refresh(),
+            MaterializedViewRefresh::AtIngestion
+        );
+        assert_eq!(tumbling_window.retention_ms(), merge.retention_ms());
+        let node = dag
+            .nodes
+            .iter()
+            .find(|n| n.id == tumbling_window.node_id)
+            .unwrap();
+        assert_eq!(node.retention_ms, Some(tumbling_window.retention_ms()));
     }
     assert_eq!(dag.raw_data_retention().unwrap(), []);
 }
 
-/// A view kept for less than its data reaches back (the older pane, which
+/// A view kept for less than its data reaches back (the older tumbling window, which
 /// reaches 2 minutes back, kept for 1 minute) is refused.
 #[test]
 fn a_view_kept_shorter_than_its_reach_is_refused() {
-    let (mut dag, _) = panes_and_kept_merge();
+    let (mut dag, _) = tumbling_windows_and_kept_merge();
     let views = dag
         .set_retention(&HashMap::new(), &HashMap::new(), None)
         .unwrap();
@@ -176,7 +186,7 @@ fn a_view_kept_shorter_than_its_reach_is_refused() {
 /// An expired deadline stops the derivation.
 #[test]
 fn the_derivation_stops_at_its_deadline() {
-    let (mut dag, _) = panes_and_kept_merge();
+    let (mut dag, _) = tumbling_windows_and_kept_merge();
     assert_eq!(
         dag.set_retention(
             &HashMap::new(),
@@ -199,7 +209,7 @@ fn quantile_sketch(algorithm: SketchAlgorithm) -> FieldDataType {
     FieldDataType::Sketch(SketchKind::new(algorithm, params), Default::default())
 }
 
-/// `tumbling_window_count` panes of `tumbling_window_width_ms` of `family` per `job` over `input`.
+/// `tumbling_window_count` tumbling windows of `tumbling_window_width_ms` of `family` per `job` over `input`.
 fn chain(
     input: &Rc<OperatorNode>,
     family: FieldDataType,
@@ -220,9 +230,9 @@ fn chain(
 }
 
 /// Three queries over one `Scan` of `m`, each merging a chain kept at
-/// ingestion: a KLL of six 10 s panes, a DDSketch of thirty 10 s panes, and
-/// a KLL of five 60 s panes. The DAG Stage 3 costs (chains unexpanded) and
-/// the installed DAG (chains expanded into panes, retention set).
+/// ingestion: a KLL of six 10 s tumbling windows, a DDSketch of thirty 10 s tumbling windows, and
+/// a KLL of five 60 s tumbling windows. The DAG Stage 3 costs (chains unexpanded) and
+/// the installed DAG (chains expanded into tumbling windows, retention set).
 fn three_chains_over_one_scan() -> (PhysicalASAPDAG, PhysicalASAPDAG) {
     let scan = scan_m();
     let chains = [
@@ -252,7 +262,7 @@ fn three_chains_over_one_scan() -> (PhysicalASAPDAG, PhysicalASAPDAG) {
         .collect();
     let timed = apply_materialization_timings_to_roots(&roots, &assignment).unwrap();
     let unexpanded = compile_physical_asap_workload(&timed).unwrap();
-    let expanded = expand_pane_chains_in_workload(&timed).unwrap();
+    let expanded = expand_tumbling_window_chains_in_workload(&timed).unwrap();
     let mut installed = compile_physical_asap_workload(&expanded.roots).unwrap();
     installed
         .set_retention(&HashMap::new(), &HashMap::new(), None)
@@ -260,8 +270,8 @@ fn three_chains_over_one_scan() -> (PhysicalASAPDAG, PhysicalASAPDAG) {
     (unexpanded, installed)
 }
 
-/// The width and sketch of the panes `node` of `dag` builds.
-fn pane_shape(dag: &PhysicalASAPDAG, node: usize) -> (u64, SketchAlgorithm) {
+/// The width and sketch of the tumbling windows `node` of `dag` builds.
+fn tumbling_window_shape(dag: &PhysicalASAPDAG, node: usize) -> (u64, SketchAlgorithm) {
     let payload = &dag.nodes.iter().find(|n| n.id == node).unwrap().payload;
     let (family, width_ms) = match payload {
         Operator::ASAP(ASAPOp::SummaryTumblingWindowChain {
@@ -272,11 +282,11 @@ fn pane_shape(dag: &PhysicalASAPDAG, node: usize) -> (u64, SketchAlgorithm) {
         Operator::ASAP(ASAPOp::SummaryAgg { family, child, .. }) => {
             let range = &dag.nodes.iter().find(|n| n.id == *child).unwrap().payload;
             let Operator::NonASAP(NonASAPOp::TimeRange { range, .. }) = range else {
-                panic!("a pane reads a TimeRange")
+                panic!("a tumbling window reads a TimeRange")
             };
             (family, range.as_millis() as u64)
         }
-        other => panic!("not a pane: {other:?}"),
+        other => panic!("not a tumbling window: {other:?}"),
     };
     let FieldDataType::Sketch(kind, _) = family else {
         panic!("a sketch")
@@ -284,10 +294,10 @@ fn pane_shape(dag: &PhysicalASAPDAG, node: usize) -> (u64, SketchAlgorithm) {
     (width_ms, *kind.algorithm())
 }
 
-/// A chain kept at ingestion has its newest pane's refresh window on the
-/// DAG Stage 3 costs, and each of its expanded panes has the same one.
+/// A chain kept at ingestion has its newest tumbling window's refresh window on the
+/// DAG Stage 3 costs, and each of its expanded tumbling windows has the same one.
 #[test]
-fn a_chain_and_each_of_its_panes_have_one_refresh_window() {
+fn a_chain_and_each_of_its_tumbling_windows_have_one_refresh_window() {
     let (unexpanded, installed) = three_chains_over_one_scan();
     let window_of = |width_ms| RefreshWindow {
         width_ms,
@@ -306,13 +316,13 @@ fn a_chain_and_each_of_its_panes_have_one_refresh_window() {
         .collect();
     assert_eq!(chains.len(), 3);
     for chain in chains {
-        let (width_ms, _) = pane_shape(&unexpanded, chain);
+        let (width_ms, _) = tumbling_window_shape(&unexpanded, chain);
         assert_eq!(unexpanded.refresh_window(chain), Some(window_of(width_ms)));
     }
     let views = installed.materialized_views().unwrap();
     assert_eq!(views.len(), 6 + 30 + 5);
     for view in &views {
-        let (width_ms, _) = pane_shape(&installed, view.node_id);
+        let (width_ms, _) = tumbling_window_shape(&installed, view.node_id);
         assert_eq!(
             installed.refresh_window(view.node_id),
             Some(window_of(width_ms))
@@ -320,10 +330,10 @@ fn a_chain_and_each_of_its_panes_have_one_refresh_window() {
     }
 }
 
-/// The 10 s KLL and 10 s DDSketch panes are one refresh group, the 60 s
-/// KLL panes another; the merges, at query time, are in none.
+/// The 10 s KLL and 10 s DDSketch tumbling windows are one refresh group, the 60 s
+/// KLL tumbling windows another; the merges, at query time, are in none.
 #[test]
-fn panes_of_one_width_form_one_refresh_group() {
+fn tumbling_windows_of_one_width_form_one_refresh_group() {
     let (_, installed) = three_chains_over_one_scan();
     let groups = installed.ingestion_refresh_groups().unwrap();
     let shapes: Vec<_> = groups
@@ -332,7 +342,7 @@ fn panes_of_one_width_form_one_refresh_group() {
             let mut shapes: Vec<_> = group
                 .views
                 .iter()
-                .map(|view| pane_shape(&installed, view.node_id))
+                .map(|view| tumbling_window_shape(&installed, view.node_id))
                 .collect();
             shapes.sort_by_key(|(width_ms, algorithm)| (*width_ms, format!("{algorithm:?}")));
             shapes.dedup();
@@ -365,20 +375,23 @@ fn panes_of_one_width_form_one_refresh_group() {
     assert_eq!(groups[1].views.len(), 5);
 }
 
-/// A pane whose window ends 30 s after a multiple of its 60 s width (a
+/// A tumbling window whose window ends 30 s after a multiple of its 60 s width (a
 /// `TimeShift(90 s)` below its range) is refreshed on another grid than a
-/// pane at no offset: another refresh group.
+/// tumbling window at no offset: another refresh group.
 #[test]
-fn a_shifted_pane_has_its_own_phase() {
+fn a_shifted_tumbling_window_has_its_own_phase() {
     let scan = scan_m();
-    let panes = [pane(&scan, 0), pane(&scan, 90_000)];
+    let tumbling_windows = [tumbling_window(&scan, 0), tumbling_window(&scan, 90_000)];
     let mut assignment = MaterializationAssignment::default();
-    for pane in &panes {
-        assignment.set(pane, Materialization::MatAtIngestion(Medium::Memory));
+    for tumbling_window in &tumbling_windows {
+        assignment.set(
+            tumbling_window,
+            Materialization::MatAtIngestion(Medium::Memory),
+        );
     }
-    let roots: Vec<QueryRoot> = panes
+    let roots: Vec<QueryRoot> = tumbling_windows
         .iter()
-        .map(|pane| QueryRoot::Operator(Rc::clone(pane)))
+        .map(|tumbling_window| QueryRoot::Operator(Rc::clone(tumbling_window)))
         .collect();
     let timed = apply_materialization_timings_to_roots(&roots, &assignment).unwrap();
     let mut dag = compile_physical_asap_workload(&timed).unwrap();
@@ -435,21 +448,21 @@ fn views_of_unbounded_windows_are_groups_of_their_own() {
     }
 }
 
-/// A rollup across jobs of a pane, both kept at ingestion, reads the pane's
-/// window: one refresh group, the pane listed before the rollup that reads
-/// it, so a run whose roots hold both computes the pane in the run.
+/// A rollup across jobs of a tumbling window, both kept at ingestion, reads the tumbling window's
+/// window: one refresh group, the tumbling window listed before the rollup that reads
+/// it, so a run whose roots hold both computes the tumbling window in the run.
 #[test]
 fn a_view_reading_a_view_of_its_group_follows_it() {
     let scan = scan_m();
-    let pane = pane(&scan, 0);
+    let tumbling_window = tumbling_window(&scan, 0);
     let rollup = OperatorNode::new_shared(Operator::ASAP(ASAPOp::SummaryMerge {
-        children: vec![Rc::clone(&pane)],
+        children: vec![Rc::clone(&tumbling_window)],
         newest_tumbling_windows: None,
         group_by: Some(vec![]),
     }))
     .unwrap();
     let mut assignment = MaterializationAssignment::default();
-    for view in [&pane, &rollup] {
+    for view in [&tumbling_window, &rollup] {
         assignment.set(view, Materialization::MatAtIngestion(Medium::Memory));
     }
     let timed = apply_materialization_timings_to_roots(
@@ -462,11 +475,14 @@ fn a_view_reading_a_view_of_its_group_follows_it() {
         .unwrap();
     let groups = dag.ingestion_refresh_groups().unwrap();
     assert_eq!(groups.len(), 1);
-    let [pane_view, rollup_view] = groups[0].views.as_slice() else {
+    let [tumbling_window_view, rollup_view] = groups[0].views.as_slice() else {
         panic!("{groups:#?}")
     };
     assert_eq!(rollup_view.node_id, dag.roots[0]);
-    assert_eq!(rollup_view.inputs.materialized_views, [pane_view.node_id]);
+    assert_eq!(
+        rollup_view.inputs.materialized_views,
+        [tumbling_window_view.node_id]
+    );
     assert_eq!(
         groups[0].refresh_window,
         Some(RefreshWindow {
@@ -477,10 +493,10 @@ fn a_view_reading_a_view_of_its_group_follows_it() {
 }
 
 /// On the DAG Stage 3 costs (chains unexpanded), a node above a chain has
-/// the window of all the chain's panes: a merge of six 10 s panes, refreshed
+/// the window of all the chain's tumbling windows: a merge of six 10 s tumbling windows, refreshed
 /// at ingestion, has refresh window (60 s, 0).
 #[test]
-fn a_node_above_an_unexpanded_chain_has_the_window_of_its_panes() {
+fn a_node_above_an_unexpanded_chain_has_the_window_of_its_tumbling_windows() {
     let (unexpanded, _) = three_chains_over_one_scan();
     let merge_of_kll_10s = unexpanded.roots[0];
     assert_eq!(
diff --git a/crates/types/tests/physical_export.rs b/crates/types/tests/physical_export.rs
index 158a6edc0..d331e4845 100644
--- a/crates/types/tests/physical_export.rs
+++ b/crates/types/tests/physical_export.rs
@@ -423,7 +423,7 @@ fn exports_summary_over_summary_as_typed_precompute_edges() {
     assert_eq!(dependency.grouping(), GroupingEdgeCompatibility::Identical);
     assert_eq!(
         dependency.window(),
-        WindowEdgeCompatibility::RequiresAlignedPanePhaseOrExactWindowEdgeResidual
+        WindowEdgeCompatibility::RequiresAlignedTumblingWindowPhaseOrExactWindowEdgeResidual
     );
     assert!(matches!(
         dependency.intermediate_schema().fields[0].dtype,
diff --git a/crates/types/tests/planner_vocabulary.rs b/crates/types/tests/planner_vocabulary.rs
index 2873adae5..5f5a6ab7a 100644
--- a/crates/types/tests/planner_vocabulary.rs
+++ b/crates/types/tests/planner_vocabulary.rs
@@ -1,10 +1,11 @@
 use asap_types::ir::physical_export::WindowEdgeCompatibility;
 
 // The renamed window-edge compatibility still reads and emits the deployed
-// wire value. (Pane coverage names are checked in physical-asap-optimization.)
+// wire value. (Tumbling-window coverage names are checked in physical-asap-optimization.)
 #[test]
 fn window_edge_compatibility_names_preserve_wire_values() {
-    let compatibility = WindowEdgeCompatibility::RequiresAlignedPanePhaseOrExactWindowEdgeResidual;
+    let compatibility =
+        WindowEdgeCompatibility::RequiresAlignedTumblingWindowPhaseOrExactWindowEdgeResidual;
     let wire = serde_json::json!("RequiresAlignedPanePhaseOrExactBoundaryResidual");
     assert_eq!(serde_json::to_value(compatibility).unwrap(), wire);
     assert_eq!(
diff --git a/crates/types/tests/summary_coverage.rs b/crates/types/tests/summary_coverage.rs
index b6eb3b525..07357264b 100644
--- a/crates/types/tests/summary_coverage.rs
+++ b/crates/types/tests/summary_coverage.rs
@@ -121,15 +121,15 @@ fn latency_where(pred: ScalarExpr) -> Rc<OperatorNode> {
     kll(filter(table(), pred), "latency")
 }
 
-/// Tumbling pane: `TimeRange(1m)` over `TimeShift(shift)` over `m`.
-fn pane(shift_ms: i64, predicates: Vec<Predicate>) -> Rc<OperatorNode> {
-    kll(pane_rows(shift_ms, predicates), "value")
+/// Tumbling window: `TimeRange(1m)` over `TimeShift(shift)` over `m`.
+fn tumbling_window(shift_ms: i64, predicates: Vec<Predicate>) -> Rc<OperatorNode> {
+    kll(tumbling_window_rows(shift_ms, predicates), "value")
 }
 
-/// Exact counter-increase pane over the same rows as [`pane`].
-fn increase_pane(shift_ms: i64, predicates: Vec<Predicate>) -> Rc<OperatorNode> {
+/// Exact counter-increase tumbling window over the same rows as [`tumbling_window`].
+fn increase_tumbling_window(shift_ms: i64, predicates: Vec<Predicate>) -> Rc<OperatorNode> {
     summary(
-        pane_rows(shift_ms, predicates),
+        tumbling_window_rows(shift_ms, predicates),
         "value",
         FieldDataType::ExactAggregate(ExactKind::Increase, ExactParams::Increase),
     )
@@ -155,7 +155,7 @@ fn window(shift_ms: i64, width_ms: u64) -> Rc<OperatorNode> {
     kll(range, "value")
 }
 
-fn pane_rows(shift_ms: i64, predicates: Vec<Predicate>) -> Rc<OperatorNode> {
+fn tumbling_window_rows(shift_ms: i64, predicates: Vec<Predicate>) -> Rc<OperatorNode> {
     let shifted = OperatorNode::new_shared(Operator::NonASAP(NonASAPOp::TimeShift {
         shift: TimeShift {
             offset_ms: shift_ms,
@@ -303,11 +303,11 @@ fn qualified_columns_stay_distinct() {
     );
 }
 
-/// Panes take their time from `TimeRange` over `TimeShift`: adjacent panes
-/// join, a gap stays two boxes, and the same pane twice overlaps.
+/// Tumbling windows take their time from `TimeRange` over `TimeShift`: adjacent tumbling windows
+/// join, a gap stays two boxes, and the same tumbling window twice overlaps.
 #[test]
-fn time_panes_merge_and_keep_gaps() {
-    let first = pane(0, vec![]);
+fn time_tumbling_windows_merge_and_keep_gaps() {
+    let first = tumbling_window(0, vec![]);
     assert_eq!(
         first.coverage().unwrap().selection()[0].relative_time(),
         relative(-60_000, 0)
@@ -316,12 +316,12 @@ fn time_panes_merge_and_keep_gaps() {
         first.coverage().unwrap().definition().children()[0],
         first.children()[0].children()[0].children()[0]
     ));
-    let joined = merge(vec![first.clone(), pane(60_000, vec![])]).unwrap();
+    let joined = merge(vec![first.clone(), tumbling_window(60_000, vec![])]).unwrap();
     assert_eq!(
         joined.coverage().unwrap().selection(),
         vec![SelectionBox::new(Default::default(), relative(-120_000, 0))]
     );
-    let gapped = merge(vec![first.clone(), pane(120_000, vec![])]).unwrap();
+    let gapped = merge(vec![first.clone(), tumbling_window(120_000, vec![])]).unwrap();
     assert_eq!(gapped.coverage().unwrap().selection().len(), 2);
     assert_eq!(
         rejected(vec![first.clone(), first]),
@@ -331,20 +331,20 @@ fn time_panes_merge_and_keep_gaps() {
     );
 }
 
-/// Counter panes merge only when their time windows are disjoint: states
+/// Counter tumbling-window merge only when their time windows are disjoint: states
 /// disjoint by a label but over the same window would interleave in time.
 #[test]
-fn counter_panes_merge_only_disjoint_in_time() {
+fn counter_tumbling_windows_merge_only_disjoint_in_time() {
     let joined = merge(vec![
-        increase_pane(0, vec![]),
-        increase_pane(60_000, vec![]),
+        increase_tumbling_window(0, vec![]),
+        increase_tumbling_window(60_000, vec![]),
     ])
     .unwrap();
     assert_eq!(
         joined.coverage().unwrap().selection()[0].relative_time(),
         relative(-120_000, 0)
     );
-    let by_job = |job| increase_pane(0, vec![Predicate(eq(2, job))]);
+    let by_job = |job| increase_tumbling_window(0, vec![Predicate(eq(2, job))]);
     assert_eq!(
         rejected(vec![by_job("api"), by_job("web")]),
         CoverageError::InputsOverlap {
@@ -353,33 +353,35 @@ fn counter_panes_merge_only_disjoint_in_time() {
     );
 }
 
-/// A day of one-minute panes (1,440 inputs) merges into one window, in
+/// A day of one-minute tumbling windows (1,440 inputs) merges into one window, in
 /// either order: the inputs' windows are sorted and only neighbours are
-/// compared, so the check is O(n log n), not all pairs. A pane listed
+/// compared, so the check is O(n log n), not all pairs. A tumbling window listed
 /// twice still overlaps.
 #[test]
-fn a_day_of_minute_panes_merges_into_one_window() {
-    const PANES: i64 = 1_440;
-    let day = relative(-PANES * 60_000, 0);
-    let newest_first: Vec<_> = (0..PANES).map(|i| pane(i * 60_000, vec![])).collect();
+fn a_day_of_minute_tumbling_windows_merges_into_one_window() {
+    const TUMBLING_WINDOW_COUNT: i64 = 1_440;
+    let day = relative(-TUMBLING_WINDOW_COUNT * 60_000, 0);
+    let newest_first: Vec<_> = (0..TUMBLING_WINDOW_COUNT)
+        .map(|i| tumbling_window(i * 60_000, vec![]))
+        .collect();
     let oldest_first: Vec<_> = newest_first.iter().rev().cloned().collect();
-    for panes in [newest_first.clone(), oldest_first] {
-        let merged = merge(panes).unwrap();
+    for tumbling_windows in [newest_first.clone(), oldest_first] {
+        let merged = merge(tumbling_windows).unwrap();
         merged.validate_structure().unwrap();
         let coverage = merged.coverage().unwrap();
         let selection = coverage.selection();
         assert_eq!(selection.len(), 1);
         assert_eq!(selection[0].relative_time(), day);
     }
-    let counters: Vec<_> = (0..PANES)
-        .map(|i| increase_pane(i * 60_000, vec![]))
+    let counters: Vec<_> = (0..TUMBLING_WINDOW_COUNT)
+        .map(|i| increase_tumbling_window(i * 60_000, vec![]))
         .collect();
     assert_eq!(
         merge(counters).unwrap().coverage().unwrap().selection()[0].relative_time(),
         day
     );
     let mut repeated = newest_first;
-    repeated.push(pane(30 * 60_000, vec![]));
+    repeated.push(tumbling_window(30 * 60_000, vec![]));
     assert_eq!(
         rejected(repeated),
         CoverageError::InputsOverlap {
@@ -424,7 +426,7 @@ fn a_long_window_spanning_others_is_rejected() {
 /// Label matchers on the scan lift like any filter.
 #[test]
 fn scan_predicates_lift() {
-    let api = pane(0, vec![Predicate(eq(2, "api"))]);
+    let api = tumbling_window(0, vec![Predicate(eq(2, "api"))]);
     let coverage = api.coverage().unwrap();
     assert_eq!(
         coverage.selection()[0].columns()[&column("job")],
@@ -435,7 +437,7 @@ fn scan_predicates_lift() {
         scan.non_asap(),
         Some(NonASAPOp::Scan { predicates, .. }) if predicates.is_empty()
     ));
-    merge(vec![api, pane(0, vec![Predicate(eq(2, "web"))])]).unwrap();
+    merge(vec![api, tumbling_window(0, vec![Predicate(eq(2, "web"))])]).unwrap();
 }
 
 /// Value ranges are selections: `latency < 100` and `latency >= 100` are
@@ -556,12 +558,12 @@ fn merges_nest() {
 #[test]
 fn timing_does_not_block_merges() {
     let ingested = Rc::new(
-        (*pane(60_000, vec![]))
+        (*tumbling_window(60_000, vec![]))
             .clone()
             .with_timing(Some(ExecutionTiming::IngestionTime)),
     );
     let queried = Rc::new(
-        (*pane(0, vec![]))
+        (*tumbling_window(0, vec![]))
             .clone()
             .with_timing(Some(ExecutionTiming::QueryTime)),
     );
@@ -679,7 +681,7 @@ fn partly_lifted_scan_predicates_keep_only_the_rest() {
         semantics: ExprSemantics::Promql,
     };
     let job = |name: &str| {
-        pane(
+        tumbling_window(
             0,
             vec![Predicate(ScalarExpr::BoolAnd(vec![
                 eq(2, name),
@@ -803,24 +805,31 @@ fn equal_definitions_get_equal_ids() {
     let us = latency_where(eq(REGION, "us"));
     let eu = latency_where(eq(REGION, "eu"));
     assert_eq!(id(&us), id(&eu));
-    let ingested = (*pane(0, vec![]))
+    let ingested = (*tumbling_window(0, vec![]))
         .clone()
         .with_timing(Some(ExecutionTiming::IngestionTime));
-    assert_eq!(id(&ingested), id(&pane(60_000, vec![])));
+    assert_eq!(id(&ingested), id(&tumbling_window(60_000, vec![])));
     assert_eq!(id(&ingested).len(), 32);
     let size = kll(filter(table(), eq(REGION, "eu")), "size");
     assert_ne!(id(&size), id(&eu));
-    assert_ne!(id(&pane(0, vec![])), id(&increase_pane(0, vec![])));
-    assert_ne!(id(&pane(0, vec![])), id(&us));
+    assert_ne!(
+        id(&tumbling_window(0, vec![])),
+        id(&increase_tumbling_window(0, vec![]))
+    );
+    assert_ne!(id(&tumbling_window(0, vec![])), id(&us));
 }
 
-/// Six 10-minute panes at offsets 0 to 50 minutes share one definition id,
+/// Six 10-minute tumbling windows at offsets 0 to 50 minutes share one definition id,
 /// each with its own time selection `(-(i + 1) · 10m, -i · 10m]`; their
 /// merge has the same id and the hour as its selection.
 #[test]
-fn panes_of_an_hour_share_one_definition_with_distinct_times() {
-    let panes: Vec<Rc<OperatorNode>> = (0..6).map(|i| window(i * 600_000, 600_000)).collect();
-    let coverages: Vec<_> = panes.iter().map(|pane| coverage_of(pane)).collect();
+fn tumbling_windows_of_an_hour_share_one_definition_with_distinct_times() {
+    let tumbling_windows: Vec<Rc<OperatorNode>> =
+        (0..6).map(|i| window(i * 600_000, 600_000)).collect();
+    let coverages: Vec<_> = tumbling_windows
+        .iter()
+        .map(|tumbling_window| coverage_of(tumbling_window))
+        .collect();
     for (i, coverage) in coverages.iter().enumerate() {
         let i = i as i64;
         assert_eq!(definition_id(coverage), definition_id(&coverages[0]));
@@ -832,7 +841,7 @@ fn panes_of_an_hour_share_one_definition_with_distinct_times() {
             )]
         );
     }
-    let hour = coverage_of(&merge(panes).unwrap());
+    let hour = coverage_of(&merge(tumbling_windows).unwrap());
     assert_eq!(definition_id(&hour), definition_id(&coverages[0]));
     assert_eq!(
         hour.selection(),
@@ -950,7 +959,7 @@ fn a_rollup_covers_the_coarser_build() {
 /// the `job` label covers a build by `job` over the same series.
 #[test]
 fn a_rollup_of_per_series_states_covers_the_build_by_its_labels() {
-    let rows = pane_rows(0, vec![]);
+    let rows = tumbling_window_rows(0, vec![]);
     let job = rows.schema.column_id("job").unwrap();
     let per_series = grouped(rows.clone(), kll_family(), Reduction::PerEntity);
     let state_job = per_series.schema.column_id("job").unwrap();
@@ -983,7 +992,7 @@ fn invalid_rollups_fail_construction() {
         (ExactKind::IRate, ExactParams::IRate),
     ] {
         let state = grouped(
-            pane_rows(0, vec![]),
+            tumbling_window_rows(0, vec![]),
             FieldDataType::ExactAggregate(kind, params),
             Reduction::by(vec![2]),
         );
diff --git a/crates/types/tests/summary_merge_structure.rs b/crates/types/tests/summary_merge_structure.rs
index 938c05d4d..b76ad5cc7 100644
--- a/crates/types/tests/summary_merge_structure.rs
+++ b/crates/types/tests/summary_merge_structure.rs
@@ -65,9 +65,9 @@ fn family_state(family: FieldDataType, region: &str) -> Rc<OperatorNode> {
     }))
     .unwrap()
 }
-/// Two KLL panes compose into one typed logical state without timing assignment.
+/// Two KLL tumbling windows compose into one typed logical state without timing assignment.
 #[test]
-fn compatible_panes_merge_structurally() {
+fn compatible_tumbling_windows_merge_structurally() {
     let root = OperatorNode::new_shared(Operator::ASAP(ASAPOp::SummaryMerge {
         children: vec![state(200, "us"), state(200, "eu")],
         newest_tumbling_windows: None,
@@ -77,7 +77,7 @@ fn compatible_panes_merge_structurally() {
     root.validate_structure().unwrap();
     assert_eq!(root.schema.fields.len(), 1);
 }
-/// An empty merge, raw rows and differently sized state cannot masquerade as compatible panes.
+/// An empty merge, raw rows and differently sized state cannot masquerade as compatible tumbling windows.
 #[test]
 fn incompatible_merge_inputs_fail() {
     for children in [
@@ -189,7 +189,7 @@ fn family_capability_table() {
             Some(MayOverlap),
             vec![],
         ),
-        // Counter panes merge exactly when ordered and disjoint in time.
+        // Counter tumbling-window merge exactly when ordered and disjoint in time.
         (
             exact(ExactKind::Rate, ExactParams::Rate),
             Some(DisjointInTime),
@@ -695,13 +695,13 @@ fn idempotent_families_merge_overlapping_states() {
     }
 }
 
-/// `SummaryMerge` takes the timing of its consumer, and reads pane states
+/// `SummaryMerge` takes the timing of its consumer, and reads tumbling-window states
 /// stored at ingestion time (#509 Example 3/4 Pattern B1) or built at query
-/// time (B2). Merging at ingestion time needs every pane at ingestion time.
+/// time (B2). Merging at ingestion time needs every tumbling window at ingestion time.
 #[test]
 fn summary_merge_timing() {
-    let panes = [state(200, "us"), state(200, "eu")];
-    let root = merge(panes.to_vec()).unwrap();
+    let tumbling_windows = [state(200, "us"), state(200, "eu")];
+    let root = merge(tumbling_windows.to_vec()).unwrap();
     let timings = |assignment: &MaterializationAssignment| {
         let timed =
             apply_materialization_timings(&root, assignment, &mut NodeToTimedNodeCache::new())
@@ -721,16 +721,16 @@ fn summary_merge_timing() {
         (QueryTime, vec![QueryTime, QueryTime])
     );
     let at_ingestion = Materialization::MatAtIngestion(Medium::Memory);
-    let mut stored_panes = MaterializationAssignment::default();
-    for pane in &panes {
-        stored_panes.set(pane, at_ingestion);
+    let mut stored_tumbling_windows = MaterializationAssignment::default();
+    for tumbling_window in &tumbling_windows {
+        stored_tumbling_windows.set(tumbling_window, at_ingestion);
     }
     assert_eq!(
-        timings(&stored_panes),
+        timings(&stored_tumbling_windows),
         (QueryTime, vec![IngestionTime, IngestionTime])
     );
     // A `SummaryAgg` without an assignment runs at query time, so a merge
-    // stored at ingestion time needs its panes there too.
+    // stored at ingestion time needs its tumbling windows there too.
     let mut only_merge = MaterializationAssignment::default();
     only_merge.set(&root, at_ingestion);
     assert!(
diff --git a/crates/types/tests/pane_chain.rs b/crates/types/tests/tumbling_window_chain.rs
similarity index 75%
rename from crates/types/tests/pane_chain.rs
rename to crates/types/tests/tumbling_window_chain.rs
index 48e7d500c..164774b64 100644
--- a/crates/types/tests/pane_chain.rs
+++ b/crates/types/tests/tumbling_window_chain.rs
@@ -1,19 +1,21 @@
-//! A `SummaryTumblingWindowChain` of tumbling panes stands for its panes: it covers what one
+//! A `SummaryTumblingWindowChain` of tumbling windows stands for its tumbling windows: it covers what one
 //! build over its whole window does, and expands into the `SummaryAgg`
-//! panes the executor runs (#509 Pass 2, window-composition rule).
+//! tumbling windows the executor runs (#509 Pass 2, window-composition rule).
 use std::ops::Bound;
 use std::rc::Rc;
 use std::time::Duration;
 
 use asap_types::ir::operator::operator_properties::{Reduction, Source, TimeShift};
-use asap_types::ir::operator::pane_chain::{expand_pane_chains, merged_chain};
+use asap_types::ir::operator::tumbling_window_chain::{
+    expand_tumbling_window_chains, merged_chain,
+};
 use asap_types::ir::scalar::ColumnRef;
 use asap_types::ir::schema::{DataType, Field, FieldDataType, Schema};
 use asap_types::ir::schema::{
     GroupingStrategy, SketchAlgorithm, SketchKind, SketchParams, SketchStatistic, SummaryUpdate,
 };
 use asap_types::ir::{ASAPOp, NonASAPOp, Operator, OperatorNode, TimeRangeKind};
-use asap_types::test_support::{pane, whole_window_build};
+use asap_types::test_support::{tumbling_window, whole_window_build};
 
 const MINUTE: u64 = 60_000;
 
@@ -57,7 +59,7 @@ fn kll() -> FieldDataType {
     )
 }
 
-/// Five 1-min KLL panes per series over `input`.
+/// Five 1-min KLL tumbling windows per series over `input`.
 fn chain(input: Rc<OperatorNode>) -> Rc<OperatorNode> {
     OperatorNode::new_shared(Operator::ASAP(ASAPOp::SummaryTumblingWindowChain {
         child: input,
@@ -92,7 +94,7 @@ fn relative_time(node: &OperatorNode) -> (Bound<i64>, Bound<i64>) {
 /// The merged chain is a state of the build over the whole 5-min window:
 /// the same schema and coverage `(-5m, 0]`, and it validates.
 #[test]
-fn merged_panes_cover_the_whole_window() {
+fn merged_tumbling_windows_cover_the_whole_window() {
     let chain = chain(scan());
     let merged = merge(vec![Rc::clone(&chain)]);
     merged.validate_structure().unwrap();
@@ -113,37 +115,37 @@ fn merged_panes_cover_the_whole_window() {
     );
 }
 
-/// Pane `i` is the build over `(-(i+1)·1m, -i·1m]`, the query's own offset
-/// folded into one shift; the panes are disjoint and tile the window.
+/// Tumbling window `i` is the build over `(-(i+1)·1m, -i·1m]`, the query's own offset
+/// folded into one shift; the tumbling windows are disjoint and tile the window.
 #[test]
-fn each_pane_is_one_shifted_minute() {
+fn each_tumbling_window_is_one_shifted_minute() {
     let offset = 3_600_000;
     let chain = chain(shifted(scan(), offset));
     for i in 0..5 {
-        let pane = pane(&chain, i).unwrap();
+        let tumbling_window = tumbling_window(&chain, i).unwrap();
         let back = offset + i64::from(i) * MINUTE as i64;
         assert_eq!(
-            relative_time(&pane),
+            relative_time(&tumbling_window),
             (
                 Bound::Excluded(-(back + MINUTE as i64)),
                 Bound::Included(-back)
             ),
-            "pane {i}"
+            "tumbling window {i}"
         );
-        let range = pane.children()[0];
+        let range = tumbling_window.children()[0];
         let Some(NonASAPOp::TimeShift { shift, child }) = range.children()[0].non_asap() else {
-            panic!("pane {i} reads a shift")
+            panic!("tumbling window {i} reads a shift")
         };
         assert_eq!(shift.offset_ms, back);
         assert!(matches!(child.non_asap(), Some(NonASAPOp::Scan { .. })));
     }
 }
 
-/// Expansion gives the executor a merge over the five panes, newest first,
+/// Expansion gives the executor a merge over the five tumbling windows, newest first,
 /// which covers what the merged chain does; a chain read without a merge
 /// does not expand.
 #[test]
-fn expansion_merges_the_panes() {
+fn expansion_merges_the_tumbling_windows() {
     let chain = chain(scan());
     let merged = merge(vec![Rc::clone(&chain)]);
     let estimate = OperatorNode::new_shared(Operator::ASAP(ASAPOp::SummaryEstimate {
@@ -151,7 +153,7 @@ fn expansion_merges_the_panes() {
         query: SketchStatistic::Quantile { q: 0.99 },
     }))
     .unwrap();
-    let expanded = expand_pane_chains(&estimate).unwrap();
+    let expanded = expand_tumbling_window_chains(&estimate).unwrap();
     expanded.validate_structure().unwrap();
     assert_eq!(expanded.schema, estimate.schema);
     let Some(ASAPOp::SummaryEstimate { summary_input, .. }) = expanded.asap() else {
@@ -162,19 +164,23 @@ fn expansion_merges_the_panes() {
     };
     assert_eq!(children.len(), 5);
     for (i, child) in children.iter().enumerate() {
-        assert_eq!(**child, pane(&chain, i as u32).unwrap(), "pane {i}");
+        assert_eq!(
+            **child,
+            tumbling_window(&chain, i as u32).unwrap(),
+            "tumbling window {i}"
+        );
     }
     assert_eq!(summary_input.coverage(), merged.coverage());
-    assert!(expand_pane_chains(&chain).is_err());
+    assert!(expand_tumbling_window_chains(&chain).is_err());
 }
 
 /// Expanding a timed chain carries its timing and materialization onto its
-/// panes: a chain materialized at ingestion time expands into panes each
+/// tumbling windows: a chain materialized at ingestion time expands into tumbling windows each
 /// built and stored at ingestion time, over ranges and shifts that run at
 /// ingestion time too, while the merge reading them stays at query time.
-/// An unmaterialized chain expands into query-time panes.
+/// An unmaterialized chain expands into query-time tumbling windows.
 #[test]
-fn expansion_carries_the_chains_timing_onto_its_panes() {
+fn expansion_carries_the_chains_timing_onto_its_tumbling_windows() {
     use asap_types::ir::properties::ExecutionTiming;
     use asap_types::ir::{
         apply_materialization_timings, MaterializationAssignment, NodeToTimedNodeCache,
@@ -196,14 +202,14 @@ fn expansion_carries_the_chains_timing_onto_its_panes() {
         let timed =
             apply_materialization_timings(&estimate, &assignment, &mut NodeToTimedNodeCache::new())
                 .unwrap();
-        let expanded = expand_pane_chains(&timed).unwrap();
+        let expanded = expand_tumbling_window_chains(&timed).unwrap();
         let merged = expanded.children()[0];
         assert_eq!(merged.timing, Some(ExecutionTiming::QueryTime));
         assert_eq!(merged.children().len(), 5);
-        for pane in merged.children() {
-            assert_eq!(pane.timing, Some(timing), "{materialization:?}");
-            assert_eq!(pane.materialization, materialization);
-            for below in OperatorNode::reachable(pane).iter().skip(1) {
+        for tumbling_window in merged.children() {
+            assert_eq!(tumbling_window.timing, Some(timing), "{materialization:?}");
+            assert_eq!(tumbling_window.materialization, materialization);
+            for below in OperatorNode::reachable(tumbling_window).iter().skip(1) {
                 assert_eq!(below.timing, Some(timing), "{}", below.operator.kind_name());
                 assert_eq!(below.materialization, Materialization::NotMaterialized);
             }
@@ -239,26 +245,29 @@ fn a_chain_reads_an_instant_vector() {
     assert!(empty.validate_structure().is_err());
 }
 
-/// Two merges over one chain (two queries reading the same panes) expand
-/// into one set of panes: the same five `SummaryAgg` nodes, not ten.
+/// Two merges over one chain (two queries reading the same tumbling windows) expand
+/// into one set of tumbling windows: the same five `SummaryAgg` nodes, not ten.
 #[test]
-fn merges_over_one_chain_share_its_panes() {
-    use asap_types::ir::operator::pane_chain::expand_pane_chains_in_workload;
+fn merges_over_one_chain_share_its_tumbling_windows() {
+    use asap_types::ir::operator::tumbling_window_chain::expand_tumbling_window_chains_in_workload;
     use asap_types::ir::QueryRoot;
     let shared = chain(scan());
     let roots = [
         QueryRoot::Operator(merge(vec![Rc::clone(&shared)])),
         QueryRoot::Operator(merge(vec![shared])),
     ];
-    let expansion = expand_pane_chains_in_workload(&roots).unwrap();
+    let expansion = expand_tumbling_window_chains_in_workload(&roots).unwrap();
     assert_eq!(expansion.chains.len(), 1);
-    assert_eq!(expansion.chains[0].panes.len(), 5);
+    assert_eq!(expansion.chains[0].tumbling_windows.len(), 5);
     let expanded = expansion.roots;
-    let panes = |root: &QueryRoot| match root {
+    let tumbling_windows = |root: &QueryRoot| match root {
         QueryRoot::Operator(node) => node.children().into_iter().cloned().collect::<Vec<_>>(),
         QueryRoot::Scalar(_) => unreachable!(),
     };
-    let (first, second) = (panes(&expanded[0]), panes(&expanded[1]));
+    let (first, second) = (
+        tumbling_windows(&expanded[0]),
+        tumbling_windows(&expanded[1]),
+    );
     assert_eq!(first.len(), 5);
     assert!(first.iter().zip(&second).all(|(a, b)| Rc::ptr_eq(a, b)));
 }
@@ -272,12 +281,12 @@ fn newest(chain: Rc<OperatorNode>, newest_tumbling_windows: u32) -> Rc<OperatorN
     .unwrap()
 }
 
-/// A merge of the newest 2 of 5 panes is a state of one build over the
+/// A merge of the newest 2 of 5 tumbling windows is a state of one build over the
 /// newest 2 minutes: coverage `(-2m, 0]`, the window build's schema, and
 /// a valid structure.
 #[test]
-fn a_merge_of_the_newest_panes_covers_their_window() {
-    use asap_types::ir::operator::pane_chain::merged_window_build;
+fn a_merge_of_the_newest_tumbling_windows_covers_their_window() {
+    use asap_types::ir::operator::tumbling_window_chain::merged_window_build;
     let partial = newest(chain(scan()), 2);
     partial.validate_structure().unwrap();
     let build = merged_window_build(&partial).unwrap();
@@ -293,10 +302,10 @@ fn a_merge_of_the_newest_panes_covers_their_window() {
     );
 }
 
-/// `newest_tumbling_windows` must name between 1 and fewer than all panes of the one
+/// `newest_tumbling_windows` must name between 1 and fewer than all tumbling windows of the one
 /// chain the merge reads; anything else is rejected.
 #[test]
-fn a_merge_of_the_newest_panes_reads_one_chain_and_fewer_than_all_panes() {
+fn a_merge_of_the_newest_tumbling_windows_reads_one_chain_and_fewer_than_all_tumbling_windows() {
     let chain = chain(scan());
     let build = whole_window_build(&chain).unwrap();
     for (children, newest_tumbling_windows) in [
@@ -315,26 +324,29 @@ fn a_merge_of_the_newest_panes_reads_one_chain_and_fewer_than_all_panes() {
     }
 }
 
-/// A merge of the newest 2 panes and a merge of all 5 over one chain
-/// expand into one set of panes: the partial merge reads the first 2 of
+/// A merge of the newest 2 tumbling windows and a merge of all 5 over one chain
+/// expand into one set of tumbling windows: the partial merge reads the first 2 of
 /// the full merge's 5 nodes, newest first, and the chain lists all 5.
 #[test]
-fn a_merge_of_the_newest_panes_reads_the_first_panes_of_the_chain() {
-    use asap_types::ir::operator::pane_chain::expand_pane_chains_in_workload;
+fn a_merge_of_the_newest_tumbling_windows_reads_the_first_tumbling_windows_of_the_chain() {
+    use asap_types::ir::operator::tumbling_window_chain::expand_tumbling_window_chains_in_workload;
     use asap_types::ir::QueryRoot;
     let shared = chain(scan());
     let roots = [
         QueryRoot::Operator(newest(Rc::clone(&shared), 2)),
         QueryRoot::Operator(merge(vec![shared])),
     ];
-    let expansion = expand_pane_chains_in_workload(&roots).unwrap();
+    let expansion = expand_tumbling_window_chains_in_workload(&roots).unwrap();
     assert_eq!(expansion.chains.len(), 1);
-    assert_eq!(expansion.chains[0].panes.len(), 5);
-    let panes = |root: &QueryRoot| match root {
+    assert_eq!(expansion.chains[0].tumbling_windows.len(), 5);
+    let tumbling_windows = |root: &QueryRoot| match root {
         QueryRoot::Operator(node) => node.children().into_iter().cloned().collect::<Vec<_>>(),
         QueryRoot::Scalar(_) => unreachable!(),
     };
-    let (partial, full) = (panes(&expansion.roots[0]), panes(&expansion.roots[1]));
+    let (partial, full) = (
+        tumbling_windows(&expansion.roots[0]),
+        tumbling_windows(&expansion.roots[1]),
+    );
     assert_eq!((partial.len(), full.len()), (2, 5));
     assert!(partial.iter().zip(&full).all(|(a, b)| Rc::ptr_eq(a, b)));
     for (root, window) in expansion.roots.iter().zip([2, 5]) {
@@ -351,7 +363,7 @@ fn a_merge_of_the_newest_panes_reads_the_first_panes_of_the_chain() {
 /// `newest_tumbling_windows` is left out of the JSON when `None`, and JSON without it
 /// reads as `None`; `Some(n)` round-trips.
 #[test]
-fn newest_panes_serializes_only_when_set() {
+fn newest_tumbling_windows_serializes_only_when_set() {
     let full: ASAPOp<()> = ASAPOp::SummaryMerge {
         children: vec![()],
         newest_tumbling_windows: None,
@@ -370,12 +382,12 @@ fn newest_panes_serializes_only_when_set() {
     assert_eq!(serde_json::from_str::<ASAPOp<()>>(&json).unwrap(), partial);
 }
 
-/// A rollup of a chain's panes to no keys (every series' panes into one
-/// state) is no pane merge, and expansion keeps its keys: the expanded
+/// A rollup of a chain's tumbling windows to no keys (every series' tumbling windows into one
+/// state) is no tumbling-window merge, and expansion keeps its keys: the expanded
 /// rollup covers what the planned one does, one build over the whole
 /// window and every series.
 #[test]
-fn expansion_keeps_a_rollup_of_the_panes() {
+fn expansion_keeps_a_rollup_of_the_tumbling_windows() {
     let chain = chain(scan());
     let rollup = OperatorNode::new_shared(Operator::ASAP(ASAPOp::SummaryMerge {
         children: vec![Rc::clone(&chain)],
@@ -384,7 +396,7 @@ fn expansion_keeps_a_rollup_of_the_panes() {
     }))
     .unwrap();
     assert!(merged_chain(&rollup).is_none());
-    let expanded = expand_pane_chains(&rollup).unwrap();
+    let expanded = expand_tumbling_window_chains(&rollup).unwrap();
     let Some(ASAPOp::SummaryMerge {
         children, group_by, ..
     }) = expanded.asap()
@@ -399,7 +411,7 @@ fn expansion_keeps_a_rollup_of_the_panes() {
     };
     assert_eq!(*reduction, Reduction::by(vec![]));
     // A rollup merges every input state: it reads a merge of the newest
-    // panes, it is not one.
+    // tumbling windows, it is not one.
     assert!(OperatorNode::new(Operator::ASAP(ASAPOp::SummaryMerge {
         children: vec![chain],
         newest_tumbling_windows: Some(2),
@@ -408,11 +420,11 @@ fn expansion_keeps_a_rollup_of_the_panes() {
     .is_err());
 }
 
-/// A rollup reads a merge of the newest panes: every series' newest 2 of 5
-/// panes into one state covers one build by no keys over the newest 2
+/// A rollup reads a merge of the newest tumbling windows: every series' newest 2 of 5
+/// tumbling windows into one state covers one build by no keys over the newest 2
 /// minutes.
 #[test]
-fn a_rollup_of_the_newest_panes_covers_their_window() {
+fn a_rollup_of_the_newest_tumbling_windows_covers_their_window() {
     let rollup = OperatorNode::new_shared(Operator::ASAP(ASAPOp::SummaryMerge {
         children: vec![newest(chain(scan()), 2)],
         newest_tumbling_windows: None,
@@ -435,10 +447,10 @@ fn a_rollup_of_the_newest_panes_covers_their_window() {
 /// typed budget stop, never a malformed chain or a partially successful plan.
 #[test]
 #[ignore = "flaky: depends on a wall-clock deadline (#1067)"]
-fn fine_pane_expansion_stops_at_the_planning_deadline() {
-    use asap_types::ir::operator::pane_chain::PaneChainExpansionError;
+fn fine_tumbling_window_expansion_stops_at_the_planning_deadline() {
+    use asap_types::ir::operator::tumbling_window_chain::TumblingWindowChainExpansionError;
     use asap_types::ir::QueryRoot;
-    use asap_types::test_support::expand_pane_chains_in_workload_before;
+    use asap_types::test_support::expand_tumbling_window_chains_in_workload_before;
     use std::time::Instant;
     let mut op = chain(scan()).operator.clone();
     let Operator::ASAP(ASAPOp::SummaryTumblingWindowChain {
@@ -457,30 +469,30 @@ fn fine_pane_expansion_stops_at_the_planning_deadline() {
     .unwrap()]))];
     let deadline = Instant::now() + Duration::from_millis(1);
     assert!(matches!(
-        expand_pane_chains_in_workload_before(&roots, Some(deadline)),
-        Err(PaneChainExpansionError::DeadlineExceeded)
+        expand_tumbling_window_chains_in_workload_before(&roots, Some(deadline)),
+        Err(TumblingWindowChainExpansionError::DeadlineExceeded)
     ));
 }
 
-/// Supplying ample budget preserves complete expansion and shared pane identity.
+/// Supplying ample budget preserves complete expansion and shared tumbling window identity.
 #[test]
 #[ignore = "flaky: depends on a wall-clock deadline (#1067)"]
-fn budgeted_expansion_preserves_every_pane_and_shared_reader() {
+fn budgeted_expansion_preserves_every_tumbling_window_and_shared_reader() {
     use asap_types::ir::QueryRoot;
-    use asap_types::test_support::expand_pane_chains_in_workload_before;
+    use asap_types::test_support::expand_tumbling_window_chains_in_workload_before;
     use std::time::Instant;
     let shared = chain(scan());
     let roots = [
         QueryRoot::Operator(merge(vec![shared.clone()])),
         QueryRoot::Operator(merge(vec![shared])),
     ];
-    let result = expand_pane_chains_in_workload_before(
+    let result = expand_tumbling_window_chains_in_workload_before(
         &roots,
         Some(Instant::now() + Duration::from_secs(10)),
     )
     .unwrap();
     assert_eq!(result.chains.len(), 1);
-    assert_eq!(result.chains[0].panes.len(), 5);
+    assert_eq!(result.chains[0].tumbling_windows.len(), 5);
     let QueryRoot::Operator(first) = &result.roots[0] else {
         unreachable!()
     };
@@ -495,7 +507,7 @@ fn budgeted_expansion_preserves_every_pane_and_shared_reader() {
 }
 
 /// JSON written before #1163 names the chain `PaneChain`, its fields
-/// `pane_width_ms` and `pane_count`, and a merge's `newest_panes`; it reads
+/// `tumbling_window_width_ms` and `tumbling_window_count`, and a merge's `newest_tumbling_windows`; it reads
 /// as today's operators.
 #[test]
 fn names_before_the_tumbling_window_rename_still_read() {
diff --git a/docs/design_docs/architecture/input-output-workflow.md b/docs/design_docs/architecture/input-output-workflow.md
index ce210cff5..446b5af2c 100644
--- a/docs/design_docs/architecture/input-output-workflow.md
+++ b/docs/design_docs/architecture/input-output-workflow.md
@@ -28,8 +28,8 @@ and [frontend dependencies](#frontend-specific-dependencies).
 
 | Output | Fields or contents | Meaning |
 |---|---|---|
-| `PlanOutput` | `plans`: one `QueryPlan { entry_index, root }` per query; `selection`: Stage 3's `Selection` (`selected_dag`, `nodes_with_proven_non_negative_weights`, `cost`, `accepted_accuracy_per_query`, `pruned_candidates`, `search_report`), set by the default pass `Stage1ToStage3Pass`; `tumbling_window_retention_ms`: how long each kept pane chain keeps its panes; standalone scalar queries in `scalar_roots` and `scalar_plans` | The selected plan; `physical_asap_dag()` exports it as one `PhysicalASAPDAG` |
-| `PlanningRun` (from `asap_planner::run_planning`) | Every stage's output: Pass 1's per-computation candidates, the selected round's Pass 2 and Stage 2 outputs (with Stage 2's pruned candidates), the selection, the selected plan, the memo after each step and a report per pane-width round | For callers that inspect or display the alternatives |
+| `PlanOutput` | `plans`: one `QueryPlan { entry_index, root }` per query; `selection`: Stage 3's `Selection` (`selected_dag`, `nodes_with_proven_non_negative_weights`, `cost`, `accepted_accuracy_per_query`, `pruned_candidates`, `search_report`), set by the default pass `Stage1ToStage3Pass`; `tumbling_window_retention_ms`: how long each kept tumbling-window chain keeps its tumbling windows; standalone scalar queries in `scalar_roots` and `scalar_plans` | The selected plan; `physical_asap_dag()` exports it as one `PhysicalASAPDAG` |
+| `PlanningRun` (from `asap_planner::run_planning`) | Every stage's output: Pass 1's per-computation candidates, the selected round's Pass 2 and Stage 2 outputs (with Stage 2's pruned candidates), the selection, the selected plan, the memo after each step and a report per tumbling-window-width round | For callers that inspect or display the alternatives |
 
 The selected plan is a planning artifact. ASAPPlanner does **not** deploy
 it; downstream systems compile it, choose placement and storage, deploy state
@@ -58,7 +58,7 @@ flowchart TD
     D["data_workload: ingesting; up sampled every 15 s"]
     M["PlanningModels: accuracy model, cost model, deployment capabilities"]
     F["Stage 0: PromQL lowering → one OperatorNode root"]
-    S1["Stage 1: exact accumulator or plain exact; panes"]
+    S1["Stage 1: exact accumulator or plain exact; tumbling windows"]
     S2["Stage 2: each summary build at query time or maintained at ingestion time"]
     S3["Stage 3: check and price every physical candidate; select one"]
     B["Backend: compile, deploy and execute the selected plan"]
@@ -303,7 +303,7 @@ alternative stays visible in `PlanningRun`.
 ```text
 PlanningWorkload + frontend dependencies + PlanningModels
     -> Stage 0: frontend lowering, one root per normalized query entry
-    -> Stage 1: Pass 1 per-computation candidates, Pass 2 sharing, panes, reuse
+    -> Stage 1: Pass 1 per-computation candidates, Pass 2 sharing, tumbling windows, reuse
     -> Stage 2: one physical candidate per materialization assignment
     -> Stage 3: check, measure and select
     -> PlanOutput
diff --git a/docs/design_docs/architecture/physical-plan-integration.md b/docs/design_docs/architecture/physical-plan-integration.md
index 802127598..a9961b710 100644
--- a/docs/design_docs/architecture/physical-plan-integration.md
+++ b/docs/design_docs/architecture/physical-plan-integration.md
@@ -264,7 +264,7 @@ configuration records partition keys, ordering keys, and function work per
 row; evidence supplies the actual partition distribution. Ordering CPU and
 memory use the same per-partition calculation as comparison sort, plus window
 function work for each row. This is **not** a streaming tumbling window,
-sliding window, pane layout, or exponential-histogram window framework.
+sliding window, tumbling-window layout, or exponential-histogram window framework.
 
 ### `Limit { limit, offset }`
 
@@ -293,7 +293,7 @@ the selector in `rate(http_requests_total[5m])` lowers to `PromqlRange` with
 `range_millis = 300000`. Evidence carries series count, evaluation-step count,
 value kind, and the maximum samples in one per-series range. CPU visits every
 input sample; local memory is `series × max_window_samples_per_series ×
-sample_width`. This query-time range buffer is not a tumbling, sliding, pane,
+sample_width`. This query-time range buffer is not a tumbling-window, sliding-window
 or exponential-histogram layout for maintaining a summary.
 
 ### `PromqlSubquery { range_millis, resolution_millis }`
diff --git a/docs/design_docs/architecture/planner-runtime-contract.md b/docs/design_docs/architecture/planner-runtime-contract.md
index c9079b376..69813bc5f 100644
--- a/docs/design_docs/architecture/planner-runtime-contract.md
+++ b/docs/design_docs/architecture/planner-runtime-contract.md
@@ -15,7 +15,7 @@ execution remain downstream. The
 |---|---|---|
 | Logical candidate semantics | ASAPPlanner | Query rewrite; summary family and parameters; grouping; accuracy guarantees when established. |
 | Summary materialization and realization selection | ASAPPlanner Stage 2 materialization (#509) | `NotMaterialized`, `MatAtIngestion(medium)` or `MatAtQuery(medium)` per sub-DAG, and how long a stored output is kept; direct build or incremental update; window implementations compared using provider evidence. |
-| Concrete implementation and deployment | ASAPQuery-backend and its workload optimizer | Library and data-structure implementation, exact pane layout, placement, sharding, storage, transmission, materialization IDs, executor configuration, and workload-wide assignment. |
+| Concrete implementation and deployment | ASAPQuery-backend and its workload optimizer | Library and data-structure implementation, exact tumbling-window layout, placement, sharding, storage, transmission, materialization IDs, executor configuration, and workload-wide assignment. |
 
 ASAPCollector and the ASAPQuery data plane execute the compiled downstream
 plans. They validate capabilities and plan identities, maintain or read the
@@ -27,15 +27,15 @@ a different summary, materialization, or realization framework.
 Once Stage 2 materialization (#509) owns summary-maintenance decisions,
 ASAPPlanner may decide that a logical summary should be incrementally
 maintained: new data updates existing summary state. It may also select the
-planner-visible window realization—such as tumbling, sliding/panes, or an
+planner-visible window realization—such as tumbling windows, sliding windows over tumbling windows, or an
 exponential histogram—because those alternatives have different accuracy,
 CPU, memory, and I/O behavior.
 
 ASAPQuery-backend then implements the selected framework. For example, after
 Planner chooses a sliding-window realization, the backend chooses the concrete
-pane representation, runtime operator implementation, placement, sharding,
+tumbling window representation, runtime operator implementation, placement, sharding,
 watermark behavior, and materialization identifiers. ASAPCollector maintains
-the compiled panes and summary state.
+the compiled tumbling windows and summary state.
 
 Thus incremental update describes how state is maintained, while tumbling,
 sliding, and exponential-histogram describe realization algorithms. They are
diff --git a/docs/design_docs/architecture/updated_interface_with_pluggable_optimization.md b/docs/design_docs/architecture/updated_interface_with_pluggable_optimization.md
index 14236c932..0ba5593fc 100644
--- a/docs/design_docs/architecture/updated_interface_with_pluggable_optimization.md
+++ b/docs/design_docs/architecture/updated_interface_with_pluggable_optimization.md
@@ -91,7 +91,7 @@ pub struct PlanOutput {
     pub scalar_roots: Vec<(usize, ScalarExpr)>,  // standalone scalar entries
     pub scalar_plans: Vec<QueryPlan>,            // the operator sub-DAGs they read
     pub selection: Option<Selection>,            // how plan selection chose, if the pass selects
-    pub tumbling_window_retention_ms: BTreeMap<PhysicalASAPNodeId, u64>, // kept pane chains' retention
+    pub tumbling_window_retention_ms: BTreeMap<PhysicalASAPNodeId, u64>, // kept tumbling-window chains' retention
 }
 
 pub struct QueryPlan {
@@ -125,7 +125,7 @@ tracked in #580.
 | Step | Call |
 |---|---|
 | Prepare roots | Entries in `entries()` order, the accuracy target from each entry's `requirements`; PromQL operator roots carry the series identity (`with_promql_series_identity`) where it has a realization |
-| Stage 1: logical ASAP-aware optimization | `generate_per_computation_logical_memo_candidates` (Pass 1, once), then per pane-width round `generate_logical_asap_memo_candidates` (Pass 2) |
+| Stage 1: logical ASAP-aware optimization | `generate_per_computation_logical_memo_candidates` (Pass 1, once), then per tumbling-window-width round `generate_logical_asap_memo_candidates` (Pass 2) |
 | Stage 2: physical ASAP-aware optimization | `generate_physical_asap_memo_candidates` per round |
 | Stage 3: plan selection | `select_plan` per round: check accuracy and latency, price under the cost model, select one plan; the facade keeps the best round's and builds it with Stage 2's `AssignmentRealizer::realize` |
 
diff --git a/docs/design_docs/concepts/accuracy-models.md b/docs/design_docs/concepts/accuracy-models.md
index ce80d12c7..60aaa2d15 100644
--- a/docs/design_docs/concepts/accuracy-models.md
+++ b/docs/design_docs/concepts/accuracy-models.md
@@ -267,7 +267,7 @@ configuration or candidate is needed.
 `AccuracyEvidenceProvider` supplies estimator contracts, operand domains
 and propagation evidence. The evidence must cover the population to which the
 claimed guarantee applies: sources, filters, grouping, evaluation windows and
-all merged panes. Evidence for a narrower population cannot silently certify
+all merged tumbling windows. Evidence for a narrower population cannot silently certify
 a wider one. Data-workload facts are declared: the planner has no clock, so the caller
 drops facts that no longer hold before planning.
 
@@ -287,7 +287,7 @@ an observation into a guarantee.
 
 A deployment declares `DataWorkload.sources[source].max_distinct_per_evaluation`
 for the source the distinct count reads. It asserts an enforced maximum
-distinct population per evaluation, including all merged panes; the classic
+distinct population per evaluation, including all merged tumbling windows; the classic
 estimator and independent uniform bucket hashing are the model's
 assumptions. Stage 1 sizes the precision from the query or allocated local
 target and leaves the failure probability symbolic, as
diff --git a/docs/design_docs/concepts/planner-pipeline.md b/docs/design_docs/concepts/planner-pipeline.md
index 9294ce0dc..939048f1d 100644
--- a/docs/design_docs/concepts/planner-pipeline.md
+++ b/docs/design_docs/concepts/planner-pipeline.md
@@ -11,7 +11,7 @@ stage.
     Logical DAG (Pre-ASAP IR): exact, language-independent query intent
             | Stage 1: logical ASAP-aware optimization
             |   Pass 1: exact or a summary per computation
-            |   Pass 2: share, split into panes, or reuse across computations
+            |   Pass 2: share, split into tumbling windows, or reuse across computations
             v
     Logical ASAP candidates (Post-ASAP IR, untimed)
             | Stage 2: physical ASAP-aware optimization
diff --git a/docs/design_docs/concepts/post-asap-ir.md b/docs/design_docs/concepts/post-asap-ir.md
index d06555ad8..726f383c3 100644
--- a/docs/design_docs/concepts/post-asap-ir.md
+++ b/docs/design_docs/concepts/post-asap-ir.md
@@ -49,7 +49,7 @@ Implemented:
   union; its coverage check rejects inputs whose selections overlap. With
   `group_by` (a rollup) the output is keyed by those input group columns, and
   each output state merges the input states of its key; `newest_tumbling_windows`
-  merges only the newest panes of one pane chain, never with `group_by`. The timing pass does
+  merges only the newest tumbling windows of one tumbling-window chain, never with `group_by`. The timing pass does
   not place it yet (`ExecutionDataStateError::UnimplementedOperator`).
 
 Reserved (migrated but unimplemented; schema derivation rejects them with
@@ -117,7 +117,7 @@ gives each sub-DAG one of three options: `NotMaterialized`,
 [`MaterializationAssignment`](../../../crates/types/src/ir/properties/timing.rs) records
 the option per sub-DAG, named by the node whose output would be stored. Any
 node may be named: a summary state, a population, or, as in #509 Example 4,
-the tumbling-window panes a query reads. `set(node, materialization)` assigns
+the tumbling windows a query reads. `set(node, materialization)` assigns
 one, and every other sub-DAG is `NotMaterialized`. Choosing the options is
 Stage 2's job (#604); until then the planner materializes nothing.
 `apply_materialization_timings(root, &assignment, &mut NodeToTimedNodeCache)` then writes a
diff --git a/docs/design_docs/physical-planning-and-deployment.md b/docs/design_docs/physical-planning-and-deployment.md
index 7fced770c..cf597bf16 100644
--- a/docs/design_docs/physical-planning-and-deployment.md
+++ b/docs/design_docs/physical-planning-and-deployment.md
@@ -56,10 +56,10 @@ decided by a `MaterializationAssignment`, as the layer contract below states.
    consumers, and the other states run at query time. The default assignment
    is `NotMaterialized` everywhere; `PlanOutput::physical_asap_dag` applies it
    only to nodes the optimization pass left untimed (a pass's own timing, such
-   as Stage 3's ingestion-time panes, is kept).
+   as Stage 3's ingestion-time tumbling windows, is kept).
 3. **Physical compile** (executor) reads the plan's materialized views: each
    view's refresh is one compiled DAG (the precompute DAG) and the query run
-   another, joined by the views. It does not see raw ingestion, panes,
+   another, joined by the views. It does not see raw ingestion, tumbling windows,
    storage or stored-state readout.
 4. **Backend** executes the compiled DAGs, serving raw data and stored views
    through its `DataStore`. A query-time summary requires the deployment to
@@ -150,13 +150,13 @@ deployment canonicalizes; it does not define a stored-definition format.
 
 Suppose p50 and p99 are requested over the same latency samples in a five-minute window,
 and one Planner candidate uses KLL with `k=200`. Assume query windows align with one-minute
-pane boundaries and that the selected parameters satisfy the required guarantees.
+tumbling-window boundaries and that the selected parameters satisfy the required guarantees.
 Operator names below are illustrative; the example defines the design, not a
 claim that the entire deployment integration is implemented.
 
 The data source identifies where samples come from. Filters, grouping and the
-window determine which samples enter each summary. Here `pane_duration: 1m`
-means each stored pane covers one minute; the query range is five minutes.
+window determine which samples enter each summary. Here `tumbling_window_duration: 1m`
+means each stored tumbling window covers one minute; the query range is five minutes.
 Neither duration specifies how often maintenance runs or how long state is kept.
 
 The example evolves through the architecture as follows:
@@ -181,9 +181,9 @@ KLLMerge
 
 KLLBuild(k=200)
   strategy = continuously maintain
-  window   = 1-minute panes
+  window   = 1-minute tumbling windows
   reuse    = p50 + p99
-  query    = merge panes covering requested aligned 5 minutes
+  query    = merge tumbling windows covering requested aligned 5 minutes
 
           │
           │ Physical Plan Compiler
@@ -191,7 +191,7 @@ KLLBuild(k=200)
 
 3. Physical DAGs
 
-Precompute DAG (the pane view's refresh):
+Precompute DAG (the tumbling window view's refresh):
 RawDataSlot<latency> → TimeRange(1m)
         ↓
 NativeKllBuild(k=200)
@@ -199,7 +199,7 @@ NativeKllBuild(k=200)
 KllStateOutput
 
 Query DAG:
-MaterializedViewSlot<KllState>[5 panes]
+MaterializedViewSlot<KllState>[5 tumbling windows]
         ↓
 NativeKllMerge(k=200)
       ┌─┴────────┐
@@ -215,7 +215,7 @@ NativeKllMerge(k=200)
 Precompute:
 OTLP latency source
         ↓
-run KLL build over each complete 1-minute input pane
+run KLL build over each complete 1-minute input tumbling window
         ↓
 store as latency-kll-1m/<window>
 
@@ -228,7 +228,7 @@ return p50 / p99
 ```
 
 Each stage adds a different class of decision while preserving the preceding
-contracts. Here, continuous maintenance means recurring production of pane state;
+contracts. Here, continuous maintenance means recurring production of tumbling-window state;
 the bounded build DAG does not itself implement an unbounded streaming window.
 
 ## 2. Logical Post-ASAP DAG → Materialization
@@ -266,10 +266,10 @@ strategy:
     continuously maintain
 
 window realization:
-    1-minute panes
+    1-minute tumbling windows
 
 query requirement:
-    combine panes covering the requested aligned 5-minute range
+    combine tumbling windows covering the requested aligned 5-minute range
 
 reuse:
     one merged state serves p50 and p99
@@ -281,8 +281,8 @@ It specifies how the selected logical summary should be maintained,
 but not its concrete operator implementation or storage location.
 
 Physical feasibility may feed back into selection. For example, if the required
-pane-based maintenance cannot be implemented, this materialization cannot be
-selected. One-minute panes alone also cannot cover an arbitrarily phased query
+tumbling-window-based maintenance cannot be implemented, this materialization cannot be
+selected. One-minute tumbling windows alone also cannot cover an arbitrarily phased query
 window; that requires supported boundary handling or a different candidate.
 
 ## 3. Materialization → Physical DAG
@@ -330,17 +330,17 @@ NativeKllBuild(k=200)
 KllStateOutput(k=200)
 ```
 
-This DAG refreshes one one-minute pane of the materialized view. Its raw data
+This DAG refreshes one one-minute tumbling window of the materialized view. Its raw data
 slot reads the samples matching the source, filters and group, and its
-`TimeRange` keeps those within the pane. The deployment supplies the samples
+`TimeRange` keeps those within the tumbling window. The deployment supplies the samples
 through its `DataStore` (§4).
 
 ### Query Physical DAG
 
 ```text
-MaterializedViewSlot<KllState> × 5 (pane i, i = 0..4)(
+MaterializedViewSlot<KllState> × 5 (tumbling window i, i = 0..4)(
     k = 200,
-    read_materialized_view(pane_i, (T - i·1m - 1m, T - i·1m])
+    read_materialized_view(tumbling_window_i, (T - i·1m - 1m, T - i·1m])
 )
         ↓
 NativeKllMerge(k=200)
@@ -410,7 +410,7 @@ the check, whether the view is refreshed at ingestion or on first read, so
 query's evaluation time (`Scope::Query`); it has no value in an ingestion run.
 
 A trailing window is a range `TimeRange(w)` over any `TimeShift`s (a tumbling
-pane adds them, offsets summing to `s`) over a `Scan`. At evaluation time
+tumbling window adds them, offsets summing to `s`) over a `Scan`. At evaluation time
 `T` it keeps the rows whose time lies in `(T - s - w, T - s]`, which is the
 window a PromQL range selector reads and a SQL filter against `now()`. Each
 `TimeShift` passes the rows through. The same operator serves a SQL table and
@@ -490,9 +490,9 @@ the plan, not inside it.
 
 `raw_data_retention()` is the per-source maximum over these scans. Example: for
 `max_over_time(m[5m])` evaluated over the last hour, raw `m` is kept 65
-minutes, because refreshing the pane for the oldest step reads that far back.
-A pane chain kept across evaluations counts as all its panes. Reusing a pane is
-optional for a runtime, and a restart or an older step rebuilds older panes
+minutes, because refreshing the tumbling window for the oldest step reads that far back.
+A tumbling-window chain kept across evaluations counts as all its tumbling windows. Reusing a tumbling window is
+optional for a runtime, and a restart or an older step rebuilds older tumbling windows
 from raw data.
 
 ### Input slots and compilation
@@ -592,8 +592,8 @@ Two views refreshed at ingestion can be built in one ingestion run, with the
 run's interval equal to each one's window, exactly when they have the same
 **refresh window**: windows of width `W` that end `p` after a multiple of `W`
 (`0 ≤ p < W`), relative to the evaluation time. A view whose `view_window` is
-`(T - o - W, T - o]` has the refresh window `(W, o mod W)`. All panes of a
-pane chain have their newest pane's refresh window. The source, the summary
+`(T - o - W, T - o]` has the refresh window `(W, o mod W)`. All tumbling windows of a
+tumbling-window chain have their newest tumbling window's refresh window. The source, the summary
 family and where the state is kept do not enter. A view with an unbounded
 window is a group of its own.
 
@@ -603,9 +603,9 @@ refresh window `(W, p)` (`PhysicalASAPDAG::refresh_window`,
 ingestion run per window `(e - W, e]`, `e ≡ p (mod W)`:
 
 - The run's roots are the views of the group whose state for the window
-  ending at `e` is not stored yet. Pane `i` of a chain at evaluation `T` is
-  the same state as the newest pane at `T - i·W`, so in steady state the
-  roots are the newest pane of each chain of the group; the older panes are
+  ending at `e` is not stored yet. Tumbling window `i` of a chain at evaluation `T` is
+  the same state as the newest tumbling window at `T - i·W`, so in steady state the
+  roots are the newest tumbling window of each chain of the group; the older tumbling windows are
   already stored.
 - A view of the group that a root reads is computed in the run, not read
   from a slot. The views of other groups that the roots read are
@@ -613,11 +613,11 @@ ingestion run per window `(e - W, e]`, `e ≡ p (mod W)`:
 - The executor runs a node that several roots share once per run, so a `Scan`
   below several views of the group reads its raw data once per window.
 - Views of different refresh windows are refreshed in different runs. With a
-  10-second and a 60-second pane chain over one `Scan`, the 10-second chain
-  needs five pane ends the 60-second chain does not, so the `Scan` is read
+  10-second and a 60-second tumbling-window chain over one `Scan`, the 10-second chain
+  needs five tumbling window ends the 60-second chain does not, so the `Scan` is read
   once for each chain.
 
-The refresh window is derived from the DAG alone (time ranges, shifts and pane
+The refresh window is derived from the DAG alone (time ranges, shifts and tumbling window
 widths), like the views and their retention. Sealing, lateness, threading and
 the alignment of the window grid stay the deployment's.
 
@@ -625,41 +625,41 @@ Stage 3's cost assumes this grouping (`asap_cost::execution_demand::computations
 a stateless ingestion-time node is charged once per refresh window of the
 views above it, not once per view. A runtime that splits a group (for
 example, because its sources seal at different times) computes the same
-states at a higher cost than priced, the same status pane reuse has. A
+states at a higher cost than priced, the same status tumbling window reuse has. A
 runtime that updates states sample by sample passes each sample once
 whatever the windows, so it runs cheaper than priced.
 
 ### Running example
 
-For the KLL p50/p99 example, with one-minute panes materialized at ingestion
+For the KLL p50/p99 example, with one-minute tumbling windows materialized at ingestion
 over `Source::TimeSeries { metric: "latency" }`, plus a p99.9 with relative
-error answered by a DDSketch chain with one-minute panes over the same `Scan`:
+error answered by a DDSketch chain with one-minute tumbling windows over the same `Scan`:
 
 ```text
 Install (once):
-    views     = plan.materialized_views()?          // [KLL and DDSketch pane nodes, refresh = at ingestion, retention]
-    groups    = plan.ingestion_refresh_groups()?    // [refresh window (1m, 0): ten KLL and DDSketch pane views]
-    refresh   = compile(dag, [], [kll_pane_0, dd_pane_0])  // the newest pane of each chain
+    views     = plan.materialized_views()?          // [KLL and DDSketch tumbling window nodes, refresh = at ingestion, retention]
+    groups    = plan.ingestion_refresh_groups()?    // [refresh window (1m, 0): ten KLL and DDSketch tumbling window views]
+    refresh   = compile(dag, [], [kll_tumbling_window_0, dd_tumbling_window_0])  // the newest tumbling window of each chain
                 // Scan → TimeRange(1m) → NativeKllBuild(k=200)
                 //                      → NativeDDSketchBuild(α=0.01)
-    query     = compile(dag, views[kll_pane_0..kll_pane_4], [p50, p99])  // 5 materialized view slots → NativeKllMerge → NativeP50, NativeP99
-    (the p99.9 query DAG reads dd_pane_0..dd_pane_4 the same way)
+    query     = compile(dag, views[kll_tumbling_window_0..kll_tumbling_window_4], [p50, p99])  // 5 materialized view slots → NativeKllMerge → NativeP50, NativeP99
+    (the p99.9 query DAG reads dd_tumbling_window_0..dd_tumbling_window_4 the same way)
 
-Each complete pane (12:04, 12:05], in one ingestion run whose roots are the
-group's views with no stored state for the pane ending 12:05 (kll_pane_0 and
-dd_pane_0; the older panes were stored by earlier runs):
+Each complete tumbling window (12:04, 12:05], in one ingestion run whose roots are the
+group's views with no stored state for the tumbling window ending 12:05 (kll_tumbling_window_0 and
+dd_tumbling_window_0; the older tumbling windows were stored by earlier runs):
     refresh.instantiate(store)
         Scan calls read_raw_data(TimeSeries { latency }, time_range_ms = (12:04, 12:05]) once;
         both builds read its rows
     store the KllState and the DDSketchState in the summary store, each under its view's coverage and interval
 
 Query at T = 12:05 over (12:00, 12:05]:
-    the installed DAG has the chain expanded: five pane views, pane i under TimeShift(i·1m)
+    the installed DAG has the chain expanded: five tumbling window views, tumbling window i under TimeShift(i·1m)
     query.instantiate(store)
-        read_materialized_view(pane_0, (12:04, 12:05]) → states of latency-kll-1m, pane ending 12:05
-        read_materialized_view(pane_1, (12:03, 12:04]) → states of latency-kll-1m, pane ending 12:04
+        read_materialized_view(tumbling_window_0, (12:04, 12:05]) → states of latency-kll-1m, tumbling window ending 12:05
+        read_materialized_view(tumbling_window_1, (12:03, 12:04]) → states of latency-kll-1m, tumbling window ending 12:04
         …
-        read_materialized_view(pane_4, (12:00, 12:01]) → states of latency-kll-1m, pane ending 12:01
+        read_materialized_view(tumbling_window_4, (12:00, 12:01]) → states of latency-kll-1m, tumbling window ending 12:01
     NativeKllMerge executes once for both readouts → p50, p99
 ```
 
@@ -694,27 +694,27 @@ The complete example makes the ownership boundary explicit:
 | Stage | KLL example decision |
 | --- | --- |
 | **Logical Post-ASAP DAG** | Use `KLL(k=200)` with shared merge for p50/p99 |
-| **Stage 2 Materialization (#509)** | Maintain 1-minute panes and reuse them for aligned five-minute queries |
-| **Materialization** | Record pane/window/freshness/reuse requirements and each node's execution timing |
+| **Stage 2 Materialization (#509)** | Maintain 1-minute tumbling windows and reuse them for aligned five-minute queries |
+| **Materialization** | Record tumbling-window width, query window, freshness and reuse requirements and each node's execution timing |
 | **Physical Plan Compiler** | Lower to native KLL build, merge, and readout operators |
 | **Physical DAG** | Define precompute and query DAGs with typed input/output boundaries |
-| **Deployment interface** | Read the `latency` raw data slot with `read_raw_data`, and each pane's materialized view slot with `read_materialized_view`, from one `DataStore` |
-| **Deployment** | Schedule one ingestion run per refresh group and window, store and resolve panes, run queries |
+| **Deployment interface** | Read the `latency` raw data slot with `read_raw_data`, and each tumbling window's materialized view slot with `read_materialized_view`, from one `DataStore` |
+| **Deployment** | Schedule one ingestion run per refresh group and window, store and resolve tumbling windows, run queries |
 
 ```text
 Logical:
     "Use KLL for p50/p99."
 
 Materialization:
-    "Maintain reusable 1-minute KLL panes."
+    "Maintain reusable 1-minute KLL tumbling windows."
 
 Physical:
     "Execute NativeKllBuild and
      NativeKllMerge → {p50, p99}."
 
 Deployment:
-    "Read OTLP here, store panes here,
-     and serve these five panes for this aligned query."
+    "Read OTLP here, store tumbling windows here,
+     and serve these five tumbling windows for this aligned query."
 ```
 
 The deployment engine executes the instantiated Physical DAGs through ASAPPlanner's
@@ -730,8 +730,8 @@ reads stored state, and serves raw data and views to the slots through its
 `DataStore`. The plan file is the only persisted handoff; a compiled
 physical DAG is derived from it by the executor and is not persisted.
 
-Each maintained pane contributes its input samples once. A replacement snapshot
-replaces that pane's state; query merging must not count both the old and new
+Each maintained tumbling window contributes its input samples once. A replacement snapshot
+replaces that tumbling window's state; query merging must not count both the old and new
 snapshots as separate inputs.
 
 ## 6. Executable acceptance coverage
@@ -741,14 +741,14 @@ operator/runtime fixtures:
 
 | Test | Contract exercised |
 | --- | --- |
-| `kll_pane_execution::five_panes_roundtrip_and_shared_merge_runs_once` | One-minute pane refreshes from raw data → five materialized view slots → shared native merge → p50/p99; counts every sample once, checks adjacent aligned windows and instruments one merge start per run |
-| `kll_pane_execution::a_store_keyed_by_definition_and_time_range_answers_the_panes` | A store that finds states only by `(definition_id, time range)` answers the five-pane query: the panes share one definition and request the five ranges that tile the window |
-| `runtime_install::panes_of_one_refresh_window_read_each_raw_window_once` | A KLL chain and a DDSketch chain of 10 s panes over one `Scan` are one refresh group: each pane window is read from raw data once, in one ingestion run that builds both panes; each state equals that of a run of its view alone, and both queries answer as the query-time reference |
-| `kll_pane_execution::panes_reject_parameters_schema_and_missing_binding` | Parameter relabelling, incompatible schemas and missing views fail explicitly |
+| `kll_tumbling_window_execution::five_tumbling_windows_roundtrip_and_shared_merge_runs_once` | One-minute tumbling window refreshes from raw data → five materialized view slots → shared native merge → p50/p99; counts every sample once, checks adjacent aligned windows and instruments one merge start per run |
+| `kll_tumbling_window_execution::a_store_keyed_by_definition_and_time_range_answers_the_tumbling_windows` | A store that finds states only by `(definition_id, time range)` answers the five-tumbling-window query: the tumbling windows share one definition and request the five ranges that tile the window |
+| `runtime_install::tumbling_windows_of_one_refresh_window_read_each_raw_window_once` | A KLL chain and a DDSketch chain of 10 s tumbling windows over one `Scan` are one refresh group: each tumbling window window is read from raw data once, in one ingestion run that builds both tumbling windows; each state equals that of a run of its view alone, and both queries answer as the query-time reference |
+| `kll_tumbling_window_execution::tumbling_windows_reject_parameters_schema_and_missing_binding` | Parameter relabelling, incompatible schemas and missing views fail explicitly |
 | `precompute_candidates::grouped_rate_can_be_materialized_before_or_after_grouped_sum` | Stored Rate state and stored Sum state answer like query time; summing counters before Rate does not |
 | `sql_to_physical::sql_filter_grouped_sum_executes_and_rebinds` | SQL text → candidate search → physical compilation → shared Scan predicates and grouped summary execution; NULL samples are ignored and fresh bindings produce new results |
 
-Pane construction, pane timestamp checks, stored identity, revisions, readiness
+Tumbling window construction, tumbling window timestamp checks, stored identity, revisions, readiness
 and complete coverage of required input samples are deployment
 responsibilities. Real storage and HTTP execution belong to
 deployment-repository E2E tests.
diff --git a/docs/design_docs/proposals/asap-aware-mapping/maintained-populations.md b/docs/design_docs/proposals/asap-aware-mapping/maintained-populations.md
index a9046e67f..0975ba578 100644
--- a/docs/design_docs/proposals/asap-aware-mapping/maintained-populations.md
+++ b/docs/design_docs/proposals/asap-aware-mapping/maintained-populations.md
@@ -147,7 +147,7 @@ implemented separately; this design does not treat it as already shipped.
 ## Relation to sketch rules and other optimizations
 
 This rule adds an exact maintained-state alternative. It is distinct from choosing
-a sketch family or merging temporal panes, and can coexist with those alternatives
+a sketch family or merging temporal tumbling windows, and can coexist with those alternatives
 in the same workload. Temporal sketch rules continue to emit
 `SummaryAgg -> SummaryEstimate` DAGs.
 
diff --git a/docs/design_docs/proposals/asap-primitive-schema.md b/docs/design_docs/proposals/asap-primitive-schema.md
index 0013d5395..ee15ead49 100644
--- a/docs/design_docs/proposals/asap-primitive-schema.md
+++ b/docs/design_docs/proposals/asap-primitive-schema.md
@@ -95,7 +95,7 @@ Based on our requirement, each field should contain the following information.
      The sketch candidates are `summary_candidates(intent)` in `crates/logical-asap-optimization/src/pass1/realization.rs`; exact accumulators come from Pass 1's `ExactAccumulator` candidates in `pass1/per_computation_candidates.rs`; the evaluations are `SketchStatistic` ([§6.5](#65-update-input-and-evaluations-irschemasketchrs-iroperatormaintained_populationrs)).
 
    - **Time window aggregation intents**: whether states built over smaller windows can answer a larger one. This depends on how the family combines states:
-     - **Merge** (`SummaryMerge`, §5.6): states over disjoint panes combine into the state of their union, e.g. two 1-minute KLL states answer a 2-minute quantile. Requires a mergeable family.
+     - **Merge** (`SummaryMerge`, §5.6): states over disjoint tumbling windows combine into the state of their union, e.g. two 1-minute KLL states answer a 2-minute quantile. Requires a mergeable family.
      - **Subtract** (`SummarySubtract`, reserved): a sliding window as a larger state minus an older one. Only families with an inverse (e.g. exact `Sum`/`Count`, CMS) can do this.
 
      Which inputs may be merged is decided by coverage (§4), not by the schema. 
@@ -296,7 +296,7 @@ In the worked example, `latency < 100` and `region = 'us'` move into `selection`
 
 **When two definitions are equal.** Merging (§5.6) requires equal definitions.
 
-- They must have the same structure. Planning details are ignored: `timing`, `guarantee` and `coverage_cache`. So a pane built at ingestion time can merge with one built at query time.
+- They must have the same structure. Planning details are ignored: `timing`, `guarantee` and `coverage_cache`. So a tumbling window built at ingestion time can merge with one built at query time.
 - `SummaryUpdate.weight_domain` is compared too. It is computed from the rest, so it differs only if something is wrong.
 - States over different tables never merge: a KLL over `m1` and one over `m2` have different definitions. To combine tables, put a `UNION ALL` with a column that marks the source table below one `SummaryAgg`; that column can then be used in `selection` or in the grouping.
 
@@ -383,7 +383,7 @@ Any other shape stays in `definition`:
 | **Absolute** (later) | an interval on the timestamp column | `ts >= t0 AND ts < t1` → `ts ∈ [t0, t1)` |
 
 - PromQL windows exclude their start, so relative windows are open on the left. A SQL trailing window takes the same timing, `>=` included.
-- Window composition ([Pass 2](planner-layering.md#pass-2-asap-aware-common-subexpression-elimination) of logical optimization) builds its tumbling panes this way: a 3-minute window as panes `(−1m, 0]`, `(−2m, −1m]`, `(−3m, −2m]`, so pane times are derived, not declared (#601).
+- Window composition ([Pass 2](planner-layering.md#pass-2-asap-aware-common-subexpression-elimination) of logical optimization) builds its tumbling windows this way: a 3-minute window as tumbling windows `(−1m, 0]`, `(−2m, −1m]`, `(−3m, −2m]`, so tumbling window times are derived, not declared (#601).
 - An instant `TimeRange` (latest sample per series) does not pick rows by time, so it stays in `definition`. The walk also stops there, so for now the label matchers of an instant selector stay in `definition` too; lifting them is planned together with `rate` (Rule 1).
 - The IR cannot yet write a timestamp constant, so absolute SQL time filters stay in `definition` for now.
 - Absolute and relative time are never compared: a state over `(−1m, 0]` and one over `ts ∈ [t0, t1)` are treated as possibly overlapping.
@@ -413,7 +413,7 @@ Any other shape stays in `definition`:
 | `c` | filter conditions on the walk (after splitting at `AND`), including `SummaryAgg.filter` and `Scan.predicates` | a few |
 | `f` | columns in the widest schema on the walk | tens |
 | `v` | values in one value set (`IN` list) | a few |
-| `n` | inputs of a `SummaryMerge` | panes per window, regions, … |
+| `n` | inputs of a `SummaryMerge` | tumbling windows per window, regions, … |
 | `b` | boxes in one input's selection | 1 for a `SummaryAgg` |
 | `N` | nodes in a `definition` | the sub-DAG size |
 
@@ -432,7 +432,7 @@ Any other shape stays in `definition`:
 | no overlap | `O(n²·b²·f·v²)` | every pair of inputs, every pair of boxes, every shared column |
 | union of selections | `O((n·b)³)` box comparisons, worst case | joins boxes that differ in only one dimension whose union is again one constraint (touching time windows, touching value ranges, or value sets of one column), until nothing more joins; each join restarts the scan |
 
-For the common cases this is small: `n` one-minute panes in time order have one box each with no columns, so the merge costs `O(n·N·f)` for the definitions, `O(n²)` for overlap and `O(n²)` for the union. Nested merges keep `n` small: a merge of merges compares only its direct inputs, whose coverage is cached.
+For the common cases this is small: `n` one-minute tumbling windows in time order have one box each with no columns, so the merge costs `O(n·N·f)` for the definitions, `O(n²)` for overlap and `O(n²)` for the union. Nested merges keep `n` small: a merge of merges compares only its direct inputs, whose coverage is cached.
 
 ### 4.3 What coverage does not contain
 
@@ -665,20 +665,20 @@ With an exact target, the planner can keep all latencies per job in one maintain
 
 - **Implemented.** All children must be state with exactly one state field and identical schemas.
 - **Coverage.** It also requires equal `definition`s and selections that do not overlap, and computes the merged coverage.
-- **Newest panes:** an optional `newest_tumbling_windows: n` merges only the newest `n` panes of the one `SummaryTumblingWindowChain` the merge reads (`1 ≤ n <` its pane count). Its coverage is one build over those panes' window, so one chain kept for the longest window serves every query whose window, on the same panes, ends at the same time and is shorter.
-- **Rollup:** an optional `group_by` field, so one operator does both merge and rollup. It lists the input's group columns the output is keyed by; `None` keeps the input's groups. A rollup merges every input state, so it does not take `newest_tumbling_windows`; it reads a merge of the newest panes instead:
+- **Newest tumbling windows:** an optional `newest_tumbling_windows: n` merges only the newest `n` tumbling windows of the one `SummaryTumblingWindowChain` the merge reads (`1 ≤ n <` its tumbling-window count). Its coverage is one build over the time range those tumbling windows cover, so one chain kept for the longest window serves every query whose window, on the same tumbling windows, ends at the same time and is shorter.
+- **Rollup:** an optional `group_by` field, so one operator does both merge and rollup. It lists the input's group columns the output is keyed by; `None` keeps the input's groups. A rollup merges every input state, so it does not take `newest_tumbling_windows`; it reads a merge of the newest tumbling windows instead:
 
 ```rust
 SummaryMerge { children: Vec<C>, newest_tumbling_windows: Option<u32>, group_by: Option<Vec<ColumnId>> }
 ```
 
-**Example A: time panes.** p99 of each series of metric `m` over the last 2 minutes:
+**Example A: time tumbling windows.** p99 of each series of metric `m` over the last 2 minutes:
 
 ```promql
 quantile_over_time(0.99, m[2m])
 ```
 
-Window composition (Pass 2) can answer it from two one-minute panes, one KLL per series in each, merged. Both panes read the same `Scan`.
+Window composition (Pass 2) can answer it from two one-minute tumbling windows, one KLL per series in each, merged. Both tumbling windows read the same `Scan`.
 
 ```text
                            ( next operator )
@@ -692,7 +692,7 @@ Window composition (Pass 2) can answer it from two one-minute panes, one KLL per
                  │  State: series labels,            │  State: series labels,
                  │  state Sketch(KLL k=200)          │  state Sketch(KLL k=200)
                  │                                   │
-     [[ SummaryAgg ]]  pane 0             [[ SummaryAgg ]]  pane 1
+     [[ SummaryAgg ]]  tumbling window 0             [[ SummaryAgg ]]  tumbling window 1
      KLL k=200, per series                KLL k=200, per series
      selection: time (−1m, 0]             selection: time (−2m, −1m]
                  ▲                                   ▲
@@ -708,12 +708,12 @@ Window composition (Pass 2) can answer it from two one-minute panes, one KLL per
                               [ Scan m ]
 ```
 
-Both panes have the same `definition` (`SummaryAgg` over `Scan m`), and their time ranges touch, so the merge covers one continuous range:
+Both tumbling windows have the same `definition` (`SummaryAgg` over `Scan m`), and their time ranges touch, so the merge covers one continuous range:
 
 ```text
 time      −2m           −1m            0
-pane 1     (─────────────]
-pane 0                   (─────────────]
+tumbling window 1     (─────────────]
+tumbling window 0                   (─────────────]
 merge      (───────────────────────────]
 ```
 
@@ -988,7 +988,7 @@ pub enum ASAPOp<C = Rc<OperatorNode>> {
     SummaryMerge {
         /// The states to merge; all have the same schema.
         children: Vec<C>,
-        /// Merge only the newest `n` panes of the one `SummaryTumblingWindowChain` read;
+        /// Merge only the newest `n` tumbling windows of the one `SummaryTumblingWindowChain` read;
         /// `None` merges every input state. Not with `group_by`.
         newest_tumbling_windows: Option<u32>,
         /// A rollup: the input's group columns the merged states are keyed
@@ -1391,7 +1391,7 @@ pub enum Constraint {
 impl SummaryCoverage {
     /// Computes the coverage of a summary node from its sub-DAG (§4.2.2).
     /// Errors: `NotSummary` for a node that is not a `SummaryAgg`,
-    /// `SummaryTumblingWindowChain` or `SummaryMerge`; `PaneChainExpansion` for a `SummaryTumblingWindowChain`
+    /// `SummaryTumblingWindowChain` or `SummaryMerge`; `TumblingWindowChainExpansion` for a `SummaryTumblingWindowChain`
     /// that does not expand to one build over its whole window; for a
     /// merge, an input's own error, `EmptyMerge` (no inputs),
     /// `DefinitionMismatch` (inputs compute different things) or
diff --git a/docs/design_docs/proposals/error-resource-profile.md b/docs/design_docs/proposals/error-resource-profile.md
index 829f5cd95..faaf5ac45 100644
--- a/docs/design_docs/proposals/error-resource-profile.md
+++ b/docs/design_docs/proposals/error-resource-profile.md
@@ -222,13 +222,13 @@ the selected materialization and window model:
 
 ```text
 updates = input_updates * materializations
-merges = query_executions * (panes_per_query - 1)
+merges = query_executions * (tumbling_windows_per_query - 1)
 queries = query_executions
-retained_sketches = retained_panes * materializations
+retained_sketches = retained_tumbling_windows * materializations
 cpu = updates*C_update + merges*C_merge + queries*C_query
 ```
 
-A tumbling window has one pane per query and no merge. A shared sliding-window
+A query whose window equals its interval keeps one tumbling window per query and merges nothing. A shared sliding-window
 plan has one materialization; a natural per-query deployment has one per
 distinct window. Retained memory is measured bytes per sketch multiplied by
 retained sketches, outside the CPU equation.
diff --git a/docs/design_docs/proposals/joint-planning-implementation-plan.md b/docs/design_docs/proposals/joint-planning-implementation-plan.md
index e6e4b6191..bf1775637 100644
--- a/docs/design_docs/proposals/joint-planning-implementation-plan.md
+++ b/docs/design_docs/proposals/joint-planning-implementation-plan.md
@@ -40,11 +40,11 @@ Implemented means present in this branch, not that every performance gate has pa
 | Capability | Current behavior | Acceptance requirement |
 | --- | --- | --- |
 | Exact, accumulator, sketch, fused, and scalar outputs | Supported local generation and selected-graph reconstruction; strict schema and guarantee checks. | Existing frontend/composition regressions, including SQL COUNT qualifiers and AVG grouping-key proofs. |
-| Shared builds, pane states, scan widening, rollup, and TopK reuse | Logical rules expose compatible shared computations and retain local choices. | Typed input/output contracts, selected-reader legality, and actual evaluator-cost checks. Unsupported operator shapes remain local. |
-| Capacity, width, and horizon configurations | Finite sketch capacities and retention configurations; complete legal integer-ms pane-width domain for the supported aligned whole-pane algorithm. | Small-domain completeness, duplicate-generation equivalence, alignment, coverage, and independent solver-oracle tests. |
+| Shared builds, tumbling-window states, scan widening, rollup, and TopK reuse | Logical rules expose compatible shared computations and retain local choices. | Typed input/output contracts, selected-reader legality, and actual evaluator-cost checks. Unsupported operator shapes remain local. |
+| Capacity, width, and horizon configurations | Finite sketch capacities and retention configurations; complete legal integer-ms tumbling-window-width domain for the supported aligned whole-tumbling-window algorithm. | Small-domain completeness, duplicate-generation equivalence, alignment, coverage, and independent solver-oracle tests. |
 | Materialization and repeated execution | Supported summary and non-summary modes validated against selected connections; production evaluator derives execution demand and retained state. | Ingestion/query timing, different evaluation grids, retained-state freshness, and shared cost ownership. |
 | Accuracy | Root guarantees are recomposed and checked; proven query-closure cuts and conservative early pruning supplement full-assignment rejection. | Preserve failure-probability and value/rank-error semantics. A changed relevant input must remain able to repair a rejected plan. |
-| Cost bounds | Certified local bounds plus validated full-assignment cost observations. Unsupported bounds remain conservative. | No bound exceeds evaluator cost, including potential candidate cycles, grouped panes, retention, and sharing. |
+| Cost bounds | Certified local bounds plus validated full-assignment cost observations. Unsupported bounds remain conservative. | No bound exceeds evaluator cost, including potential candidate cycles, grouped tumbling windows, retention, and sharing. |
 | Objectives | Usage-over-time, provisioned-price, and cluster-capacity latency/memory/Pareto ranking use the configured evaluator. | Same feasibility and ranking as independent final evaluation. Bounded Pareto traversal must report incompleteness. |
 | Calibration | Explicit frozen factor, no-measurement default factor, or complete-catalog fit. | No fitting to an arbitrary timeout-dependent prefix; imported measurements are not newly collected runtime data. |
 | Search controls | Structural pruning, certified independent components, warm starts, validated seed, and cooperative budgets. | No removed global constraints or lost sharing opportunities; timeouts cannot become optimality certificates. |
@@ -52,9 +52,9 @@ Implemented means present in this branch, not that every performance gate has pa
 
 Raw-source retention and fixed request overhead are currently accounted for by the authoritative workload evaluator. Explicit `G_raw` candidates in the design are a possible direct encoding, not a second implemented retention owner. Never charge both representations for the same resource.
 
-## Complete pane widths and bounded planning
+## Complete tumbling-window widths and bounded planning
 
-Query window semantics remain fixed. Complete width generation enumerates the legal positive integer-millisecond divisors of the relevant window/evaluation grids, subject to alignment, offsets, representable pane counts, and executable configurations. Different consumer subsets may select different widths. Complete width coverage does not imply arbitrary sketch capacities or unsupported window algorithms.
+Query window semantics remain fixed. Complete width generation enumerates the legal positive integer-millisecond divisors of the relevant window/evaluation grids, subject to alignment, offsets, representable tumbling-window counts, and executable configurations. Different consumer subsets may select different widths. Complete width coverage does not imply arbitrary sketch capacities or unsupported window algorithms.
 
 For bounded searches with a fixed calibration model, the same engine first searches a reader-grid/GCD seed domain, using at most the smaller of 5 seconds and one quarter of the available wall budget. It then searches the complete domain with the remaining wall and evaluation budgets. The seed is accepted only after normal accuracy, materialization, latency, and cost validation. The two results use the same configured ranking; a restricted seed supplies no lower bound for the complete domain.
 
@@ -66,7 +66,7 @@ After obtaining a validated seed, bounded materialization proposals keep its com
 
 Exhaustive/keep-every diagnostics and complete-catalog calibration use a single complete domain. A complete-catalog fit cannot be replaced by a partial seed fit. If no validated plan exists when the budget ends, return an explicit no-plan diagnostic. Internal generation/reconstruction errors propagate rather than silently choosing a seed.
 
-The deadline is cooperative: generation loops, inventory/configuration construction, MILP construction, and physical DAG flattening/export check it. Export propagates a distinct deadline error rather than declaring the candidate infeasible. An individual evaluator or external solver call may still finish after its allowance. Physical DAG validation counts producer/edge-role multiplicities in a hash map, avoiding quadratic scans for large pane fan-in. Reports distinguish seed time, complete-phase time, full catalog construction, assignment-search completion, selected seed/fallback reason, and solver status/gap. A fallback clears restricted-domain bound/gap claims. `full_catalog_completed` does not mean every assignment was evaluated.
+The deadline is cooperative: generation loops, inventory/configuration construction, MILP construction, and physical DAG flattening/export check it. Export propagates a distinct deadline error rather than declaring the candidate infeasible. An individual evaluator or external solver call may still finish after its allowance. Physical DAG validation counts producer/edge-role multiplicities in a hash map, avoiding quadratic scans for large tumbling window fan-in. Reports distinguish seed time, complete-phase time, full catalog construction, assignment-search completion, selected seed/fallback reason, and solver status/gap. A fallback clears restricted-domain bound/gap claims. `full_catalog_completed` does not mean every assignment was evaluated.
 
 ## Delivery stages
 
diff --git a/docs/design_docs/proposals/joint-planning-search.md b/docs/design_docs/proposals/joint-planning-search.md
index 764e48de8..c844438b3 100644
--- a/docs/design_docs/proposals/joint-planning-search.md
+++ b/docs/design_docs/proposals/joint-planning-search.md
@@ -4,7 +4,7 @@
 
 ## 1. Motivation and Challenges
 
-ASAP primitives increase both the opportunities for query optimization and the difficulty of searching for a good plan. A quantile, for example, may be computed directly or estimated from a summary. Several quantiles may use the same summary, and several windows may use overlapping sets of panes. The cost of one query therefore depends on decisions made for other queries. Selecting the cheapest implementation of each query independently can miss the cheapest workload plan.
+ASAP primitives increase both the opportunities for query optimization and the difficulty of searching for a good plan. A quantile, for example, may be computed directly or estimated from a summary. Several quantiles may use the same summary, and several windows may use overlapping sets of tumbling windows. The cost of one query therefore depends on decisions made for other queries. Selecting the cheapest implementation of each query independently can miss the cheapest workload plan.
 
 ASAPPlanner also optimizes for **workload patterns**, including repeated queries, their evaluation frequencies and alignment, and overlap among their windows. The unit of optimization is therefore a workload over time, not just a set of queries executed once. These patterns introduce further choices about when to recompute, which consumers can share an execution, and which intermediate states to maintain or retain across evaluations.
 
@@ -15,7 +15,7 @@ Q1: P95(X[15m]), evaluated every 1m
 Q2: P99(X[15m]), evaluated every 5m
 ```
 
-Over 60 aligned minute ticks, separate query-time KLL builds require 60 + 12 executions. A compatible shared build can serve both queries at the 12 common query evaluation events, reducing the total to 60 builds. Another supported candidate may maintain 1m panes at ingestion and merge them at evaluation, trading update and retained-state costs against repeated whole-window construction. Eligible retained-state candidates introduce refresh and lifetime choices as well. Repetition alone does not make an earlier window's state valid for a later window; reuse must preserve coverage and freshness.
+Over 60 aligned minute ticks, separate query-time KLL builds require 60 + 12 executions. A compatible shared build can serve both queries at the 12 common query evaluation events, reducing the total to 60 builds. Another supported candidate may maintain 1m tumbling windows at ingestion and merge them at evaluation, trading update and retained-state costs against repeated whole-window construction. Eligible retained-state candidates introduce refresh and lifetime choices as well. Repetition alone does not make an earlier window's state valid for a later window; reuse must preserve coverage and freshness.
 
 The search space therefore grows across algorithm, configuration, consumer sharing, materialization, and temporal reuse choices together. Selecting a producer's consumers can change its execution frequency and required retention, so these decisions cannot be priced independently. Explicitly expanding every query evaluation event can further multiply the optimization model's size, even when query texts and algorithm candidates remain unchanged. Workload-pattern optimization thus adds both a combinatorial planning challenge and a need for compact representation of repeated execution demand.
 
@@ -114,31 +114,31 @@ G99 += EstimateQuantile(0.99, G_KLL)
 
 Conventional CSE discovers identical computations. ASAP-aware CSE also exposes common intermediate state for different results. It creates or reuses a state group without merging `G95` and `G99`.
 
-Window rules can similarly introduce a pane-state group and a merge candidate:
+Window rules can similarly introduce a tumbling-window-state group and a merge candidate:
 
 ```text
-G_panes: aligned 1m KLL panes covering 15m
-G_KLL += MergeLatest15(G_panes)
+G_tumbling_windows: aligned 1m KLL tumbling windows covering 15m
+G_KLL += MergeLatest15(G_tumbling_windows)
 ```
 
 ### Stage 2: expand physical candidates
 
 Non-summary query-time materialization must be a query output or have a selected immediate consumer used by only one query; the materialized node itself must have multiple query readers. These connection-dependent constraints match Stage 2's highest-shared-node rule and are enforced in MILP. Summary-state eligibility remains separate.
 
-Physical rules provide executable operators, configurations, and materialization assignments for the generated computations. For example, a supported pane implementation can maintain state at ingestion and merge it at evaluation. This introduces two timing decisions within the same query, rather than one materialization choice for the whole query. Eligibility that depends on consumers is checked against the selected connections; considering every potential consumer at once could incorrectly reject a useful candidate.
+Physical rules provide executable operators, configurations, and materialization assignments for the generated computations. For example, a supported tumbling window implementation can maintain state at ingestion and merge it at evaluation. This introduces two timing decisions within the same query, rather than one materialization choice for the whole query. Eligibility that depends on consumers is checked against the selected connections; considering every potential consumer at once could incorrectly reject a useful candidate.
 
-For the running example, assume evaluations occur at aligned minute boundaries and the deployment supports ingestion-time pane maintenance. Stage 2 can expand the state groups as follows; `s` is a generated KLL capacity:
+For the running example, assume evaluations occur at aligned minute boundaries and the deployment supports ingestion-time tumbling window maintenance. Stage 2 can expand the state groups as follows; `s` is a generated KLL capacity:
 
 ```text
 Group     Physical candidate     Computation                 Materialization
-G_panes   P_ingest(s)             Maintain aligned 1m panes   MatAtIngestion(Memory)
-G_KLL     K_merge(s)              MergeLatest15(G_panes)      MatAtQuery(Memory)
+G_tumbling_windows   P_ingest(s)             Maintain aligned 1m tumbling windows   MatAtIngestion(Memory)
+G_KLL     K_merge(s)              MergeLatest15(G_tumbling_windows)      MatAtQuery(Memory)
 G_KLL     K_build(s)              BuildKLL(G_input, 15m)      MatAtQuery(Memory)
 G95       E95                    EstimateQuantile(.95, G_KLL) NotMaterialized
 G99       E99                    EstimateQuantile(.99, G_KLL) NotMaterialized
 ```
 
-`P_ingest(s)` retains the panes needed to cover the 15m window. `K_merge(s)` constructs window state from those panes at evaluation; `K_build(s)` instead builds window state from available raw input. Each candidate records its input requirements and costs. The estimators can use either compatible state candidate. Exact and local KLL candidates from Pass 1 also receive supported physical implementations and remain available. Stage 2 has generated choices; it has not yet selected a build or connected an estimator to it.
+`P_ingest(s)` retains the tumbling windows needed to cover the 15m window. `K_merge(s)` constructs window state from those tumbling windows at evaluation; `K_build(s)` instead builds window state from available raw input. Each candidate records its input requirements and costs. The estimators can use either compatible state candidate. Exact and local KLL candidates from Pass 1 also receive supported physical implementations and remain available. Stage 2 has generated choices; it has not yet selected a build or connected an estimator to it.
 
 Window semantics, algorithms, and materialization remain separate dimensions. Their definitions and support restrictions belong in [Window and Materialization Choices](window-materialization-choices.md).
 
@@ -146,16 +146,16 @@ Window semantics, algorithms, and materialization remain separate dimensions. Th
 
 Selection chooses physical candidates and connects their required inputs until every query root is covered. Several consumers may connect to one KLL candidate or to different candidates from `G_KLL`. The selected graph is reconstructed as a `PhysicalASAPDAG` and validated. This is where implementation costs are compared jointly; the earlier rules expose the choices on which that comparison depends.
 
-Suppose the pane-based choice has the lowest modeled cost among feasible plans, and capacity `s*` satisfies both queries after pane merges. Stage 3 selects `P_ingest(s*)`, `K_merge(s*)`, `E95`, and `E99`, together with their required upstream input, and chooses these connections:
+Suppose the tumbling-window-based choice has the lowest modeled cost among feasible plans, and capacity `s*` satisfies both queries after tumbling-window merges. Stage 3 selects `P_ingest(s*)`, `K_merge(s*)`, `E95`, and `E99`, together with their required upstream input, and chooses these connections:
 
 ```text
 Selected input for X
         │
         ▼
-P_ingest(s*)              maintain 1m panes at ingestion
+P_ingest(s*)              maintain 1m tumbling windows at ingestion
         │
         ▼
-K_merge(s*)               merge the latest 15 panes at evaluation
+K_merge(s*)               merge the latest 15 tumbling windows at evaluation
         ├───────────────┐
         ▼               ▼
        E95             E99
@@ -164,7 +164,7 @@ K_merge(s*)               merge the latest 15 panes at evaluation
        Q1              Q2
 ```
 
-For a common evaluation of Q1 and Q2, the selected merge state serves both estimators. Pane maintenance is charged once for the shared pane chain, and merge work once per common evaluation; each estimator contributes its own extraction cost. `K_build(s*)` and the exact/local candidates are unselected in this example. If timing or accuracy prevents this sharing, Stage 3 may connect the estimators to different candidates from `G_KLL`. Thus Stage 2 enumerates executable choices, while Stage 3 determines which choices execute and which consumers share them.
+For a common evaluation of Q1 and Q2, the selected merge state serves both estimators. Tumbling window maintenance is charged once for the shared tumbling-window chain, and merge work once per common evaluation; each estimator contributes its own extraction cost. `K_build(s*)` and the exact/local candidates are unselected in this example. If timing or accuracy prevents this sharing, Stage 3 may connect the estimators to different candidates from `G_KLL`. Thus Stage 2 enumerates executable choices, while Stage 3 determines which choices execute and which consumers share them.
 
 ## 4. Cost Model
 
@@ -180,7 +180,7 @@ The current evaluator owns shared raw retention; explicit retention candidates a
 
 Fixed request overhead does not affect plan selection. If query `q` executes `N_q` times over the accounting horizon with fixed per-request cost `h_q`, add `Σ_q N_q × h_q` to the reported total after optimization. Its resource usage still counts against applicable budgets. Any overhead that changes with implementation or connections belongs in the corresponding decision-dependent cost model instead.
 
-The following cases make the accounting concrete. Let `B` be the cost of one whole-window KLL build, `M` one pane merge, and `E95` and `E99` the extraction costs. These are illustrative work charges; retained and temporary resources are accounted for separately over the same horizon.
+The following cases make the accounting concrete. Let `B` be the cost of one whole-window KLL build, `M` one tumbling-window merge, and `E95` and `E99` the extraction costs. These are illustrative work charges; retained and temporary resources are accounted for separately over the same horizon.
 
 | Case | Selected execution | Cost accounting |
 | --- | --- | --- |
@@ -188,8 +188,8 @@ The following cases make the accounting concrete. Let `B` be the cost of one who
 | Shared query-time build | Q1 and Q2 use one compatible build in a common evaluation. | `B + E95 + E99`. Query-local state is charged for its actual lifetime. |
 | Repeated common evaluations | Both queries evaluate together `n` times; state is discarded after each evaluation. | `n × (B + E95 + E99)`. Selecting one candidate does not mean building only once over the entire horizon. |
 | Different evaluation timestamps | Q1 evaluates every minute; Q2 every five minutes on the same grid. Both use a 15m window. | Over 15 evaluation ticks, a shareable query-local build executes 15 times, with 15 P95 extractions and 3 P99 extractions: `15B + 15E95 + 3E99`. This assumes sharing at the three common timestamps; an earlier window state cannot automatically answer a later window. |
-| Ingestion-maintained panes | One pane chain feeds a shared query-time merge and both estimators. | Ingestion updates and pane retention are charged once for the chain. Add `n × (M + E95 + E99)` for `n` common evaluations, plus query-local merge memory. |
-| State retained across evaluations | An eligible pane-chain candidate uses `MatAtQueryKeptAcrossEvaluations(Memory)`. | Charge initial construction, required refresh/update work, retained memory/storage over its lifetime, and evaluation work. Reuse does not eliminate freshness maintenance; generate this case only when supported. |
+| Ingestion-maintained tumbling windows | One tumbling-window chain feeds a shared query-time merge and both estimators. | Ingestion updates and tumbling-window retention are charged once for the chain. Add `n × (M + E95 + E99)` for `n` common evaluations, plus query-local merge memory. |
+| State retained across evaluations | An eligible tumbling-window-chain candidate uses `MatAtQueryKeptAcrossEvaluations(Memory)`. | Charge initial construction, required refresh/update work, retained memory/storage over its lifetime, and evaluation work. Reuse does not eliminate freshness maintenance; generate this case only when supported. |
 | Multiple selected candidates in one group | Some consumers use a small KLL state and others a separate large state. | Charge each selected state's build/update and retention, then each consumer's local work. Equal group identity does not collapse two physical candidates into one charge. |
 | Shared raw-data retention | Two consumers need 5m and 15m of the same raw source and compatible retention scope. | Both consumers connect to `Retain15m` in `G_raw[d]`. Charge that candidate once; reads and intermediate KLL state have separate owners. |
 | Per-request overhead | Two requests share computation but still require separate response handling. | Report fixed overhead as `Σ_q N_q × h_q`; omit this constant from the optimization objective but retain its applicable resource usage. Decision-dependent overhead stays in the optimization model. |
@@ -202,7 +202,7 @@ The direct-cost objective computes the total modeled cost of the selected execut
 
 Direct pricing currently covers certified query-time exact and fixed sketch configurations, including KMV, KLL, DDS, Count-Min, CountSketch, Theta, and source-certified HLL. Every sketch arrives at its final size: Pass 1 sizes it for its readers' failure probabilities over the values their targets cover, Pass 2 shares it at its strictest reader's size, and Stage 3 never resizes, so precomputed prices stay valid. Matching schedules use a compact demand model. Mixed fixed intervals, known/unknown phases, estimated rates, scheduled requests, one-off requests and range evaluations use finite demand atoms following the evaluator's accounting policy. Different fixed intervals add; an unknown phase joins the first selected known phase on its interval; estimates add; nonrepeating demand uses the largest selected batch. These rules describe the configured cost model, not a new runtime scheduler. The production encoding needs neither a query-subset table nor an integer rate lattice. There is one production mixed-schedule encoding; the former subset and lattice encoders are removed. Behavioral selection tests use the current encoder and compare against separately computed evaluator costs. The model includes raw retention, request overhead, and latency-dependent temporary state, and checks the decoded total against the complete DAG evaluator. Accuracy still requires full output validation.
 
-Direct pane pricing covers query-time rebuilding, eligible state retained across evaluations, and fixed-retention ingestion maintenance. Source-certified HLL panes use the same population and failure-probability checks as HLL whole-window builds. Rebuilt state pays for execution demand and temporary lifetime; retained state pays for resident panes and refreshes. Ingestion work is excluded from query latency; the maximum compaction delay among reached ingestion states contributes to query latency and temporary holding cost.
+Direct tumbling window pricing covers query-time rebuilding, eligible state retained across evaluations, and fixed-retention ingestion maintenance. Source-certified HLL tumbling windows use the same population and failure-probability checks as HLL whole-window builds. Rebuilt state pays for execution demand and temporary lifetime; retained state pays for resident tumbling windows and refreshes. Ingestion work is excluded from query latency; the maximum compaction delay among reached ingestion states contributes to query latency and temporary holding cost.
 
 **Producer-dependent prices are joint decisions.** For each supported candidate, costing derives finite local pricing options from complete ordered tuples of its producers' priced output interfaces. Executable binary operations and relational joins preserve input positions even when two positions use the same producer. Shared ingestion ancestors contribute their work once to a worker-count certificate. An option records local CPU/state costs, output statistics, upstream work and the resulting certified worker count. For example, two producer configurations requiring 0.9 and 2.4 CPU-seconds per ingestion second produce one-worker and three-worker options; their compaction delays need not agree. A downstream reader can likewise have different merge/extraction costs for different state capacities. The optimizer retains these options rather than keeping only the first price class.
 
@@ -210,7 +210,7 @@ Let `price[c,k]` select pricing option `k` of candidate `c`. Require `Σ_k price
 
 Local interface generation deduplicates identical outputs, costs and upstream-work certificates; it does not enumerate complete workload DAGs. It covers supported single-input and multi-input operators and timing configurations. Acyclic catalogs use dependency order; catalogs with potential cycles propagate local interfaces for at most the candidate count, sufficient for every legal acyclic dependency depth. Query-time upstream work is not part of an ingestion worker certificate, preventing irrelevant path histories from multiplying equivalent interfaces. Final DAG ordering and one pricing option per physical candidate exclude cyclic executions. All legal scan-lookback classes participate jointly, with exact context matching on each scan connection; sharing one wider scan across narrower consumers requires an additional maximum-demand witness and remains outside this encoding. Uncertified operators or domains exceeding the finite interface/tuple/time budget use the existing validated fallback. Generation reserves time for fallback rather than consuming the entire planning budget. Joint and fixed-price extraction share that reserved deadline. Unsupported profiles, including schedule-atom construction timeouts, skip the optional direct proposal and continue through validated search; invalid profile errors remain fatal. A worker count is derived from the selected upstream work, not an independently tunable cluster size. The bounded production seed uses the first interchangeable execution copy while retaining all its pricing options; the full search retains every copy. This is a restricted proposal, not a proof that additional copies are unnecessary. Reports distinguish joint price-option solves from fixed-profile direct solves.
 
-Range demand distinguishes evaluations from requests. Query-local state follows the union of evaluation offsets, while eligible query-kept state refreshes once per request. Pane pricing options carry retention-span tiers: a selected tier must cover every selected reader and have a reader witnessing that maximum. This prevents both undercharging long ranges and charging retention demanded only by unselected readers. Existing pane alignment, freshness and materialization restrictions still apply.
+Range demand distinguishes evaluations from requests. Query-local state follows the union of evaluation offsets, while eligible query-kept state refreshes once per request. Tumbling window pricing options carry retention-span tiers: a selected tier must cover every selected reader and have a reader witnessing that maximum. This prevents both undercharging long ranges and charging retention demanded only by unselected readers. Existing tumbling-window alignment, freshness and materialization restrictions still apply.
 
 For a nonmaterialized node, let `A` be its normalized average holding time, `r_q` binary query reach, `e_q` the evaluation rate, and `L_q` query latency. Encode `Σ e_q × r_q × A = Σ e_q × r_q × L_q` by linearizing each binary/continuous product. Multiplying `A` by each selected execution-demand atom is linearized similarly. This models finite nonnegative rates without enumerating denominators or reader subsets. When all reached readers have zero expected demand, holding time falls back to the longest reader latency, matching the evaluator. Materialized state uses the longest reached-query latency.
 
@@ -278,17 +278,17 @@ r[q,c]                                    ∈ {0,1}   candidate c provides query
 
 Connection variables exist only for compatible producer–consumer requirements. Capacity and materialization belong to candidate configuration, so selection needs no separate copy or instance variables.
 
-#### Pane width is an optimization decision
+#### Tumbling-window width is an optimization decision
 
-The query's window width is fixed semantics. The pane width is a physical decision, selected jointly with retention, summary capacity, materialization, and consumer connections. Do not restrict the search to a few manually chosen widths and describe the result as optimal over all supported pane widths.
+The query's window width is fixed semantics. The tumbling-window width is a physical decision, selected jointly with retention, summary capacity, materialization, and consumer connections. Do not restrict the search to a few manually chosen widths and describe the result as optimal over all supported tumbling-window widths.
 
-For the supported whole-pane, aligned reconstruction algorithm, use the declared time resolution (currently integer milliseconds). Derive the complete legal width set from the window boundaries and evaluation grid. For example, a 15m window evaluated every 1m admits positive integer-millisecond divisors of 60,000, subject to alignment, offset, representable pane counts, and physical eligibility. A 5m pane alone cannot serve every minute endpoint. Different compatible reader subsets can select different widths.
+For the supported whole-tumbling-window, aligned reconstruction algorithm, use the declared time resolution (currently integer milliseconds). Derive the complete legal width set from the window boundaries and evaluation grid. For example, a 15m window evaluated every 1m admits positive integer-millisecond divisors of 60,000, subject to alignment, offset, representable tumbling-window counts, and physical eligibility. A 5m tumbling window alone cannot serve every minute endpoint. Different compatible reader subsets can select different widths.
 
-This finite domain has an exact MILP encoding: activate width-specific configurations with binary decisions. If a single chain is represented by mutually exclusive width configurations, `sum_d u[d] = active` and its selected width is `sum_d d*u[d]`. The candidate graph encodes the same choice through configuration-specific candidate activations and compatible connections. Multiple chains may be active, so there is no single workload-wide pane-width variable.
+This finite domain has an exact MILP encoding: activate width-specific configurations with binary decisions. If a single chain is represented by mutually exclusive width configurations, `sum_d u[d] = active` and its selected width is `sum_d d*u[d]`. The candidate graph encodes the same choice through configuration-specific candidate activations and compatible connections. Multiple chains may be active, so there is no single workload-wide tumbling-window-width variable.
 
-Precompute each configuration's local resource estimates and reader compatibility. A free integer width by itself would leave nonlinear terms such as `window_width / pane_width` and arbitrary measured size/cost functions; it would not make the current model a valid MILP. Complete discrete encoding avoids that issue. Prune widths only with a proof covering costs, accuracy, and sharing interfaces; a candidate-count cap must be reported as a restricted domain.
+Precompute each configuration's local resource estimates and reader compatibility. A free integer width by itself would leave nonlinear terms such as `window_width / tumbling_window_width` and arbitrary measured size/cost functions; it would not make the current model a valid MILP. Complete discrete encoding avoids that issue. Prune widths only with a proof covering costs, accuracy, and sharing interfaces; a candidate-count cap must be reported as a restricted domain.
 
-A proven optimum applies to all generated legal widths and the other configured finite decisions under the encoded model. A planning-budget stop returns a validated incumbent and an available certified bound, not a globally optimal pane width. This does not claim optimality over unsupported boundary reconstruction, new window algorithms, or every possible sketch capacity.
+A proven optimum applies to all generated legal widths and the other configured finite decisions under the encoded model. A planning-budget stop returns a validated incumbent and an available certified bound, not a globally optimal tumbling-window width. This does not claim optimality over unsupported boundary reconstruction, new window algorithms, or every possible sketch capacity.
 
 #### Auxiliary variables: `order`, `run`, and `need`
 
@@ -453,7 +453,7 @@ connect[producer,consumer,requirement]
     ≤ compatible[producer,consumer,requirement]
 ```
 
-These checks include supported modes, deployment capabilities, pane alignment and coverage, retention guarantees, and producer/consumer timing. Omitting invalid candidates and connections implements the same restrictions. For example, an ingestion-maintained candidate cannot depend on data available only at query time, and a 15m consumer cannot connect to a raw-retention candidate covering only 5m.
+These checks include supported modes, deployment capabilities, tumbling-window alignment and coverage, retention guarantees, and producer/consumer timing. Omitting invalid candidates and connections implements the same restrictions. For example, an ingestion-maintained candidate cannot depend on data available only at query time, and a 15m consumer cannot connect to a raw-retention candidate covering only 5m.
 
 Consumer-dependent freshness, invalidation, and lifetime checks may involve several selected connections; pairwise compatibility alone does not establish them. Such checks require a valid joint linear encoding or the feasibility cuts defined below. Retained-state candidates are eligible only with a defined refresh/update policy and its cost. The query-time `run` equations do not constitute an ingestion or retained-state model.
 
@@ -499,7 +499,7 @@ These bounds conservatively allow all selected candidates' allocations to overla
 
 For each query `q`, the configured evaluator must establish latency at or below `Latency_limit[q]` for all required query evaluation events under the declared deployment assumptions. The latency quantity must match the requirement, including any freshness or ingestion-to-visibility component. CPU-time summed over the workload is not query latency, and `order[c]` is not an execution schedule.
 
-Where the configured latency model has a valid linear encoding, include it directly. Otherwise evaluate the selected graph and add a feasibility cut for a failing assignment. For instance, if a particular query-time build path exceeds Q1's deadline but an ingestion-maintained pane path does not, the failing path is excluded without excluding the pane choice. A focused path cut is valid only if omitted choices cannot repair its latency; otherwise use the full-assignment cut below.
+Where the configured latency model has a valid linear encoding, include it directly. Otherwise evaluate the selected graph and add a feasibility cut for a failing assignment. For instance, if a particular query-time build path exceeds Q1's deadline but an ingestion-maintained tumbling window path does not, the failing path is excluded without excluding the tumbling window choice. A focused path cut is valid only if omitted choices cannot repair its latency; otherwise use the full-assignment cut below.
 
 #### Feasibility cuts for checks without a direct linear encoding
 
@@ -545,13 +545,13 @@ Search reductions must preserve joint choices. A candidate that costs more alone
 
 Bounded fixed-calibration search first attempts to obtain a validated seed from a smaller reader-grid/GCD width domain using the same engine, then progressively adds legal widths toward the complete domain. A cached divisor frontier skips rounds that introduce no new width. Logical expansion reuses the pre-state-expansion memo and generates newly introduced window expressions; state expansion, physical inventory, and the MILP are rebuilt for each attempted domain. This is not incremental MILP solving. Only a definite budget stop may fall back to that validated seed; internal errors remain errors. Exhaustive archives and complete-catalog calibration skip this seed phase. Reports distinguish complete-domain generation from exhaustive assignment traversal, and a seed fallback supplies no full-domain optimum or gap certificate. Generation and model construction cooperate with the deadline; individual evaluator calls may overrun it.
 
-Three complementary reductions control dense pane inventories:
+Three complementary reductions control dense tumbling window inventories:
 
 - **Compatibility memoization and producer-list sharing.** Cache exact compatibility subproblems and intern identical ordered producer lists. Separate input positions still have separate connection decisions. This reduces repeated checking and storage, not the logical edge count or MILP variable count by itself.
-- **Terminal reader factoring.** Equivalent unary summary estimators and exact-accumulator finalizers used only by query outputs can become one reader template with the union of their compatible producers. Equality includes operator parameters, result contracts, timing, materialization, local cost, input contracts, and output eligibility. Each output retains an independent binding through execution scopes; consumers may still choose different producers. Internal readers and pane-merge operators are excluded. In particular, merges with different pane counts are not interchangeable.
+- **Terminal reader factoring.** Equivalent unary summary estimators and exact-accumulator finalizers used only by query outputs can become one reader template with the union of their compatible producers. Equality includes operator parameters, result contracts, timing, materialization, local cost, input contracts, and output eligibility. Each output retains an independent binding through execution scopes; consumers may still choose different producers. Internal readers and tumbling-window-merge operators are excluded. In particular, merges with different tumbling-window counts are not interchangeable.
 - **Progressive width generation.** Spend the shared planning budget on successively larger finite domains and retain the best validated incumbent across rounds. Report attempted domains and pending widths. A restricted-domain lower bound or gap is not a certificate for the complete domain; only a completed full-domain solve can provide that certificate.
 
-The first two reductions preserve the represented choices under their stated contracts; the third controls work before a timeout and may leave choices unexplored. General cost-based DP compression needs a richer boundary contract covering sharing, resource use, accuracy, and execution demand; it is not implied by compatibility memoization. Fine pane widths cannot be discarded merely because their local cost is high.
+The first two reductions preserve the represented choices under their stated contracts; the third controls work before a timeout and may leave choices unexplored. General cost-based DP compression needs a richer boundary contract covering sharing, resource use, accuracy, and execution demand; it is not implied by compatibility memoization. Fine tumbling-window widths cannot be discarded merely because their local cost is high.
 
 Within the seed budget, the same MILP can also hold a validated plan's computations and producer connections fixed and try supported query-time materializations. The normal evaluator measures whether retaining a shared result avoids enough repeated upstream work to reduce cost. These limited proposals use the existing solve/evaluation budgets; their bounds and infeasibility apply only to the restricted proposal, never to the full search. This does not create another selector or an optimality claim for the seed.
 
@@ -598,7 +598,7 @@ Generate memo candidates and compatible connections
 
 The MILP retains shared producer activation, configuration, consumer assignment, connection-dependent demand, and global resource constraints. Local plans can replace their internal decisions only if boundary compatibility, cost ownership, and all cross-region constraints are preserved, including acyclicity after expansion. Shared raw retention is a boundary decision even when the computation regions otherwise appear independent. Nonseparable pricing or scheduling interactions must likewise remain represented jointly.
 
-Pane width follows the same rule. A pane chain used exclusively inside a region can be optimized locally over its generated legal widths. A chain potentially shared across regions must expose its width, coverage, materialization, and guarantees as boundary configurations. Fixing each query's locally cheapest width before joint selection can discard the globally cheapest shared chain.
+Tumbling-window width follows the same rule. A tumbling-window chain used exclusively inside a region can be optimized locally over its generated legal widths. A chain potentially shared across regions must expose its width, coverage, materialization, and guarantees as boundary configurations. Fixing each query's locally cheapest width before joint selection can discard the globally cheapest shared chain.
 
 ### Independent components and global budgets
 
@@ -636,7 +636,7 @@ The candidate memo and its Pass 2 rules belong in `logical-asap-optimization`; p
 
 Evaluation must distinguish generation coverage from selection correctness. Small workloads are exhaustively enumerated over candidate subsets and compatible connections under the same inventory, then compared with MILP results. Cases include multiple selected candidates in one group, shared build costs, separate execution scopes, fusion outputs, and composed accuracy/resource requirements. Scaling experiments measure candidate and connection counts, generation and solve time, planner memory, and validated execution savings. Together these measurements establish whether the representation avoids repeated search work and whether joint selection justifies its planning cost.
 
-For decomposition, compare the original MILP, DP-compressed MILP, and exhaustive enumeration on small inventories. They must agree on feasible optima under the same models. Include shared build ownership, differing evaluation alignments, global memory budgets, competing pane widths, external reuse opportunities, and expansion-time acyclicity. Measure local DP time, boundary-state/frontier sizes, candidate and connection counts before/after compression, and total planning time; fewer MILP variables alone do not establish a speedup.
+For decomposition, compare the original MILP, DP-compressed MILP, and exhaustive enumeration on small inventories. They must agree on feasible optima under the same models. Include shared build ownership, differing evaluation alignments, global memory budgets, competing tumbling-window widths, external reuse opportunities, and expansion-time acyclicity. Measure local DP time, boundary-state/frontier sizes, candidate and connection counts before/after compression, and total planning time; fewer MILP variables alone do not establish a speedup.
 
 ### Expected planning performance and execution benefits
 
diff --git a/docs/design_docs/proposals/planner-layering-example1-acceptance.md b/docs/design_docs/proposals/planner-layering-example1-acceptance.md
index 94cc4f30c..176692367 100644
--- a/docs/design_docs/proposals/planner-layering-example1-acceptance.md
+++ b/docs/design_docs/proposals/planner-layering-example1-acceptance.md
@@ -18,8 +18,8 @@ whose expectation needs a feature that is not in the stack yet is
 | Stage | Doc (#509) | MVP (this spec) |
 |---|---|---|
 | Query-language frontends | 1 workload `LogicalDAG` | same |
-| Logical ASAP-aware optimization | Pass 1 (3) × identical-expression rule (2) × window-composition rule (3 × 3) = **54** | Pass 1 (3), each with 2 identical-expression candidates and 6 window-composition candidates (Q1's rate and Q2's option in six 10-s tumbling panes, alone or both, each also with a shared scan) = **27**. Sliding windows are not implemented. |
-| Physical ASAP-aware optimization | Materialization options per window form = **156** | Physical operator implementation, plus materialization: each logical candidate with every sub-DAG `NotMaterialized` (27: the doc's Raw plans, with panes rebuilt at every refresh), each pane chain also `MatAtIngestion(Memory)` (30 more), and each shared input built once per evaluation, `MatAtQuery(Memory)`, with every pane chain at query time (15 more) = **72** |
+| Logical ASAP-aware optimization | Pass 1 (3) × identical-expression rule (2) × window-composition rule (3 × 3) = **54** | Pass 1 (3), each with 2 identical-expression candidates and 6 window-composition candidates (Q1's rate and Q2's option in six 10-s tumbling windows, alone or both, each also with a shared scan) = **27**. Sliding windows are not implemented. |
+| Physical ASAP-aware optimization | Materialization options per window form = **156** | Physical operator implementation, plus materialization: each logical candidate with every sub-DAG `NotMaterialized` (27: the doc's Raw plans, with tumbling windows rebuilt at every refresh), each tumbling-window chain also `MatAtIngestion(Memory)` (30 more), and each shared input built once per evaluation, `MatAtQuery(Memory)`, with every tumbling-window chain at query time (15 more) = **72** |
 | Plan selection | 1 plan | 1 plan |
 
 Every MVP candidate is one of the doc's candidates: in logical ASAP-aware
@@ -111,9 +111,9 @@ Invariants:
 
 * Every logical candidate keeps its all-`NotMaterialized` physical candidate,
   and none is pruned, so no candidate is dropped before plan selection. A
-  logical candidate with `n` pane chains has 2ⁿ physical candidates: each
+  logical candidate with `n` tumbling-window chains has 2ⁿ physical candidates: each
   chain `NotMaterialized` or `MatAtIngestion(Memory)` (ids `P<n>-m<k>`).
-  Only pane chains are placed at ingestion time; Q1's rate panes may be,
+  Only tumbling-window chains are placed at ingestion time; Q1's rate tumbling windows may be,
   because continuously ingesting PromQL data is taken to arrive in time
   order per series. A logical candidate with a shared input has one more:
   the highest node both queries read (the scan, or the time range above
@@ -141,13 +141,13 @@ Invariants:
 | P10 | invalid | Count-Min + heap: a top-*k* output has no guarantee (a heap's bound is per item frequency, not top-*k* membership), and the deployment has no evidence that it meets the target |
 | P19 | invalid | CountSketch + heap: the same reason |
 
-The 48 heap candidates (whole window or panes, rebuilt or maintained,
+The 48 heap candidates (whole window or tumbling windows, rebuilt or maintained,
 with or without a shared input built once) are invalid for that reason; the
 other 23 exact candidates are valid but costlier. Count-Min's weights are the raw samples of `http_requests_total`,
 which the workload declares a counter, so they are proven non-negative;
 without that declaration Count-Min is also rejected on its weights. Exact
-panes rebuilt at every refresh cost 7.79, and maintaining a query's exact
-panes at ingestion time costs about 54.0.
+tumbling windows rebuilt at every refresh cost 7.79, and maintaining a query's exact
+tumbling windows at ingestion time costs about 54.0.
 
 Invariants:
 
@@ -189,7 +189,7 @@ per evaluation, within its 100 ms.
    The planner also reads "physical operator implementation" from the
    physical ASAP-aware optimization section ("TopK as a sort followed by a
    limit"), and enumerates materialization for summary builds and shared
-   inputs: each pane chain is `NotMaterialized` or `MatAtIngestion(Memory)`,
+   inputs: each tumbling-window chain is `NotMaterialized` or `MatAtIngestion(Memory)`,
    and the highest node both queries read is `NotMaterialized` or
    `MatAtQuery(Memory)`.
 5. **Where exact top-*k* becomes sort + limit.** The Pass 1 diagram draws
@@ -209,7 +209,7 @@ per evaluation, within its 100 ms.
 8. **Latency.** The doc says an exact top 10 rebuilt at every refresh "may
    miss" 100 ms. With the illustrative calibration it takes about 46 ms, so
    the exact plan meets the bound.
-9. **Accuracy of Count-Min heap merges.** The heap panes are invalid like
+9. **Accuracy of Count-Min heap merges.** The heap tumbling windows are invalid like
    their whole-window builds, so the approximate merge is never judged.
 10. **Input sharing in Pass 2.** The doc gives each Pass 1 candidate "2 input
     choices (separate or shared)". Following Algorithm 2 line 31 (one
diff --git a/docs/design_docs/proposals/planner-layering-example2-acceptance.md b/docs/design_docs/proposals/planner-layering-example2-acceptance.md
index 018c77727..0932addcc 100644
--- a/docs/design_docs/proposals/planner-layering-example2-acceptance.md
+++ b/docs/design_docs/proposals/planner-layering-example2-acceptance.md
@@ -101,7 +101,7 @@ evaluation.
 | Each node of a valid candidate is charged once per consuming query while `NotMaterialized`, once when materialized | `stage3_plan_selection_charges_each_node_per_consuming_query` | passes |
 | No candidate builds a Theta sketch | `stage3_plan_selection_has_no_theta_candidate` | passes |
 | A UnivMon estimate has a guarantee, so it is judged against its target instead of rejected for having none | `stage3_plan_selection_judges_univmon_with_an_accuracy_model` | ignored: needs a UnivMon entropy accuracy model (#788); L2 and the distinct count have one |
-| Given a distinct bound for the source, classic HLL's failure probability is bound and Q1's HLL is accepted; a larger bound enlarges its precision, also in a tumbling-pane chain | `stage3_plan_selection_accepts_hll_given_a_distinct_bound`, `…_enlarges_hll_for_a_larger_distinct_bound`, `…_enlarges_tumbling_pane_hll` | passes |
+| Given a distinct bound for the source, classic HLL's failure probability is bound and Q1's HLL is accepted; a larger bound enlarges its precision, also in a tumbling-window chain | `stage3_plan_selection_accepts_hll_given_a_distinct_bound`, `…_enlarges_hll_for_a_larger_distinct_bound`, `…_enlarges_tumbling_window_hll` | passes |
 | KMV certifies Q1 for any failure probability, without a distinct bound | `stage3_plan_selection_accepts_kmv_for_any_failure_probability_without_a_bound` | passes |
 | UnivMon's distinct count is certified given a distinct bound its layers cover; its L2 is certified from layer 0 alone, also through SQL Q3's exact population count and `CASE` | `stage3_plan_selection_accepts_univmon_distinct_given_a_distinct_bound`, `…_rejects_univmon_distinct_past_its_layers`, `…_accepts_univmon_l2` | passes |
 | One materialized UnivMon for all three costs no more than three separate UnivMons | `stage3_plan_selection_shared_univmon_costs_no_more_than_three` | ignored: needs a UnivMon entropy accuracy model (#788) |
diff --git a/docs/design_docs/proposals/planner-layering-example3-acceptance.md b/docs/design_docs/proposals/planner-layering-example3-acceptance.md
index 49872955f..3e885ea21 100644
--- a/docs/design_docs/proposals/planner-layering-example3-acceptance.md
+++ b/docs/design_docs/proposals/planner-layering-example3-acceptance.md
@@ -44,9 +44,9 @@ Shared data workload, except Pattern A's `arrival` is `Mixed`.
 |---|---|---|
 | Query-language frontends | A: five scan → range → quantile chains. B: one. | Same; q3–q5 also have a `time_shift`. |
 | Logical ASAP-aware optimization, Pass 1 | A: exact or KLL over its own interval per query, 2⁵ = 32. B: exact, KLL. | A: exact, KLL (k = 547), DDSketch per query, 3⁵ = **243**. B: exact, KLL (k = 269), DDSketch, **3**. |
-| Logical ASAP-aware optimization, Pass 2 | A: window composition adds one EH of KLLs over [T − 5 y, T], one merge + p99 estimate per query, plus a candidate for every grouping of two or more queries onto shared window summaries ("hundreds"). B: each Pass 1 option × {none, sliding L = 5 min s = 1 min (5 active windows), 1-min tumbling (merge 5)} = 6. Independent kept. | Identical-expression rule: each Pass 1 candidate also gets its shared-input candidates (A: 3 per Pass 1 candidate; B: none). Window-composition rule, tumbling panes only: B's KLL and DDSketch each also come as 1-min tumbling panes (a `SummaryTumblingWindowChain` of 5, merged before the p99 estimate), **5** in all; A is run once, so it gets none. No sliding windows or EHs. |
-| Physical ASAP-aware optimization | See Example 4. | Each logical candidate with every sub-DAG `NotMaterialized` (A: 972; B: 5), plus, for A, each highest shared input (a scan or a shift) also built once per evaluation, `MatAtQuery(Memory)` (A: 2,187 in all), and, for B, each pane chain maintained `MatAtIngestion(Memory)` (B: 7 in all). |
-| Plan selection | Not stated for Example 3. | A: 288 valid, 1,899 invalid: every candidate with a DDSketch misses the rank target (its bound is relative). KLL for all five queries (P485) is selected at 207,189.43 per second (cost model 1); all exact costs 327,132,784.05, about 1,600 times as much, its values held for the whole of each long query. B: KLL (P2, 2.363 per second); the 1-min KLL panes rebuilt at every evaluation cost 3.611 (the same rows and updates plus merging 5 panes per series, and the panes held while the query runs); maintained at ingestion time they keep six panes of 1,000,000 per-series KLLs for 654.54; exact costs 2.458; DDSketch, whole or in panes, misses the rank target. Every valid B plan meets 200 ms: 126 ms for the whole-window KLL, 131 ms for the rebuilt panes, 7 ms for the maintained panes, 144 ms exact. |
+| Logical ASAP-aware optimization, Pass 2 | A: window composition adds one EH of KLLs over [T − 5 y, T], one merge + p99 estimate per query, plus a candidate for every grouping of two or more queries onto shared window summaries ("hundreds"). B: each Pass 1 option × {none, sliding L = 5 min s = 1 min (5 active windows), 1-min tumbling (merge 5)} = 6. Independent kept. | Identical-expression rule: each Pass 1 candidate also gets its shared-input candidates (A: 3 per Pass 1 candidate; B: none). Window-composition rule, tumbling windows only: B's KLL and DDSketch each also come as 1-min tumbling windows (a `SummaryTumblingWindowChain` of 5, merged before the p99 estimate), **5** in all; A is run once, so it gets none. No sliding windows or EHs. |
+| Physical ASAP-aware optimization | See Example 4. | Each logical candidate with every sub-DAG `NotMaterialized` (A: 972; B: 5), plus, for A, each highest shared input (a scan or a shift) also built once per evaluation, `MatAtQuery(Memory)` (A: 2,187 in all), and, for B, each tumbling-window chain maintained `MatAtIngestion(Memory)` (B: 7 in all). |
+| Plan selection | Not stated for Example 3. | A: 288 valid, 1,899 invalid: every candidate with a DDSketch misses the rank target (its bound is relative). KLL for all five queries (P485) is selected at 207,189.43 per second (cost model 1); all exact costs 327,132,784.05, about 1,600 times as much, its values held for the whole of each long query. B: KLL (P2, 2.363 per second); the 1-min KLL tumbling windows rebuilt at every evaluation cost 3.611 (the same rows and updates plus merging 5 tumbling windows per series, and the tumbling windows held while the query runs); maintained at ingestion time they keep six tumbling windows of 1,000,000 per-series KLLs for 654.54; exact costs 2.458; DDSketch, whole or in tumbling windows, misses the rank target. Every valid B plan meets 200 ms: 126 ms for the whole-window KLL, 131 ms for the rebuilt tumbling windows, 7 ms for the maintained tumbling windows, 144 ms exact. |
 
 ## Invariants and tests
 
@@ -74,16 +74,16 @@ Shared data workload, except Pattern A's `arrival` is `Mixed`.
 | The query lowers to scan → range 5m → quantile, no summary | `stage0_query_language_frontends_b_lowers_to_one_range_quantile` | passes |
 | Exact and KLL options | `stage1_logical_asap_optimization_b_pass1_offers_exact_and_kll` | passes |
 | Each summary option appears with no window, a 5-min sliding window with a 1-min slide, and 1-min tumbling windows | `stage1_logical_asap_optimization_b_window_composition_adds_sliding_and_tumbling_per_option` | ignored: sliding (#522) |
-| Each summary option appears with no window and as 1-min tumbling panes, 5 merged before the estimate | `stage1_logical_asap_optimization_b_window_composition_adds_tumbling_per_mergeable_option` | passes |
+| Each summary option appears with no window and as 1-min tumbling windows, 5 merged before the estimate | `stage1_logical_asap_optimization_b_window_composition_adds_tumbling_per_mergeable_option` | passes |
 | Window parameters are legal: L divides W; s divides L and the evaluation interval; a tumbling length divides W and the interval | `stage1_logical_asap_optimization_b_window_parameters_are_legal` | passes |
 | Sliding with L = W has no merge; tumbling merges before the estimate | `stage1_logical_asap_optimization_b_merge_only_where_the_window_form_needs_it` | ignored: sliding (#522) |
 | A window form that merges uses a mergeable summary (KLL, DDSketch), in both patterns | `stage1_logical_asap_optimization_window_merges_use_mergeable_summaries` | passes |
 | One selected, cheapest valid, each node charged once per consuming query | `stage3_plan_selection_b_selects_cheapest_valid` | passes |
-| Panes rebuilt at query time cost the whole build plus the merge; whole-window KLL is selected | `stage3_plan_selection_b_panes_rebuilt_at_query_time_add_the_merge` | passes |
+| Tumbling windows rebuilt at query time cost the whole build plus the merge; whole-window KLL is selected | `stage3_plan_selection_b_tumbling_windows_rebuilt_at_query_time_add_the_merge` | passes |
 
 **Reading window summaries.** Tests read a build's window summary through
 `planner_layering_common::window_form(dag, build)`: a `SummaryTumblingWindowChain` is
-`Tumbling { length_ms }` (its pane width), and any other build `None`.
+`Tumbling { length_ms }` (its tumbling-window width), and any other build `None`.
 `Sliding { length_ms, slide_ms }` and `ExponentialHistogram { horizon_ms }`
 wait for their IR. Merges are read as `SummaryMerge` nodes between the build
 and the `SummaryEstimate`.
diff --git a/docs/design_docs/proposals/planner-layering-example4-acceptance.md b/docs/design_docs/proposals/planner-layering-example4-acceptance.md
index ce03e06a3..65b0b1a5f 100644
--- a/docs/design_docs/proposals/planner-layering-example4-acceptance.md
+++ b/docs/design_docs/proposals/planner-layering-example4-acceptance.md
@@ -49,16 +49,16 @@ every other logical candidate gets its own the same way (not counted).
 time, both kept. Not materializing it is the no-window plan, so it is not a
 separate option.
 
-**Today:** Pass 2 builds tumbling panes (`SummaryTumblingWindowChain`), and physical
+**Today:** Pass 2 builds tumbling windows (`SummaryTumblingWindowChain`), and physical
 ASAP-aware optimization enumerates `NotMaterialized`, `MatAtIngestion` and
 `MatAtQuery` (state reused within one evaluation) for every summary build.
-B1 and B2 exist. B3 (panes built at query time and kept across
+B1 and B2 exist. B3 (tumbling windows built at query time and kept across
 evaluations) is offered when the deployment declares
 `query_time_results_retained` in its `deployment_capabilities`: Stage 2 then
-adds `MatAtQueryKeptAcrossEvaluations` for a tumbling-pane chain that builds
-one new pane per evaluation. Pattern A's shared EH needs window segments shared across
+adds `MatAtQueryKeptAcrossEvaluations` for a tumbling-window chain that builds
+one new tumbling window per evaluation. Pattern A's shared EH needs window segments shared across
 queries (#628, #634), so A1–A3 do not exist yet. B3's
-4 kept panes plus the newest cost 436.59 per second under cost model 1,
+4 kept tumbling windows plus the newest cost 436.59 per second under cost model 1,
 between B2 (3.611) and B1 (654.54).
 
 ## Invariants and tests
@@ -69,7 +69,7 @@ between B2 (3.611) and B1 (654.54).
 medium (`MatAtIngestion`, `MatAtQuery`, `NotMaterialized`), and the kept
 event-time span through `retention_ms(p, node)`. The IR does not record
 retention, so the adapter derives it the way plan selection prices kept
-state: a chain of `N` panes of width `w` keeps `N·w`, plus one pane while
+state: a chain of `N` tumbling windows of width `w` keeps `N·w`, plus one tumbling window while
 maintained at ingestion time; a whole-window build keeps its window, plus
 the next one at ingestion time; each plus the offset of the shifts below
 it.
@@ -78,7 +78,7 @@ it.
 
 | Invariant | Test | Status |
 |---|---|---|
-| Every node upstream of an ingestion-time node also runs at ingestion time (all variants) | `stage2_physical_asap_optimization_ingestion_time_upstream_is_ingestion_time`; the monthly variant in `stage2_physical_asap_optimization_monthly_ingestion_time_upstream_is_ingestion_time` | passes: B1 and the monthly variant's maintained panes; the monthly test is ignored as slow (run in release by hand) |
+| Every node upstream of an ingestion-time node also runs at ingestion time (all variants) | `stage2_physical_asap_optimization_ingestion_time_upstream_is_ingestion_time`; the monthly variant in `stage2_physical_asap_optimization_monthly_ingestion_time_upstream_is_ingestion_time` | passes: B1 and the monthly variant's maintained tumbling windows; the monthly test is ignored as slow (run in release by hand) |
 | With data at rest, no node runs at ingestion time | `stage2_physical_asap_optimization_at_rest_runs_nothing_at_ingestion_time` | passes |
 | A materialized output covers its consumers: retention ≥ max over its readers of `lookback` + offset | `stage2_physical_asap_optimization_materialized_output_covers_its_consumers`; the monthly variant in `stage2_physical_asap_optimization_monthly_materialized_output_covers_its_consumers` | passes: B1 keeps 6 min ≥ 5 min; the monthly test is ignored as slow (run in release by hand) |
 
diff --git a/docs/design_docs/proposals/planner-layering.md b/docs/design_docs/proposals/planner-layering.md
index f3deb1320..887be27b7 100644
--- a/docs/design_docs/proposals/planner-layering.md
+++ b/docs/design_docs/proposals/planner-layering.md
@@ -275,7 +275,7 @@ lists each stage's input and output types.
 | DAG of logical memo groups | `DagOfLogicalMemoGroups` | Stage 0's groups, before any implementation choice: the workload's logical DAG hash-consed (below). |
 | Memo candidates | `MemoCandidates` | The groups, and the candidates for each memo group (`candidates[group]`). Pass 1 creates it from the DAG of logical memo groups; the Pass 2 rules add candidates and groups. |
 | Candidate for a memo group | `CandidateForMemoGroup` | One way to implement a group over child groups. `fused_groups`: for a fused computation, the groups it absorbs beyond the group whose candidate it is; empty otherwise. `root_node`: its own nodes, down to the nodes of the groups it reads. `input_groups`: the groups it reads, whose implementations are chosen separately. `origin`: the rule that made it (`OriginOfCandidateForMemoGroup`, below). `accuracy_budget_parts`: the number of equal shares of the accuracy budget its summaries are sized for, 1 for the whole budget and `n` when it is one of `n` approximate inputs of a query. |
-| Concrete summary-state group | a `MemoGroup` whose node is a `SummaryAgg` or a `SummaryTumblingWindowChain` | One summary state at one size, or one pane chain at one layout, that several readers may share. A choice several groups depend on, such as a shared size or a pane grid, is one concrete group per value, when two or more readers may read that value, and each of them gets a candidate reading that group: of two readers needing a KLL with `k ≥ 345` and `k ≥ 200`, both may read a group `KLL(345)`, and the second may also keep its own private `KLL(200)`. Choosing a value is choosing a group, so the memo has no separate type for such a choice. The other Pass 2 rules add groups too (below). |
+| Concrete summary-state group | a `MemoGroup` whose node is a `SummaryAgg` or a `SummaryTumblingWindowChain` | One summary state at one size, or one tumbling-window chain at one layout, that several readers may share. A choice several groups depend on, such as a shared size or a tumbling-window grid, is one concrete group per value, when two or more readers may read that value, and each of them gets a candidate reading that group: of two readers needing a KLL with `k ≥ 345` and `k ≥ 200`, both may read a group `KLL(345)`, and the second may also keep its own private `KLL(200)`. Choosing a value is choosing a group, so the memo has no separate type for such a choice. The other Pass 2 rules add groups too (below). |
 
 **Stage 0: hash-consing.** Hash-consing merges structurally equal nodes into
 one. It makes no implementation choice, so this section counts it as Stage 0
@@ -305,13 +305,13 @@ They may still read one shared child group.
 made it in `OriginOfCandidateForMemoGroup`. Rules add candidates and keep the existing
 ones. A rule that shares a producer (a widened scan, a canonical
 preprocessing, a ranking, a finer aggregate, a summary readout, a summary
-state or pane chain) also adds one group for it, with one candidate of the
+state or tumbling-window chain) also adds one group for it, with one candidate of the
 rule's origin, and gives each reader a candidate that reads that group.
 
 | `OriginOfCandidateForMemoGroup` | Added by | Candidates |
 |---|---|---|
 | `Pass1` | `try_populate_pass1` (`pass2/memo/groups.rs`) | Every Pass 1 choice of the group's measures: exact, exact accumulator, each summary family and size, and fused computations. Each summary choice comes at every `accuracy_budget_parts` from 1 to the most approximate inputs a query reaching the group has. A fused candidate implements the groups it absorbs only when no other reader needs them; otherwise they stay groups of their own. |
-| `Panes` | Window composition: `add_local_window_composition` and `extend_local_window_composition` (`pass2/memo/window_candidates.rs`) | A window summary computed from tumbling panes, at each pane width the reader's evaluation grid allows. The pane chain stays private to the candidate. |
+| `TumblingWindows` | Window composition: `add_local_window_composition` and `extend_local_window_composition` (`pass2/memo/window_candidates.rs`) | A window summary computed from tumbling windows, at each tumbling-window width the reader's evaluation grid allows. The tumbling-window chain stays private to the candidate. |
 | `WidenedScans` | Scan widening: `add_scan_label_candidates` (`pass2/memo/rules/scan_labels.rs`) | A reader of a metric's scans widened to a shared label set, read through a `Project`. |
 | `SummaryInput` | `factor_summary_inputs` (`pass2/memo/rules/summary_inputs.rs`) | Canonical value preprocessing feeding a summary build. |
 | `TopKReuse` | Exact top-k reuse: `add_topk_candidates` (`pass2/memo/rules/topk.rs`) | One ranking (`Limit(k_max)` over `Sort`), and each top-k reading its first `k` rows from it. |
@@ -321,7 +321,7 @@ rule's origin, and gives each reader a candidate that reads that group.
 
 The state-configuration rule (`pass2/memo/rules/shared_configuration_readers.rs`) runs just
 before the shared builds are found. It rewrites readers to each shared size
-and to the newest panes of each pane chain layout they may read, so that
+and to the newest tumbling windows of each tumbling-window chain layout they may read, so that
 equal builds appear, and a rewrite keeps the origin of the candidate it
 rewrites.
 
@@ -332,7 +332,7 @@ instead of whole candidates:
 |---|---|
 | 0 | Hash-conses the frontends' roots into groups (`DagOfLogicalMemoGroups`). |
 | 1, Pass 1 | Emits the candidates for each memo group: exact, exact accumulator, each summary family and size, fused computations. |
-| 1, Pass 2 | Each rule adds candidates to groups. Identical expression is group identity (nothing to add). Summary capability: a reader reading a concrete summary-state group shared with other groups, one group per shared size. Window composition: tumbling panes, and the newest panes of a shared chain, one concrete group per chain layout (grid, longest window, size). Rollup and exact top-k reuse: a candidate that reads another group (a finer grouping, a ranking). Scan widening: a reader of a metric's scans widened to a shared label set. |
+| 1, Pass 2 | Each rule adds candidates to groups. Identical expression is group identity (nothing to add). Summary capability: a reader reading a concrete summary-state group shared with other groups, one group per shared size. Window composition: tumbling windows, and the newest tumbling windows of a shared chain, one concrete group per chain layout (grid, longest window, size). Rollup and exact top-k reuse: a candidate that reads another group (a finer grouping, a ranking). Scan widening: a reader of a metric's scans widened to a shared label set. |
 | 2 | Chooses each candidate's materialization, once for a group however many parents read it. A scan read through one window is built once; one read through different windows may also be read per reader. |
 | 3 | Chooses one candidate per needed group, and costs each candidate's own nodes, per node, given its readers; plan-level charges are added once per plan. A source's retained raw data is a concrete group `raw window(S, H)`, one per distinct lookback `H` of the source's query-time readers (a window plus any offset); its storage of `H` of raw data is charged once when it is chosen (planned). |
 
@@ -388,7 +388,7 @@ target's 0.001 divided over the source's 10,000 series. The memo stands for 7 ×
 - 33 size at least one operand's summary for half of the budget.
 
 **Step 3, Stage 1 Pass 2: window composition.** The groups stay the same 7.
-G2 and G4 get 120 `Panes` candidates each (6 summary candidates × 20 pane
+G2 and G4 get 120 `TumblingWindows` candidates each (6 summary candidates × 20 tumbling window
 widths, from 1 s to 60 s, that divide one minute), 127 candidates each in
 all; the memo has 259 candidates.
 
@@ -396,7 +396,7 @@ all; the memo has 259 candidates.
 (rules 2–9 of `generate_logical_asap_memo_candidates`, then
 `add_shared_summary_state_groups`):
 - 354 groups: the 7 above; 336 `SummaryTumblingWindowChain` groups (7 summary configurations
-  × 48 pane layouts, with pane widths from 20 ms to 60 s); 7 `SummaryAgg`
+  × 48 tumbling-window layouts, with tumbling-window widths from 20 ms to 60 s); 7 `SummaryAgg`
   state groups (the 6 summaries above and a KLL with `k` 1156,
   `failure_probability` 1e-7); 2 `SummaryAgg` groups for G6's sum and count
   accumulators; and 2 `FinalizeExactAccumulator` groups (G6's sum and count
@@ -406,7 +406,7 @@ all; the memo has 259 candidates.
   rule rewrote to the shared configurations with `k` 567, 1156 and 1184; each
   keeps `accuracy_budget_parts` 1, and the `k` 1184 one composes the same DAG as the
   `accuracy_budget_parts` 2 KLL),
-  336 `Panes` and 345 `SharedBuild`. G6 has 3: `Pass1`, `SummaryResult` and
+  336 `TumblingWindows` and 345 `SharedBuild`. G6 has 3: `Pass1`, `SummaryResult` and
   `SharedBuild`.
 - Enumeration stops at `stage_pipeline`'s default limit of 1,000 candidate
   DAGs (`--memo-enumeration-limit`), as it does after step 3.
@@ -426,7 +426,7 @@ with accuracy guarantees enforced and the `aws-fargate-us-east-1` cost model).
 production does (with the series-identity column) and reads the memo from the
 production run. It asserts the Stage 0 and Pass 1 numbers above. The last
 step is the memo of the planning round whose plan was selected, so it depends
-on the time budget; the test runs one round over the complete pane-width
+on the time budget; the test runs one round over the complete tumbling-window-width
 domain, which gives 438 groups and 2158 candidates.
 
 #### Algorithm: memo to candidate DAGs
@@ -500,7 +500,7 @@ recursion depth is the number of needed groups, and memory holds at most
 #### How the search uses the memo
 
 Hash-cons the workload into groups; generate each group's candidates (Pass 1,
-then the Pass 2 transformations), and expand shared sizes, pane horizons and
+then the Pass 2 transformations), and expand shared sizes, tumbling-window horizons and
 (planned) raw windows into concrete groups, so that choosing a threshold is
 choosing a group; choose one candidate per needed group; compose the choice
 into one plan and check and cost it with Stage 2 and Stage 3. The search is a
@@ -510,9 +510,9 @@ Stage 3 validate and cost it, and each validated cost constrains the MILP
 again (evaluator-backed refinement). Stage 3 realizes each proposed choice
 through Stage 2's `AssignmentRealizer`, which the facade builds and passes in,
 so Stage 3 does not depend on the Stage 2 crate. The facade first finds an
-incumbent (the best validated plan so far) in a round over seed pane grids,
-then exposes finer pane widths in later rounds, each round running Pass 2,
-Stage 2 and Stage 3; only a completed round over the full pane-width domain
+incumbent (the best validated plan so far) in a round over seed tumbling-window grids,
+then exposes finer tumbling-window widths in later rounds, each round running Pass 2,
+Stage 2 and Stage 3; only a completed round over the full tumbling-window-width domain
 bounds the declared search space, and otherwise the result is the best
 validated plan found. On tiny catalogs, tests check that this
 bounded search selects the same plan cost as a complete traversal of the same
@@ -532,9 +532,9 @@ candidates is in `crates/plan-selection/src/search/`.
 | Stage 0 | `generate_dag_of_logical_memo_groups` → `DagOfLogicalMemoGroups`, `MemoGroup`, `MemoGroupId` | `pass2/memo.rs` (the types: `asap_types::stages`); hash-consing is `share_common_sub_dags` in `pass2/cse.rs` |
 | Pass 1 | `generate_per_computation_logical_memo_candidates` → `PerComputationLogicalMemoCandidates` (with `ComputationTarget` and `HowToComputeAggregateMeasure`, in `asap_types::stages`), the one entry: inside it, the computation targets (walking the memo groups), the summaries the deployment does not support and those no query can use pruned, the candidates attached to the groups (`try_populate_pass1`), then the accuracy-scoped sizes | `pass1/logical_memo_candidates.rs`; `pass1/per_computation_candidates.rs`; `pass2/memo/groups.rs` |
 | Memo types | `DagOfLogicalMemoGroups`, `PerComputationLogicalMemoCandidates` (with `ComputationTarget`, `FusedComputation`, `HavingEntry`, `HavingPlacement`, `HowToComputeAggregateMeasure`), `MemoCandidates`, `CandidateForMemoGroup`, `OriginOfCandidateForMemoGroup`, `LogicalASAPMemoCandidates`, `CandidateGenerationTimeout`, `root_groups`, `queries_rooted_at` | `crates/types/src/stages/` (`asap_types::stages`) |
-| Pass 2 | `generate_logical_asap_memo_candidates` → `LogicalASAPMemoCandidates`, one pane-width round over a `Pass2RoundState` (kept between rounds: the memo after step 1 and before the rules, and the widths already generated). It calls in this order: 1. window composition for the round's new widths (`extend_local_window_composition`); 2–9. the rules in `pass2/memo/rules/`: scan widening, summary inputs, top-k reuse, finer aggregate, rollup, window rollup, summary results, state configurations; 10. `add_shared_summary_state_groups`, the shared builds | `pass2/logical_memo_candidates.rs` (`LogicalASAPMemoCandidates` itself: `asap_types::stages`); `pass2/memo/window_candidates.rs`, `pass2/memo/rules/`, `pass2/memo/state_groups.rs`, `pass2/memo/shared_configurations.rs` |
+| Pass 2 | `generate_logical_asap_memo_candidates` → `LogicalASAPMemoCandidates`, one tumbling-window-width round over a `Pass2RoundState` (kept between rounds: the memo after step 1 and before the rules, and the widths already generated). It calls in this order: 1. window composition for the round's new widths (`extend_local_window_composition`); 2–9. the rules in `pass2/memo/rules/`: scan widening, summary inputs, top-k reuse, finer aggregate, rollup, window rollup, summary results, state configurations; 10. `add_shared_summary_state_groups`, the shared builds | `pass2/logical_memo_candidates.rs` (`LogicalASAPMemoCandidates` itself: `asap_types::stages`); `pass2/memo/window_candidates.rs`, `pass2/memo/rules/`, `pass2/memo/state_groups.rs`, `pass2/memo/shared_configurations.rs` |
 | Memo to candidate DAGs | `enumerate`, `build_logical_asap_dags_from_chosen_candidates`, `ChosenCandidatePerMemoGroup`, `AllChosenCandidatesPerMemoGroup`, `ErrorBuildingLogicalASAPDagsFromChosenCandidates` | `pass2/memo/enumeration.rs` (re-exported at the crate root) |
-| Production memo build and search | The facade's `run_planning` builds the DAG of logical memo groups and runs Pass 1 (`generate_per_computation_logical_memo_candidates`) once; then, for each pane-width round, `generate_logical_asap_memo_candidates` (the `Pass2RoundState` is kept between rounds), `generate_physical_asap_memo_candidates` and Stage 3's `select_plan`. It keeps the best round's selection (`asap_cost::PlanRanking`) and builds that plan with Stage 2's `AssignmentRealizer::realize`. Behind `select_plan`: `candidates/`, `milp/` and `refinement/` | `crates/planner/src/run.rs`; `crates/plan-selection/src/search/` |
+| Production memo build and search | The facade's `run_planning` builds the DAG of logical memo groups and runs Pass 1 (`generate_per_computation_logical_memo_candidates`) once; then, for each tumbling-window-width round, `generate_logical_asap_memo_candidates` (the `Pass2RoundState` is kept between rounds), `generate_physical_asap_memo_candidates` and Stage 3's `select_plan`. It keeps the best round's selection (`asap_cost::PlanRanking`) and builds that plan with Stage 2's `AssignmentRealizer::realize`. Behind `select_plan`: `candidates/`, `milp/` and `refinement/` | `crates/planner/src/run.rs`; `crates/plan-selection/src/search/` |
 
 ## ASAPPlanner Detailed Design: Planning Stages and their decisions/Strategies
 
@@ -605,9 +605,9 @@ the memo path's entry points.
 | 0. Frontends | Query text, language → one logical root per query, carrying its accuracy target | Same: a `QueryRoot` per query | `lower_promql_query_workload`, `lower_sql_dialect` (`asap-frontend-*`); `plan_installable` (`asap_planner`) runs the frontends and Stages 1–3 on the user input |
 | 1, Pass 1 | Logical roots; the deployment's supported summaries → the Pass 1 inventory, every computation's candidates (`PerComputationCandidates`, now Pass 1's crate-private working form) | Logical roots → `DagOfLogicalMemoGroups` (hash-consed `MemoGroup`s); with the Pass 1 inventory, less the summaries the deployment does not support and those no query reading them can use → `PerComputationLogicalMemoCandidates`: the `MemoCandidates` (each group's `CandidateForMemoGroup`s, with the accuracy-scoped sizes), the computation targets and the pruned candidates (`PrunedCandidate<HowToComputeAggregateMeasure>`) | `generate_dag_of_logical_memo_groups`, `generate_per_computation_logical_memo_candidates` |
 | 1, Pass 2 | One Pass 1 choice per computation → that choice rewritten by each sharing rule, every subset of sharing choices (no longer in the code) | `MemoCandidates`; the entries' recurrence and range steps → the same memo with each rule's candidates added to the groups they implement | the memo rules (`pass2/memo/rules/`), `pass2::memo::window_candidates` |
-| 1, concrete summary-state groups | (part of Pass 2) | `MemoCandidates` → the memo with concrete summary-state groups: one group per shared size or pane layout that readers can read | `add_shared_summary_state_groups`, Pass 2's last step; the Pass 2 output is `LogicalASAPMemoCandidates` (`generate_logical_asap_memo_candidates`) |
+| 1, concrete summary-state groups | (part of Pass 2) | `MemoCandidates` → the memo with concrete summary-state groups: one group per shared size or tumbling-window layout that readers can read | `add_shared_summary_state_groups`, Pass 2's last step; the Pass 2 output is `LogicalASAPMemoCandidates` (`generate_logical_asap_memo_candidates`) |
 | 2 | One whole-workload logical candidate; entries (recurrence, predictability), `DataWorkload`, query-time retention → its physical candidates, one per materialization assignment | `LogicalASAPMemoCandidates`; entries, `DataWorkload`, query-time and raw-data retention → `PhysicalASAPMemoCandidates`: every operator node of every candidate with each allowed timing and materialization (one physical candidate each, no copies), the producers of each input, reader constraints (each applied to every selected run of its candidate), and the pruned candidates (`PrunedCandidate<PhysicalCandidateKey>`) | `generate_physical_asap_memo_candidates` (`asap_physical_asap_optimization`) |
-| 3 | Every physical candidate; accuracy targets, accuracy model and evidence, cost model → one plan | `PhysicalASAPMemoCandidates`; entries, `DataWorkload`, `AccuracyCheckInputs`, `CostInputs`, Stage 2's realizer, a deadline → `Selection`: the selected plan (`selected_dag`, a `DagOfSelectedCandidates`: one node per run of a candidate, so a candidate recomputed by two readers or shared as two instances over different inputs is two nodes, with an edge per input), its cost, the accepted accuracy per query and the search report | `select_plan` (`asap_plan_selection`); the facade (`run_planning`, output `PlanningRun`) runs it per pane-width round and builds the selected `PhysicalWorkloadPlan` with `AssignmentRealizer::realize`, one plan node per selected node |
+| 3 | Every physical candidate; accuracy targets, accuracy model and evidence, cost model → one plan | `PhysicalASAPMemoCandidates`; entries, `DataWorkload`, `AccuracyCheckInputs`, `CostInputs`, Stage 2's realizer, a deadline → `Selection`: the selected plan (`selected_dag`, a `DagOfSelectedCandidates`: one node per run of a candidate, so a candidate recomputed by two readers or shared as two instances over different inputs is two nodes, with an edge per input), its cost, the accepted accuracy per query and the search report | `select_plan` (`asap_plan_selection`); the facade (`run_planning`, output `PlanningRun`) runs it per tumbling-window-width round and builds the selected `PhysicalWorkloadPlan` with `AssignmentRealizer::realize`, one plan node per selected node |
 | 4. Execution | The selected `PhysicalASAPDAG` → query results | Same: an `InstallablePlan` (`{dag, query_texts}`) → query results | The deployment runtime installs the `InstallablePlan` |
 
 What changed with the memo:
@@ -845,8 +845,8 @@ Pass 1 attaches the family to its memo group, it creates one sized candidate
 per split of the accuracy budget: `accuracy_budget_parts` from 1 to the most
 approximate inputs of a query reaching the group, each sized by the accuracy
 model for its share. Pass 2 never resizes a summary for its own readers: a
-pane chain inherits the size of the build it replaces (a merge of equal-size
-panes keeps the guarantee when the family's merged error is `Exact` or
+tumbling-window chain inherits the size of the build it replaces (a merge of equal-size
+tumbling windows keeps the guarantee when the family's merged error is `Exact` or
 `AsIfBuiltOverUnion`), and a build shared by several readers takes the
 strictest reader's size, one state group per distinct size. The failure
 probability is part of Pass 1's size too
@@ -1112,46 +1112,46 @@ flowchart TB
 ```
 
 The planner implements a subset of the window-composition rule today:
-`Tumbling(L)` only, as a `SummaryTumblingWindowChain` (one node for all its panes) read
+`Tumbling(L)` only, as a `SummaryTumblingWindowChain` (one node for all its tumbling windows) read
 through a `SummaryMerge`, with `L = gcd(W_q, E_q)` for each query. Two or
 more queries share one chain when their builds have the same family (at any
 size), the same summary input data and the same output column names, and
 their windows end at the same time. Two shared grids are offered: the
-finest of their own pane widths, for the queries whose widths it divides
+finest of their own tumbling-window widths, for the queries whose widths it divides
 (never finer than a chain some query builds anyway), and the gcd of all
-their widths, even when it is finer than every query's own panes (1-min and
-90-s panes share 30-s panes). Queries that repeat at different intervals
-read the same panes, each at its own cadence. Finer panes mean more states
-kept and more panes merged, so Stage 3's pricing decides which grid, if
-any, pays; no pane-count limit is imposed beyond the pane count fitting in
+their widths, even when it is finer than every query's own tumbling windows (1-min and
+90-s tumbling windows share 30-s tumbling windows). Queries that repeat at different intervals
+read the same tumbling windows, each at its own cadence. Finer tumbling windows mean more states
+kept and more tumbling windows merged, so Stage 3's pricing decides which grid, if
+any, pays; no tumbling-window-count limit is imposed beyond the tumbling-window count fitting in
 32 bits. The chain covers the longest window and is sized
 for all of them, each parameter at its largest value among them, as the
 summary-capability rule sizes a shared build. Each query merges only the
-newest panes covering its own window (`SummaryMerge.newest_tumbling_windows`), since a
+newest tumbling windows covering its own window (`SummaryMerge.newest_tumbling_windows`), since a
 shorter window ending at the same time is the newest part of the longest.
 For example, `quantile_over_time(0.5, m[1m])` and
 `quantile_over_time(0.9, m[5m])`, both every 10 s, read one chain of thirty
-10-s KLL panes: the 1-min query merges the newest 6, the 5-min query all
+10-s KLL tumbling windows: the 1-min query merges the newest 6, the 5-min query all
 30. And `quantile_over_time(0.5, m[15m])` every 1 min and every 5 min read
-one chain of fifteen 1-min panes instead of fifteen 1-min and three 5-min
-panes. A query grouped by fewer keys also reads the chain of a finer
-grouping whose window is at least its own, on panes that divide its own,
+one chain of fifteen 1-min tumbling windows instead of fifteen 1-min and three 5-min
+tumbling windows. A query grouped by fewer keys also reads the chain of a finer
+grouping whose window is at least its own, on tumbling windows that divide its own,
 when the family merges states of different groups: it merges its newest
-panes, then rolls the groups up into its own (a regrouping `SummaryMerge`
-over the newest-panes merge). For example, `SELECT city,
+tumbling windows, then rolls the groups up into its own (a regrouping `SummaryMerge`
+over the newest-tumbling-window merge). For example, `SELECT city,
 percentile_cont(0.9) … INTERVAL '20' MINUTE GROUP BY city` and the global
 p50 and p90 over the last 5 minutes, both every 10 s, read one chain of 120
-per-city 10-s KLL panes: the 5-minute query merges each city's newest 30,
+per-city 10-s KLL tumbling windows: the 5-minute query merges each city's newest 30,
 then all cities into one state that answers both its percentiles. The chain
 is sized for every reader, here both queries' ε. A rollup to no keys over
 a SQL table's states stands for a global SQL aggregate, so it has one
 state, empty over no rows. A family that merges exactly keeps each query's
-guarantee, since a merge of fewer panes is one build over the shorter
+guarantee, since a merge of fewer tumbling windows is one build over the shorter
 window, and each query fails with at most the shared state's failure
-probability. Stage 3 prices each merge by the panes it reads, at its
+probability. Stage 3 prices each merge by the tumbling windows it reads, at its
 query's rate. The per-query chains stay candidates too. A chain read at different intervals is not kept across
 evaluations from query time: that option needs every reader to build one
-new pane per evaluation. Long-window segments, sliding windows and
+new tumbling window per evaluation. Long-window segments, sliding windows and
 Exponential Histograms are not implemented yet.
 
 ### 2. Physical ASAP-aware optimization
@@ -1216,21 +1216,21 @@ only, since raw rows are not maintained at ingestion time. Below an
 ingestion-time build it stays `NotMaterialized`: the ingestion side reads
 its own copy. A `MatAtQuery` state is reused within one evaluation only. When the
 deployment's capabilities declare `query_time_results_retained`, a
-tumbling-pane chain that builds exactly one new pane per evaluation also gets
-`MatAtQueryKeptAcrossEvaluations(Memory)`: the panes built at query time are
+tumbling-window chain that builds exactly one new tumbling window per evaluation also gets
+`MatAtQueryKeptAcrossEvaluations(Memory)`: the tumbling windows built at query time are
 kept for the next evaluations. Nothing is placed on disk yet.
 
 A runtime builds every ingestion-time state on the grid of its width anchored
 at the epoch, so an ingestion-time build must end on that grid at every
-evaluation of its readers. For a pane chain, the pane width divides each
+evaluation of its readers. For a tumbling-window chain, the tumbling-window width divides each
 known evaluation phase. For a whole-window build (one window per evaluation,
-no pane chain), the readers share one fixed interval, their declared phases
+no tumbling-window chain), the readers share one fixed interval, their declared phases
 agree, and the interval and a declared phase are multiples of the window:
 `m[5m]` every 5 minutes is one tumbling 5-minute window maintained at
-ingestion time and read at each evaluation, as a one-pane chain would be, while `m[20s]` every 20 s at phase
-5 s, or every 30 s, is not kept whole (Pass 2 offers 5 s or 10 s panes). A
+ingestion time and read at each evaluation, as a one-tumbling-window chain would be, while `m[20s]` every 20 s at phase
+5 s, or every 30 s, is not kept whole (Pass 2 offers 5 s or 10 s tumbling windows). A
 reader whose phase is not declared is taken to evaluate at multiples of its
-interval, as for a pane chain.
+interval, as for a tumbling-window chain.
 
 #### Physical operator implementation
 
diff --git a/docs/design_docs/proposals/window-materialization-choices.md b/docs/design_docs/proposals/window-materialization-choices.md
index da284fb73..7646956cd 100644
--- a/docs/design_docs/proposals/window-materialization-choices.md
+++ b/docs/design_docs/proposals/window-materialization-choices.md
@@ -9,18 +9,18 @@ This document separates window semantics, implementation, and materialization wh
 Keep these dimensions separate:
 
 - **Semantics:** requested window width, offset, evaluation timestamps, and alignment.
-- **Implementation:** raw recomputation, supported direct sliding state, fixed-width panes, or an EH algorithm.
+- **Implementation:** raw recomputation, supported direct sliding state, fixed-width tumbling windows, or an EH algorithm.
 - **Materialization:** when each internal state is computed and how long it is retained.
 
-A pane is an aligned, non-overlapping fixed-width interval and its aggregate/summary state. An EH bucket represents a portion of the stream under an exponential histogram algorithm, with algorithm-specific merge, expiration, and error rules.
+A tumbling window is an aligned, non-overlapping fixed-width interval and its aggregate/summary state. An EH bucket represents a portion of the stream under an exponential histogram algorithm, with algorithm-specific merge, expiration, and error rules.
 
 | Implementation | Ingestion, when maintained there | Evaluation |
 | --- | --- | --- |
 | Direct sliding-window state | Add data and remove expired contributions. | Read state and compute result. |
-| Pane-based | Update panes and evict expired panes. | Merge required panes and compute result. |
+| Tumbling-window-based | Update tumbling windows and evict expired tumbling windows. | Merge required tumbling windows and compute result. |
 | EH-based | Update, merge, and evict buckets. | Estimate the window result. |
 
-This table describes possible strategies. Current pane support does not imply general direct sliding-state or EH support. Offer only executable candidates. Multiple pane widths can coexist; alignment, coverage, mergeability, retention, and error contracts determine legality. A 15m window evaluated every 1m can use 1m panes; complete 5m panes alone generally cannot cover every endpoint.
+This table describes possible strategies. Current tumbling window support does not imply general direct sliding-state or EH support. Offer only executable candidates. Multiple tumbling-window widths can coexist; alignment, coverage, mergeability, retention, and error contracts determine legality. A 15m window evaluated every 1m can use 1m tumbling windows; complete 5m tumbling windows alone generally cannot cover every endpoint.
 
-Use existing `Materialization` options: `NotMaterialized`, `MatAtQuery(Memory)`, `MatAtIngestion(Memory)`, and `MatAtQueryKeptAcrossEvaluations(Memory)`. Assign them to eligible internal nodes, not necessarily the entire query. For example, maintain panes at ingestion and merge at query time. Generate only supported assignments: retained query-time state currently requires deployment capability and an eligible pane chain. Ingestion timing and upstream dependencies must satisfy Stage 2 rules.
+Use existing `Materialization` options: `NotMaterialized`, `MatAtQuery(Memory)`, `MatAtIngestion(Memory)`, and `MatAtQueryKeptAcrossEvaluations(Memory)`. Assign them to eligible internal nodes, not necessarily the entire query. For example, maintain tumbling windows at ingestion and merge at query time. Generate only supported assignments: retained query-time state currently requires deployment capability and an eligible tumbling-window chain. Ingestion timing and upstream dependencies must satisfy Stage 2 rules.
 
diff --git a/docs/develop_docs/asap-aware-mapping-architecture.md b/docs/develop_docs/asap-aware-mapping-architecture.md
index 68b6f3107..985f89235 100644
--- a/docs/develop_docs/asap-aware-mapping-architecture.md
+++ b/docs/develop_docs/asap-aware-mapping-architecture.md
@@ -17,7 +17,7 @@ in `asap-integration-tests` (`crate_graph`) checks these edges with
 
 | Crate | Role |
 | --- | --- |
-| `asap-types` (`crates/types`) | Shared vocabulary, by IR section: `ir::operator` (`OperatorNode`, `NonASAPOp`, `ASAPOp`, operator parameters, `AggIntent`), `ir::scalar` (`ScalarExpr`, `ColumnRef`), `ir::schema` (`Schema`, `FieldDataType`, summary-state types such as `SketchAlgorithm` and `FamilyCapability`), `ir::properties` (`AccuracyTarget`, `AccuracyMetric`, `AccuracyGuarantee`, execution timing, summary coverage), plus `ir::flat` and `ir::physical_export`; the planner inputs (`workload`); Stage 2 decision data (`physical`: `Materialization`, panes) |
+| `asap-types` (`crates/types`) | Shared vocabulary, by IR section: `ir::operator` (`OperatorNode`, `NonASAPOp`, `ASAPOp`, operator parameters, `AggIntent`), `ir::scalar` (`ScalarExpr`, `ColumnRef`), `ir::schema` (`Schema`, `FieldDataType`, summary-state types such as `SketchAlgorithm` and `FamilyCapability`), `ir::properties` (`AccuracyTarget`, `AccuracyMetric`, `AccuracyGuarantee`, execution timing, summary coverage), plus `ir::flat` and `ir::physical_export`; the planner inputs (`workload`); Stage 2 decision data (`physical`: `Materialization`, tumbling windows) |
 | `asap-frontend-sql`, `asap-frontend-promql`, `asap-frontend-metricsql` (with `asap-frontend-common`) | Stage 0, the query-language frontends: lower each query into the logical DAG (`QueryRoot`s of `NonASAPOp` nodes, no summaries, no timing) |
 | `asap-logical-asap-optimization` (`crates/logical-asap-optimization`) | Stage 1: Pass 1 and Pass 2 (the memo rules) |
 | `asap-accuracy` (`crates/accuracy`) | The accuracy model the stages share: the analytical rules (per-family estimators, composition, budget split, target check) and the deployment's `AccuracyModel` and `AccuracyEvidenceProvider`; depends only on `asap-types` |
@@ -59,7 +59,7 @@ Selection (selected_dag, cost, accepted_accuracy_per_query, search_report)
 ```
 
 `asap_planner::run_planning` runs all of it over lowered roots: Pass 1 once,
-then Pass 2, Stage 2 and Stage 3 per pane-width round, keeping the best
+then Pass 2, Stage 2 and Stage 3 per tumbling-window-width round, keeping the best
 round's selection and building that plan with `AssignmentRealizer::realize`.
 It returns every stage's output (`PlanningRun`); `Stage1ToStage3Pass` is the
 same pipeline behind the `OptimizationPass` trait.
@@ -68,7 +68,7 @@ same pipeline behind the `OptimizationPass` trait.
 | --- | --- |
 | Pass 1: which computations a query has (`ComputationTarget`), how each can be computed (`HowToComputeAggregateMeasure`: `Exact`, `ExactAccumulator`, `Summary`), fused computations (`FusedComputation`), pruning (`PruneReason`) and composing one choice into a logical DAG (`compose_logical_candidate`) | `asap-logical-asap-optimization`, `pass1/per_computation_candidates.rs` |
 | Which summary families serve an intent (`summary_candidates`) | `asap-logical-asap-optimization`, `pass1/realization.rs` |
-| Pass 2 memo rules: shared producers (identical expressions by memo group identity, one build at different sizes), scan-label widening, window composition (tumbling panes), rollup, exact top-k reuse and finer-aggregate reuse | `asap-logical-asap-optimization`, `pass2/memo/rules/` and `pass2/memo/window_candidates.rs`, over the helpers in `pass2/asap_aware_cse.rs` |
+| Pass 2 memo rules: shared producers (identical expressions by memo group identity, one build at different sizes), scan-label widening, window composition (tumbling windows), rollup, exact top-k reuse and finer-aggregate reuse | `asap-logical-asap-optimization`, `pass2/memo/rules/` and `pass2/memo/window_candidates.rs`, over the helpers in `pass2/asap_aware_cse.rs` |
 | Enumeration of the plans a memo stands for (reference pricer, DAG viewer) | `asap-logical-asap-optimization`, `pass2/memo/enumeration.rs` |
 | What each summary family can merge and answer (`FamilyCapability::of`: `merge_inputs`, `readouts`) | `asap-types`, `ir/schema/family_capability.rs` |
 | Stage 2: materialization options per summary build (`NotMaterialized`, `MatAtIngestion`, `MatAtQuery`, `MatAtQueryKeptAcrossEvaluations`), ingestion-time eligibility, physical operator implementation | `asap-physical-asap-optimization` |
@@ -83,8 +83,8 @@ The current production search organizes these computations in memo result/state
 groups and jointly selects physical candidates and connections; it does not
 traverse the whole-workload Cartesian product described by the historical rule
 APIs below. See [joint planning](../design_docs/proposals/joint-planning-search.md)
-for the current workflow. The unused standalone pane-sharing selector has been
-removed; pane sharing is selected by the same joint MILP as other computation.
+for the current workflow. The unused standalone tumbling-window-sharing selector has been
+removed; tumbling window sharing is selected by the same joint MILP as other computation.
 The unwired maintained-population rule has been removed as well; no Stage 1 pass offers a population candidate.
 
 ## Algorithm in one pass
@@ -96,7 +96,7 @@ The unwired maintained-population rule has been removed as well; no Stage 1 pass
    targets beneath it.
 2. **Enumeration** takes one choice per target and composes the logical DAG.
    For each composed DAG, the Pass 2 rules find what can be shared, split into
-   panes or reused, and each subset of their candidates becomes another
+   tumbling windows or reused, and each subset of their candidates becomes another
    Stage 1 candidate.
 3. **Stage 2** gives each summary build its materialization options and emits
    one physical candidate per assignment (the all-`NotMaterialized` one
diff --git a/docs/develop_docs/asap-aware-mapping-contracts.md b/docs/develop_docs/asap-aware-mapping-contracts.md
index f2242fa43..7248d4829 100644
--- a/docs/develop_docs/asap-aware-mapping-contracts.md
+++ b/docs/develop_docs/asap-aware-mapping-contracts.md
@@ -81,8 +81,8 @@ asap-physical-asap-optimization -p asap-plan-selection -p asap-types
   options: `NotMaterialized` always; `MatAtIngestion(Memory)` when the build
   is eligible to run as data arrives; `MatAtQuery(Memory)` when two or more
   queries read it (reused within one evaluation);
-  `MatAtQueryKeptAcrossEvaluations(Memory)` for a tumbling-pane chain that
-  builds one new pane per evaluation, when the deployment declares
+  `MatAtQueryKeptAcrossEvaluations(Memory)` for a tumbling-window chain that
+  builds one new tumbling window per evaluation, when the deployment declares
   `query_time_results_retained`.
 - One `PhysicalCandidate` per assignment, the all-`NotMaterialized` one first
   (`P<n>`, then `P<n>-m<k>`). An assignment that puts a build at ingestion
@@ -128,7 +128,7 @@ asap-physical-asap-optimization -p asap-plan-selection -p asap-types
 | --- | --- |
 | What a query means | the frontend (Stage 0) |
 | Which computations exist and how each may be computed | Pass 1 |
-| What is shared, split into panes or reused | Pass 2 |
+| What is shared, split into tumbling windows or reused | Pass 2 |
 | When each build runs and whether it is kept | Stage 2 |
 | Which plan is valid and which is chosen | Stage 3 |
 | What the executor can build, retain and how it is priced | the deployment, through `PlanningModels` (`DeploymentCapabilities`, `CostInputs`, `AccuracyModel`) |
diff --git a/docs/develop_docs/extend-asap-aware-mapping.md b/docs/develop_docs/extend-asap-aware-mapping.md
index dbd795964..cc41ad6f3 100644
--- a/docs/develop_docs/extend-asap-aware-mapping.md
+++ b/docs/develop_docs/extend-asap-aware-mapping.md
@@ -19,7 +19,7 @@ A new sketch that Pass 1 can offer for an intent.
    table (`SketchAlgorithm::capability`), read unchanged by
    `FamilyCapability::of_per_instance_sketch`
    (`crates/types/src/ir/schema/family_capability.rs`). Pass 2's sharing,
-   pane and rollup rules read only this table. Which readouts the executor
+   tumbling window and rollup rules read only this table. Which readouts the executor
    evaluates is its own declaration, `EVALUATED_READOUTS`
    (`crates/executor/src/capability.rs`); add the family's readouts there
    once the executor answers them.
@@ -47,7 +47,7 @@ Tests: a Pass 1 test in `crates/logical-asap-optimization/tests/per_computation_
 that the intent gets the new candidate (and that a deployment without it
 prunes it with `UnsupportedByDeployment`); an estimator test beside the
 estimator; an execution test in `crates/integration-tests/tests/` such as
-`frequency_execution.rs` or `kll_pane_execution.rs`.
+`frequency_execution.rs` or `kll_tumbling_window_execution.rs`.
 
 ## 2. Add a Pass 2 rule
 
diff --git a/docs/develop_docs/library-api.md b/docs/develop_docs/library-api.md
index 8892e9b9b..58872fcd5 100644
--- a/docs/develop_docs/library-api.md
+++ b/docs/develop_docs/library-api.md
@@ -167,7 +167,7 @@ example, see `lineitem_catalog` in [the planner's end-to-end tests](../../crates
 (Stage 0), then the default optimization pass `Stage1ToStage3Pass`, which runs
 logical ASAP-aware optimization (Stage 1), physical ASAP-aware optimization
 (Stage 2) and plan selection (Stage 3): Pass 1 once, then Pass 2, Stage 2
-and Stage 3 per pane-width round, keeping the best round's plan.
+and Stage 3 per tumbling-window-width round, keeping the best round's plan.
 
 ```text
 asap_planner::e2e_plan(input: UserInput<'_>) -> Result<PlanOutput, PlanError>   // async
@@ -200,14 +200,14 @@ asap_plan_selection::select_plan(
 | --- | --- |
 | `PlanningModels::new(accuracy, evidence)` | Your `&dyn AccuracyModel` and `&dyn AccuracyEvidenceProvider`, with default cost inputs and deployment capabilities; `with_accuracy` and `with_evidence` replace one of them |
 | `PlanningModels::builtin()` | Built-in accuracy model (`BuiltinAccuracyModel`) and no extra evidence (`NoAccuracyEvidence`). `with_cost_inputs(&settings)` sets the deployment's `CostInputs`; `with_deployment_capabilities(&capabilities)` sets its `DeploymentCapabilities` (field `deployment_capabilities`) |
-| `DeploymentCapabilities` (`asap_logical_asap_optimization`, re-exported as `asap_planner::DeploymentCapabilities`) | What the executor supports: `supported_summaries` (`None`, the default, supports every summary the planner builds; otherwise `SupportedSummary { family: SketchAlgorithm, readouts: Vec<StatisticKind> }` entries; Pass 1 prunes others with `PruneReason::UnsupportedByDeployment`), `raw_data_retained` (default `true`; when `false`, a candidate that scans raw data at query time is pruned by Stage 2, and stored data is refused with `asap_planner::SelectionError::InvalidDeploymentCapabilities`) and `query_time_results_retained` (default `false`; when `true`, Stage 2 offers `MatAtQueryKeptAcrossEvaluations` for tumbling panes) |
+| `DeploymentCapabilities` (`asap_logical_asap_optimization`, re-exported as `asap_planner::DeploymentCapabilities`) | What the executor supports: `supported_summaries` (`None`, the default, supports every summary the planner builds; otherwise `SupportedSummary { family: SketchAlgorithm, readouts: Vec<StatisticKind> }` entries; Pass 1 prunes others with `PruneReason::UnsupportedByDeployment`), `raw_data_retained` (default `true`; when `false`, a candidate that scans raw data at query time is pruned by Stage 2, and stored data is refused with `asap_planner::SelectionError::InvalidDeploymentCapabilities`) and `query_time_results_retained` (default `false`; when `true`, Stage 2 offers `MatAtQueryKeptAcrossEvaluations` for tumbling windows) |
 | `CostInputs` (`asap_cost`) | `cost_model`, `resource_speed` (`ms_per_cpu_op`, `ms_per_scanned_byte`), `non_repeating_query_horizon_seconds` (default 3,600) and `measured_operation_costs` (`MeasuredOperationCosts`, default empty: `operators`, one `OperatorCost { operator, phase, sketch / exact / measure, ns_per_unit, ns_per_invocation, memory_bytes_per_state }` per measured operator kind, phase and family; `ns_per_evaluation` per query request; `provenance` (executor version, machine). A node with an entry is priced from it, a sketch between the two nearest measured sizes; every other node from the formulas times one calibration factor fitted from the measured nodes; each node's `NodeCost::price_source` says which. The earlier JSON array of `MeasuredOperationCost { sketch, operation, cpu_ns_per_operation }` still loads) |
 | `CostModel::UsageOverTime(ResourceUnitCost)` | Cost model 1 (default, `ResourceUnitCost::illustrative()`): unit cost × usage per second; the cheapest valid candidate wins |
 | `CostModel::ProvisionedCapacity(ResourceUnitCost)` | Cost model 2: unit cost × peak memory, peak CPU cores and disk; the cheapest valid candidate wins |
 | `CostModel::ClusterCapacity(ClusterLimits)` | Cost model 3: memory, disk and optional CPU cores are hard limits; `ClusterObjective::{LowestLatency, LeastMemory}` chooses among the candidates that fit |
 | `PlanOutput.plans` | One `QueryPlan { entry_index, root }` per query, in `QueryWorkload::entries()` order |
 | `PlanOutput.selection` | `Some` with Stage 3's `Selection` under the default pass: `selected_dag`, `nodes_with_proven_non_negative_weights`, `cost` (the selected plan's `PlanCost` with its `ResourceUsage` and `cost_per_second`, `None` under cost model 3), `accepted_accuracy_per_query`, `pruned_candidates` and `search_report` |
-| `PlanOutput.tumbling_window_retention_ms` | For each pane chain the selected plan keeps beyond one evaluation, by node id, how long its panes are kept (`RealizedPlan::tumbling_window_retention_ms`) |
+| `PlanOutput.tumbling_window_retention_ms` | For each tumbling-window chain the selected plan keeps beyond one evaluation, by node id, how long its tumbling windows are kept (`RealizedPlan::tumbling_window_retention_ms`) |
 | `PlanningRun` | `per_computation_candidates`, the selected round's `logical_asap_candidates` and `physical_asap_candidates`, `selection`, `selected_physical_plan` (`RealizedPlan`), `selected_plan` (the roots to run), `memo_steps` and `report`; `per_computation_candidates` and `memo_steps` are kept only with `PlanSearchSettings::inspect` (per round: counts and Pass 2, Stage 2 and Stage 3 times) |
 | `PlanOutput::physical_asap_dag()` | The planned queries as one `PhysicalASAPDAG`, timed with the default `MaterializationAssignment` (see [Export](#export)) |
 
diff --git a/docs/develop_docs/physical-compile-coverage.md b/docs/develop_docs/physical-compile-coverage.md
index 47947f6fd..9d68caec1 100644
--- a/docs/develop_docs/physical-compile-coverage.md
+++ b/docs/develop_docs/physical-compile-coverage.md
@@ -7,7 +7,7 @@ Audience: developers moving computation from ASAPQuery-backend into
 
 Logical selection decides what to compute. A `MaterializationAssignment` sets
 node timing (Stage 2 materialization chooses it per physical candidate). `physical_planner::compile` turns a timed `PhysicalASAPDAG` into physical
-operator DAGs. The backend owns ingestion, panes, storage, stored-state
+operator DAGs. The backend owns ingestion, tumbling windows, storage, stored-state
 evaluation, external exact engines, pricing/selection, and execution scheduling.
 
 A backend lowering is *covered* when `compile` accepts the corresponding
@@ -138,7 +138,7 @@ average switches to an incremental mean once the running sum would overflow.
 The grouped path also serves SQL `SUM`/`AVG` over Float64, which are now
 compensated the same way.
 Stored exact `Sum` now retains a Kahan-Neumaier compensation term through
-updates, pane merges, and persistence. A truly overflowing sum remains infinite; the
+updates, tumbling-window merges, and persistence. A truly overflowing sum remains infinite; the
 checked `avg_over_time` division still rejects that case.
 
 Totals after this change: 20 Supported, 4 Partial, 5 Missing, 2 Backend.
diff --git a/docs/develop_docs/planner-snapshots.md b/docs/develop_docs/planner-snapshots.md
index 18da32aa1..1460b6238 100644
--- a/docs/develop_docs/planner-snapshots.md
+++ b/docs/develop_docs/planner-snapshots.md
@@ -34,7 +34,7 @@ Floats are rounded to 12 significant digits. Everything about the search
 except whether it proved the plan optimal is left out: candidate ids (such as
 `pane-round-12-joint-plan-1`), the search report's counters, bounds and timings, the Stage 1 and Stage 2
 candidate lists, and the memo (`stage_pipeline` runs with `--no-memo`). These
-vary from run to run because the search's pane-width rounds have wall-clock
+vary from run to run because the search's tumbling-window-width rounds have wall-clock
 budgets, so a different round can find the same plan.
 
 ## Sketch plan snapshots
@@ -74,7 +74,7 @@ The test also fails, instead of recording a snapshot, in these cases:
 
 - A query's search was ended by a wall-clock budget: its status is
   `time_limit`, or planning used the whole 240 s limit. Its plan would then
-  depend on machine speed. Only the final pane round's status is checked: an
+  depend on machine speed. Only the final tumbling-window-width round's status is checked: an
   earlier round cut short by its own wall-clock budget is not reported.
 - A snapshot file has no matching checked query in `corpus.json`.
 - `stage_pipeline` crashed.
diff --git a/docs/develop_docs/pre-asap-ir.md b/docs/develop_docs/pre-asap-ir.md
index 0b14ec292..b4af14f72 100644
--- a/docs/develop_docs/pre-asap-ir.md
+++ b/docs/develop_docs/pre-asap-ir.md
@@ -437,7 +437,7 @@ rate(http_requests_total[5m])
 ```
 
 A SQL trailing window on the scanned table's time index lowers to the same `Range` node
-over the `Scan`, so its summaries get the same tumbling panes and ingestion-time builds:
+over the `Scan`, so its summaries get the same tumbling windows and ingestion-time builds:
 
 ```sql
 SELECT COUNT(DISTINCT src_ip) FROM flows WHERE ts >= now() - INTERVAL '5 minutes'
@@ -450,7 +450,7 @@ on the table's `time_index`, with a fixed-length `w` (days and smaller; a month
 length). It reads the window with PromQL's range timing, `(T - w, T]` at evaluation time
 `T`: the start is exclusive for `>=` too, so a row stamped exactly `T - w` is not read, and rows
 later than `T` have not arrived yet. Any other time condition stays a `Scan` predicate, and so
-does the window itself when another conjunct also reads `now()` (in a pane or at ingestion time
+does the window itself when another conjunct also reads `now()` (in a tumbling window or at ingestion time
 that conjunct would read other rows).
 
 **Fields:**
@@ -462,7 +462,7 @@ that conjunct would read other rows).
 
 PromQL `offset` / `@` time shift on a selector — a pass-through wrapper that moves *when*
 the child is evaluated but leaves its schema unchanged. Pass 2 also shifts a SQL table's
-`Scan` this way for each tumbling pane of a trailing window.
+`Scan` this way for each tumbling window of a trailing window.
 
 ```promql
 up offset 5m
diff --git a/docs/develop_docs/pane-search-compression-evaluation.md b/docs/develop_docs/tumbling-window-search-compression-evaluation.md
similarity index 81%
rename from docs/develop_docs/pane-search-compression-evaluation.md
rename to docs/develop_docs/tumbling-window-search-compression-evaluation.md
index f9e02b3db..9d88e65e2 100644
--- a/docs/develop_docs/pane-search-compression-evaluation.md
+++ b/docs/develop_docs/tumbling-window-search-compression-evaluation.md
@@ -1,15 +1,15 @@
-# Pane-search compression evaluation
+# Tumbling-window-search compression evaluation
 
-This report is for planner developers. It separates three changes: storing repeated producer lists once, factoring equivalent candidate connections, and spending a bounded search budget across progressively larger pane-width domains. Storage compression alone does not reduce the number of MILP variables. Searching fewer widths before a timeout does not prove equivalence to the complete domain.
+This report is for planner developers. It separates three changes: storing repeated producer lists once, factoring equivalent candidate connections, and spending a bounded search budget across progressively larger tumbling-window-width domains. Storage compression alone does not reduce the number of MILP variables. Searching fewer widths before a timeout does not prove equivalence to the complete domain.
 
 ## Reproduction
 
 Use frozen `stage_pipeline` executables; record their SHA-256 hashes. Do not run the four-case comparison concurrently with another benchmark. Both sides use the same input files, AWS pricing, deployment capabilities, enforced accuracy, a 30-second cooperative planning budget, and a 90-second external process timeout. Each case runs sequentially. Whole-process wall time and peak RSS include plan export and validation, so wall time may exceed the cooperative planning budget.
 
 ```bash
-python3 tools/benchmark_pane_search.py summarize BEFORE_BINARY BEFORE_DIR
-python3 tools/benchmark_pane_search.py run AFTER_BINARY AFTER_DIR
-python3 tools/benchmark_pane_search.py compare BEFORE_DIR AFTER_DIR COMPARISON.md
+python3 tools/benchmark_tumbling_window_search.py summarize BEFORE_BINARY BEFORE_DIR
+python3 tools/benchmark_tumbling_window_search.py run AFTER_BINARY AFTER_DIR
+python3 tools/benchmark_tumbling_window_search.py compare BEFORE_DIR AFTER_DIR COMPARISON.md
 ```
 
 `summarize` imports existing plan, timing, and `summary.json` artifacts without executing the planner again. Each directory receives `results.json`, with the binary hash, input fingerprints, full search reports, selected cost/usage, and acceptance checks. Comparison rejects mismatched inputs, budgets, or concurrency. Missing old metrics remain **unreported**, rather than zero.
@@ -17,20 +17,20 @@ python3 tools/benchmark_pane_search.py compare BEFORE_DIR AFTER_DIR COMPARISON.m
 Broader acceptance uses the same runner:
 
 ```bash
-python3 tools/benchmark_pane_search.py run AFTER_BINARY VIEWER_DIR --suite viewer --jobs 2
-python3 tools/benchmark_pane_search.py run AFTER_BINARY ASAP_DIR --suite asap --jobs 2
+python3 tools/benchmark_tumbling_window_search.py run AFTER_BINARY VIEWER_DIR --suite viewer --jobs 2
+python3 tools/benchmark_tumbling_window_search.py run AFTER_BINARY ASAP_DIR --suite asap --jobs 2
 ```
 
 For an archived 30-workload baseline without input fingerprints, compare only cost and acceptance after checking its original pricing configuration:
 
 ```bash
-python3 tools/benchmark_pane_search.py compare OLD_ASAP_DIR ASAP_DIR QUALITY.md --quality-only
+python3 tools/benchmark_tumbling_window_search.py compare OLD_ASAP_DIR ASAP_DIR QUALITY.md --quality-only
 ```
 
 This mode checks serialized workloads, deployment capabilities, accuracy modes, Stage 0 DAGs, and objective/calibration settings. It deliberately excludes planning-time and memory comparisons; the old runner must confirm the pricing profile because historical documents do not serialize it.
 
 
-These suites contain the nine viewer workload examples and 30 mixed ASAPQuery workloads, respectively. They check query coverage, enforced accuracy, finite cost, valid cost bounds, no stored-output errors, and no global bound, gap, optimum, or exhaustion claim while pane widths remain pending. Existing Rust/JavaScript tests remain responsible for DAG structure and installation invariants.
+These suites contain the nine viewer workload examples and 30 mixed ASAPQuery workloads, respectively. They check query coverage, enforced accuracy, finite cost, valid cost bounds, no stored-output errors, and no global bound, gap, optimum, or exhaustion claim while tumbling-window widths remain pending. Existing Rust/JavaScript tests remain responsible for DAG structure and installation invariants.
 
 ## Baseline
 
@@ -54,7 +54,7 @@ Independent correctness checks should cover:
 - Producer-list sharing preserves membership, order, and duplicate input positions. Mutating one shared list must not mutate another list. Cached compatibility includes every semantic/configuration field used by the uncached check.
 - Tiny complete-domain problems retain the same feasible assignments and minimum evaluated cost before and after factoring. Include multiple readers, different materializations, duplicate input positions, optional dependencies, and shared upstream producers. Reconstruction must restore every factored operation and preserve costs, accuracy, and query coverage.
 - Terminal unary factoring must not absorb a node with additional consumers, observable materialization/state, unsupported error propagation, or different execution demand. Shared producer work remains charged once; reader-specific work remains per use.
-- Progressive pane-width domains are nested; each round adds `Panes` candidates to the candidate memo only for newly admitted pane widths. Each round rebuilds its physical inventory and MILP, so previously considered assignments may be revisited. The domains eventually include the complete legal finite domain when the budget permits. A restricted-domain optimum never becomes a global certificate; timeout preserves the best validated incumbent.
+- Progressive tumbling-window-width domains are nested; each round adds `TumblingWindows` candidates to the candidate memo only for newly admitted tumbling-window widths. Each round rebuilds its physical inventory and MILP, so previously considered assignments may be revisited. The domains eventually include the complete legal finite domain when the budget permits. A restricted-domain optimum never becomes a global certificate; timeout preserves the best validated incumbent.
 - The four-case benchmark must show measurable changes on the dense rangeheavy cases. Report cost regressions or incomplete-domain effects explicitly. Full 30-workload and nine-viewer acceptance must pass without relaxing accuracy or latency requirements.
 
 ## After-change results
@@ -108,9 +108,9 @@ The nine viewer workloads also passed **9/9**, with **40/40** query requirements
 
 ### Final regression follow-up
 
-The regression suite found a genuine optimization regression outside window planning. Two identical SQL percentiles over an at-rest table were sent through progressive pane rounds solely because they repeat every ten minutes. No computation had a pane-eligible window, so the rounds rebuilt the same 40-configuration, 150-connection model and restarted refinement. The 128-evaluation budget expired with two identical unmaterialized KLL builds, costing 0.007678692288679677 per second instead of the baseline's one shared query-materialized build at 0.006000017830006526 (+27.98%). The original pointer-sharing assertion failed both in the suite and in isolation; it was retained unchanged.
+The regression suite found a genuine optimization regression outside window planning. Two identical SQL percentiles over an at-rest table were sent through progressive tumbling window rounds solely because they repeat every ten minutes. No computation had a tumbling-window-eligible window, so the rounds rebuilt the same 40-configuration, 150-connection model and restarted refinement. The 128-evaluation budget expired with two identical unmaterialized KLL builds, costing 0.007678692288679677 per second instead of the baseline's one shared query-materialized build at 0.006000017830006526 (+27.98%). The original pointer-sharing assertion failed both in the suite and in isolation; it was retained unchanged.
 
-Revision `fe171f64` bypasses pane-domain expansion when the initial computations contain neither a positive range window nor an existing pane chain. It searches the complete candidate domain directly; at-rest status alone does not disable pane planning. The same SQL fixture now passes the original sharing test and selects one shared KLL with exactly the baseline cost. Its report records 58 evaluations, `optimal`, one `Complete` round, and no pending widths. This fix avoids repeated identical-domain searches rather than increasing the budget or relaxing correctness checks.
+Revision `fe171f64` bypasses tumbling-window-domain expansion when the initial computations contain neither a positive range window nor an existing tumbling-window chain. It searches the complete candidate domain directly; at-rest status alone does not disable tumbling window planning. The same SQL fixture now passes the original sharing test and selects one shared KLL with exactly the baseline cost. Its report records 58 evaluations, `optimal`, one `Complete` round, and no pending widths. This fix avoids repeated identical-domain searches rather than increasing the budget or relaxing correctness checks.
 
 The final frozen executable is `/mydata/pane-compression-validation/stage-pipeline-after-gate-final`, SHA-256 `a3234d62d2a6717e3772aba240959f6a224a4e1e031fe9cba27854079f8622f2`, built from `fe171f64`. SQL before/after artifacts are `/tmp/identical-sql-{before,after,gate-fixed}.json`; the unchanged integration test log is `/tmp/sql-sharing-pane-gate-after.log`.
 
diff --git a/docs/user_guide_docs/stage-viewer.md b/docs/user_guide_docs/stage-viewer.md
index 2e9c6bc1c..eb068e952 100644
--- a/docs/user_guide_docs/stage-viewer.md
+++ b/docs/user_guide_docs/stage-viewer.md
@@ -32,7 +32,7 @@ what the workload is. Start with:
 - **1 · dashboard panels**: two dashboard panels; the all-exact
   plan wins.
 - **3b · live p99 panel**: the whole-window KLL beats exact and
-  the panes.
+  the tumbling windows.
 - **Ratio of quantiles (memo after each step)**: `avg by (job) (quantile_over_time(0.5, data[5m]) /
   quantile_over_time(0.5, data[5m]) + quantile_over_time(0.9, data[5m]))`.
   This one shows the memo: 7 groups, and 7 × 7 = 49 complete DAGs after
@@ -67,7 +67,7 @@ In the lanes:
   summary operators;
 - a thick border marks a query's result, and `shared ×n` marks a node that n
   queries read;
-- click a `SummaryTumblingWindowChain` node to unfold its panes, and click again to fold them.
+- click a `SummaryTumblingWindowChain` node to unfold its tumbling windows, and click again to fold them.
 
 To follow one query, pick it in **highlight query**: everything it does not
 reach dims, in the lanes and in the Memo. Click a node to see its details;
diff --git a/tools/benchmark_pane_search.py b/tools/benchmark_tumbling_window_search.py
similarity index 96%
rename from tools/benchmark_pane_search.py
rename to tools/benchmark_tumbling_window_search.py
index ecd6da8db..4feb482ff 100644
--- a/tools/benchmark_pane_search.py
+++ b/tools/benchmark_tumbling_window_search.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Run or summarize frozen-binary pane-search benchmarks without rebuilding.
+"""Run or summarize frozen-binary tumbling-window-search benchmarks without rebuilding.
 
 Linux /usr/bin/time measures whole-process peak RSS. Search counters describe
 reported domains and must not be confused with a complete-catalog optimum.
@@ -61,12 +61,12 @@ def inputs(entry, budget):
 
 
 def domain_certificate_valid(report):
-    pending = report.get("pane_widths_pending") is True
+    pending = report.get("tumbling_window_widths_pending") is True
     if pending and (report.get("lower_bound") is not None or report.get("relative_gap") is not None
                     or any(report.get(key) is True for key in
                            ("full_catalog_completed", "catalog_exhausted", "evaluation_complete"))):
         return False
-    incomplete = pending or ("pane_widths_pending" in report and not report.get("full_catalog_completed"))
+    incomplete = pending or ("tumbling_window_widths_pending" in report and not report.get("full_catalog_completed"))
     return not (incomplete and report.get("status") == "optimal")
 
 
@@ -180,7 +180,7 @@ def compare(args):
     old = {r["workload"]: r for r in before["results"]}
     if set(old) != {r["workload"] for r in after["results"]}:
         raise ValueError("Comparison requires the same completed workload set")
-    lines = ["# Pane-search benchmark comparison", "",
+    lines = ["# Tumbling-window-search benchmark comparison", "",
              f"Before binary: `{before['binary_sha256']}`. After binary: `{after['binary_sha256']}`.", "",
              "Single-run measurements; execution cost and accuracy are planner-model results, not measured stream execution.", "",
              "| Workload | Metric | Before | After | Change |", "|---|---|---:|---:|---:|"]
@@ -231,7 +231,7 @@ def compare(args):
                     b = None
             change = f"{(b / a - 1) * 100:+.2f}%" if type(a) in (int, float) and a != 0 and type(b) in (int, float) else "—"
             lines.append(f"| {row['workload']} | {key} | {a if a is not None else 'unreported'} | {b if b is not None else 'unreported'} | {change} |")
-        domain_keys = ("status", "pane_width_rounds", "inventory_pane_width_domain", "pane_widths_pending", "full_catalog_completed", "catalog_exhausted", "evaluation_complete")
+        domain_keys = ("status", "tumbling_window_width_rounds", "inventory_tumbling_window_width_domain", "tumbling_window_widths_pending", "full_catalog_completed", "catalog_exhausted", "evaluation_complete")
         for key in (() if args.quality_only else domain_keys):
             lines.append(f"| {row['workload']} | {key} | {previous['search'].get(key, 'unreported')} | {row['search'].get(key, 'unreported')} | — |")
     if not args.quality_only:
diff --git a/tools/dag-viewer/README.md b/tools/dag-viewer/README.md
index 07b9662b2..4afdc45d9 100644
--- a/tools/dag-viewer/README.md
+++ b/tools/dag-viewer/README.md
@@ -71,10 +71,10 @@ To run it, see [RUNNING.md](RUNNING.md).
   series, or one shared instance. A standalone scalar query (`time()`,
   `scalar(v)`, `1 + 2`) is a dashed `Scalar` node over the nodes it reads.
   Query roots have a thick border. A node that several queries' roots reach
-  says `shared ×n`. A `SummaryTumblingWindowChain` is one node (`30 panes × 20 s`); clicking
-  it draws its panes, newest first, each a `TimeShift` by its offset (none
-  for the newest), a `TimeRange` of one pane and the pane's build with its
-  window (`window t−40 s … t−20 s`), and clicking a pane folds them back.
+  says `shared ×n`. A `SummaryTumblingWindowChain` is one node (`30 tumbling windows × 20 s`); clicking
+  it draws its tumbling windows, newest first, each a `TimeShift` by its offset (none
+  for the newest), a `TimeRange` of one tumbling window and the tumbling window's build with its
+  window (`window t−40 s … t−20 s`), and clicking a tumbling window folds them back.
   This is display only: the document keeps the chain.
 - **Enumerated DAGs**, between the Stage 0 and Stage 1 lanes, shown only
   when the document has `memo.enumeration`: the complete candidate DAGs the
@@ -104,10 +104,10 @@ To run it, see [RUNNING.md](RUNNING.md).
   the background goes back to the query's highlight.
 - **Materialized views** under the Stage 2 lane: the selected plan's
   materialized views as `plan_installable` gives them, one row per Stage 2 node: its
-  coverage definition, operator and summary parameters, panes (`30 × 20 s`
-  for a pane chain), how it is refreshed, its retention, the Stage 3 cost and the
-  queries that read it. A chain's row lists its installed panes (node id,
-  pane, window, retention) under **installed**. Clicking a row selects its
+  coverage definition, operator and summary parameters, tumbling windows (`30 × 20 s`
+  for a tumbling-window chain), how it is refreshed, its retention, the Stage 3 cost and the
+  queries that read it. A chain's row lists its installed tumbling windows (node id,
+  tumbling window, window, retention) under **installed**. Clicking a row selects its
   node in the Stage 2 lane. Stage 3 predicts no
   per-node state size, so the table has none. The lane's header also shows
   the shown candidate's Stage 3 usage.
@@ -123,11 +123,11 @@ To run it, see [RUNNING.md](RUNNING.md).
   count (`745 candidates (64 listed)` when the document lists only some) and
   the queries it is the root of; its implementation candidates sit inside
   it, bordered by origin (Pass1, SharedBuild, SummaryResult, SummaryInput,
-  Panes, Rollup, TopKReuse, WidenedScans), with a double border and
+  TumblingWindows, Rollup, TopKReuse, WidenedScans), with a double border and
   `✚ new` when the step added them. An edge goes from each candidate to
   each child group it reads (at Stage 0, which has no candidates, from the
   group). Readers sit above what they read. A group listing more than 12
-  candidates is drawn as one node per origin with its count (`360 Panes`);
+  candidates is drawn as one node per origin with its count (`360 TumblingWindows`);
   clicking a count lists them, clicking the group folds them back. On the
   last tab the selected plan's candidates (`selected_choice`) are filled
   green with `✓ selected`, and so are the edges they read along. The header
@@ -262,8 +262,8 @@ are ignored, `stage_pipeline`'s default.
                              "retention_ms": 600000,
                              "stage2_node_id": 1, "installed_position": 0, "installed_count": 30 }]
   },
-  "planning_report": { "pass1_ms": 3.1, "selected_round": 1, "pane_widths_pending": false, "time_limit_ms": 30000,
-                       "rounds": [{ "pane_width_domain": "SeedGrids", "memo_groups": 12, "logical_candidates": 30,
+  "planning_report": { "pass1_ms": 3.1, "selected_round": 1, "tumbling_window_widths_pending": false, "time_limit_ms": 30000,
+                       "rounds": [{ "tumbling_window_width_domain": "SeedGrids", "memo_groups": 12, "logical_candidates": 30,
                                     "operator_nodes": 40, "physical_candidates": 96, "stage2_pruned_candidates": 4,
                                     "pass2_ms": 1.2, "stage2_ms": 3.4, "stage3_ms": 150.0,
                                     "search_report": { "...": "..." }, "error": null }] },
@@ -303,10 +303,10 @@ are ignored, `stage_pipeline`'s default.
   run's cost model (`--cost-model`): null under cost model 3, which has no
   prices; a node's is null under cost models 2 and 3, which price or limit
   the whole plan's peaks.
-- `planning_report` is the facade's: Pass 1's time, then per pane-width
+- `planning_report` is the facade's: Pass 1's time, then per tumbling-window-width
   round its domain, Pass 2's and Stage 2's counts, each stage's time, and
-  Stage 3's search report or error; `selected_round` and whether some pane
-  widths were not searched (`pane_widths_pending`).
+  Stage 3's search report or error; `selected_round` and whether some tumbling window
+  widths were not searched (`tumbling_window_widths_pending`).
 - `reference_pricing` (only with `--exhaustive`) is the reference pricer
   over the enumerated memo choices (`E<n>` logical, `E<n>-<k>` physical),
   with keys named as Stage 3's `Selection` names its fields: per shown
@@ -376,12 +376,12 @@ are ignored, `stage_pipeline`'s default.
   its workload entry's own JSON.
 - `materialized_views` are the selected plan's materialized views from
   `installable_plan_of` (what `plan_installable` returns): the node id in
-  the installable DAG (pane chains expanded into panes), `refresh`
+  the installable DAG (tumbling-window chains expanded into tumbling windows), `refresh`
   (`at_ingestion` or `on_first_read`), `coverage`, `inputs` and
   `retention_ms`. `stage2_node_id` is the node of the selected Stage 2
   candidate it is installed from (null when Stage 3 recorded no cost to map
   it by), `installed_position` its position among that node's installed
-  nodes (a pane chain's panes, newest first) and `installed_count` their
+  nodes (a tumbling-window chain's tumbling windows, newest first) and `installed_count` their
   number. Empty without a selection; `materialized_views_error` says why when
   the plan is not installable.
 - `pruned_candidate_count_by_cause` counts the pruned candidates by cause,
@@ -431,7 +431,7 @@ sections are still shown. If a check fails, it shows the problems instead.
 
 - `index.html`, `app.js`: the page.
 - `stages.js`: document checks, the candidate list, lane elements and node
-  labels, pane-chain expansion, the queries reaching each node and the
+  labels, tumbling-window-chain expansion, the queries reaching each node and the
   highlighted neighborhoods; no DOM. `stages.test.mjs`: its Node tests.
 - `enumeration.js`: the Enumerated DAGs panel and the checks of
   `memo.enumeration`. `enumeration.test.mjs`: its Node tests, over
diff --git a/tools/dag-viewer/app.js b/tools/dag-viewer/app.js
index fc4505fca..dc67b6383 100644
--- a/tools/dag-viewer/app.js
+++ b/tools/dag-viewer/app.js
@@ -33,7 +33,7 @@
       { selector: 'node:selected', style: { 'overlay-color': tok('--accent'), 'overlay-opacity': 0.14, 'overlay-padding': 5 } },
       { selector: 'edge', style: { width: 1.6, 'line-color': tok('--edge'), 'target-arrow-color': tok('--edge'), 'target-arrow-shape': 'triangle', 'curve-style': 'bezier', 'arrow-scale': 0.9 } },
       { selector: '.dimmed', style: { opacity: 0.15 } },
-      { selector: 'node.pane', style: { 'border-style': 'dashed' } },
+      { selector: 'node.tumblingWindow', style: { 'border-style': 'dashed' } },
       { selector: 'edge:selected', style: { 'line-color': tok('--accent'), 'target-arrow-color': tok('--accent'), width: 2.6 } },
     ];
   }
@@ -43,9 +43,9 @@
     $(`lane${i}-meta`).textContent = text;
   }
 
-  // Per lane: what it draws (to redraw it with a pane chain expanded or
+  // Per lane: what it draws (to redraw it with a tumbling-window chain expanded or
   // collapsed) and its elements; per drawn DAG, the SummaryTumblingWindowChain node ids drawn
-  // as panes, so switching plans and back keeps each plan's expanded chains.
+  // as tumbling windows, so switching plans and back keeps each plan's expanded chains.
   const drawn = [null, null, null];
   const laneElements = [[], [], []];
   const expandedByDag = new WeakMap();
@@ -75,11 +75,11 @@
 
   function redraw(i) { const d = drawn[i]; render(i, d.dag, d.physical, d.costPerNode, d.ids); }
 
-  // A SummaryTumblingWindowChain expands into its panes; a pane collapses its chain; any
+  // A SummaryTumblingWindowChain expands into its tumbling windows; a tumbling window collapses its chain; any
   // other node is shown and its upstream and downstream highlighted.
   function tapNode(d, i) {
     if (d.expandable) { expandedOf(drawn[i].dag).add(d.nodeId); redraw(i); showNode(d, i); return; }
-    if (d.kind === 'pane') { expandedOf(drawn[i].dag).delete(d.paneOf); redraw(i); return; }
+    if (d.kind === 'tumblingWindow') { expandedOf(drawn[i].dag).delete(d.tumblingWindowOf); redraw(i); return; }
     showNode(d, i);
     dim(i, new Set(stageNeighborhoodIds(laneElements[i], d.id)));
   }
@@ -121,8 +121,8 @@
     }
     if (d.rootFor && d.rootFor.length) items.push(['query root of', d.rootFor.join(', ')]);
     if (d.reachedBy) items.push(['queries reaching it', d.reachedBy.join(', ') || 'none']);
-    if (d.paneOf !== undefined) items.push(['pane', `${d.pane + 1} of ${body.tumbling_window_count} of SummaryTumblingWindowChain ${d.paneOf}, window ${paneWindowText(d.pane, body.tumbling_window_width_ms)}`]);
-    if (d.expandable) items.push(['panes', `${body.tumbling_window_count} × ${durationText(body.tumbling_window_width_ms)} (click the chain to show them, a pane to hide them)`]);
+    if (d.tumblingWindowOf !== undefined) items.push(['tumbling window', `${d.tumblingWindowIndex + 1} of ${body.tumbling_window_count} of SummaryTumblingWindowChain ${d.tumblingWindowOf}, window ${tumblingWindowTimeText(d.tumbling_window, body.tumbling_window_width_ms)}`]);
+    if (d.expandable) items.push(['tumbling windows', `${body.tumbling_window_count} × ${durationText(body.tumbling_window_width_ms)} (click the chain to show them, a tumbling window to hide them)`]);
     if (d.timing !== undefined) items.push(['runs at', formatTiming(d.timing)]);
     if (n.materialization) items.push(['materialization', compactWire(n.materialization)]);
     if (n.output_state && n.output_state.primitive) items.push(['output primitive', compactWire(n.output_state.primitive)]);
@@ -331,8 +331,8 @@
       : '<span class="status">No source declared.</span>';
   }
 
-  // The selected plan's materialized views, one row per Stage 2 node (a pane
-  // chain's panes listed inside its row); a row selects its Stage 2 node.
+  // The selected plan's materialized views, one row per Stage 2 node (a tumbling window
+  // chain's tumbling windows listed inside its row); a row selects its Stage 2 node.
   function renderMaterializedViews() {
     const selection = selectionTable(doc);
     if (!selection.selected_candidate) {
@@ -346,19 +346,19 @@
       return;
     }
     const groups = materializedViewGroups(doc);
-    const count = groups.reduce((n, g) => n + g.panes.length, 0);
+    const count = groups.reduce((n, g) => n + g.tumblingWindows.length, 0);
     $('views-meta').innerHTML = selection.materialized_views_error
       ? `<span class="error">no installable plan: ${esc(selection.materialized_views_error)}</span>`
       : `<b>${count}</b> materialized view${count === 1 ? '' : 's'} in <b>${groups.length}</b> group${groups.length === 1 ? '' : 's'} of <b>${esc(selection.selected_candidate)}</b>` +
         (count ? '' : ': nothing is kept across evaluations; every query computes at query time');
-    const panes = (g) => (g.panes.length > 1
-      ? `<details><summary>${esc(g.panes.length)} installed nodes</summary><ul>${g.panes.map((p) => `<li>node ${esc(p.nodeId)} · ${esc(p.pane)} · window ${esc(p.window)} · kept ${esc(p.retention)}</li>`).join('')}</ul></details>`
-      : `node ${esc(g.panes[0].nodeId)} · window ${esc(g.panes[0].window)}`);
+    const tumblingWindowsCell = (g) => (g.tumblingWindows.length > 1
+      ? `<details><summary>${esc(g.tumblingWindows.length)} installed nodes</summary><ul>${g.tumblingWindows.map((p) => `<li>node ${esc(p.nodeId)} · ${esc(p.tumblingWindow)} · window ${esc(p.window)} · kept ${esc(p.retention)}</li>`).join('')}</ul></details>`
+      : `node ${esc(g.tumblingWindows[0].nodeId)} · window ${esc(g.tumblingWindows[0].window)}`);
     $('materializedViews').innerHTML = groups.length ? table(
-      ['Stage 2 node', 'definition', 'kind', 'panes', 'refresh', 'retention', 'installed', 'Stage 3 cost', 'read by'],
+      ['Stage 2 node', 'definition', 'kind', 'tumbling windows', 'refresh', 'retention', 'installed', 'Stage 3 cost', 'read by'],
       groups.map((g) => `<tr class="clickable" tabindex="0" data-node="${g.stage2NodeId === null ? '' : esc(g.stage2NodeId)}"><td>${g.stage2NodeId === null ? '—' : esc(g.stage2NodeId)}</td>` +
-        `<td class="wrap">${esc(g.definition)}</td><td class="wrap">${esc(g.kind)}</td><td>${esc(g.panesText)}</td><td>${esc(g.refresh)}</td>` +
-        `<td>${esc(g.retention)}</td><td class="wrap">${panes(g)}</td><td class="wrap">${esc(g.cost)}</td><td class="wrap">${esc(g.readBy.join(', ') || '—')}</td></tr>`).join('')) : '';
+        `<td class="wrap">${esc(g.definition)}</td><td class="wrap">${esc(g.kind)}</td><td>${esc(g.tumblingWindowsText)}</td><td>${esc(g.refresh)}</td>` +
+        `<td>${esc(g.retention)}</td><td class="wrap">${tumblingWindowsCell(g)}</td><td class="wrap">${esc(g.cost)}</td><td class="wrap">${esc(g.readBy.join(', ') || '—')}</td></tr>`).join('')) : '';
     $('materializedViews').querySelectorAll('tr.clickable').forEach((tr) => {
       const pick = (e) => { if (e && e.target && e.target.closest && e.target.closest('details')) return; if (tr.dataset.node !== '') selectStage2Node(Number(tr.dataset.node)); };
       tr.addEventListener('click', pick);
@@ -388,7 +388,7 @@
     if (current.physical !== selected) selectPhysical(selected);
     const cy = cys[2];
     if (!cy) return;
-    // An expanded pane chain is drawn as its panes: select the newest.
+    // An expanded tumbling-window chain is drawn as its tumbling windows: select the newest.
     let node = cy.getElementById(`n${id}`);
     if (!node || node.length === 0) node = cy.getElementById(`n${id}p0`);
     if (!node || node.length === 0) return;
diff --git a/tools/dag-viewer/examples/memo-ratio-of-quantiles.json b/tools/dag-viewer/examples/memo-ratio-of-quantiles.json
index 803c2eefb..b0c203020 100644
--- a/tools/dag-viewer/examples/memo-ratio-of-quantiles.json
+++ b/tools/dag-viewer/examples/memo-ratio-of-quantiles.json
@@ -113595,7 +113595,7 @@
         "immediate_candidates": 5166,
         "independent_components": 1,
         "inventory_construction_ms": 442.233775,
-        "inventory_pane_width_domain": "Expanding { max_parts: 64 }",
+        "inventory_tumbling_window_width_domain": "Expanding { max_parts: 64 }",
         "joint_price_solve_calls": 0,
         "local_candidate_generation_ms": 0.317655,
         "logical_candidates": 1738,
@@ -113605,7 +113605,7 @@
         "model_construction_ms": 241.089117,
         "objective": "monetary_cost",
         "output_references": 1,
-        "pane_width_rounds": [
+        "tumbling_window_width_rounds": [
           "SeedGrids",
           "Expanding { max_parts: 4 }",
           "Expanding { max_parts: 8 }",
@@ -113613,7 +113613,7 @@
           "Expanding { max_parts: 32 }",
           "Expanding { max_parts: 64 }"
         ],
-        "pane_widths_pending": true,
+        "tumbling_window_widths_pending": true,
         "peak_milp_constraints": 31547,
         "peak_milp_variables": 21948,
         "physical_configurations": 6175,
diff --git a/tools/dag-viewer/index.html b/tools/dag-viewer/index.html
index 7978634b0..48609cbdd 100644
--- a/tools/dag-viewer/index.html
+++ b/tools/dag-viewer/index.html
@@ -215,7 +215,7 @@ <h1>ASAPPlanner Stage Viewer</h1>
 
     <div style="display:grid; gap:12px; min-width:0">
       <div class="toolbar"><label><span class="eyebrow">highlight query</span> <select id="queryPick" aria-label="Highlight one query's path"></select></label>
-        <span class="hint-inline">Dims what the query's root does not reach. Click a node to highlight what it reads and what reads it, the background to clear; click a pane chain to show its panes.</span></div>
+        <span class="hint-inline">Dims what the query's root does not reach. Click a node to highlight what it reads and what reads it, the background to clear; click a tumbling-window chain to show its tumbling windows.</span></div>
       <div class="lanes">
         <section class="panel lane" aria-labelledby="lane0-title">
           <div class="panel-head"><div><div class="eyebrow">Stage 0</div><h2 id="lane0-title">Query-language frontends</h2></div></div>
diff --git a/tools/dag-viewer/memo.js b/tools/dag-viewer/memo.js
index cb20788e9..d60046ecb 100644
--- a/tools/dag-viewer/memo.js
+++ b/tools/dag-viewer/memo.js
@@ -314,7 +314,7 @@ function memoStepElements(memo, s, options) {
 
   // Rank rows, highest rank on top; a rank wider than the row width wraps.
   // The row width grows with the drawing's area so that a step with
-  // hundreds of groups (one pane-chain group per grid) stays roughly as
+  // hundreds of groups (one tumbling-window-chain group per grid) stays roughly as
   // wide as it is tall, readable when the panel fits it.
   const area = boxes.reduce((n, b) => n + (b.width + MEMO_ITEM.groupGap) * (b.height + MEMO_ITEM.rowGap), 0);
   const rowWidth = Math.max(MEMO_ITEM.rowWidth, Math.sqrt(area) * 1.8);
diff --git a/tools/dag-viewer/memo.test.mjs b/tools/dag-viewer/memo.test.mjs
index dac7d0279..244329c9d 100644
--- a/tools/dag-viewer/memo.test.mjs
+++ b/tools/dag-viewer/memo.test.mjs
@@ -71,7 +71,7 @@ test('each step says what it added over the previous one', () => {
   assert.deepEqual(pass1.groupsAdded, []);
   const pass2 = call('memoStepDiff', memo, 2);
   // G2 grows from 2 to 20 (18 TumblingWindows and SharedBuild, 11 listed), G3 gains a
-  // rollup, the new pane-chain group G6 has one.
+  // rollup, the new tumbling-window-chain group G6 has one.
   assert.deepEqual(pass2.groupsAdded, [6]);
   assert.equal(pass2.candidatesDelta, 18 + 1 + 1);
   assert.equal(pass2.listedAdded, 11 + 1 + 1);
diff --git a/tools/dag-viewer/stages.js b/tools/dag-viewer/stages.js
index 5de7fb998..b8e4472f8 100644
--- a/tools/dag-viewer/stages.js
+++ b/tools/dag-viewer/stages.js
@@ -5,7 +5,8 @@
 const STAGE_PIPELINE_FORMAT = 'asap-stage-pipeline/v1';
 
 // Documents written before #1163 name the tumbling-window chain `PaneChain`,
-// its fields `pane_*` and the memo origin `panes` (`Panes` in older MILP
+// its fields `pane_*`, the planning report's `pane_width_domain` and
+// `pane_widths_pending`, and the memo origin `panes` (`Panes` in older MILP
 // search reports); renames them in place to today's names, keeping each
 // object's key order, so the rest of the viewer reads one set of names.
 // Remove once no document the viewer must open predates #1163.
@@ -15,6 +16,8 @@ const TUMBLING_WINDOW_RENAMES = Object.freeze({
   pane_count: 'tumbling_window_count',
   newest_panes: 'newest_tumbling_windows',
   pane_retention_ms: 'tumbling_window_retention_ms',
+  pane_width_domain: 'tumbling_window_width_domain',
+  pane_widths_pending: 'tumbling_window_widths_pending',
 });
 const ORIGIN_RENAMES = Object.freeze({ panes: 'tumbling_windows', Panes: 'TumblingWindows' });
 const has = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
@@ -586,8 +589,8 @@ function searchText(doc) {
   }
   const planning = doc.planning_report;
   if (planning && Array.isArray(planning.rounds)) {
-    parts.push(`${planning.rounds.length} pane-width round${planning.rounds.length === 1 ? '' : 's'} (${planning.rounds.map((r) => r.pane_width_domain).join(', ')})`);
-    if (planning.pane_widths_pending) parts.push('some pane widths not searched');
+    parts.push(`${planning.rounds.length} tumbling-window-width round${planning.rounds.length === 1 ? '' : 's'} (${planning.rounds.map((r) => r.tumbling_window_width_domain).join(', ')})`);
+    if (planning.tumbling_window_widths_pending) parts.push('some tumbling-window widths not searched');
   }
   const counts = selectionTable(doc).pruned_candidate_count_by_cause;
   if (doc.search === 'exhaustive' && counts && Object.keys(counts).length) {
@@ -700,11 +703,11 @@ function stageNodeLines(operator, inputSchema) {
       break;
     case 'SummaryEstimate': lines.push(`query: ${compactWire(op.query)}`); break;
     case 'SummaryMerge':
-      if (op.newest_tumbling_windows) lines.push(`newest ${op.newest_tumbling_windows} panes`);
+      if (op.newest_tumbling_windows) lines.push(`newest ${op.newest_tumbling_windows} tumbling windows`);
       break;
     case 'SummaryTumblingWindowChain':
       lines.push(`summary: ${summaryFamilyText(op.family)}`);
-      lines.push(`${op.tumbling_window_count} panes × ${durationText(op.tumbling_window_width_ms)}`);
+      lines.push(`${op.tumbling_window_count} tumbling windows × ${durationText(op.tumbling_window_width_ms)}`);
       if (grouping) lines.push(grouping);
       break;
     default: break;
@@ -736,9 +739,9 @@ function stageQueryReach(lane) {
   return reach;
 }
 
-// A pane's window relative to the evaluation time `t`: pane `k` (0 is the
+// The time range a tumbling window covers, relative to the evaluation time `t`: tumbling window `k` (0 is the
 // newest) of width `width` covers "t−(k+1)·width … t−k·width".
-function paneWindowText(k, width) {
+function tumblingWindowTimeText(k, width) {
   const end = k === 0 ? 't' : `t−${durationText(k * width)}`;
   return `t−${durationText((k + 1) * width)} … ${end}`;
 }
@@ -760,9 +763,9 @@ function timingClass(timing) {
 // nodes show their timing), `costPerNode` (the candidate's Stage 3
 // `per_node` costs), `queryIds` (the workload's query ids, to mark each
 // query's root), `expandedChains` (ids of SummaryTumblingWindowChain nodes to draw as their
-// panes: per pane `k`, newest first, a TimeShift by k panes (`n<id>p<k>s`,
-// none for the newest), a TimeRange of one pane (`n<id>p<k>r`) and the
-// pane's build (`n<id>p<k>`), each pane fed by the chain's input and read by
+// tumbling windows: per tumbling window `k`, newest first, a TimeShift by k tumbling windows (`n<id>p<k>s`,
+// none for the newest), a TimeRange of one tumbling window (`n<id>p<k>r`) and the
+// tumbling window's build (`n<id>p<k>`), each tumbling window fed by the chain's input and read by
 // the chain's readers). Display only: the document keeps the chain.
 function stageLaneElements(dag, options) {
   const { physical = false, costPerNode = null, queryIds = [], expandedChains = [] } = options || {};
@@ -792,16 +795,16 @@ function stageLaneElements(dag, options) {
       const width = body.tumbling_window_width_ms;
       for (let k = 0; k < body.tumbling_window_count; k += 1) {
         const id = `n${node.id}p${k}`;
-        const common = { paneOf: node.id, pane: k, reachedBy: queries, rootFor: [], timing: node.timing, node: node.raw };
+        const common = { tumblingWindowOf: node.id, tumblingWindowIndex: k, reachedBy: queries, rootFor: [], timing: node.timing, node: node.raw };
         if (k > 0) {
           nodes.push({ data: Object.assign({ id: `${id}s`, nodeId: `${node.id}p${k}s`, kind: 'TimeShift', group: group('TimeShift'),
-            label: `TimeShift\nshift: ${durationText(k * width)}` }, common), classes: `pane ${timingClass(node.timing)}`.trim() });
+            label: `TimeShift\nshift: ${durationText(k * width)}` }, common), classes: `tumblingWindow ${timingClass(node.timing)}`.trim() });
         }
         nodes.push({ data: Object.assign({ id: `${id}r`, nodeId: `${node.id}p${k}r`, kind: 'TimeRange', group: group('TimeRange'),
-          label: `TimeRange\nrange: ${durationText(width)}` }, common), classes: `pane ${timingClass(node.timing)}`.trim() });
-        nodes.push({ data: Object.assign({ id, nodeId: `${node.id}p${k}`, kind: 'pane', group: 'summary',
-          label: [`pane ${k + 1} of ${body.tumbling_window_count}`, `summary: ${summaryFamilyText(body.family)}`, `window ${paneWindowText(k, width)}`,
-            'click to collapse'].join('\n') }, common), classes: `pane ${timingClass(node.timing)}`.trim() });
+          label: `TimeRange\nrange: ${durationText(width)}` }, common), classes: `tumblingWindow ${timingClass(node.timing)}`.trim() });
+        nodes.push({ data: Object.assign({ id, nodeId: `${node.id}p${k}`, kind: 'tumblingWindow', group: 'summary',
+          label: [`tumbling window ${k + 1} of ${body.tumbling_window_count}`, `summary: ${summaryFamilyText(body.family)}`, `window ${tumblingWindowTimeText(k, width)}`,
+            'click to collapse'].join('\n') }, common), classes: `tumblingWindow ${timingClass(node.timing)}`.trim() });
       }
       return;
     }
@@ -829,21 +832,21 @@ function stageLaneElements(dag, options) {
     const into = expanded.has(e.consumer);
     const from = expanded.has(e.producer);
     if (!into && !from) { edge(`e${index}`, `n${e.producer}`, `n${e.consumer}`, e.raw); return; }
-    // An expanded chain's input feeds each pane's window; each pane feeds
+    // An expanded chain's input feeds each tumbling window's TimeRange; each tumbling window feeds
     // the chain's readers.
-    const panes = (chain) => byId.get(chain).body.tumbling_window_count;
+    const tumblingWindowCount = (chain) => byId.get(chain).body.tumbling_window_count;
     if (into) {
-      for (let k = 0; k < panes(e.consumer); k += 1) {
-        const pane = `n${e.consumer}p${k}`;
-        edge(`e${index}p${k}`, `n${e.producer}`, k > 0 ? `${pane}s` : `${pane}r`, e.raw);
-        if (k > 0) edge(`e${index}p${k}s`, `${pane}s`, `${pane}r`, null);
-        edge(`e${index}p${k}r`, `${pane}r`, pane, null);
+      for (let k = 0; k < tumblingWindowCount(e.consumer); k += 1) {
+        const tumblingWindowId = `n${e.consumer}p${k}`;
+        edge(`e${index}p${k}`, `n${e.producer}`, k > 0 ? `${tumblingWindowId}s` : `${tumblingWindowId}r`, e.raw);
+        if (k > 0) edge(`e${index}p${k}s`, `${tumblingWindowId}s`, `${tumblingWindowId}r`, null);
+        edge(`e${index}p${k}r`, `${tumblingWindowId}r`, tumblingWindowId, null);
       }
     }
     if (from) {
-      // A merge of the chain's newest panes reads only those.
+      // A merge of the chain's newest tumbling windows reads only those.
       const consumer = byId.get(e.consumer);
-      const read = (consumer && consumer.body && consumer.body.newest_tumbling_windows) || panes(e.producer);
+      const read = (consumer && consumer.body && consumer.body.newest_tumbling_windows) || tumblingWindowCount(e.producer);
       for (let k = 0; k < read; k += 1) {
         edge(`e${index}q${k}`, `n${e.producer}p${k}`, into ? `n${e.consumer}p0r` : `n${e.consumer}`, e.raw);
       }
@@ -997,8 +1000,8 @@ function physicalReaders(dag, nodeId, queryIds) {
 }
 
 // The selected plan's materialized views as table rows: the coverage's
-// definition, the Stage 2 node's operator and summary parameters, its pane
-// (a pane chain's panes, newest first), how and when it is refreshed, its
+// definition, the Stage 2 node's operator and summary parameters, its tumbling window
+// (a tumbling-window chain's tumbling windows, newest first), how and when it is refreshed, its
 // retention, the Stage 3 cost of its Stage 2 node and the queries that read
 // it. Empty without a selection.
 function materializedViewRows(doc) {
@@ -1013,15 +1016,15 @@ function materializedViewRows(doc) {
     const node = nodes.get(output.stage2_node_id);
     const [kind, body] = node ? stageOperatorParts(node.payload) : ['—', {}];
     const summary = kind === 'SummaryAgg' || kind === 'SummaryTumblingWindowChain' ? summaryFamilyText(body.family) : '';
-    const pane = kind === 'SummaryTumblingWindowChain' && typeof output.installed_position === 'number'
-      ? `pane ${output.installed_position + 1} of ${output.installed_count} (newest first), ${durationText(body.tumbling_window_width_ms)} wide` : '—';
+    const tumblingWindow = kind === 'SummaryTumblingWindowChain' && typeof output.installed_position === 'number'
+      ? `tumbling window ${output.installed_position + 1} of ${output.installed_count} (newest first), ${durationText(body.tumbling_window_width_ms)} wide` : '—';
     const cost = perNode[String(output.stage2_node_id)];
     return {
       nodeId: output.node_id,
       stage2NodeId: node ? output.stage2_node_id : null,
       definition: output.coverage.definition_id,
       kind: summary ? `${kind} · ${summary}` : kind,
-      pane,
+      tumblingWindow,
       refresh: output.refresh === 'at_ingestion' ? 'at ingestion' : 'on first read (kept across evaluations)',
       inputs: `${output.inputs.raw_data_windows.length} raw-data window(s)` +
         (output.inputs.materialized_views.length ? `, views ${output.inputs.materialized_views.join(', ')}` : ''),
@@ -1035,10 +1038,10 @@ function materializedViewRows(doc) {
 }
 
 // The selected plan's materialized views grouped by the Stage 2 node they are
-// installed from: one group per pane chain (its panes, newest first, with
+// installed from: one group per tumbling-window chain (its tumbling windows, newest first, with
 // "count × width"), one per other node. Each group has its Stage 2 node,
 // definition(s), kind, how it is refreshed, its retention (a range when the
-// panes differ), the Stage 3 cost and the queries that read it.
+// tumbling windows differ), the Stage 3 cost and the queries that read it.
 function materializedViewGroups(doc) {
   const rows = materializedViewRows(doc);
   const candidate = ((doc.stage2_physical_asap_optimization || {}).candidates || []).find((c) => c.id === selectionTable(doc).selected_candidate);
@@ -1052,22 +1055,22 @@ function materializedViewGroups(doc) {
   });
   const joined = (values) => [...new Set(values)].join(', ');
   return groups.map((key) => {
-    const panes = byNode.get(key).slice().sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
-    const first = panes[0];
+    const tumblingWindows = byNode.get(key).slice().sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
+    const first = tumblingWindows[0];
     const node = nodes.get(first.stage2NodeId);
     const [kind, body] = node ? stageOperatorParts(node.payload) : ['—', {}];
-    const retention = panes.map((p) => p.retention);
+    const retention = tumblingWindows.map((p) => p.retention);
     return {
       stage2NodeId: first.stage2NodeId,
-      nodeIds: panes.map((p) => p.nodeId),
-      definition: joined(panes.map((p) => p.definition)),
+      nodeIds: tumblingWindows.map((p) => p.nodeId),
+      definition: joined(tumblingWindows.map((p) => p.definition)),
       kind: first.kind,
-      panesText: kind === 'SummaryTumblingWindowChain' ? `${body.tumbling_window_count} × ${durationText(body.tumbling_window_width_ms)}` : '—',
-      refresh: joined(panes.map((p) => p.refresh)),
+      tumblingWindowsText: kind === 'SummaryTumblingWindowChain' ? `${body.tumbling_window_count} × ${durationText(body.tumbling_window_width_ms)}` : '—',
+      refresh: joined(tumblingWindows.map((p) => p.refresh)),
       retention: new Set(retention).size === 1 ? retention[0] : `${retention[0]} … ${retention[retention.length - 1]}`,
       cost: first.cost,
       readBy: first.readBy,
-      panes,
+      tumblingWindows,
     };
   });
 }
@@ -1171,7 +1174,7 @@ function validateMemoPlan(plan, queryCount) {
   return errors;
 }
 
-// A coupling site's chosen threshold as text: a shared build's size, a pane
+// A coupling site's chosen threshold as text: a shared build's size, a tumbling window
 // chain's grid, a scan's label set or a raw horizon.
 function couplingThresholdText(kind, threshold) {
   const t = threshold || {};
@@ -1180,7 +1183,7 @@ function couplingThresholdText(kind, threshold) {
       if ('state' in t) return `finer state ${summaryFamilyText(t.state)}`;
       if (!t.params) return 'exact accumulator (no size)';
       return [Object.keys(t.params)[0]].concat(wireParams(t.params)).join(' · ');
-    case 'SummaryTumblingWindowChain': return `${durationText(t.tumbling_window_width_ms)} panes over ${durationText(t.longest_window_ms)} · ${summaryFamilyText(t.family)}`;
+    case 'SummaryTumblingWindowChain': return `${durationText(t.tumbling_window_width_ms)} tumbling windows over ${durationText(t.longest_window_ms)} · ${summaryFamilyText(t.family)}`;
     case 'ScanLabels': return `labels ${(t.labels || []).join(', ') || 'none'}`;
     case 'RawHorizon': return `raw horizon ${durationText(t.horizon_ms)}`;
     default: return compactWire(threshold);
diff --git a/tools/dag-viewer/stages.test.mjs b/tools/dag-viewer/stages.test.mjs
index a4c69c9c3..dd5b3f3a8 100644
--- a/tools/dag-viewer/stages.test.mjs
+++ b/tools/dag-viewer/stages.test.mjs
@@ -1,4 +1,4 @@
-// Node tests of stages.js (no DOM): pane-chain expansion, the queries that
+// Node tests of stages.js (no DOM): tumbling-window-chain expansion, the queries that
 // reach each node, the highlighted neighborhoods and the grouped materialized
 // outputs, over the committed seed-862 workload example; the elements load
 // into the vendored cytoscape (headless), which refuses duplicate ids and
@@ -36,18 +36,20 @@ test('durations read largest unit first', () => {
   assert.equal(call('durationText', 580000), '9 min 40 s');
   assert.equal(call('durationText', 20000), '20 s');
   assert.equal(call('durationText', 3600000), '1 h');
-  assert.equal(call('paneWindowText', 0, 20000), 't−20 s … t');
-  assert.equal(call('paneWindowText', 2, 20000), 't−1 min … t−40 s');
+  assert.equal(call('tumblingWindowTimeText', 0, 20000), 't−20 s … t');
+  assert.equal(call('tumblingWindowTimeText', 2, 20000), 't−1 min … t−40 s');
 });
 
-test('a collapsed chain is one node; expanded, one build, range and shift per pane', () => {
+test('a collapsed chain is one node; expanded, one build, range and shift per tumbling window', () => {
   const collapsed = call('stageLaneElements', dag, { physical: true, queryIds });
   assert.ok(nodesOf(collapsed).some((e) => e.data.id === `n${chain.id}` && e.data.expandable));
   const expanded = call('stageLaneElements', dag, { physical: true, queryIds, expandedChains: [chain.id] });
-  const panes = nodesOf(expanded).filter((e) => e.data.paneOf === chain.id);
-  assert.equal(panes.filter((e) => e.data.kind === 'pane').length, body.tumbling_window_count);
-  assert.equal(panes.filter((e) => e.data.kind === 'TimeRange').length, body.tumbling_window_count);
-  assert.equal(panes.filter((e) => e.data.kind === 'TimeShift').length, body.tumbling_window_count - 1);
+  const tumblingWindows = nodesOf(expanded).filter((e) => e.data.tumblingWindowOf === chain.id);
+  assert.equal(tumblingWindows.filter((e) => e.data.kind === 'tumblingWindow').length, body.tumbling_window_count);
+  assert.equal(tumblingWindows.filter((e) => e.data.kind === 'TimeRange').length, body.tumbling_window_count);
+  assert.equal(tumblingWindows.filter((e) => e.data.kind === 'TimeShift').length, body.tumbling_window_count - 1);
+  // Each expanded node carries the one class app.js styles with a dashed border.
+  assert.ok(tumblingWindows.every((e) => e.classes.split(' ').includes('tumblingWindow')));
   const ids = new Set(nodesOf(expanded).map((e) => e.data.id));
   for (const edge of edgesOf(expanded)) {
     assert.ok(ids.has(edge.data.source) && ids.has(edge.data.target), edge.data.id);
@@ -62,7 +64,7 @@ test('a collapsed chain is one node; expanded, one build, range and shift per pa
   assert.equal(cy.elements('.dimmed').length, all.length - keep.size);
 });
 
-test('a merge of the newest panes reads only those panes, and says so', () => {
+test('a merge of the newest tumbling windows reads only those tumbling windows, and says so', () => {
   const partial = JSON.parse(JSON.stringify(dag));
   const merge = partial.nodes.find((n) => n.payload.ASAP && n.payload.ASAP.SummaryMerge
     && partial.edges.some((e) => e.consumer === n.id && e.producer === chain.id));
@@ -72,7 +74,7 @@ test('a merge of the newest panes reads only those panes, and says so', () => {
   const into = edgesOf(elements).filter((e) => e.data.target === `n${merge.id}` && e.data.source.startsWith(`n${chain.id}p`));
   assert.equal(into.map((e) => e.data.source).sort().join(), `n${chain.id}p0,n${chain.id}p1`);
   const label = nodesOf(elements).find((e) => e.data.id === `n${merge.id}`).data.label;
-  assert.match(label, /newest 2 panes/);
+  assert.match(label, /newest 2 tumbling windows/);
 });
 
 test('every node lists the queries reaching it; shared nodes say how many', () => {
@@ -97,11 +99,11 @@ test('a query keeps its own nodes and a node its neighborhood', () => {
   assert.ok(!around.has(`n${dag.roots[8]}`));
 });
 
-test('materialized views group by pane chain', () => {
+test('materialized views group by tumbling-window chain', () => {
   const groups = call('materializedViewGroups', doc);
   assert.equal(groups.length, 6);
-  assert.equal(groups.reduce((n, g) => n + g.panes.length, 0), doc.stage3_plan_selection.materialized_views.length);
-  assert.equal(groups[0].panesText, `${body.tumbling_window_count} × 20 s`);
+  assert.equal(groups.reduce((n, g) => n + g.tumblingWindows.length, 0), doc.stage3_plan_selection.materialized_views.length);
+  assert.equal(groups[0].tumblingWindowsText, `${body.tumbling_window_count} × 20 s`);
 });
 
 test('the candidate header shows the selection\'s warnings', () => {
@@ -158,7 +160,7 @@ test('a memo-MILP document shows its shared sketch, readers and certified summar
   const chain = view.sharedUnits.find((u) => u.kind === 'coupling site · SummaryTumblingWindowChain');
   assert.deepEqual([...chain.readers], ['G3', 'G4']);
   assert.deepEqual([...chain.queries], ['q1', 'q2']);
-  assert.match(chain.threshold, /^1 min panes over 1 h · DDSketch · alpha 0.05/);
+  assert.match(chain.threshold, /^1 min tumbling windows over 1 h · DDSketch · alpha 0.05/);
   assert.equal(view.groups.find((g) => g.id === 'G3').chosen, 'TumblingWindows · Project · at S1');
 });
 
@@ -222,7 +224,9 @@ test('a document written before the tumbling-window rename (#1163) upgrades to t
     .replaceAll('"tumbling_window_width_ms"', '"pane_width_ms"')
     .replaceAll('"tumbling_window_count"', '"pane_count"')
     .replaceAll('"newest_tumbling_windows"', '"newest_panes"')
-    .replaceAll('"tumbling_window_retention_ms"', '"pane_retention_ms"'));
+    .replaceAll('"tumbling_window_retention_ms"', '"pane_retention_ms"')
+    .replaceAll('"tumbling_window_width_domain"', '"pane_width_domain"')
+    .replaceAll('"tumbling_window_widths_pending"', '"pane_widths_pending"'));
   assert.ok(JSON.stringify(old).includes('"PaneChain"'));
   assert.deepEqual(call('upgradeTumblingWindowNames', old), doc);
 });
diff --git a/tools/dag-viewer/test_viewer.py b/tools/dag-viewer/test_viewer.py
index def79a52e..2577816f6 100644
--- a/tools/dag-viewer/test_viewer.py
+++ b/tools/dag-viewer/test_viewer.py
@@ -26,7 +26,7 @@
 EXAMPLE1 = HERE / "examples" / "planner-layering-example1.json"
 # A committed workload example: ASAPQuery's random workload seed 862,
 # workload-01 (nine repeating PromQL queries), planned with the default
-# search as the MVP deployment; its selected plan keeps panes at ingestion.
+# search as the MVP deployment; its selected plan keeps tumbling windows at ingestion.
 SEED862 = HERE / "examples" / "random-mixed-seed-862-workload-01.json"
 # A hand-written priced `memo` section for Example 1: four enumerated
 # Pass 1 DAGs, E2 selected, E3 cheaper than it, E4 invalid.
@@ -489,7 +489,7 @@ def test_header_names_the_search_and_its_report(self):
         report = self.doc["stage3_plan_selection"]["search_report"]
         self.assertIn(f"search {report['status'].replace('_', ' ')}", text)
         self.assertIn(f"MILP {report['milp_variables']} variables", text)
-        self.assertIn("pane-width round", text)
+        self.assertIn("tumbling-window-width round", text)
         outputs = self.doc["stage3_plan_selection"]["selected_dag"]["node_of_output_reference"]
         self.assertEqual(len(outputs), 2)
         # Archived documents (before Stage 3's `Selection`) still render
@@ -618,10 +618,10 @@ def test_materialized_view_rows_map_to_stage2_nodes_and_their_readers(self):
         first = rows[0]
         self.assertEqual(first["definition"], stored[0]["coverage"]["definition_id"])
         self.assertTrue(first["kind"].startswith("SummaryTumblingWindowChain · "), first["kind"])
-        self.assertRegex(first["pane"], r"^pane 1 of \d+ \(newest first\), ")
+        self.assertRegex(first["tumblingWindow"], r"^tumbling window 1 of \d+ \(newest first\), ")
         self.assertEqual(first["refresh"], "at ingestion")
         self.assertTrue(all(r["stage2NodeId"] is not None and r["readBy"] for r in rows))
-        # q1 and q2 share one pane chain of exact sums.
+        # q1 and q2 share one tumbling-window chain of exact sums.
         self.assertEqual(first["readBy"], ["q1", "q2"])
 
     def test_queries_show_recurrence_and_predictability(self):
@@ -644,13 +644,13 @@ def test_exhaustive_header_counts_pruned_candidates_by_cause(self):
         text = self.js.call("searchText", example1())
         self.assertRegex(text, r"pruned: [a-z ]+ ×\d+")
 
-    def test_pane_chain_box_shows_its_panes(self):
+    def test_tumbling_window_chain_box_shows_its_tumbling_windows(self):
         selected = self.doc["stage2_physical_asap_optimization"]["candidates"][0]
         chain = next(n for n in selected["dag"]["nodes"] if "SummaryTumblingWindowChain" in n["payload"].get("ASAP", {}))
         lines = self.js.call("stageNodeLines", chain["payload"], None)
         body = chain["payload"]["ASAP"]["SummaryTumblingWindowChain"]
         self.assertEqual(lines[0], "SummaryTumblingWindowChain")
-        self.assertIn(f"{body['tumbling_window_count']} panes × ", lines[2])
+        self.assertIn(f"{body['tumbling_window_count']} tumbling windows × ", lines[2])
 
     def test_usage_and_deployment_lines(self):
         cost = self.doc["stage3_plan_selection"]["costs"][self.doc["stage3_plan_selection"]["selected"]]
@@ -668,10 +668,10 @@ def test_planning_workload_queries_read_the_workload_json(self):
 
 
 @unittest.skipIf(py_mini_racer is None, "viewer tests require py_mini_racer")
-class PanesAndPathsTests(unittest.TestCase):
-    """Display only: a pane chain expands into its panes on request, each
+class TumblingWindowsAndPathsTests(unittest.TestCase):
+    """Display only: a tumbling-window chain expands into its tumbling windows on request, each
     node lists the queries whose root reaches it, and the query and node
-    neighborhoods the page highlights. The seed-862 plan keeps six pane
+    neighborhoods the page highlights. The seed-862 plan keeps six tumbling window
     chains; queries q1-q7 read metric "data", q8 and q9 "data_total"."""
 
     def setUp(self):
@@ -689,25 +689,25 @@ def elements(self, **options):
     def node(self, elements, element_id):
         return next(e for e in lane_nodes(elements) if e["data"]["id"] == element_id)
 
-    def test_chains_stay_collapsed_by_default_and_print_their_panes(self):
+    def test_chains_stay_collapsed_by_default_and_print_their_tumbling_windows(self):
         chain = self.node(self.elements(), f"n{self.chain['id']}")
         self.assertEqual(chain["data"]["kind"], "SummaryTumblingWindowChain")
-        self.assertIn(f"{self.body['tumbling_window_count']} panes × 20 s", chain["data"]["label"])
+        self.assertIn(f"{self.body['tumbling_window_count']} tumbling windows × 20 s", chain["data"]["label"])
         self.assertTrue(chain["data"]["expandable"])
 
-    def test_an_expanded_chain_shows_each_pane_with_its_time_range_shift_and_window(self):
+    def test_an_expanded_chain_shows_each_tumbling_window_with_its_time_range_shift_and_window(self):
         count, chain_id = self.body["tumbling_window_count"], self.chain["id"]
         elements = self.elements(expandedChains=[chain_id])
         ids = {e["data"]["id"] for e in lane_nodes(elements)}
         self.assertNotIn(f"n{chain_id}", ids)
-        panes = [e for e in lane_nodes(elements) if e["data"].get("paneOf") == chain_id]
-        kinds = sorted(e["data"]["kind"] for e in panes)
-        # One build, one TimeRange per pane; a TimeShift for every pane but the newest.
-        self.assertEqual(kinds.count("pane"), count)
+        tumbling_windows = [e for e in lane_nodes(elements) if e["data"].get("tumblingWindowOf") == chain_id]
+        kinds = sorted(e["data"]["kind"] for e in tumbling_windows)
+        # One build, one TimeRange per tumbling window; a TimeShift for every tumbling window but the newest.
+        self.assertEqual(kinds.count("tumblingWindow"), count)
         self.assertEqual(kinds.count("TimeRange"), count)
         self.assertEqual(kinds.count("TimeShift"), count - 1)
         newest = self.node(elements, f"n{chain_id}p0")
-        self.assertIn("pane 1 of 30", newest["data"]["label"])
+        self.assertIn("tumbling window 1 of 30", newest["data"]["label"])
         self.assertIn("window t−20 s … t", newest["data"]["label"])
         oldest = self.node(elements, f"n{chain_id}p{count - 1}")
         self.assertIn("window t−10 min … t−9 min 40 s", oldest["data"]["label"])
@@ -715,7 +715,7 @@ def test_an_expanded_chain_shows_each_pane_with_its_time_range_shift_and_window(
         self.assertIn("shift: 20 s", shift["data"]["label"])
         edges = [(e["data"]["source"], e["data"]["target"]) for e in lane_edges(elements)]
         child = f"n{self.body['child']}"
-        # The chain's input feeds every pane's window; every pane feeds the chain's readers.
+        # The chain's input feeds every tumbling window's TimeRange; every tumbling window feeds the chain's readers.
         self.assertIn((child, f"n{chain_id}p0r"), edges)
         self.assertIn((child, f"n{chain_id}p1s"), edges)
         self.assertIn((f"n{chain_id}p1s", f"n{chain_id}p1r"), edges)
@@ -728,7 +728,7 @@ def test_an_expanded_chain_shows_each_pane_with_its_time_range_shift_and_window(
     def test_each_node_lists_the_queries_reaching_it_and_shared_nodes_say_so(self):
         elements = self.elements()
         # The quantile queries q3-q5 read the same 100 s window of one
-        # per-series DDSketch pane chain, so they share its scan and merge.
+        # per-series DDSketch tumbling-window chain, so they share its scan and merge.
         scans = [e for e in lane_nodes(elements) if e["data"]["kind"] == "Scan"]
         shared = next(e for e in scans if e["data"]["reachedBy"] == ["q3", "q4", "q5"])
         self.assertIn("shared ×3", shared["data"]["label"])
@@ -762,17 +762,17 @@ def test_a_node_neighborhood_is_everything_upstream_and_downstream(self):
             self.assertIn(f"n{root}", kept)
         self.assertNotIn(f"n{self.dag['roots'][8]}", kept)  # q9 reads another metric
 
-    def test_materialized_views_group_by_pane_chain(self):
+    def test_materialized_views_group_by_tumbling_window_chain(self):
         groups = self.js.call("materializedViewGroups", self.doc)
         self.assertEqual(len(groups), 6)
-        self.assertEqual(sum(len(g["panes"]) for g in groups), len(self.doc["stage3_plan_selection"]["materialized_views"]))
+        self.assertEqual(sum(len(g["tumblingWindows"]) for g in groups), len(self.doc["stage3_plan_selection"]["materialized_views"]))
         first = groups[0]
         self.assertEqual(first["stage2NodeId"], self.chain["id"])
-        self.assertEqual(first["panesText"], "30 × 20 s")
+        self.assertEqual(first["tumblingWindowsText"], "30 × 20 s")
         self.assertEqual((first["refresh"], first["retention"]), ("at ingestion", "10 min"))
         self.assertEqual(first["readBy"], ["q1", "q2"])
-        self.assertEqual(first["panes"][0]["window"], "t−20 s … t")
-        self.assertEqual(first["panes"][1]["window"], "t−40 s … t−20 s")
+        self.assertEqual(first["tumblingWindows"][0]["window"], "t−20 s … t")
+        self.assertEqual(first["tumblingWindows"][1]["window"], "t−40 s … t−20 s")
 
 
 class WorkloadSetTests(unittest.TestCase):
@@ -1043,7 +1043,7 @@ def test_workload_sets_without_a_server_mark_what_needs_it(self):
         self.assertIn("no server", js.eval("__els.setsServer.textContent"))
         self.assertIn("Random mixed · seed-862 (10)", js.eval("__els.setPick.innerHTML"))
 
-    def test_materialized_views_table_has_one_row_per_pane_chain(self):
+    def test_materialized_views_table_has_one_row_per_tumbling_window_chain(self):
         js = self.page("?doc=s.json", {"s.json": SEED862.read_text()})
         self.assertEqual(js.eval("(__els.materializedViews.innerHTML.match(/data-node=/g) || []).length"), 6)
         self.assertIn("300 materialized views in 6 groups", self.text(js, "views-meta"))
@@ -1062,15 +1062,15 @@ def test_picking_a_query_dims_what_it_does_not_reach(self):
         js.eval("__els.queryPick.__on.change({ target: { value: '' } })")
         self.assertEqual(js.eval("__dimmed.cy2.length"), 0)
 
-    def test_tapping_a_pane_chain_expands_it_and_a_pane_collapses_it(self):
+    def test_tapping_a_tumbling_window_chain_expands_it_and_a_tumbling_window_collapses_it(self):
         js = self.page("?doc=s.json", {"s.json": SEED862.read_text()})
         chain = next(e for e in self.ev(js, "__rendered.cy2") if e["data"].get("kind") == "SummaryTumblingWindowChain")
         js.eval(f"__taps['cy2 node']({{ target: __rendered.cy2.find((e) => e.data.id === {json.dumps(chain['data']['id'])}) && {{ data() {{ return __rendered.cy2.find((e) => e.data.id === {json.dumps(chain['data']['id'])}).data; }}, id() {{ return {json.dumps(chain['data']['id'])}; }} }} }})")
         ids = {e["data"]["id"] for e in self.ev(js, "__rendered.cy2")}
         self.assertNotIn(chain["data"]["id"], ids)
-        pane = chain["data"]["id"] + "p0"
-        self.assertIn(pane, ids)
-        js.eval(f"__taps['cy2 node']({{ target: {{ data() {{ return __rendered.cy2.find((e) => e.data.id === {json.dumps(pane)}).data; }}, id() {{ return {json.dumps(pane)}; }} }} }})")
+        tumbling_window = chain["data"]["id"] + "p0"
+        self.assertIn(tumbling_window, ids)
+        js.eval(f"__taps['cy2 node']({{ target: {{ data() {{ return __rendered.cy2.find((e) => e.data.id === {json.dumps(tumbling_window)}).data; }}, id() {{ return {json.dumps(tumbling_window)}; }} }} }})")
         self.assertIn(chain["data"]["id"], {e["data"]["id"] for e in self.ev(js, "__rendered.cy2")})
 
     def test_an_expanded_chain_stays_expanded_after_switching_plans_and_back(self):