diff --git a/differential-dataflow/examples/cursors.rs b/differential-dataflow/examples/cursors.rs
index 8dcfc739d..f4d209284 100644
--- a/differential-dataflow/examples/cursors.rs
+++ b/differential-dataflow/examples/cursors.rs
@@ -93,8 +93,8 @@ fn main() {
         }
 
         /* Return trace content after the last round. */
-        let batches = graph_trace.batches_through(Antichain::new().borrow()).unwrap();
-        let (mut cursor, storage) = cursor_list(batches);
+        let batches = graph_trace.spans_through(Antichain::new().borrow()).unwrap();
+        let (mut cursor, storage) = cursor_list(batches.into_iter().filter_map(|b| b.inner).collect());
         cursor.to_vec(&storage, |k| k.clone(), |v| v.clone())
     })
     .unwrap().join();
diff --git a/differential-dataflow/examples/multitemporal.rs b/differential-dataflow/examples/multitemporal.rs
index 0850745c1..ffc9b2e06 100644
--- a/differential-dataflow/examples/multitemporal.rs
+++ b/differential-dataflow/examples/multitemporal.rs
@@ -99,8 +99,8 @@ fn main() {
                             else {
                                 println!("Report at {:?}", query_time);
                                 // enumerate the contents of `trace` at `query_time`.
-                                let batches = trace.batches_through(Antichain::new().borrow()).unwrap();
-                                let (mut cursor, storage) = cursor_list(batches);
+                                let batches = trace.spans_through(Antichain::new().borrow()).unwrap();
+                                let (mut cursor, storage) = cursor_list(batches.into_iter().filter_map(|b| b.inner).collect());
                                 while let Some(key) = cursor.get_key(&storage) {
                                     while let Some(_val) = cursor.get_val(&storage) {
                                         let mut sum = 0;
diff --git a/differential-dataflow/examples/spines.rs b/differential-dataflow/examples/spines.rs
index e90f12e1c..6bfe3b224 100644
--- a/differential-dataflow/examples/spines.rs
+++ b/differential-dataflow/examples/spines.rs
@@ -56,21 +56,21 @@ fn main() {
 
             match mode.as_str() {
                 "key" => {
-                    use differential_dataflow::trace::implementations::ord_neu::{OrdKeyBatcher, RcOrdKeyBuilder, OrdKeySpine};
+                    use differential_dataflow::trace::implementations::ord_neu::{OrdKeyBatcher, VecOrdKeyBuilder, OrdKeySpine};
                     let (data_input, data) = scope.new_collection::<String, isize>();
                     let (keys_input, keys) = scope.new_collection::<String, isize>();
-                    let data = data.arrange::<OrdKeyBatcher<String,_,isize>, RcOrdKeyBuilder<String,_,isize>, OrdKeySpine<String,_,isize>>();
-                    let keys = keys.arrange::<OrdKeyBatcher<String,_,isize>, RcOrdKeyBuilder<String,_,isize>, OrdKeySpine<String,_,isize>>();
+                    let data = data.arrange::<OrdKeyBatcher<String,_,isize>, VecOrdKeyBuilder<String,_,isize>, OrdKeySpine<String,_,isize>>();
+                    let keys = keys.arrange::<OrdKeyBatcher<String,_,isize>, VecOrdKeyBuilder<String,_,isize>, OrdKeySpine<String,_,isize>>();
                     keys.join_core(data, |_k, &(), &()| Option::<()>::None)
                         .probe_with(&mut probe);
                     Workload { data_input, keys_input }
                 },
                 "val" => {
-                    use differential_dataflow::trace::implementations::ord_neu::{OrdValBatcher, RcOrdValBuilder, OrdValSpine};
+                    use differential_dataflow::trace::implementations::ord_neu::{OrdValBatcher, VecOrdValBuilder, OrdValSpine};
                     let (data_input, data) = scope.new_collection::<String, isize>();
                     let (keys_input, keys) = scope.new_collection::<String, isize>();
-                    let data = data.map(|x| (x, ())).arrange::<OrdValBatcher<String,(),_,isize>, RcOrdValBuilder<String,(),_,isize>, OrdValSpine<String,(),_,isize>>();
-                    let keys = keys.map(|x| (x, ())).arrange::<OrdValBatcher<String,(),_,isize>, RcOrdValBuilder<String,(),_,isize>, OrdValSpine<String,(),_,isize>>();
+                    let data = data.map(|x| (x, ())).arrange::<OrdValBatcher<String,(),_,isize>, VecOrdValBuilder<String,(),_,isize>, OrdValSpine<String,(),_,isize>>();
+                    let keys = keys.map(|x| (x, ())).arrange::<OrdValBatcher<String,(),_,isize>, VecOrdValBuilder<String,(),_,isize>, OrdValSpine<String,(),_,isize>>();
                     keys.join_core(data, |_k, &(), &()| Option::<()>::None)
                         .probe_with(&mut probe);
                     Workload { data_input, keys_input }
diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index b01b92ca6..53ce59fdb 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -785,7 +785,7 @@ pub mod vec {
         where
             T2: Trace<Batch: Navigable, Time=T>+'static,
             for<'a> BatchCursor<T2>: Cursor<Key<'a>= &'a K, ValOwn = V, Time = T2::Time, Diff: Abelian>,
-            Bu: Builder<Time=T2::Time, Input = Vec<((K, V), T2::Time, BatchDiff<T2>)>, Output = T2::Batch> + 'static,
+            Bu: Builder<Time=T2::Time, Input = Vec<((K, V), T2::Time, BatchDiff<T2>)>, Output: Into<T2::Batch>> + 'static,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(V, BatchDiff<T2>)>)+'static,
         {
             self.reduce_core::<_,Bu,T2>(name, move |key, input, output, change| {
@@ -805,7 +805,7 @@ pub mod vec {
             V: Clone+'static,
             T2: Trace<Batch: Navigable, Time=T>+'static,
             for<'a> BatchCursor<T2>: Cursor<Key<'a>=&'a K, ValOwn = V, Time = T2::Time>,
-            Bu: Builder<Time=T2::Time, Input = Vec<((K, V), T2::Time, BatchDiff<T2>)>, Output = T2::Batch> + 'static,
+            Bu: Builder<Time=T2::Time, Input = Vec<((K, V), T2::Time, BatchDiff<T2>)>, Output: Into<T2::Batch>> + 'static,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(V,BatchDiff<T2>)>, &mut Vec<(V, BatchDiff<T2>)>)+'static,
         {
             self.arrange_by_key_named(&format!("Arrange: {}", name))
@@ -968,7 +968,7 @@ pub mod vec {
             Ba: crate::trace::Batcher<Output=Vec<((D, ()), T, R)>, Time=T> + 'static,
             Tr: crate::trace::Trace<Batch: Navigable, Time=T>+'static,
             for<'a> BatchCursor<Tr>: Cursor<Time=Tr::Time, Diff=R>,
-            Bu: crate::trace::Builder<Time=Tr::Time, Input=Vec<((D, ()), T, R)>, Output=Tr::Batch>,
+            Bu: crate::trace::Builder<Time=Tr::Time, Input=Vec<((D, ()), T, R)>, Output: Into<Tr::Batch>>,
             F: Fn(BatchKey<'_, Tr>, BatchVal<'_, Tr>) -> D + 'static,
         {
             use crate::operators::arrange::arrangement::Arrange;
@@ -1036,7 +1036,7 @@ pub mod vec {
         fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<'scope, TraceAgent<Tr>>
         where
             Ba: crate::trace::Batcher<Output=Vec<((K, V), T, R)>, Time=T> + 'static,
-            Bu: crate::trace::Builder<Time=T, Input=Vec<((K, V), T, R)>, Output = Tr::Batch>,
+            Bu: crate::trace::Builder<Time=T, Input=Vec<((K, V), T, R)>, Output: Into<Tr::Batch>>,
             Tr: crate::trace::Trace<Time=T> + 'static,
         {
             let exchange = timely::dataflow::channels::pact::Exchange::new(move |update: &((K,V),T,R)| (update.0).0.hashed().into());
@@ -1051,7 +1051,7 @@ pub mod vec {
         fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<'scope, TraceAgent<Tr>>
         where
             Ba: crate::trace::Batcher<Output=Vec<((K, ()), T, R)>, Time=T> + 'static,
-            Bu: crate::trace::Builder<Time=T, Input=Vec<((K, ()), T, R)>, Output = Tr::Batch>,
+            Bu: crate::trace::Builder<Time=T, Input=Vec<((K, ()), T, R)>, Output: Into<Tr::Batch>>,
             Tr: crate::trace::Trace<Time=T> + 'static,
         {
             let exchange = timely::dataflow::channels::pact::Exchange::new(move |update: &((K,()),T,R)| (update.0).0.hashed().into());
diff --git a/differential-dataflow/src/columnar/collection/operators.rs b/differential-dataflow/src/columnar/collection/operators.rs
index c5f00d540..ff7b3f21a 100644
--- a/differential-dataflow/src/columnar/collection/operators.rs
+++ b/differential-dataflow/src/columnar/collection/operators.rs
@@ -169,6 +169,7 @@ where
                 input.for_each(|time, batches| {
                     let mut session = output.session_with_builder(&time);
                     for batch in batches.drain(..) {
+                        let Some(batch) = batch.inner else { continue };
                         let mut cursor = batch.cursor();
                         while cursor.key_valid(&batch) {
                             while cursor.val_valid(&batch) {
diff --git a/differential-dataflow/src/columnar/trace/chunk.rs b/differential-dataflow/src/columnar/trace/chunk.rs
index 393058920..89c6e0fbc 100644
--- a/differential-dataflow/src/columnar/trace/chunk.rs
+++ b/differential-dataflow/src/columnar/trace/chunk.rs
@@ -546,6 +546,7 @@ fn advance_trie<U: ColumnarUpdate>(
 
 #[cfg(test)]
 mod test {
+    use timely::progress::Antichain;
     use std::collections::VecDeque;
     use columnar::Push;
     use super::{ColChunk, Chunk};
@@ -647,18 +648,14 @@ mod test {
     #[test]
     fn cursor_handles_straddle() {
         use crate::trace::cursor::Cursor;
-        use crate::trace::Description;
         use crate::trace::chunk::ChunkBatch;
-        use timely::progress::Antichain;
 
         let chunks = vec![
             chunk(vec![(0, 0, 0, 1), (1, 0, 0, 1), (1, 1, 0, 1)]),
             chunk(vec![(1, 1, 1, 1), (1, 2, 0, 1)]),
             chunk(vec![(2, 0, 0, 1)]),
         ];
-        let desc = Description::new(
-            Antichain::from_elem(0u64), Antichain::from_elem(2u64), Antichain::from_elem(0u64));
-        let batch = ChunkBatch::new(chunks, desc);
+        let batch = ChunkBatch::new(chunks);
 
         let mut cursor = batch.cursor();
         let got = cursor.to_vec(&batch, |k| *k, |v| *v);
@@ -678,12 +675,10 @@ mod test {
     // resumable merge -> advance -> settle pipeline end to end.
     #[test]
     fn batch_merger_resumable_matches_reference() {
-        use crate::trace::Description;
         use crate::trace::implementations::spine_fueled::Merger;
         use crate::trace::chunk::{ChunkBatch, ChunkBatchMerger, is_graded};
         use crate::trace::cursor::Cursor;
         use crate::consolidation::consolidate_updates;
-        use timely::progress::Antichain;
 
         let mut seed = 0x9E3779B97F4A7C15u64;
         let mut rng = move || { seed ^= seed << 13; seed ^= seed >> 7; seed ^= seed << 17; seed };
@@ -700,9 +695,7 @@ mod test {
         }
         fn batch(updates: &[Upd], sz: usize) -> ChunkBatch<ColChunk<Upd>> {
             let chunks: Vec<_> = updates.chunks(sz).map(|c| chunk(c.to_vec())).collect();
-            let desc = Description::new(
-                Antichain::from_elem(0u64), Antichain::from_elem(10u64), Antichain::from_elem(0u64));
-            ChunkBatch::new(chunks, desc)
+            ChunkBatch::new(chunks)
         }
         fn read(b: &ChunkBatch<ColChunk<Upd>>) -> Vec<Upd> {
             let mut out = Vec::new();
@@ -737,13 +730,16 @@ mod test {
             }
             let result = merger.done();
 
-            assert!(is_graded(&result.chunks), "ungraded result: {:?}",
-                result.chunks.iter().map(Chunk::len).collect::<Vec<_>>());
-            let got = read(&result);
+            let chunks: &[ColChunk<Upd>] = result.as_ref().map_or(&[], |b| &b.chunks[..]);
+            assert!(is_graded(chunks), "ungraded result: {:?}",
+                chunks.iter().map(Chunk::len).collect::<Vec<_>>());
+            let got = result.as_ref().map_or_else(Vec::new, read);
             let mut want: Vec<((u64, u64), u64, i64)> =
                 u1.iter().chain(u2.iter()).map(|&(k, v, t, d)| ((k, v), t.max(f), d)).collect();
             consolidate_updates(&mut want);
             let want: Vec<Upd> = want.into_iter().map(|((k, v), t, d)| (k, v, t, d)).collect();
+            // A merge that cancels to nothing reports an absent updates.
+            assert_eq!(result.is_none(), want.is_empty(), "absence must track emptiness\n  u1={u1:?}\n  u2={u2:?}\n  f={f}");
             assert_eq!(got, want, "fuel-driven merge mismatch\n  u1={u1:?}\n  u2={u2:?}\n  f={f}");
         }
     }
@@ -798,7 +794,6 @@ mod test {
     // the right advanced-and-consolidated result.
     #[test]
     fn advance_single_key_spanning_pushes() {
-        use timely::progress::Antichain;
         let frontier = Antichain::from_elem(100u64);
         let n = 50u64;
         let mut q = VecDeque::new();
@@ -815,7 +810,6 @@ mod test {
     // withholding the (possibly-growing) last group as the carry when not `done`.
     #[test]
     fn advance_emits_complete_groups_eagerly() {
-        use timely::progress::Antichain;
         let frontier = Antichain::from_elem(5u64);
         // Group (0,0) is complete within this chunk; group (1,0) might still grow.
         let mut q = VecDeque::from([chunk(vec![(0, 0, 0, 1), (0, 0, 1, 1), (1, 0, 0, 1)])]);
@@ -833,7 +827,6 @@ mod test {
     // group boundaries.
     #[test]
     fn advance_resumable_matches_oneshot() {
-        use timely::progress::Antichain;
         let frontier = Antichain::from_elem(3u64);
         // Groups span chunk boundaries and carry several times each.
         let input = || vec![
@@ -865,7 +858,6 @@ mod test {
     // boundaries, exercising the meld / withhold / split path.
     #[test]
     fn advance_matches_row_reference() {
-        use timely::progress::Antichain;
         use crate::consolidation::consolidate_updates;
 
         let mut seed = 0x2545F4914F6CDD1Du64;
diff --git a/differential-dataflow/src/operators/arrange/agent.rs b/differential-dataflow/src/operators/arrange/agent.rs
index 4da615ce9..8850feecc 100644
--- a/differential-dataflow/src/operators/arrange/agent.rs
+++ b/differential-dataflow/src/operators/arrange/agent.rs
@@ -10,7 +10,7 @@ use timely::progress::Timestamp;
 use timely::progress::{Antichain, frontier::AntichainRef};
 use timely::dataflow::operators::CapabilitySet;
 
-use crate::trace::{Trace, TraceReader, BatchReader};
+use crate::trace::{Span, Trace, TraceReader};
 
 use timely::scheduling::Activator;
 
@@ -62,10 +62,10 @@ impl<Tr: TraceReader> TraceReader for TraceAgent<Tr> {
     fn get_physical_compaction(&mut self) -> AntichainRef<'_, Tr::Time> {
         self.physical_compaction.borrow()
     }
-    fn batches_through(&mut self, frontier: AntichainRef<'_, Tr::Time>) -> Option<Vec<Self::Batch>> {
-        self.trace.borrow_mut().trace.batches_through(frontier)
+    fn spans_through(&mut self, frontier: AntichainRef<'_, Tr::Time>) -> Option<Vec<Span<Tr::Time, Tr::Batch>>> {
+        self.trace.borrow_mut().trace.spans_through(frontier)
     }
-    fn map_batches<F: FnMut(&Self::Batch)>(&self, f: F) { self.trace.borrow().trace.map_batches(f) }
+    fn map_spans<F: FnMut(&Span<Tr::Time, Tr::Batch>)>(&self, f: F) { self.trace.borrow().trace.map_spans(f) }
 }
 
 impl<Tr: TraceReader> TraceAgent<Tr> {
@@ -117,9 +117,9 @@ impl<Tr: TraceReader> TraceAgent<Tr> {
         self.trace
             .borrow_mut()
             .trace
-            .map_batches(|batch| {
-                new_queue.push_back(TraceReplayInstruction::Batch(batch.clone(), timely::progress::Stamp::from_elem(Tr::Time::minimum())));
-                upper = Some(batch.upper().clone());
+            .map_spans(|span| {
+                new_queue.push_back(TraceReplayInstruction::Span(span.clone(), timely::progress::Stamp::from_elem(Tr::Time::minimum())));
+                upper = Some(span.upper().clone());
             });
 
         if let Some(upper) = upper {
@@ -299,8 +299,8 @@ impl<Tr: TraceReader+'static> TraceAgent<Tr> {
                                 TraceReplayInstruction::Frontier(frontier) => {
                                     capabilities.downgrade(&frontier.borrow()[..]);
                                 },
-                                TraceReplayInstruction::Batch(batch, hint) => {
-                                    if !hint.is_empty() && !batch.is_empty() {
+                                TraceReplayInstruction::Span(batch, hint) => {
+                                    if !hint.is_empty() && batch.has_updates() {
                                         let delayed = capabilities.delayed_stamp(&hint);
                                         output.session(&delayed).give(batch);
                                     }
@@ -438,10 +438,14 @@ impl<Tr: TraceReader+'static> TraceAgent<Tr> {
                                             capabilities.downgrade(&frontier.borrow()[..]);
                                         }
                                     },
-                                    TraceReplayInstruction::Batch(batch, hint) => {
-                                        if !hint.is_empty() && !batch.is_empty() {
+                                    TraceReplayInstruction::Span(batch, hint) => {
+                                        if !hint.is_empty() && batch.has_updates() {
                                             let delayed = capabilities.delayed_stamp(&hint);
-                                            output.session(&delayed).give(BatchFrontier::make_from(batch, since.borrow(), until.borrow()));
+                                            let wrapped = Span::new(
+                                                batch.desc,
+                                                batch.inner.map(|p| BatchFrontier::make_from(p, since.borrow(), until.borrow())),
+                                            );
+                                            output.session(&delayed).give(wrapped);
                                         }
                                     }
                                 }
diff --git a/differential-dataflow/src/operators/arrange/arrangement.rs b/differential-dataflow/src/operators/arrange/arrangement.rs
index dc8e07cfd..97d81f7dd 100644
--- a/differential-dataflow/src/operators/arrange/arrangement.rs
+++ b/differential-dataflow/src/operators/arrange/arrangement.rs
@@ -31,9 +31,9 @@ use timely::progress::Stamp;
 use crate::{Data, VecCollection, AsCollection};
 use crate::difference::Semigroup;
 use crate::lattice::Lattice;
-use crate::trace::{self, Trace, TraceReader, Navigable, Batcher, Builder, Cursor, BatchCursor, BatchDiff, BatchKey, BatchVal, BatchValOwn};
+use crate::trace::{self, SpanOf, Trace, TraceReader, Navigable, Batcher, Builder, Cursor, BatchCursor, BatchDiff, BatchKey, BatchVal, BatchValOwn};
 
-use trace::wrappers::enter::{TraceEnter, BatchEnter,};
+use trace::wrappers::enter::{TraceEnter, enter_span};
 
 use super::TraceAgent;
 
@@ -47,7 +47,7 @@ pub struct Arranged<'scope, Tr: TraceReader> {
     /// This stream contains the same batches of updates the trace itself accepts, so there should
     /// be no additional overhead to receiving these records. The batches can be navigated just as
     /// the batches in the trace, by key and by value.
-    pub stream: Stream<'scope, Tr::Time, Vec<Tr::Batch>>,
+    pub stream: Stream<'scope, Tr::Time, Vec<SpanOf<Tr>>>,
     /// A shared trace, updated by the `Arrange` operator and readable by others.
     pub trace: Tr,
 }
@@ -75,7 +75,7 @@ impl<'scope, Tr: TraceReader> Arranged<'scope, Tr> {
         TInner: Refines<Tr::Time>+Lattice,
     {
         Arranged {
-            stream: self.stream.enter(child).map(|bw| BatchEnter::make_from(bw)),
+            stream: self.stream.enter(child).map(enter_span),
             trace: TraceEnter::make_from(self.trace),
         }
     }
@@ -98,7 +98,7 @@ impl<'scope, Tr: TraceReader> Arranged<'scope, Tr> {
     pub fn as_container<I, L>(self, mut logic: L) -> crate::Collection<'scope, Tr::Time, I::Item>
     where
         I: IntoIterator<Item: Container>,
-        L: FnMut(Tr::Batch) -> I+'static,
+        L: FnMut(SpanOf<Tr>) -> I+'static,
     {
         self.stream.unary(Pipeline, "AsContainer", move |_,_| move |input, output| {
             input.for_each(|time, data| {
@@ -115,7 +115,7 @@ impl<'scope, Tr: TraceReader> Arranged<'scope, Tr> {
 
     /// Flattens the stream into a `VecCollection`.
     ///
-    /// The underlying `Stream<T, Vec<BatchWrapper<T::Batch>>>` is a much more efficient way to access the data,
+    /// The underlying `Stream<T, Vec<SpanOf<T>>>` is a much more efficient way to access the data,
     /// and this method should only be used when the data need to be transformed or exchanged, rather than
     /// supplied as arguments to an operator using the same key-value structure.
     pub fn as_collection<D: Data, L>(self, mut logic: L) -> VecCollection<'scope, Tr::Time, D, BatchDiff<Tr>>
@@ -129,7 +129,7 @@ impl<'scope, Tr: TraceReader> Arranged<'scope, Tr> {
 
     /// Flattens the stream into a `VecCollection`.
     ///
-    /// The underlying `Stream<T, Vec<BatchWrapper<T::Batch>>>` is a much more efficient way to access the data,
+    /// The underlying `Stream<T, Vec<SpanOf<T>>>` is a much more efficient way to access the data,
     /// and this method should only be used when the data need to be transformed or exchanged, rather than
     /// supplied as arguments to an operator using the same key-value structure.
     ///
@@ -168,7 +168,7 @@ impl<'scope, Tr: TraceReader> Arranged<'scope, Tr> {
     ///
     /// This method exists for streams of batches without the corresponding arrangement.
     /// If you have the arrangement, its `flat_map_ref` method is equivalent to this.
-    pub fn flat_map_batches<I, L>(stream: Stream<'scope, Tr::Time, Vec<Tr::Batch>>, mut logic: L) -> VecCollection<'scope, Tr::Time, I::Item, BatchDiff<Tr>>
+    pub fn flat_map_batches<I, L>(stream: Stream<'scope, Tr::Time, Vec<SpanOf<Tr>>>, mut logic: L) -> VecCollection<'scope, Tr::Time, I::Item, BatchDiff<Tr>>
     where
         Tr::Batch: Navigable,
         BatchCursor<Tr>: Cursor<Time = Tr::Time>,
@@ -179,7 +179,7 @@ impl<'scope, Tr: TraceReader> Arranged<'scope, Tr> {
             input.for_each(|time, data| {
                 let mut session = output.session(&time);
                 for wrapper in data.iter() {
-                    let batch = &wrapper;
+                    let Some(batch) = wrapper.inner.as_ref() else { continue };
                     let mut cursor = batch.cursor();
                     while let Some(key) = cursor.get_key(batch) {
                         while let Some(val) = cursor.get_val(batch) {
@@ -253,7 +253,7 @@ impl<'scope, Tr1: TraceReader<Batch: Navigable>+'static> Arranged<'scope, Tr1> {
         BatchCursor<Tr1>: Cursor<Time = Tr1::Time, KeyContainer = KC>,
         for<'a> BatchCursor<Tr1>: Cursor<Key<'a> = KC::ReadItem<'a>>,
         for<'a> BatchCursor<Tr2>: Cursor<Key<'a> = KC::ReadItem<'a>, ValOwn: Data, Time = Tr2::Time, Diff: Abelian>,
-        Bu: Builder<Time=Tr1::Time, Output = Tr2::Batch, Input: Default> + 'static,
+        Bu: Builder<Time=Tr1::Time, Output: Into<Tr2::Batch>, Input: Default> + 'static,
         L: FnMut(KC::ReadItem<'_>, &[(BatchVal<'_, Tr1>, BatchDiff<Tr1>)], &mut Vec<(BatchValOwn<Tr2>, BatchDiff<Tr2>)>)+'static,
         P: FnMut(&mut Bu::Input, KC::ReadItem<'_>, &mut Vec<(BatchValOwn<Tr2>, Tr2::Time, BatchDiff<Tr2>)>) + 'static,
     {
@@ -274,7 +274,7 @@ impl<'scope, Tr1: TraceReader<Batch: Navigable>+'static> Arranged<'scope, Tr1> {
         BatchCursor<Tr1>: Cursor<Time = Tr1::Time, KeyContainer = KC>,
         for<'a> BatchCursor<Tr1>: Cursor<Key<'a> = KC::ReadItem<'a>>,
         for<'a> BatchCursor<Tr2>: Cursor<Key<'a> = KC::ReadItem<'a>, ValOwn: Data, Time = Tr2::Time>,
-        Bu: Builder<Time=Tr1::Time, Output = Tr2::Batch, Input: Default> + 'static,
+        Bu: Builder<Time=Tr1::Time, Output: Into<Tr2::Batch>, Input: Default> + 'static,
         L: FnMut(KC::ReadItem<'_>, &[(BatchVal<'_, Tr1>, BatchDiff<Tr1>)], &mut Vec<(BatchValOwn<Tr2>, BatchDiff<Tr2>)>, &mut Vec<(BatchValOwn<Tr2>, BatchDiff<Tr2>)>)+'static,
         P: FnMut(&mut Bu::Input, KC::ReadItem<'_>, &mut Vec<(BatchValOwn<Tr2>, Tr2::Time, BatchDiff<Tr2>)>) + 'static,
     {
@@ -307,7 +307,7 @@ pub trait Arrange<'scope, T: Timestamp+Lattice, C> : Sized {
     fn arrange<Ba, Bu, Tr>(self) -> Arranged<'scope, TraceAgent<Tr>>
     where
         Ba: Batcher<Output=C, Time=T> + 'static,
-        Bu: Builder<Time=T, Input=Ba::Output, Output = Tr::Batch>,
+        Bu: Builder<Time=T, Input=Ba::Output, Output: Into<Tr::Batch>>,
         Tr: Trace<Time=T> + 'static,
     {
         self.arrange_named::<Ba, Bu, Tr>("Arrange")
@@ -319,7 +319,7 @@ pub trait Arrange<'scope, T: Timestamp+Lattice, C> : Sized {
     fn arrange_named<Ba, Bu, Tr>(self, name: &str) -> Arranged<'scope, TraceAgent<Tr>>
     where
         Ba: Batcher<Output=C, Time=T> + 'static,
-        Bu: Builder<Time=T, Input=Ba::Output, Output = Tr::Batch>,
+        Bu: Builder<Time=T, Input=Ba::Output, Output: Into<Tr::Batch>>,
         Tr: Trace<Time=T> + 'static,
     ;
 }
@@ -335,7 +335,7 @@ where
     P: ParallelizationContract<Tr::Time, C>,
     Chu: ContainerBuilder<Container=Ba::Output> + for<'a> PushInto<&'a mut C> + 'static,
     Ba: Batcher<Time=Tr::Time> + 'static,
-    Bu: Builder<Time=Tr::Time, Input=Ba::Output, Output = Tr::Batch>,
+    Bu: Builder<Time=Tr::Time, Input=Ba::Output, Output: Into<Tr::Batch>>,
     Tr: Trace+'static,
 {
     // The `Arrange` operator is tasked with reacting to an advancing input
@@ -448,7 +448,7 @@ where
 
                     // Extract all updates not in advance of the input frontier, as one batch.
                     let (mut chain, description) = batcher.seal(frontier.frontier().to_owned());
-                    let batch = Bu::seal(&mut chain, description);
+                    let batch = trace::Span::new(description, Bu::seal(&mut chain).map(Into::into));
 
                     let stamp = retired.iter().map(|c| c.time().clone()).collect::<Stamp<_>>();
                     writer.insert(batch.clone(), stamp);
diff --git a/differential-dataflow/src/operators/arrange/mod.rs b/differential-dataflow/src/operators/arrange/mod.rs
index e864cfda3..f0afe1781 100644
--- a/differential-dataflow/src/operators/arrange/mod.rs
+++ b/differential-dataflow/src/operators/arrange/mod.rs
@@ -54,7 +54,7 @@ pub enum TraceReplayInstruction<Tr: TraceReader> {
     /// Describes a batch of data and the stamp justifying its contents.
     ///
     /// The stamp is empty exactly when the batch is empty.
-    Batch(Tr::Batch, timely::progress::Stamp<Tr::Time>),
+    Span(crate::trace::SpanOf<Tr>, timely::progress::Stamp<Tr::Time>),
 }
 
 // Short names for strongly and weakly owned activators and shared queues.
diff --git a/differential-dataflow/src/operators/arrange/upsert.rs b/differential-dataflow/src/operators/arrange/upsert.rs
index bc48bd1d3..5d1f4f1ff 100644
--- a/differential-dataflow/src/operators/arrange/upsert.rs
+++ b/differential-dataflow/src/operators/arrange/upsert.rs
@@ -138,7 +138,7 @@ where
         Val<'a> = &'a V,
         Diff=isize,
     >,
-    Bu: Builder<Time=Tr::Time, Input = Vec<((K, V), Tr::Time, BatchDiff<Tr>)>, Output = Tr::Batch>,
+    Bu: Builder<Time=Tr::Time, Input = Vec<((K, V), Tr::Time, BatchDiff<Tr>)>, Output: Into<Tr::Batch>>,
 {
     let mut reader: Option<TraceAgent<Tr>> = None;
 
@@ -278,7 +278,7 @@ where
                                     builder.push(&mut updates);
                                 }
                                 let description = Description::new(prev_frontier.clone(), upper.clone(), Antichain::from_elem(Tr::Time::minimum()));
-                                let batch = builder.done(description);
+                                let batch = crate::trace::Span::new(description, builder.done().map(Into::into));
                                 prev_frontier.clone_from(&upper);
 
                                 // Communicate `batch` to the arrangement and the stream.
diff --git a/differential-dataflow/src/operators/arrange/writer.rs b/differential-dataflow/src/operators/arrange/writer.rs
index 21761c05e..19af3feaf 100644
--- a/differential-dataflow/src/operators/arrange/writer.rs
+++ b/differential-dataflow/src/operators/arrange/writer.rs
@@ -8,7 +8,7 @@ use std::cell::RefCell;
 
 use timely::progress::Antichain;
 
-use crate::trace::{Trace, Batch, BatchReader};
+use crate::trace::{Trace, Span, SpanOf};
 
 use super::TraceAgentQueueWriter;
 use super::TraceReplayInstruction;
@@ -47,28 +47,28 @@ impl<Tr: Trace> TraceWriter<Tr> {
         }
     }
 
-    /// Advances the trace by `batch`.
+    /// Advances the trace by `span`.
     ///
-    /// The `hint` argument is either `None` in the case of an empty batch,
-    /// or is `Some(time)` for a time less or equal to all updates in the
-    /// batch and which is suitable for use as a capability.
-    pub fn insert(&mut self, batch: Tr::Batch, hint: timely::progress::Stamp<Tr::Time>) {
+    /// The `hint` argument is either `None` when the span carries no updates,
+    /// or is `Some(time)` for a time less or equal to all updates in its batch
+    /// and which is suitable for use as a capability.
+    pub fn insert(&mut self, span: SpanOf<Tr>, hint: timely::progress::Stamp<Tr::Time>) {
 
         // Something is wrong if not a sequence.
-        if !(&self.upper == batch.lower()) {
-            println!("{:?} vs {:?}", self.upper, batch.lower());
+        if !(&self.upper == span.lower()) {
+            println!("{:?} vs {:?}", self.upper, span.lower());
         }
-        assert!(&self.upper == batch.lower());
-        assert!(batch.lower() != batch.upper());
+        assert!(&self.upper == span.lower());
+        assert!(span.lower() != span.upper());
 
-        self.upper.clone_from(batch.upper());
+        self.upper.clone_from(span.upper());
 
         // push information to each listener that still exists.
         let mut borrow = self.queues.borrow_mut();
         for queue in borrow.iter_mut() {
             if let Some(pair) = queue.upgrade() {
-                pair.1.borrow_mut().push_back(TraceReplayInstruction::Batch(batch.clone(), hint.clone()));
-                pair.1.borrow_mut().push_back(TraceReplayInstruction::Frontier(batch.upper().clone()));
+                pair.1.borrow_mut().push_back(TraceReplayInstruction::Span(span.clone(), hint.clone()));
+                pair.1.borrow_mut().push_back(TraceReplayInstruction::Frontier(span.upper().clone()));
                 pair.0.activate();
             }
         }
@@ -76,15 +76,15 @@ impl<Tr: Trace> TraceWriter<Tr> {
 
         // push data to the trace, if it still exists.
         if let Some(trace) = self.trace.upgrade() {
-            trace.borrow_mut().trace.insert(batch);
+            trace.borrow_mut().trace.insert(span);
         }
 
     }
 
-    /// Inserts an empty batch up to `upper`.
+    /// Inserts an update-free span up to `upper`.
     pub fn seal(&mut self, upper: Antichain<Tr::Time>) {
         if self.upper != upper {
-            self.insert(Tr::Batch::empty(self.upper.clone(), upper), timely::progress::Stamp::new());
+            self.insert(Span::empty(self.upper.clone(), upper), timely::progress::Stamp::new());
         }
     }
 }
diff --git a/differential-dataflow/src/operators/count.rs b/differential-dataflow/src/operators/count.rs
index 37586e0a7..1f707c3b5 100644
--- a/differential-dataflow/src/operators/count.rs
+++ b/differential-dataflow/src/operators/count.rs
@@ -11,7 +11,7 @@ use crate::difference::{IsZero, Semigroup};
 use crate::hashable::Hashable;
 use crate::collection::AsCollection;
 use crate::operators::arrange::Arranged;
-use crate::trace::{BatchCursor, BatchDiff, BatchDiffGat, BatchReader, Cursor, Navigable, TraceReader};
+use crate::trace::{BatchCursor, BatchDiff, BatchDiffGat, Cursor, Navigable, TraceReader};
 
 /// Extension trait for the `count` differential dataflow method.
 pub trait CountTotal<'scope, T: Timestamp + TotalOrder + Lattice, K: ExchangeData, R: Semigroup> : Sized {
@@ -96,7 +96,7 @@ where
 
                     let mut session = output.session(&caps);
 
-                    let (mut batch_cursor, batch_storage) = crate::trace::cursor::cursor_list(batch_storage);
+                    let (mut batch_cursor, batch_storage) = crate::trace::cursor::cursor_list(batch_storage.into_iter().filter_map(|b| b.inner).collect());
                     let (mut trace_cursor, trace_storage) = crate::trace::cursor::cursor_list(trace.batches_through(lower_limit.borrow()).unwrap());
 
                     while let Some(key) = batch_cursor.get_key(&batch_storage) {
diff --git a/differential-dataflow/src/operators/int_proxy/join.rs b/differential-dataflow/src/operators/int_proxy/join.rs
index a1ceaaa22..da487276a 100644
--- a/differential-dataflow/src/operators/int_proxy/join.rs
+++ b/differential-dataflow/src/operators/int_proxy/join.rs
@@ -10,7 +10,6 @@ use timely::progress::Timestamp;
 
 use crate::difference::{Multiply, Semigroup};
 use crate::lattice::Lattice;
-use crate::trace::BatchReader;
 use super::ProxyBridge;
 use crate::operators::join::{Fresh, JoinTactic};
 use crate::operators::ValueHistory;
@@ -21,7 +20,7 @@ use super::history::IdHistory;
 ///
 /// The harness repeatedly invokes [`advance`](Self::advance) to draw a block of the proxy collection,
 /// then [`cross`](Self::cross) to turn that block's matches into output containers, until `advance` reports the key space exhausted.
-pub trait ProxyJoinBackend<B0: BatchReader, B1: BatchReader<Time = B0::Time>> {
+pub trait ProxyJoinBackend<T, B0, B1> {
     /// Diff type of the first input.
     type R0: Semigroup + Multiply<Self::R1, Output = Self::ROut>;
     /// Diff type of the second input.
@@ -39,10 +38,10 @@ pub trait ProxyJoinBackend<B0: BatchReader, B1: BatchReader<Time = B0::Time>> {
     /// which are greater or equal to the initial `from`, and not greater or equal to its value when returned.
     fn advance(
         &mut self,
-        instance: &JoinInstance<B0, B1>,
+        instance: &JoinInstance<T, B0, B1>,
         from: &mut Option<u64>,
-        bridge0: &mut ProxyBridge<B0::Time, Self::R0>,
-        bridge1: &mut ProxyBridge<B0::Time, Self::R1>,
+        bridge0: &mut ProxyBridge<T, Self::R0>,
+        bridge1: &mut ProxyBridge<T, Self::R1>,
     );
 
     /// Interpret matches derived from the immediately preceding [`Self::advance`] call and place
@@ -51,14 +50,14 @@ pub trait ProxyJoinBackend<B0: BatchReader, B1: BatchReader<Time = B0::Time>> {
     /// block produced no matches, in which case the next `advance` may overwrite that state.
     fn cross(
         &mut self,
-        instance: &JoinInstance<B0, B1>,
-        matches: &mut JoinMatches<B0::Time, Self::ROut>,
+        instance: &JoinInstance<T, B0, B1>,
+        matches: &mut JoinMatches<T, Self::ROut>,
         output: &mut Vec<Self::Output>,
     );
 }
 
 /// A unit of proxied join work, for presentation to the backend.
-pub struct JoinInstance<B0: BatchReader, B1: BatchReader<Time = B0::Time>> {
+pub struct JoinInstance<T, B0, B1> {
     /// The first input's batches.
     pub batches0: Vec<B0>,
     /// The second input's batches.
@@ -66,7 +65,7 @@ pub struct JoinInstance<B0: BatchReader, B1: BatchReader<Time = B0::Time>> {
     /// A lower bound on the meet of pairs of update times.
     ///
     /// This can be applied when loading updates to consolidate on load.
-    pub lower: B0::Time,
+    pub lower: T,
 }
 
 /// Presentation of discovered join matches.
@@ -98,14 +97,15 @@ impl<B0, B1, Bk> ProxyJoinTactic<B0, B1, Bk> {
     }
 }
 
-impl<B0, B1, Bk> JoinTactic<B0, B1, Bk::Output> for ProxyJoinTactic<B0, B1, Bk>
+impl<T, B0, B1, Bk> JoinTactic<T, B0, B1, Bk::Output> for ProxyJoinTactic<B0, B1, Bk>
 where
-    B0: BatchReader + 'static,
-    B1: BatchReader<Time = B0::Time> + 'static,
-    Bk: ProxyJoinBackend<B0, B1> + 'static,
+    T: Timestamp + Lattice + 'static,
+    B0: 'static,
+    B1: 'static,
+    Bk: ProxyJoinBackend<T, B0, B1> + 'static,
     Bk::Output: 'static,
 {
-    fn prep(&mut self, input0: Vec<B0>, input1: Vec<B1>, _fresh: Fresh, meet: B0::Time) -> Box<dyn Iterator<Item = Bk::Output>> {
+    fn prep(&mut self, input0: Vec<B0>, input1: Vec<B1>, _fresh: Fresh, meet: T) -> Box<dyn Iterator<Item = Bk::Output>> {
         Box::new(ProxyJoinIter {
             backend: Rc::clone(&self.backend),
             instance: JoinInstance { batches0: input0, batches1: input1, lower: meet },
@@ -125,36 +125,33 @@ where
 /// The iterator draws the proxy collection from the back-end a block at a time (`Bk::advance`).
 /// Each block is then translated to output updates with joined times and multiplied differences,
 /// which are provided to the back-end to translate into output containers, which are then returned.
-struct ProxyJoinIter<B0, B1, Bk>
+struct ProxyJoinIter<T, B0, B1, Bk>
 where
-    B0: BatchReader,
-    B1: BatchReader<Time = B0::Time>,
-    Bk: ProxyJoinBackend<B0, B1>,
+    Bk: ProxyJoinBackend<T, B0, B1>,
 {
     /// The backend, shared across all outstanding iterators.
     backend: Rc<RefCell<Bk>>,
     /// The iterator's inputs, and the time at which they can consolidate as they load.
-    instance: JoinInstance<B0, B1>,
+    instance: JoinInstance<T, B0, B1>,
     /// Progress through the key space: `Some(h)` for key hashes at or above `h` remaining, `None`
     /// once the backend reports the iteration is complete.
     from: Option<u64>,
     /// The current block: the two runs `advance` last drew, which one `next` consumes entirely.
-    p0: ProxyBridge<B0::Time, Bk::R0>,
-    p1: ProxyBridge<B0::Time, Bk::R1>,
+    p0: ProxyBridge<T, Bk::R0>,
+    p1: ProxyBridge<T, Bk::R1>,
     /// Per-key replay histories, held across the iterator and reloaded per key when needed.
-    h0: IdHistory<B0::Time, Bk::R0>,
-    h1: IdHistory<B0::Time, Bk::R1>,
+    h0: IdHistory<T, Bk::R0>,
+    h1: IdHistory<T, Bk::R1>,
     /// The block's matched records, held across blocks to keep their allocations.
-    matches: JoinMatches<B0::Time, Bk::ROut>,
+    matches: JoinMatches<T, Bk::ROut>,
     /// The last block's containers, in reverse, served from the back one `next` at a time.
     ready: Vec<Bk::Output>,
 }
 
-impl<B0, B1, Bk> Iterator for ProxyJoinIter<B0, B1, Bk>
+impl<T, B0, B1, Bk> Iterator for ProxyJoinIter<T, B0, B1, Bk>
 where
-    B0: BatchReader,
-    B1: BatchReader<Time = B0::Time>,
-    Bk: ProxyJoinBackend<B0, B1>,
+    T: Timestamp + Lattice,
+    Bk: ProxyJoinBackend<T, B0, B1>,
 {
     type Item = Bk::Output;
 
@@ -169,11 +166,10 @@ where
     }
 }
 
-impl<B0, B1, Bk> ProxyJoinIter<B0, B1, Bk>
+impl<T, B0, B1, Bk> ProxyJoinIter<T, B0, B1, Bk>
 where
-    B0: BatchReader,
-    B1: BatchReader<Time = B0::Time>,
-    Bk: ProxyJoinBackend<B0, B1>,
+    T: Timestamp + Lattice,
+    Bk: ProxyJoinBackend<T, B0, B1>,
 {
     /// Draw the next block from the backend.
     fn refill(&mut self) {
diff --git a/differential-dataflow/src/operators/int_proxy/reduce.rs b/differential-dataflow/src/operators/int_proxy/reduce.rs
index f988beb08..0b668680e 100644
--- a/differential-dataflow/src/operators/int_proxy/reduce.rs
+++ b/differential-dataflow/src/operators/int_proxy/reduce.rs
@@ -11,13 +11,13 @@ use timely::progress::frontier::AntichainRef;
 
 use crate::difference::Semigroup;
 use crate::lattice::Lattice;
-use crate::trace::{BatchReader, Description};
+use crate::trace::{Span, Description};
 use super::ProxyBridge;
 use crate::operators::reduce::{sort_dedup, ReduceTactic};
 use crate::operators::ValueHistory;
 
 /// A unit of proxied reduce work, presented to the backend.
-pub struct ReduceInstance<'a, B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
+pub struct ReduceInstance<'a, T, B1, B2> {
     /// The accumulated input history.
     pub source_batches: &'a [B1],
     /// The freshly arrived input delta.
@@ -25,7 +25,7 @@ pub struct ReduceInstance<'a, B1: BatchReader, B2: BatchReader<Time = B1::Time>>
     /// The accumulated output history.
     pub output_batches: &'a [B2],
     /// The compaction frontier for loading (the retire's lower bound).
-    pub lower: AntichainRef<'a, B1::Time>,
+    pub lower: AntichainRef<'a, T>,
 }
 
 /// One window of the key space: the presentations a bounded, hash-contiguous snip needs.
@@ -68,7 +68,7 @@ impl<T, RIn, ROut> ReduceWindow<T, RIn, ROut> {
 /// The protocol for each round of invocation is
 /// `begin [ next_window reduce_corrections* emit ]* finish`,
 /// where the window loop runs until `next_window` reports the key space exhausted.
-pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
+pub trait ProxyReduceBackend<T, B1, B2> {
     /// Diff type presented for the input.
     type RIn: Semigroup;
     /// Diff type of the output.
@@ -79,7 +79,7 @@ pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>>
     /// It is the backend's job to prepare output batches for each of these descriptions.
     /// The computation proceeds in windows of keys, where only the backend maintains this
     /// work in progress, until `finish()` is called.
-    fn begin(&mut self, description: Description<B1::Time>);
+    fn begin(&mut self, description: Description<T>);
 
     /// Present the next window of the key space, and advance `from` past it.
     ///
@@ -103,10 +103,10 @@ pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>>
     /// enough that the presentations are affordable, as all are live at once.
     fn next_window(
         &mut self,
-        instance: &ReduceInstance<'_, B1, B2>,
+        instance: &ReduceInstance<'_, T, B1, B2>,
         changed: &[u64],
         from: &mut Option<u64>,
-        window: &mut ReduceWindow<B1::Time, Self::RIn, Self::ROut>,
+        window: &mut ReduceWindow<T, Self::RIn, Self::ROut>,
     );
 
     /// A wave of input-output reconciliation, in which the backend supplies necessary edits.
@@ -124,10 +124,11 @@ pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>>
     ) -> (Vec<(u64, Self::ROut)>, Vec<usize>);
 
     /// Commit a collection of updates to the batch in progress.
-    fn emit(&mut self, records: &[((u64, u64), B1::Time, Self::ROut)]);
+    fn emit(&mut self, records: &[((u64, u64), T, Self::ROut)]);
 
-    /// Complete the session matching `begin`, yielding the batch it described.
-    fn finish(&mut self) -> B2;
+    /// Complete the session matching `begin`, yielding the batch it described,
+    /// or `None` when the span it described carries no updates.
+    fn finish(&mut self) -> Option<B2>;
 }
 
 /// A proxy-space [`ReduceTactic`]: matches input and output records by `key_hash`.
@@ -153,21 +154,20 @@ fn debug_assert_pending_frontier<T: PartialOrder + Clone>(pending: &BTreeMap<u64
     }, "maintained pending frontier differs from pending times");
 }
 
-impl<B1, B2, Bk> ReduceTactic<B1, B2> for ProxyReduceTactic<B1::Time, Bk>
+impl<T, B1, B2, Bk> ReduceTactic<T, B1, B2> for ProxyReduceTactic<T, Bk>
 where
-    B1: BatchReader,
-    B2: BatchReader<Time = B1::Time>,
-    Bk: ProxyReduceBackend<B1, B2>,
+    T: Timestamp + Lattice,
+    Bk: ProxyReduceBackend<T, B1, B2>,
 {
     fn retire(
         &mut self,
         source_batches: Vec<B1>,
         output_batches: Vec<B2>,
         input_batches: Vec<B1>,
-        lower: &Antichain<B1::Time>,
-        upper: &Antichain<B1::Time>,
-        held: &Antichain<B1::Time>,
-    ) -> (Option<B2>, Antichain<B1::Time>) {
+        lower: &Antichain<T>,
+        upper: &Antichain<T>,
+        held: &Antichain<T>,
+    ) -> (Option<Span<T, B2>>, Antichain<T>) {
         if held.elements().iter().all(|t| upper.less_equal(t)) {
             debug_assert!(
                 self.pending.values().flatten().all(|time| held.less_equal(time)),
@@ -188,14 +188,14 @@ where
         // A time at or beyond it remains carried in `self.pending`. Partition in place: rebuilding
         // the whole map cloned every carried timestamp on every retire, even though only the small
         // due subset changes.
-        let mut due: BTreeMap<u64, Vec<B1::Time>> = BTreeMap::new();
+        let mut due: BTreeMap<u64, Vec<T>> = BTreeMap::new();
         let mut pending_frontier = Antichain::new();
         for (&key, times) in self.pending.iter_mut() {
             let mut ready = Vec::new();
             times.retain_mut(|time| {
                 let carried = upper.less_equal(time);
                 if carried { pending_frontier.insert_ref(time); }
-                else { ready.push(std::mem::replace(time, B1::Time::minimum())); }
+                else { ready.push(std::mem::replace(time, T::minimum())); }
                 carried
             });
             if !ready.is_empty() { due.insert(key, ready); }
@@ -210,32 +210,32 @@ where
         // one. This is exactly where a due-only `changed` differs from the whole pending set: times
         // beyond `upper` can remain when nothing is due, and releasing their capabilities would
         // strand them (see the frontier clause of the `ReduceTactic::retire` contract).
-        if changed.is_empty() && instance.input_batches.iter().all(|b| b.is_empty()) {
+        if changed.is_empty() && instance.input_batches.is_empty() {
             debug_assert_pending_frontier(&self.pending, &pending_frontier);
             return (None, pending_frontier);
         }
 
         // The single output batch spans the retired interval.
-        let description = Description::new(lower.clone(), upper.clone(), Antichain::from_elem(B1::Time::minimum()));
-        self.backend.begin(description);
+        let description = Description::new(lower.clone(), upper.clone(), Antichain::from_elem(T::minimum()));
+        self.backend.begin(description.clone());
 
         // Progress through the key space: `Some(h)` for key hashes at or above `h` remaining, `None`
         // once the backend reports the space covered.
         let mut from = Some(0u64);
-        let mut window: ReduceWindow<B1::Time, Bk::RIn, Bk::ROut> = ReduceWindow::default();
+        let mut window: ReduceWindow<T, Bk::RIn, Bk::ROut> = ReduceWindow::default();
 
         // Retire-wide reusable scratch: cleared per window or wave, never reallocated. Fresh
         // per-key/per-wave `Vec`s were once the dominant cost here, which is why the slots and the
         // staging buffers are held across the whole retire rather than built where they are used.
-        let mut slots: Vec<KeySweep<B1::Time, Bk::RIn, Bk::ROut>> = Vec::new();
+        let mut slots: Vec<KeySweep<T, Bk::RIn, Bk::ROut>> = Vec::new();
         let mut live: Vec<usize> = Vec::new();
-        let mut deltas: Vec<((u64, u64), B1::Time, Bk::ROut)> = Vec::new();
+        let mut deltas: Vec<((u64, u64), T, Bk::ROut)> = Vec::new();
         let mut batch_keys: Vec<u64> = Vec::new();
         let mut in_ends: Vec<usize> = Vec::new();
         let mut in_all: Vec<(u64, Bk::RIn)> = Vec::new();
         let mut out_ends: Vec<usize> = Vec::new();
         let mut out_all: Vec<(u64, Bk::ROut)> = Vec::new();
-        let mut active: Vec<(usize, B1::Time)> = Vec::new();
+        let mut active: Vec<(usize, T)> = Vec::new();
         let mut in_accum: Vec<(u64, Bk::RIn)> = Vec::new();
         let mut cur_out: Vec<(u64, Bk::ROut)> = Vec::new();
 
@@ -386,7 +386,7 @@ where
             }
         }
 
-        let produced = Some(self.backend.finish());
+        let produced = Some(Span::new(description, self.backend.finish()));
         debug_assert_pending_frontier(&self.pending, &pending_frontier);
         (produced, pending_frontier)
     }
diff --git a/differential-dataflow/src/operators/int_proxy/vec_backend.rs b/differential-dataflow/src/operators/int_proxy/vec_backend.rs
index 8a2c13361..253534169 100644
--- a/differential-dataflow/src/operators/int_proxy/vec_backend.rs
+++ b/differential-dataflow/src/operators/int_proxy/vec_backend.rs
@@ -36,7 +36,7 @@ use crate::trace::Description;
 
 use super::{ProxyReduceBackend, ReduceInstance, ReduceWindow};
 
-/// The batch type of a hash-keyed [`ChunkSpine`](crate::trace::chunk::vec::ChunkSpine): payload
+/// The batch type of a hash-keyed [`ChunkSpine`](crate::trace::chunk::vec::ChunkSpine): updates
 /// `D` is `(K, V)` on the input side and `(K, W)` on the output side.
 type VBatch<D, T, R> = Rc<ChunkBatch<VecChunk<u64, D, T, R>>>;
 
@@ -63,8 +63,7 @@ pub struct VecReduceBackend<K, V, W, T, R, L> {
     /// Lookup-only: the non-determinism of the map's iteration order is never observed.
     out_ids: HashMap<(K, W), u64>,
 
-    /// The retire's output batch description, and the chunks accumulated for it.
-    description: Option<Description<T>>,
+    /// The chunks accumulated for the retire's output batch.
     chunks: Vec<VecChunk<u64, (K, W), T, R>>,
     /// Scratch to re-order one `emit`'s output by types, rather than transient identifiers.
     stage: Vec<((u64, (K, W)), T, R)>,
@@ -85,14 +84,13 @@ impl<K, V, W, T, R, L> VecReduceBackend<K, V, W, T, R, L> {
             in_pool: Vec::new(),
             out_pool: Vec::new(),
             out_ids: HashMap::new(),
-            description: None,
             chunks: Vec::new(),
             stage: Vec::new(),
         }
     }
 }
 
-impl<K, V, W, T, R, L> ProxyReduceBackend<VBatch<(K, V), T, R>, VBatch<(K, W), T, R>>
+impl<K, V, W, T, R, L> ProxyReduceBackend<T, VBatch<(K, V), T, R>, VBatch<(K, W), T, R>>
     for VecReduceBackend<K, V, W, T, R, L>
 where
     K: Ord + Clone + std::hash::Hash + 'static,
@@ -105,15 +103,14 @@ where
     type RIn = R;
     type ROut = R;
 
-    fn begin(&mut self, description: Description<T>) {
-        self.description = Some(description);
+    fn begin(&mut self, _description: Description<T>) {
         self.chunks.clear();
     }
 
     #[inline(never)]
     fn next_window(
         &mut self,
-        instance: &ReduceInstance<'_, VBatch<(K, V), T, R>, VBatch<(K, W), T, R>>,
+        instance: &ReduceInstance<'_, T, VBatch<(K, V), T, R>, VBatch<(K, W), T, R>>,
         changed: &[u64],
         from: &mut Option<u64>,
         window: &mut ReduceWindow<T, R, R>,
@@ -322,13 +319,12 @@ where
     }
 
     #[inline(never)]
-    fn finish(&mut self) -> VBatch<(K, W), T, R> {
+    fn finish(&mut self) -> Option<VBatch<(K, W), T, R>> {
         self.in_pool.clear();
         self.out_pool.clear();
         self.out_ids.clear();
-        let description = self.description.take().expect("finish without begin");
         let chunks = std::mem::take(&mut self.chunks);
-        Rc::new(ChunkBatch::new(chunks, description))
+        if chunks.is_empty() { None } else { Some(Rc::new(ChunkBatch::new(chunks))) }
     }
 }
 
diff --git a/differential-dataflow/src/operators/join.rs b/differential-dataflow/src/operators/join.rs
index a10fba48a..e249ef33b 100644
--- a/differential-dataflow/src/operators/join.rs
+++ b/differential-dataflow/src/operators/join.rs
@@ -17,7 +17,7 @@ use timely::dataflow::operators::CapabilitySet;
 
 use crate::lattice::Lattice;
 use crate::operators::arrange::Arranged;
-use crate::trace::{BatchCursor, BatchDiff, BatchReader, BatchVal, Cursor, Navigable, TraceReader};
+use crate::trace::{BatchCursor, BatchDiff, BatchVal, Cursor, Navigable, TraceReader};
 use crate::trace::cursor::cursor_list;
 use crate::trace::implementations::containers::BatchContainer;
 use crate::operators::ValueHistory;
@@ -27,12 +27,13 @@ use crate::operators::ValueHistory;
 /// The trait is parameterized by the output container `C`, not by the builder that assembles it: a tactic
 /// yields finished containers, and how it produces them (pushing records into a [`ContainerBuilder`], or
 /// otherwise) is its own concern.
-pub trait JoinTactic<B0: BatchReader, B1: BatchReader<Time = B0::Time>, C> {
+pub trait JoinTactic<T, B0, B1, C> {
     /// Prepare the join of two lists of batches into an iterator of output containers.
     ///
     /// The supplied `fresh` and `meet` indicate respectively which input is "novel", and should drive the
-    /// join, as well as a lower bound on that input's times, so that the other input can be loaded compacted.
-    fn prep(&mut self, input0: Vec<B0>, input1: Vec<B1>, fresh: Fresh, meet: B0::Time) -> Box<dyn Iterator<Item = C>>;
+    /// join, as well as a lower bound on that input's times, so that the other input can be loaded
+    /// compacted.
+    fn prep(&mut self, input0: Vec<B0>, input1: Vec<B1>, fresh: Fresh, meet: T) -> Box<dyn Iterator<Item = C>>;
 }
 
 /// Which input contributed the freshly-arrived batch of a deferred join unit.
@@ -78,13 +79,13 @@ where
 ///
 /// This is the general join operator: it does the dataflow plumbing (frontiers, capabilities, trace
 /// compaction) and routes the per-batch work through the tactic. It requires only `TraceReader` of its
-/// inputs, never `Navigable`: it extracts trace batches via `batches_through`, and building cursors over
+/// inputs, never `Navigable`: it extracts trace batches via `spans_through`, and building cursors over
 /// them (if that is how the join proceeds) is the tactic's concern.
 pub fn join_with_tactic<'scope, Tr1, Tr2, T, C>(arranged1: Arranged<'scope, Tr1>, arranged2: Arranged<'scope, Tr2>, name: &str, mut tactic: T) -> Stream<'scope, Tr1::Time, C>
 where
     Tr1: TraceReader+'static,
     Tr2: TraceReader<Time = Tr1::Time>+'static,
-    T: JoinTactic<Tr1::Batch, Tr2::Batch, C>+'static,
+    T: JoinTactic<Tr1::Time, Tr1::Batch, Tr2::Batch, C>+'static,
     C: Container + 'static,
 {
     // Rename traces for symmetry from here on out.
@@ -105,7 +106,7 @@ where
         // initial work for the two traces, and before the operator is constructed.
 
         // Acknowledged frontier for each input.
-        // These two are used exclusively to track batch boundaries on which we may want/need to call `batches_through`.
+        // These two are used exclusively to track batch boundaries on which we may want/need to call `spans_through`.
         // They will drive our physical compaction of each trace, and we want to maintain at all times that each is beyond
         // the physical compaction frontier of their corresponding trace.
         // Should we ever *drop* a trace, these are 1. much harder to maintain correctly, but 2. no longer used.
@@ -121,7 +122,7 @@ where
         let mut todo1: VecDeque<(CapabilitySet<Tr1::Time>, Box<dyn Iterator<Item = C>>)> = VecDeque::new();
 
         // We'll unload the initial batches here, to put ourselves in a less non-deterministic state to start.
-        trace1.map_batches(|batch1| {
+        trace1.map_spans(|batch1| {
             acknowledged1.clone_from(batch1.upper());
             // No `todo1` work here, because we haven't accepted anything into `batches2` yet.
             // It is effectively "empty", because we choose to drain `trace1` before `trace2`.
@@ -138,7 +139,7 @@ where
         // We capture batch2's batches first and establish work second to avoid taking a `RefCell` lock
         // on both traces at the same time, as they could be the same trace and this would panic.
         let mut batch2_list = Vec::new();
-        trace2.map_batches(|batch2| {
+        trace2.map_spans(|batch2| {
             acknowledged2.clone_from(batch2.upper());
             batch2_list.push(batch2.clone());
         });
@@ -161,13 +162,15 @@ where
 
         // Load up deferred work joining each captured `trace2` batch against `trace1`.
         for batch2 in batch2_list.into_iter() {
+            // Empty batches carry no updates, and have nothing to join.
+            let Some(updates2) = batch2.inner else { continue };
             // It is safe to ask for `ack1` because we have confirmed it to be in advance of `distinguish_since`.
             let trace1_storage = trace1.batches_through(acknowledged1.borrow()).unwrap();
             // We could downgrade the capability here, but doing so is a bit complicated mathematically.
             // TODO: downgrade the capability by searching out the one time in `batch2.lower()` and not
             // in `batch2.upper()`. Only necessary for non-empty batches, as empty batches may not have
             // that property.
-            let work = tactic.prep(trace1_storage, vec![batch2], Fresh::Input1, capability.time().clone());
+            let work = tactic.prep(trace1_storage, vec![updates2], Fresh::Input1, capability.time().clone());
             todo1.push_back((CapabilitySet::from_elem(capability.clone()), work));
         }
 
@@ -222,11 +225,11 @@ where
                         // still be joined (its updates remain real at times finer than the trace's
                         // compaction frontier, and no other work item has accounted for them).
                         if !PartialOrder::less_equal(batch1.upper(), &preload_upper1) {
-                            if !batch1.is_empty() {
+                            if let Some(updates1) = batch1.inner.clone() {
                                 // It is safe to ask for `ack2` as we validated that it was at least `get_physical_compaction()`
                                 // at start-up, and have held back physical compaction ever since.
                                 let trace2_storage = trace2.batches_through(acknowledged2.borrow()).unwrap();
-                                let work = tactic.prep(vec![batch1.clone()], trace2_storage, Fresh::Input0, meet.clone().expect("non-empty stamp"));
+                                let work = tactic.prep(vec![updates1], trace2_storage, Fresh::Input0, meet.clone().expect("non-empty stamp"));
                                 todo0.push_back((capability.clone(), work));
                             }
 
@@ -276,11 +279,11 @@ where
                         // still be joined (its updates remain real at times finer than the trace's
                         // compaction frontier, and no other work item has accounted for them).
                         if !PartialOrder::less_equal(batch2.upper(), &preload_upper2) {
-                            if !batch2.is_empty() {
+                            if let Some(updates2) = batch2.inner.clone() {
                                 // It is safe to ask for `ack1` as we validated that it was at least `get_physical_compaction()`
                                 // at start-up, and have held back physical compaction ever since.
                                 let trace1_storage = trace1.batches_through(acknowledged1.borrow()).unwrap();
-                                let work = tactic.prep(trace1_storage, vec![batch2.clone()], Fresh::Input1, meet.clone().expect("non-empty stamp"));
+                                let work = tactic.prep(trace1_storage, vec![updates2], Fresh::Input1, meet.clone().expect("non-empty stamp"));
                                 todo1.push_back((capability.clone(), work));
                             }
 
@@ -407,10 +410,9 @@ mod cursors {
     /// implements is over the container `CB` yields (`CB::Container`).
     pub struct CursorTactic<B0, B1, L, CB>
     where
-        B0: BatchReader + Navigable,
-        B1: BatchReader<Time = B0::Time> + Navigable,
-        B0::Cursor: Cursor<Time = B0::Time>,
-        B1::Cursor: for<'a> Cursor<Key<'a> = <B0::Cursor as Cursor>::Key<'a>, Time = B0::Time>,
+        B0: Navigable,
+        B1: Navigable,
+        B1::Cursor: for<'a> Cursor<Key<'a> = <B0::Cursor as Cursor>::Key<'a>, Time = <B0::Cursor as Cursor>::Time>,
     {
         logic: Rc<RefCell<L>>,
         _marker: std::marker::PhantomData<(B0, B1, CB)>,
@@ -418,10 +420,9 @@ mod cursors {
 
     impl<B0, B1, L, CB> CursorTactic<B0, B1, L, CB>
     where
-        B0: BatchReader + Navigable,
-        B1: BatchReader<Time = B0::Time> + Navigable,
-        B0::Cursor: Cursor<Time = B0::Time>,
-        B1::Cursor: for<'a> Cursor<Key<'a> = <B0::Cursor as Cursor>::Key<'a>, Time = B0::Time>,
+        B0: Navigable,
+        B1: Navigable,
+        B1::Cursor: for<'a> Cursor<Key<'a> = <B0::Cursor as Cursor>::Key<'a>, Time = <B0::Cursor as Cursor>::Time>,
     {
         /// Construct a tactic that applies `logic` to each matched `(key, val0, val1)`.
         pub fn new(logic: L) -> Self {
@@ -429,16 +430,15 @@ mod cursors {
         }
     }
 
-    impl<B0, B1, L, CB> JoinTactic<B0, B1, CB::Container> for CursorTactic<B0, B1, L, CB>
+    impl<B0, B1, L, CB> JoinTactic<<B0::Cursor as Cursor>::Time, B0, B1, CB::Container> for CursorTactic<B0, B1, L, CB>
     where
-        B0: BatchReader + Navigable + 'static,
-        B1: BatchReader<Time = B0::Time> + Navigable + 'static,
-        B0::Cursor: Cursor<Time = B0::Time>,
-        B1::Cursor: for<'a> Cursor<Key<'a> = <B0::Cursor as Cursor>::Key<'a>, Time = B0::Time>,
+        B0: Navigable + 'static,
+        B1: Navigable + 'static,
+        B1::Cursor: for<'a> Cursor<Key<'a> = <B0::Cursor as Cursor>::Key<'a>, Time = <B0::Cursor as Cursor>::Time>,
         CB: ContainerBuilder<Container: Default> + 'static,
-        L: for<'a> FnMut(<B0::Cursor as Cursor>::Key<'a>, <B0::Cursor as Cursor>::Val<'a>, <B1::Cursor as Cursor>::Val<'a>, B0::Time, &<B0::Cursor as Cursor>::Diff, &<B1::Cursor as Cursor>::Diff, &mut CB) + 'static,
+        L: for<'a> FnMut(<B0::Cursor as Cursor>::Key<'a>, <B0::Cursor as Cursor>::Val<'a>, <B1::Cursor as Cursor>::Val<'a>, <B0::Cursor as Cursor>::Time, &<B0::Cursor as Cursor>::Diff, &<B1::Cursor as Cursor>::Diff, &mut CB) + 'static,
     {
-        fn prep(&mut self, input0: Vec<B0>, input1: Vec<B1>, fresh: Fresh, meet: B0::Time) -> Box<dyn Iterator<Item = CB::Container>> {
+        fn prep(&mut self, input0: Vec<B0>, input1: Vec<B1>, fresh: Fresh, meet: <B0::Cursor as Cursor>::Time) -> Box<dyn Iterator<Item = CB::Container>> {
             // The accumulated side's history is advanced by `meet` to consolidate it before the
             // cross-product; the fresh side is left, as its times already lie at or beyond `meet`. `fresh`
             // fixes which side is which. The advance is output-neutral either way (the fresh side's times are
diff --git a/differential-dataflow/src/operators/reduce.rs b/differential-dataflow/src/operators/reduce.rs
index b57ee92e2..a2d7f63a2 100644
--- a/differential-dataflow/src/operators/reduce.rs
+++ b/differential-dataflow/src/operators/reduce.rs
@@ -20,10 +20,13 @@ use timely::dataflow::operators::CapabilitySet;
 use timely::dataflow::channels::pact::Pipeline;
 
 use crate::operators::arrange::{Arranged, TraceAgent};
-use crate::trace::{BatchCursor, BatchDiff, BatchKey, BatchReader, BatchVal, BatchValOwn, Builder, Cursor, Description, ExertionLogic, Navigable, Trace, TraceReader};
+use crate::trace::{Span, BatchCursor, BatchDiff, BatchKey, BatchVal, BatchValOwn, Builder, Cursor, Description, ExertionLogic, Navigable, Trace, TraceReader};
 use crate::trace::cursor::cursor_list;
 use crate::trace::implementations::containers::BatchContainer;
 
+/// The time type of the updates' cursor: the time coordinate the tactics work in.
+type TimeOf<B> = <<B as Navigable>::Cursor as Cursor>::Time;
+
 /// Sort and deduplicate a list. Shared by the cursor and reference tactics (via their
 /// `use super::*`) and the proxy tactic (`crate::operators::reduce::sort_dedup`), which
 /// each previously carried an identical copy.
@@ -39,7 +42,7 @@ pub(crate) fn sort_dedup<T: Ord>(list: &mut Vec<T>) {
 /// Unlike join, reduce does not suspend: its output is at most linear in its input, so a single
 /// `retire` runs the whole `[lower, upper)` interval to completion rather than yielding under a fuel
 /// budget.
-pub trait ReduceTactic<B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
+pub trait ReduceTactic<T, B1, B2> {
     /// Retire the interval `[lower, upper)`, producing the output batch it informs.
     ///
     /// It is presented with the pre-existing input batches and output batches (those before `lower`),
@@ -67,10 +70,10 @@ pub trait ReduceTactic<B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
         source_batches: Vec<B1>,
         output_batches: Vec<B2>,
         input_batches: Vec<B1>,
-        lower: &Antichain<B1::Time>,
-        upper: &Antichain<B1::Time>,
-        held: &Antichain<B1::Time>,
-    ) -> (Option<B2>, Antichain<B1::Time>);
+        lower: &Antichain<T>,
+        upper: &Antichain<T>,
+        held: &Antichain<T>,
+    ) -> (Option<Span<T, B2>>, Antichain<T>);
 }
 
 /// A key-wise reduction of values in an input trace.
@@ -94,7 +97,7 @@ where
     BatchCursor<Tr1>: Cursor<Time = Tr1::Time, KeyContainer = KC>,
     for<'a> BatchCursor<Tr1>: Cursor<Key<'a> = KC::ReadItem<'a>>,
     for<'a> BatchCursor<Tr2>: Cursor<Key<'a> = KC::ReadItem<'a>, ValOwn: Data, Time = Tr2::Time>,
-    Bu: Builder<Time=Tr2::Time, Output = Tr2::Batch, Input: Default> + 'static,
+    Bu: Builder<Time=Tr2::Time, Output: Into<Tr2::Batch>, Input: Default> + 'static,
     L: FnMut(KC::ReadItem<'_>, &[(BatchVal<'_, Tr1>, BatchDiff<Tr1>)], &mut Vec<(BatchValOwn<Tr2>, BatchDiff<Tr2>)>, &mut Vec<(BatchValOwn<Tr2>, BatchDiff<Tr2>)>)+'static,
     P: FnMut(&mut Bu::Input, KC::ReadItem<'_>, &mut Vec<(BatchValOwn<Tr2>, Tr2::Time, BatchDiff<Tr2>)>) + 'static,
 {
@@ -111,13 +114,13 @@ pub use reference::reduce_trace_reference;
 /// This is the general reduce operator: it does the dataflow plumbing (frontiers, capabilities, output
 /// trace maintenance) and routes the per-interval work through the tactic. It requires only
 /// `TraceReader` of its input and `Trace` of its output, never `Navigable`: it extracts batches via
-/// `batches_through`, and building cursors over them (if that is how the reduce proceeds) is the
+/// `spans_through`, and building cursors over them (if that is how the reduce proceeds) is the
 /// tactic's concern.
 pub fn reduce_with_tactic<'scope, Tr1, Tr2, T>(trace: Arranged<'scope, Tr1>, name: &str, mut tactic: T) -> Arranged<'scope, TraceAgent<Tr2>>
 where
     Tr1: TraceReader + 'static,
     Tr2: Trace<Time = Tr1::Time> + 'static,
-    T: ReduceTactic<Tr1::Batch, Tr2::Batch> + 'static,
+    T: ReduceTactic<Tr1::Time, Tr1::Batch, Tr2::Batch> + 'static,
 {
     let mut result_trace = None;
 
@@ -197,11 +200,11 @@ where
 
                     // Retire the interval. The tactic reasons only about times: it returns the output
                     // batch to ship, if any, and the new frontier of interesting times.
-                    let (produced, new_frontier) = tactic.retire(source_batches, output_batches, batch_storage, &lower_limit, &upper_limit, &held);
+                    let (produced, new_frontier) = tactic.retire(source_batches, output_batches, batch_storage.into_iter().filter_map(|b| b.inner).collect(), &lower_limit, &upper_limit, &held);
 
                     // Contract check (see `ReduceTactic::retire`). Cheap, debug-only.
                     debug_assert!(
-                        produced.as_ref().is_none_or(|batch| batch.description().lower() == &lower_limit && batch.description().upper() == &upper_limit),
+                        produced.as_ref().is_none_or(|batch| batch.lower() == &lower_limit && batch.upper() == &upper_limit),
                         "ReduceTactic::retire output must span [lower, upper)",
                     );
 
@@ -257,10 +260,9 @@ mod cursors {
     /// The conventional cursor-based [`ReduceTactic`].
     pub struct CursorTactic<B1, B2, Bu, L, P>
     where
-        B1: BatchReader + Navigable,
-        B2: BatchReader<Time = B1::Time> + Navigable,
-        B1::Cursor: Cursor<Time = B1::Time>,
-        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = B1::Time>,
+        B1: Navigable,
+        B2: Navigable,
+        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = TimeOf<B1>>,
     {
         logic: L,
         push: P,
@@ -271,18 +273,17 @@ mod cursors {
         next_pending_keys: <B1::Cursor as Cursor>::KeyContainer,
         next_pending_time: <B1::Cursor as Cursor>::TimeContainer,
         // Buffers reused across activations.
-        interesting_times: Vec<B1::Time>,
-        new_interesting_times: Vec<B1::Time>,
+        interesting_times: Vec<TimeOf<B1>>,
+        new_interesting_times: Vec<TimeOf<B1>>,
         // Output batches may need to be built piecemeal, and these temp storage help there.
         _marker: PhantomData<(B2, Bu)>,
     }
 
     impl<B1, B2, Bu, L, P> CursorTactic<B1, B2, Bu, L, P>
     where
-        B1: BatchReader + Navigable,
-        B2: BatchReader<Time = B1::Time> + Navigable,
-        B1::Cursor: Cursor<Time = B1::Time>,
-        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = B1::Time>,
+        B1: Navigable,
+        B2: Navigable,
+        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = TimeOf<B1>>,
     {
         /// Construct a tactic that applies `logic` to each key and shapes output with `push`.
         pub fn new(logic: L, push: P) -> Self {
@@ -300,25 +301,24 @@ mod cursors {
         }
     }
 
-    impl<B1, B2, Bu, L, P> ReduceTactic<B1, B2> for CursorTactic<B1, B2, Bu, L, P>
+    impl<B1, B2, Bu, L, P> ReduceTactic<TimeOf<B1>, B1, B2> for CursorTactic<B1, B2, Bu, L, P>
     where
-        B1: BatchReader + Navigable,
-        B2: BatchReader<Time = B1::Time> + Navigable,
-        B1::Cursor: Cursor<Time = B1::Time>,
-        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = B1::Time>,
-        Bu: Builder<Time = B1::Time, Output = B2, Input: Default>,
+        B1: Navigable,
+        B2: Navigable,
+        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = TimeOf<B1>>,
+        Bu: Builder<Time = TimeOf<B1>, Output: Into<B2>, Input: Default>,
         L: FnMut(<B1::Cursor as Cursor>::Key<'_>, &[(<B1::Cursor as Cursor>::Val<'_>, <B1::Cursor as Cursor>::Diff)], &mut Vec<(<B2::Cursor as Cursor>::ValOwn, <B2::Cursor as Cursor>::Diff)>, &mut Vec<(<B2::Cursor as Cursor>::ValOwn, <B2::Cursor as Cursor>::Diff)>),
-        P: FnMut(&mut Bu::Input, <B1::Cursor as Cursor>::Key<'_>, &mut Vec<(<B2::Cursor as Cursor>::ValOwn, B1::Time, <B2::Cursor as Cursor>::Diff)>),
+        P: FnMut(&mut Bu::Input, <B1::Cursor as Cursor>::Key<'_>, &mut Vec<(<B2::Cursor as Cursor>::ValOwn, TimeOf<B1>, <B2::Cursor as Cursor>::Diff)>),
     {
         fn retire(
             &mut self,
             source_batches: Vec<B1>,
             output_batches: Vec<B2>,
             input_batches: Vec<B1>,
-            lower: &Antichain<B1::Time>,
-            upper: &Antichain<B1::Time>,
-            held: &Antichain<B1::Time>,
-        ) -> (Option<B2>, Antichain<B1::Time>)
+            lower: &Antichain<TimeOf<B1>>,
+            upper: &Antichain<TimeOf<B1>>,
+            held: &Antichain<TimeOf<B1>>,
+        ) -> (Option<Span<TimeOf<B1>, B2>>, Antichain<TimeOf<B1>>)
         {
             let mut produced = None;
 
@@ -334,7 +334,7 @@ mod cursors {
 
                 // Prepare one output buffer and builder: the batch spans [lower, upper) and
                 // ships stamped with the held times that justify its contents.
-                let mut output_updates = Vec::<(<B2::Cursor as Cursor>::ValOwn, B1::Time, <B2::Cursor as Cursor>::Diff)>::new();
+                let mut output_updates = Vec::<(<B2::Cursor as Cursor>::ValOwn, TimeOf<B1>, <B2::Cursor as Cursor>::Diff)>::new();
                 let mut builder = Bu::new();
                 // Temporary staging for output building.
                 let mut buffer = Bu::Input::default();
@@ -424,16 +424,16 @@ mod cursors {
 
                 // Build the batch spanning the interval, and hand it back to the driver
                 // to ship and commit.
-                let description = Description::new(lower.clone(), upper.clone(), Antichain::from_elem(<B1::Time as Timestamp>::minimum()));
-                produced = Some(builder.done(description));
+                let description = Description::new(lower.clone(), upper.clone(), Antichain::from_elem(<TimeOf<B1> as Timestamp>::minimum()));
+                produced = Some(Span::new(description, builder.done().map(Into::into)));
 
                 // Refresh pending keys and times.
                 self.pending_keys.clear(); std::mem::swap(&mut self.next_pending_keys, &mut self.pending_keys);
                 self.pending_time.clear(); std::mem::swap(&mut self.next_pending_time, &mut self.pending_time);
 
                 // Compute the new frontier of interesting times for the operator to hold.
-                let mut frontier = Antichain::<B1::Time>::new();
-                let mut owned_time = <B1::Time as Timestamp>::minimum();
+                let mut frontier = Antichain::<TimeOf<B1>>::new();
+                let mut owned_time = <TimeOf<B1> as Timestamp>::minimum();
                 for pos in 0 .. self.pending_time.len() {
                     <B1::Cursor as Cursor>::clone_time_onto(self.pending_time.index(pos), &mut owned_time);
                     frontier.insert_ref(&owned_time);
@@ -798,7 +798,7 @@ pub(crate) mod reference {
         Tr2: Trace<Batch: Navigable, Time = Tr1::Time> + 'static,
         BatchCursor<Tr1>: Cursor<Time = Tr1::Time>,
         for<'a> BatchCursor<Tr2>: Cursor<Key<'a> = BatchKey<'a, Tr1>, ValOwn: Data, Time = Tr2::Time>,
-        Bu: Builder<Time=Tr2::Time, Output = Tr2::Batch, Input: Default> + 'static,
+        Bu: Builder<Time=Tr2::Time, Output: Into<Tr2::Batch>, Input: Default> + 'static,
         L: FnMut(BatchKey<'_, Tr1>, &[(BatchVal<'_, Tr1>, BatchDiff<Tr1>)], &mut Vec<(BatchValOwn<Tr2>, BatchDiff<Tr2>)>, &mut Vec<(BatchValOwn<Tr2>, BatchDiff<Tr2>)>)+'static,
         P: FnMut(&mut Bu::Input, BatchKey<'_, Tr1>, &mut Vec<(BatchValOwn<Tr2>, Tr2::Time, BatchDiff<Tr2>)>) + 'static,
     {
@@ -818,10 +818,9 @@ pub(crate) mod reference {
     /// per-key engine differs.
     pub struct ReferenceTactic<B1, B2, Bu, L, P>
     where
-        B1: BatchReader + Navigable,
-        B2: BatchReader<Time = B1::Time> + Navigable,
-        B1::Cursor: Cursor<Time = B1::Time>,
-        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = B1::Time>,
+        B1: Navigable,
+        B2: Navigable,
+        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = TimeOf<B1>>,
     {
         logic: L,
         push: P,
@@ -829,17 +828,16 @@ pub(crate) mod reference {
         pending_time: <B1::Cursor as Cursor>::TimeContainer,
         next_pending_keys: <B1::Cursor as Cursor>::KeyContainer,
         next_pending_time: <B1::Cursor as Cursor>::TimeContainer,
-        interesting_times: Vec<B1::Time>,
-        new_interesting_times: Vec<B1::Time>,
+        interesting_times: Vec<TimeOf<B1>>,
+        new_interesting_times: Vec<TimeOf<B1>>,
         _marker: PhantomData<(B2, Bu)>,
     }
 
     impl<B1, B2, Bu, L, P> ReferenceTactic<B1, B2, Bu, L, P>
     where
-        B1: BatchReader + Navigable,
-        B2: BatchReader<Time = B1::Time> + Navigable,
-        B1::Cursor: Cursor<Time = B1::Time>,
-        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = B1::Time>,
+        B1: Navigable,
+        B2: Navigable,
+        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = TimeOf<B1>>,
     {
         /// Construct a tactic that applies `logic` to each key and shapes output with `push`.
         pub fn new(logic: L, push: P) -> Self {
@@ -857,25 +855,24 @@ pub(crate) mod reference {
         }
     }
 
-    impl<B1, B2, Bu, L, P> ReduceTactic<B1, B2> for ReferenceTactic<B1, B2, Bu, L, P>
+    impl<B1, B2, Bu, L, P> ReduceTactic<TimeOf<B1>, B1, B2> for ReferenceTactic<B1, B2, Bu, L, P>
     where
-        B1: BatchReader + Navigable,
-        B2: BatchReader<Time = B1::Time> + Navigable,
-        B1::Cursor: Cursor<Time = B1::Time>,
-        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = B1::Time>,
-        Bu: Builder<Time = B1::Time, Output = B2, Input: Default>,
+        B1: Navigable,
+        B2: Navigable,
+        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = TimeOf<B1>>,
+        Bu: Builder<Time = TimeOf<B1>, Output: Into<B2>, Input: Default>,
         L: FnMut(<B1::Cursor as Cursor>::Key<'_>, &[(<B1::Cursor as Cursor>::Val<'_>, <B1::Cursor as Cursor>::Diff)], &mut Vec<(<B2::Cursor as Cursor>::ValOwn, <B2::Cursor as Cursor>::Diff)>, &mut Vec<(<B2::Cursor as Cursor>::ValOwn, <B2::Cursor as Cursor>::Diff)>),
-        P: FnMut(&mut Bu::Input, <B1::Cursor as Cursor>::Key<'_>, &mut Vec<(<B2::Cursor as Cursor>::ValOwn, B1::Time, <B2::Cursor as Cursor>::Diff)>),
+        P: FnMut(&mut Bu::Input, <B1::Cursor as Cursor>::Key<'_>, &mut Vec<(<B2::Cursor as Cursor>::ValOwn, TimeOf<B1>, <B2::Cursor as Cursor>::Diff)>),
     {
         fn retire(
             &mut self,
             source_batches: Vec<B1>,
             output_batches: Vec<B2>,
             input_batches: Vec<B1>,
-            lower: &Antichain<B1::Time>,
-            upper: &Antichain<B1::Time>,
-            held: &Antichain<B1::Time>,
-        ) -> (Option<B2>, Antichain<B1::Time>)
+            lower: &Antichain<TimeOf<B1>>,
+            upper: &Antichain<TimeOf<B1>>,
+            held: &Antichain<TimeOf<B1>>,
+        ) -> (Option<Span<TimeOf<B1>, B2>>, Antichain<TimeOf<B1>>)
         {
             let mut produced = None;
 
@@ -885,7 +882,7 @@ pub(crate) mod reference {
                 let (mut output_cursor, ref output_storage) = cursor_list(output_batches);
                 let (mut batch_cursor, ref batch_storage) = cursor_list(input_batches);
 
-                let mut output_updates = Vec::<(<B2::Cursor as Cursor>::ValOwn, B1::Time, <B2::Cursor as Cursor>::Diff)>::new();
+                let mut output_updates = Vec::<(<B2::Cursor as Cursor>::ValOwn, TimeOf<B1>, <B2::Cursor as Cursor>::Diff)>::new();
                 let mut builder = Bu::new();
                 let mut buffer = Bu::Input::default();
 
@@ -955,14 +952,14 @@ pub(crate) mod reference {
                 }
                 drop(thinker);
 
-                let description = Description::new(lower.clone(), upper.clone(), Antichain::from_elem(<B1::Time as Timestamp>::minimum()));
-                produced = Some(builder.done(description));
+                let description = Description::new(lower.clone(), upper.clone(), Antichain::from_elem(<TimeOf<B1> as Timestamp>::minimum()));
+                produced = Some(Span::new(description, builder.done().map(Into::into)));
 
                 self.pending_keys.clear(); std::mem::swap(&mut self.next_pending_keys, &mut self.pending_keys);
                 self.pending_time.clear(); std::mem::swap(&mut self.next_pending_time, &mut self.pending_time);
 
-                let mut frontier = Antichain::<B1::Time>::new();
-                let mut owned_time = <B1::Time as Timestamp>::minimum();
+                let mut frontier = Antichain::<TimeOf<B1>>::new();
+                let mut owned_time = <TimeOf<B1> as Timestamp>::minimum();
                 for pos in 0 .. self.pending_time.len() {
                     <B1::Cursor as Cursor>::clone_time_onto(self.pending_time.index(pos), &mut owned_time);
                     frontier.insert_ref(&owned_time);
diff --git a/differential-dataflow/src/operators/threshold.rs b/differential-dataflow/src/operators/threshold.rs
index 0ab6e35e8..c9502976f 100644
--- a/differential-dataflow/src/operators/threshold.rs
+++ b/differential-dataflow/src/operators/threshold.rs
@@ -14,7 +14,7 @@ use crate::difference::{Semigroup, Abelian};
 use crate::hashable::Hashable;
 use crate::collection::AsCollection;
 use crate::operators::arrange::Arranged;
-use crate::trace::{BatchCursor, BatchDiff, BatchDiffGat, BatchKey, BatchReader, Cursor, Navigable, TraceReader};
+use crate::trace::{BatchCursor, BatchDiff, BatchDiffGat, BatchKey, Cursor, Navigable, TraceReader};
 
 /// Extension trait for the `distinct` differential dataflow method.
 pub trait ThresholdTotal<'scope, T: Timestamp + TotalOrder + Lattice, K: ExchangeData, R: ExchangeData+Semigroup> : Sized {
@@ -146,7 +146,7 @@ where
 
                     let mut session = output.session(&caps);
 
-                    let (mut batch_cursor, batch_storage) = crate::trace::cursor::cursor_list(batch_storage);
+                    let (mut batch_cursor, batch_storage) = crate::trace::cursor::cursor_list(batch_storage.into_iter().filter_map(|b| b.inner).collect());
                     let (mut trace_cursor, trace_storage) = crate::trace::cursor::cursor_list(trace.batches_through(lower_limit.borrow()).unwrap());
 
                     while let Some(key) = batch_cursor.get_key(&batch_storage) {
diff --git a/differential-dataflow/src/trace/chunk/mod.rs b/differential-dataflow/src/trace/chunk/mod.rs
index 6c894b85b..b1aecc244 100644
--- a/differential-dataflow/src/trace/chunk/mod.rs
+++ b/differential-dataflow/src/trace/chunk/mod.rs
@@ -57,7 +57,7 @@ use std::collections::VecDeque;
 use timely::progress::Antichain;
 use timely::progress::frontier::AntichainRef;
 use crate::lattice::Lattice;
-use crate::trace::{Batch, BatchReader, Description, Navigable};
+use crate::trace::Navigable;
 use crate::trace::implementations::spine_fueled::SpineBatch;
 use crate::trace::cursor::Cursor;
 use crate::trace::implementations::BatchContainer;
@@ -238,21 +238,19 @@ where
 type KeyCon<C> = <<C as Navigable>::Cursor as Cursor>::KeyContainer;
 type ValCon<C> = <<C as Navigable>::Cursor as Cursor>::ValContainer;
 
-/// A batch is a [`Chunk`] sequence plus a [`Description`].
+/// A batch: an ordered [`Chunk`] sequence whose concatenation is its updates.
 pub struct ChunkBatch<C: Chunk> {
     /// Ordered, consolidated chunks; their concatenation is the batch.
     pub chunks: Vec<C>,
-    /// The lower, upper, and since frontiers of the batch.
-    pub description: Description<C::Time>,
 }
 
 impl<C: Chunk> ChunkBatch<C> {
     /// Assemble a batch from ordered chunks.
-    pub fn new(chunks: Vec<C>, description: Description<C::Time>) -> Self {
+    pub fn new(chunks: Vec<C>) -> Self {
         for chunk in &chunks {
             assert!(chunk.len() > 0, "ChunkBatch chunks must be non-empty");
         }
-        ChunkBatch { chunks, description }
+        ChunkBatch { chunks }
     }
 }
 
@@ -263,28 +261,13 @@ impl<C: NavigableChunk> crate::trace::Navigable for ChunkBatch<C> {
     }
 }
 
-impl<C: Chunk> BatchReader for ChunkBatch<C> {
-    type Time = C::Time;
-    fn len(&self) -> usize { self.chunks.iter().map(C::len).sum() }
-    fn description(&self) -> &Description<Self::Time> { &self.description }
-}
-
 impl<C: Chunk + Default + 'static> SpineBatch for ChunkBatch<C>
 where
     C::Time: timely::progress::Timestamp + Lattice + Ord,
 {
+    type Time = C::Time;
     type Merger = ChunkBatchMerger<C>;
-}
-
-impl<C: Chunk + Default + 'static> Batch for ChunkBatch<C>
-where
-    C::Time: timely::progress::Timestamp + Lattice + Ord,
-{
-    fn empty(lower: Antichain<Self::Time>, upper: Antichain<Self::Time>) -> Self {
-        use timely::progress::Timestamp;
-        let since = Antichain::from_elem(Self::Time::minimum());
-        ChunkBatch::new(Vec::new(), Description::new(lower, upper, since))
-    }
+    fn len(&self) -> usize { self.chunks.iter().map(C::len).sum() }
 }
 
 /// A merge-batcher [`Merger`](crate::trace::implementations::merge_batcher::Merger)
@@ -296,11 +279,11 @@ where
 /// the trace. Both settle their output, since the batcher's chains want to be graded.
 pub type ChunkBatcher<C> = crate::trace::implementations::merge_batcher::MergeBatcher<ChunkMerger<C>>;
 
-/// A spine of `Rc`-shared [`ChunkBatch`]es of type `C`: the trace type for `arrange`.
+/// A spine of `Rc`-shared [`ChunkBatch`]s of type `C`: the trace type for `arrange`.
 pub type ChunkSpine<C> = crate::trace::implementations::spine_fueled::Spine<std::rc::Rc<ChunkBatch<C>>>;
 
-/// A reference-counted [`ChunkBatch`] builder over chunks of type `C`.
-pub type ChunkBuilder<C> = crate::trace::rc_blanket_impls::RcBuilder<ChunkBatchBuilder<C>>;
+/// A [`ChunkBatch`] builder over chunks of type `C`, emitting `Rc`-shared updates.
+pub type ChunkBuilder<C> = ChunkBatchBuilder<C>;
 
 /// A cursor over a [`ChunkBatch`], merging the per-chunk cursors.
 ///
@@ -566,7 +549,7 @@ where
     fn len(chunk: &C) -> usize { chunk.len() }
 }
 
-/// The resumable [`SpineBatch::Merger`] for [`ChunkBatch`]: merges two batches and advances
+/// The resumable [`SpineBatch::Merger`] for [`ChunkBatch`]: merges two updates and advances
 /// their times to the compaction frontier, a fuel-bounded step at a time.
 ///
 /// Each step pipelines [`merge`](Chunk::merge) → [`advance`](Chunk::advance) →
@@ -576,9 +559,6 @@ where
 pub struct ChunkBatchMerger<C: Chunk> {
     /// Compaction frontier supplied at construction.
     frontier: Antichain<C::Time>,
-    /// Result frontiers, retained for the output description.
-    lower: Antichain<C::Time>,
-    upper: Antichain<C::Time>,
     /// Input deques, refilled from the sources (clones) head-of-list at a time.
     in1: VecDeque<C>,
     in2: VecDeque<C>,
@@ -602,13 +582,9 @@ where
     C: Chunk + Default + 'static,
     C::Time: timely::progress::Timestamp + Lattice + Ord + 'static,
 {
-    fn new(source1: &ChunkBatch<C>, source2: &ChunkBatch<C>, frontier: AntichainRef<C::Time>) -> Self {
-        let lower = source1.description.lower().meet(source2.description.lower());
-        let upper = source1.description.upper().join(source2.description.upper());
+    fn new(_source1: &ChunkBatch<C>, _source2: &ChunkBatch<C>, frontier: AntichainRef<C::Time>) -> Self {
         Self {
             frontier: frontier.to_owned(),
-            lower,
-            upper,
             in1: VecDeque::new(),
             in2: VecDeque::new(),
             idx1: 0,
@@ -666,10 +642,9 @@ where
         }
     }
 
-    fn done(self) -> ChunkBatch<C> {
+    fn done(self) -> Option<ChunkBatch<C>> {
         debug_assert!(self.merged.is_empty() && self.advanced.is_empty());
-        let description = Description::new(self.lower, self.upper, self.frontier);
-        ChunkBatch::new(self.settled.into(), description)
+        wrap(self.settled.into())
     }
 }
 
@@ -702,19 +677,25 @@ where
         }
     }
 
-    fn done(self, description: Description<C::Time>) -> ChunkBatch<C> {
+    fn done(self) -> Option<Self::Output> {
         let ChunkBatchBuilder { mut input, mut output } = self;
         C::settle(&mut input, true, &mut output);
-        ChunkBatch::new(output.into(), description)
+        let chunks: Vec<C> = output.into();
+        wrap(chunks)
     }
 
-    fn seal(chain: &mut Vec<C>, description: Description<C::Time>) -> ChunkBatch<C> {
+    fn seal(chain: &mut Vec<C>) -> Option<Self::Output> {
         // We settle the chain because we are not guaranteed to received pre-settled data.
         // This should be efficient on pre-settled data.
-        ChunkBatch::new(settle_all(std::mem::take(chain)), description)
+        wrap(settle_all(std::mem::take(chain)))
     }
 }
 
+/// Wraps settled chunks as a batch, absent when there are no chunks.
+fn wrap<C: Chunk>(chunks: Vec<C>) -> Option<ChunkBatch<C>> {
+    (!chunks.is_empty()).then(|| ChunkBatch::new(chunks))
+}
+
 /// Whether `chunks` satisfy the [`Chunk::TARGET`] grading invariant: every chunk
 /// at most `TARGET`, and every adjacent pair summing to more than `TARGET` (so no
 /// two neighbours could be combined into one legal chunk — a *maximal packing*).
diff --git a/differential-dataflow/src/trace/chunk/vec.rs b/differential-dataflow/src/trace/chunk/vec.rs
index d2e32e9c5..315a96138 100644
--- a/differential-dataflow/src/trace/chunk/vec.rs
+++ b/differential-dataflow/src/trace/chunk/vec.rs
@@ -392,6 +392,7 @@ where K: Ord+Clone+'static, V: Ord+Clone+'static, T: Lattice+Timestamp, R: Ord+S
 
 #[cfg(test)]
 mod test {
+    use timely::progress::Antichain;
     use std::collections::VecDeque;
     use super::{Chunk, VecChunk};
     use crate::trace::chunk::merge_chains;
@@ -413,7 +414,6 @@ mod test {
     fn extract_partitions_and_grades() {
         use super::TARGET;
         use crate::trace::chunk::{is_graded, settle_all};
-        use timely::progress::Antichain;
 
         // 4·TARGET updates spread over many input chunks; even times ship
         // (< frontier), odd times keep (>= frontier), so both sides straddle.
@@ -442,7 +442,6 @@ mod test {
     // pushing the (possibly-growing) last group back as the carry when not `done`.
     #[test]
     fn advance_emits_complete_groups_eagerly() {
-        use timely::progress::Antichain;
 
         let frontier = Antichain::from_elem(5u64);
         // Group (0,0) is complete within this chunk; group (1,0) might still grow.
@@ -463,7 +462,6 @@ mod test {
     // at group boundaries.
     #[test]
     fn advance_resumable_matches_oneshot() {
-        use timely::progress::Antichain;
 
         let frontier = Antichain::from_elem(3u64);
         // Groups span chunk boundaries and carry several times each.
@@ -497,7 +495,6 @@ mod test {
     // It must still produce the right advanced+consolidated result at the end.
     #[test]
     fn advance_single_key_spanning_pushes() {
-        use timely::progress::Antichain;
 
         let frontier = Antichain::from_elem(100u64);
         let n = 50u64;
@@ -601,12 +598,10 @@ mod test {
     // resumable merge→advance→settle pipeline and the grade-at-yield invariant.
     #[test]
     fn batch_merger_resumable_matches_reference() {
-        use crate::trace::Description;
         use crate::trace::implementations::spine_fueled::Merger;
         use crate::trace::chunk::{ChunkBatch, ChunkBatchMerger, is_graded};
         use crate::trace::cursor::Cursor;
         use crate::consolidation::consolidate_updates;
-        use timely::progress::Antichain;
 
         let mut seed = 0x9E3779B97F4A7C15u64;
         let mut rng = move || { seed ^= seed << 13; seed ^= seed >> 7; seed ^= seed << 17; seed };
@@ -626,9 +621,7 @@ mod test {
         // Cut a consolidated set into a batch of small chunks, so groups straddle.
         fn batch(updates: &[((u64, u64), u64, i64)], sz: usize) -> ChunkBatch<VecChunk<u64, u64, u64, i64>> {
             let chunks: Vec<_> = updates.chunks(sz).map(|c| VecChunk(Rc::new(c.to_vec()))).collect();
-            let desc = Description::new(
-                Antichain::from_elem(0u64), Antichain::from_elem(10u64), Antichain::from_elem(0u64));
-            ChunkBatch::new(chunks, desc)
+            ChunkBatch::new(chunks)
         }
         // Flatten a batch through its straddle-aware cursor, then consolidate.
         fn read(b: &ChunkBatch<VecChunk<u64, u64, u64, i64>>) -> Vec<((u64, u64), u64, i64)> {
@@ -665,13 +658,16 @@ mod test {
             let result = merger.done();
 
             // The produced batch is graded (grade-at-yield, so also at done).
-            assert!(is_graded(&result.chunks), "ungraded result: {:?}",
-                result.chunks.iter().map(Chunk::len).collect::<Vec<_>>());
+            let chunks: &[VecChunk<u64, u64, u64, i64>] = result.as_ref().map_or(&[], |b| &b.chunks[..]);
+            assert!(is_graded(chunks), "ungraded result: {:?}",
+                chunks.iter().map(Chunk::len).collect::<Vec<_>>());
             // ...and its contents are the merged sources, advanced to `f`, consolidated.
-            let got = read(&result);
+            let got = result.as_ref().map_or_else(Vec::new, read);
             let mut want: Vec<_> = u1.iter().chain(u2.iter()).cloned().collect();
             for u in want.iter_mut() { u.1 = u.1.max(f); }
             consolidate_updates(&mut want);
+            // A merge that cancels to nothing reports an absent updates.
+            assert_eq!(result.is_none(), want.is_empty(), "absence must track emptiness\n  u1={u1:?}\n  u2={u2:?}\n  f={f}");
             assert_eq!(got, want, "fuel-driven merge mismatch\n  u1={u1:?}\n  u2={u2:?}\n  f={f}");
         }
     }
@@ -714,21 +710,14 @@ mod test {
     #[test]
     fn cursor_handles_straddle() {
         use crate::trace::cursor::Cursor;
-        use crate::trace::Description;
         use crate::trace::chunk::ChunkBatch;
-        use timely::progress::Antichain;
 
         let chunks = vec![
             chunk(vec![((0, 0), 0, 1), ((1, 0), 0, 1), ((1, 1), 0, 1)]),
             chunk(vec![((1, 1), 1, 1), ((1, 2), 0, 1)]),
             chunk(vec![((2, 0), 0, 1)]),
         ];
-        let desc = Description::new(
-            Antichain::from_elem(0u64),
-            Antichain::from_elem(2u64),
-            Antichain::from_elem(0u64),
-        );
-        let batch = ChunkBatch::new(chunks, desc);
+        let batch = ChunkBatch::new(chunks);
 
         let mut cursor = batch.cursor();
         let got = cursor.to_vec(&batch, |k| *k, |v| *v);
@@ -781,15 +770,11 @@ mod test {
     #[test]
     fn seek_key_hint_is_direction_independent() {
         use crate::trace::cursor::Cursor;
-        use crate::trace::Description;
         use crate::trace::chunk::ChunkBatch;
-        use timely::progress::Antichain;
 
         // One key per chunk (even keys 0, 2, .., 38) so seeks cross boundaries both ways.
         let chunks: Vec<_> = (0..20u64).map(|k| chunk(vec![((2 * k, 0u64), 0u64, 1i64)])).collect();
-        let desc = Description::new(
-            Antichain::from_elem(0u64), Antichain::from_elem(1u64), Antichain::from_elem(0u64));
-        let batch = ChunkBatch::new(chunks, desc);
+        let batch = ChunkBatch::new(chunks);
 
         // First key `>= tgt`: the next even at or above `tgt`, or absent past the last (38).
         let oracle = |tgt: u64| { let e = tgt + (tgt & 1); (e <= 38).then_some(e) };
diff --git a/differential-dataflow/src/trace/cursor/mod.rs b/differential-dataflow/src/trace/cursor/mod.rs
index 2b563ea37..4fc3c65d8 100644
--- a/differential-dataflow/src/trace/cursor/mod.rs
+++ b/differential-dataflow/src/trace/cursor/mod.rs
@@ -19,7 +19,7 @@ use crate::trace::implementations::containers::BatchContainer;
 ///
 /// This is the entry point for accessing batch data through cursors, and the place that opinions
 /// about keys and values are introduced (via the `Cursor` associated type). Cut-and-merge assembly
-/// is the trace's concern: [`TraceReader::batches_through`](crate::trace::TraceReader::batches_through)
+/// is the trace's concern: [`TraceReader::spans_through`](crate::trace::TraceReader::spans_through)
 /// selects the batches, and [`cursor_list()`] merges their cursors.
 pub trait Navigable {
 
@@ -33,7 +33,7 @@ pub trait Navigable {
     fn cursor(&self) -> Self::Cursor;
 }
 
-/// The cursor type for a trace's batches.
+/// The cursor type for the updates in a trace's batches.
 pub type BatchCursor<Tr> = <<Tr as crate::trace::TraceReader>::Batch as Navigable>::Cursor;
 
 /// The borrowed key type of a trace's batch cursor.
@@ -49,14 +49,14 @@ pub type BatchDiff<Tr> = <BatchCursor<Tr> as Cursor>::Diff;
 /// The borrowed time type of a trace's batch cursor.
 pub type BatchTimeGat<'a, Tr> = <BatchCursor<Tr> as Cursor>::TimeGat<'a>;
 
-/// Assembles a merged cursor over a sequence of batches.
+/// Assembles a merged cursor over several batches' updates.
 ///
-/// The batches become the cursor's storage and are returned alongside the cursor; they must be kept
-/// alive and handed to the cursor's navigation methods.
-pub fn cursor_list<B: crate::trace::BatchReader + Navigable>(batches: Vec<B>) -> (CursorList<B::Cursor>, Vec<B>) {
-    let cursors = batches.iter().map(|batch| batch.cursor()).collect::<Vec<_>>();
-    let cursor = CursorList::new(cursors, &batches);
-    (cursor, batches)
+/// The updates become the cursor's storage and are returned alongside the cursor; they must be
+/// kept alive and handed to the cursor's navigation methods.
+pub fn cursor_list<B: Navigable>(updates: Vec<B>) -> (CursorList<B::Cursor>, Vec<B>) {
+    let cursors = updates.iter().map(|u| u.cursor()).collect::<Vec<_>>();
+    let cursor = CursorList::new(cursors, &updates);
+    (cursor, updates)
 }
 
 /// A cursor for navigating ordered `(key, val, time, diff)` updates.
diff --git a/differential-dataflow/src/trace/cursor/wrappers/enter.rs b/differential-dataflow/src/trace/cursor/wrappers/enter.rs
index dec50e2bc..2cf6f1db1 100644
--- a/differential-dataflow/src/trace/cursor/wrappers/enter.rs
+++ b/differential-dataflow/src/trace/cursor/wrappers/enter.rs
@@ -5,14 +5,13 @@ use timely::progress::timestamp::Refines;
 use crate::lattice::Lattice;
 use crate::trace::implementations::BatchContainer;
 use crate::trace::wrappers::enter::BatchEnter;
-use crate::trace::{BatchReader, Navigable};
+use crate::trace::Navigable;
 use crate::trace::cursor::Cursor;
 
 impl<B, TInner> Navigable for BatchEnter<B, TInner>
 where
-    B: BatchReader + Navigable,
-    TInner: Refines<B::Time>+Lattice,
-    TInner: Refines<<B::Cursor as Cursor>::Time>,
+    B: Navigable,
+    TInner: Refines<<B::Cursor as Cursor>::Time>+Lattice,
 {
     type Cursor = BatchCursorEnter<B::Cursor, TInner>;
 
diff --git a/differential-dataflow/src/trace/cursor/wrappers/frontier.rs b/differential-dataflow/src/trace/cursor/wrappers/frontier.rs
index 26d2e28ae..18d633478 100644
--- a/differential-dataflow/src/trace/cursor/wrappers/frontier.rs
+++ b/differential-dataflow/src/trace/cursor/wrappers/frontier.rs
@@ -2,13 +2,12 @@
 
 use crate::trace::implementations::BatchContainer;
 use crate::trace::wrappers::frontier::BatchFrontier;
-use crate::trace::{BatchReader, Navigable};
+use crate::trace::Navigable;
 use crate::trace::cursor::Cursor;
 
-impl<B> Navigable for BatchFrontier<B>
+impl<B> Navigable for BatchFrontier<B, <B::Cursor as Cursor>::Time>
 where
-    B: BatchReader + Navigable,
-    B::Cursor: Cursor<Time = B::Time>,
+    B: Navigable,
 {
     type Cursor = BatchCursorFrontier<B::Cursor>;
 
@@ -27,9 +26,9 @@ pub struct BatchCursorFrontier<C> {
 
 impl<C> Cursor for BatchCursorFrontier<C>
 where
-    C: Cursor<Storage: BatchReader<Time = C::Time>>,
+    C: Cursor,
 {
-    type Storage = BatchFrontier<C::Storage>;
+    type Storage = BatchFrontier<C::Storage, C::Time>;
 
     type Key<'a> = C::Key<'a>;
     type ValOwn = C::ValOwn;
diff --git a/differential-dataflow/src/trace/implementations/mod.rs b/differential-dataflow/src/trace/implementations/mod.rs
index 9b69cb12d..e6baa739d 100644
--- a/differential-dataflow/src/trace/implementations/mod.rs
+++ b/differential-dataflow/src/trace/implementations/mod.rs
@@ -48,10 +48,10 @@ pub mod chunker;
 pub use self::chunker::ContainerChunker;
 pub use self::ord_neu::OrdValSpine as ValSpine;
 pub use self::ord_neu::OrdValBatcher as ValBatcher;
-pub use self::ord_neu::RcOrdValBuilder as ValBuilder;
+pub use self::ord_neu::VecOrdValBuilder as ValBuilder;
 pub use self::ord_neu::OrdKeySpine as KeySpine;
 pub use self::ord_neu::OrdKeyBatcher as KeyBatcher;
-pub use self::ord_neu::RcOrdKeyBuilder as KeyBuilder;
+pub use self::ord_neu::VecOrdKeyBuilder as KeyBuilder;
 
 use std::convert::TryInto;
 
diff --git a/differential-dataflow/src/trace/implementations/ord_neu.rs b/differential-dataflow/src/trace/implementations/ord_neu.rs
index 7080c91d2..81e396b9e 100644
--- a/differential-dataflow/src/trace/implementations/ord_neu.rs
+++ b/differential-dataflow/src/trace/implementations/ord_neu.rs
@@ -13,7 +13,6 @@ use std::rc::Rc;
 use crate::trace::implementations::spine_fueled::Spine;
 use crate::trace::implementations::merge_batcher::MergeBatcher;
 use crate::trace::implementations::merge_batcher::vec::VecMerger;
-use crate::trace::rc_blanket_impls::RcBuilder;
 
 use super::{Layout, Vector};
 
@@ -25,14 +24,14 @@ pub type OrdValSpine<K, V, T, R> = Spine<Rc<OrdValBatch<Vector<((K,V),T,R)>>>>;
 /// A batcher using ordered lists.
 pub type OrdValBatcher<K, V, T, R> = MergeBatcher<VecMerger<(K, V), T, R>>;
 /// A builder using ordered lists.
-pub type RcOrdValBuilder<K, V, T, R> = RcBuilder<OrdValBuilder<Vector<((K,V),T,R)>, Vec<((K,V),T,R)>>>;
+pub type VecOrdValBuilder<K, V, T, R> = OrdValBuilder<Vector<((K,V),T,R)>, Vec<((K,V),T,R)>>;
 
 /// A trace implementation using a spine of ordered lists.
 pub type OrdKeySpine<K, T, R> = Spine<Rc<OrdKeyBatch<Vector<((K,()),T,R)>>>>;
 /// A batcher for ordered lists.
 pub type OrdKeyBatcher<K, T, R> = MergeBatcher<VecMerger<(K, ()), T, R>>;
 /// A builder for ordered lists.
-pub type RcOrdKeyBuilder<K, T, R> = RcBuilder<OrdKeyBuilder<Vector<((K,()),T,R)>, Vec<((K,()),T,R)>>>;
+pub type VecOrdKeyBuilder<K, T, R> = OrdKeyBuilder<Vector<((K,()),T,R)>, Vec<((K,()),T,R)>>;
 
 pub use layers::{Vals, Upds};
 /// Layers are containers of lists of some type.
@@ -248,7 +247,7 @@ pub mod val_batch {
     use timely::container::PushInto;
     use timely::progress::{Antichain, frontier::AntichainRef};
 
-    use crate::trace::{Batch, BatchReader, Builder, Cursor, Description};
+    use crate::trace::{Builder, Cursor};
     use crate::trace::implementations::spine_fueled::{SpineBatch, Merger};
     use crate::trace::implementations::{BatchContainer, BuilderInput};
     use crate::trace::implementations::layout;
@@ -273,10 +272,9 @@ pub mod val_batch {
         pub upds: Upds<L::OffsetContainer, L::TimeContainer, L::DiffContainer>,
     }
 
-    /// An immutable collection of update tuples, from a contiguous interval of logical times.
+    /// The updates of a batch, as immutable update tuples.
     ///
-    /// The `L` parameter captures how the updates should be laid out, and `C` determines which
-    /// merge batcher to select.
+    /// The `L` parameter captures how the updates should be laid out.
     #[derive(Serialize, Deserialize)]
     #[serde(bound = "
         L::KeyContainer: Serialize + for<'a> Deserialize<'a>,
@@ -288,8 +286,6 @@ pub mod val_batch {
     pub struct OrdValBatch<L: Layout> {
         /// The updates themselves.
         pub storage: OrdValStorage<L>,
-        /// Description of the update times this layer represents.
-        pub description: Description<layout::Time<L>>,
         /// The number of updates reflected in the batch.
         ///
         /// We track this separately from `storage` because due to the singleton optimization,
@@ -313,34 +309,14 @@ pub mod val_batch {
         }
     }
 
-    impl<L: Layout> BatchReader for OrdValBatch<L> {
-
+    impl<L: Layout> SpineBatch for OrdValBatch<L> {
         type Time = layout::Time<L>;
+        type Merger = OrdValMerger<L>;
         fn len(&self) -> usize {
             // Normally this would be `self.updates.len()`, but we have a clever compact encoding.
             // Perhaps we should count such exceptions to the side, to provide a correct accounting.
             self.updates
         }
-        fn description(&self) -> &Description<layout::Time<L>> { &self.description }
-    }
-
-    impl<L: Layout> SpineBatch for OrdValBatch<L> {
-        type Merger = OrdValMerger<L>;
-    }
-
-    impl<L: Layout> Batch for OrdValBatch<L> {
-        fn empty(lower: Antichain<Self::Time>, upper: Antichain<Self::Time>) -> Self {
-            use timely::progress::Timestamp;
-            Self {
-                storage: OrdValStorage {
-                    keys: L::KeyContainer::with_capacity(0),
-                    vals: Default::default(),
-                    upds: Default::default(),
-                },
-                description: Description::new(lower, upper, Antichain::from_elem(Self::Time::minimum())),
-                updates: 0,
-            }
-        }
     }
 
     /// State for an in-progress merge.
@@ -351,25 +327,15 @@ pub mod val_batch {
         key_cursor2: usize,
         /// result that we are currently assembling.
         result: OrdValStorage<L>,
-        /// description
-        description: Description<layout::Time<L>>,
+        /// Frontier through which times should be advanced, from the result's description.
+        since: Antichain<layout::Time<L>>,
         /// Staging area to consolidate owned times and diffs, before sealing.
         staging: UpdsBuilder<L::TimeContainer, L::DiffContainer>,
     }
 
-    impl<L: Layout> Merger<OrdValBatch<L>> for OrdValMerger<L>
-    where
-        OrdValBatch<L>: Batch<Time=layout::Time<L>>,
-    {
+    impl<L: Layout> Merger<OrdValBatch<L>> for OrdValMerger<L> {
         fn new(batch1: &OrdValBatch<L>, batch2: &OrdValBatch<L>, compaction_frontier: AntichainRef<layout::Time<L>>) -> Self {
 
-            assert!(batch1.upper() == batch2.lower());
-            use crate::lattice::Lattice;
-            let mut since = batch1.description().since().join(batch2.description().since());
-            since = since.join(&compaction_frontier.to_owned());
-
-            let description = Description::new(batch1.lower().clone(), batch2.upper().clone(), since);
-
             let batch1 = &batch1.storage;
             let batch2 = &batch2.storage;
 
@@ -381,16 +347,13 @@ pub mod val_batch {
                     vals: Vals::merge_capacity(&batch1.vals, &batch2.vals),
                     upds: Upds::merge_capacity(&batch1.upds, &batch2.upds),
                 },
-                description,
+                since: compaction_frontier.to_owned(),
                 staging: UpdsBuilder::default(),
             }
         }
-        fn done(self) -> OrdValBatch<L> {
-            OrdValBatch {
-                updates: self.staging.total(),
-                storage: self.result,
-                description: self.description,
-            }
+        fn done(self) -> Option<OrdValBatch<L>> {
+            let updates = self.staging.total();
+            (updates > 0).then(|| OrdValBatch { updates, storage: self.result })
         }
         fn work(&mut self, source1: &OrdValBatch<L>, source2: &OrdValBatch<L>, fuel: &mut isize) {
 
@@ -554,7 +517,7 @@ pub mod val_batch {
                 let (time, diff) = source.upds.get_abs(i);
                 use crate::lattice::Lattice;
                 let mut new_time: layout::Time<L> = L::TimeContainer::into_owned(time);
-                new_time.advance_by(self.description.since().borrow());
+                new_time.advance_by(self.since.borrow());
                 self.staging.push(new_time, L::DiffContainer::into_owned(diff));
             }
         }
@@ -709,24 +672,21 @@ pub mod val_batch {
         }
 
         #[inline(never)]
-        fn done(mut self, description: Description<Self::Time>) -> OrdValBatch<L> {
+        fn done(mut self) -> Option<Self::Output> {
             self.staging.seal(&mut self.result.upds);
             self.result.vals.offs.push_ref(self.result.vals.vals.len());
-            OrdValBatch {
-                updates: self.staging.total(),
-                storage: self.result,
-                description,
-            }
+            let updates = self.staging.total();
+            (updates > 0).then(|| OrdValBatch { updates, storage: self.result })
         }
 
-        fn seal(chain: &mut Vec<Self::Input>, description: Description<Self::Time>) -> Self::Output {
+        fn seal(chain: &mut Vec<Self::Input>) -> Option<Self::Output> {
             let (keys, vals, upds) = Self::Input::key_val_upd_counts(&chain[..]);
             let mut builder = Self::with_capacity(keys, vals, upds);
             for mut chunk in chain.drain(..) {
                 builder.push(&mut chunk);
             }
 
-            builder.done(description)
+            builder.done()
         }
     }
 }
@@ -739,7 +699,7 @@ pub mod key_batch {
     use timely::container::PushInto;
     use timely::progress::{Antichain, frontier::AntichainRef};
 
-    use crate::trace::{Batch, BatchReader, Builder, Cursor, Description};
+    use crate::trace::{Builder, Cursor};
     use crate::trace::implementations::spine_fueled::{SpineBatch, Merger};
     use crate::trace::implementations::{BatchContainer, BuilderInput};
     use crate::trace::implementations::layout;
@@ -776,8 +736,6 @@ pub mod key_batch {
     pub struct OrdKeyBatch<L: Layout> {
         /// The updates themselves.
         pub storage: OrdKeyStorage<L>,
-        /// Description of the update times this layer represents.
-        pub description: Description<layout::Time<L>>,
         /// The number of updates reflected in the batch.
         ///
         /// We track this separately from `storage` because due to the singleton optimization,
@@ -813,34 +771,14 @@ pub mod key_batch {
         }
     }
 
-    impl<L: Layout<ValContainer: BatchContainer<Owned: Default>>> BatchReader for OrdKeyBatch<L> {
-
+    impl<L: Layout<ValContainer: BatchContainer<Owned: Default>>> SpineBatch for OrdKeyBatch<L> {
         type Time = layout::Time<L>;
+        type Merger = OrdKeyMerger<L>;
         fn len(&self) -> usize {
             // Normally this would be `self.updates.len()`, but we have a clever compact encoding.
             // Perhaps we should count such exceptions to the side, to provide a correct accounting.
             self.updates
         }
-        fn description(&self) -> &Description<layout::Time<L>> { &self.description }
-    }
-
-    impl<L: Layout<ValContainer: BatchContainer<Owned: Default>>> SpineBatch for OrdKeyBatch<L> {
-        type Merger = OrdKeyMerger<L>;
-    }
-
-    impl<L: Layout<ValContainer: BatchContainer<Owned: Default>>> Batch for OrdKeyBatch<L> {
-        fn empty(lower: Antichain<Self::Time>, upper: Antichain<Self::Time>) -> Self {
-            use timely::progress::Timestamp;
-            Self {
-                storage: OrdKeyStorage {
-                    keys: L::KeyContainer::with_capacity(0),
-                    upds: Upds::default(),
-                },
-                description: Description::new(lower, upper, Antichain::from_elem(Self::Time::minimum())),
-                updates: 0,
-                value: Self::create_value(),
-            }
-        }
     }
 
     /// State for an in-progress merge.
@@ -851,26 +789,16 @@ pub mod key_batch {
         key_cursor2: usize,
         /// result that we are currently assembling.
         result: OrdKeyStorage<L>,
-        /// description
-        description: Description<layout::Time<L>>,
+        /// Frontier through which times should be advanced, from the result's description.
+        since: Antichain<layout::Time<L>>,
 
         /// Local stash of updates, to use for consolidation.
         staging: UpdsBuilder<L::TimeContainer, L::DiffContainer>,
     }
 
-    impl<L: Layout<ValContainer: BatchContainer<Owned: Default>>> Merger<OrdKeyBatch<L>> for OrdKeyMerger<L>
-    where
-        OrdKeyBatch<L>: Batch<Time=layout::Time<L>>,
-    {
+    impl<L: Layout<ValContainer: BatchContainer<Owned: Default>>> Merger<OrdKeyBatch<L>> for OrdKeyMerger<L> {
         fn new(batch1: &OrdKeyBatch<L>, batch2: &OrdKeyBatch<L>, compaction_frontier: AntichainRef<layout::Time<L>>) -> Self {
 
-            assert!(batch1.upper() == batch2.lower());
-            use crate::lattice::Lattice;
-            let mut since = batch1.description().since().join(batch2.description().since());
-            since = since.join(&compaction_frontier.to_owned());
-
-            let description = Description::new(batch1.lower().clone(), batch2.upper().clone(), since);
-
             let batch1 = &batch1.storage;
             let batch2 = &batch2.storage;
 
@@ -881,17 +809,17 @@ pub mod key_batch {
                     keys: L::KeyContainer::merge_capacity(&batch1.keys, &batch2.keys),
                     upds: Upds::merge_capacity(&batch1.upds, &batch2.upds),
                 },
-                description,
+                since: compaction_frontier.to_owned(),
                 staging: UpdsBuilder::default(),
             }
         }
-        fn done(self) -> OrdKeyBatch<L> {
-            OrdKeyBatch {
-                updates: self.staging.total(),
+        fn done(self) -> Option<OrdKeyBatch<L>> {
+            let updates = self.staging.total();
+            (updates > 0).then(|| OrdKeyBatch {
+                updates,
                 storage: self.result,
-                description: self.description,
                 value: OrdKeyBatch::<L>::create_value(),
-            }
+            })
         }
         fn work(&mut self, source1: &OrdKeyBatch<L>, source2: &OrdKeyBatch<L>, fuel: &mut isize) {
 
@@ -975,7 +903,7 @@ pub mod key_batch {
                 let (time, diff) = source.upds.get_abs(i);
                 use crate::lattice::Lattice;
                 let mut new_time = L::TimeContainer::into_owned(time);
-                new_time.advance_by(self.description.since().borrow());
+                new_time.advance_by(self.since.borrow());
                 self.staging.push(new_time, L::DiffContainer::into_owned(diff));
             }
         }
@@ -1108,24 +1036,24 @@ pub mod key_batch {
         }
 
         #[inline(never)]
-        fn done(mut self, description: Description<Self::Time>) -> OrdKeyBatch<L> {
+        fn done(mut self) -> Option<Self::Output> {
             self.staging.seal(&mut self.result.upds);
-            OrdKeyBatch {
-                updates: self.staging.total(),
+            let updates = self.staging.total();
+            (updates > 0).then(|| OrdKeyBatch {
+                updates,
                 storage: self.result,
-                description,
                 value: OrdKeyBatch::<L>::create_value(),
-            }
+            })
         }
 
-        fn seal(chain: &mut Vec<Self::Input>, description: Description<Self::Time>) -> Self::Output {
+        fn seal(chain: &mut Vec<Self::Input>) -> Option<Self::Output> {
             let (keys, vals, upds) = Self::Input::key_val_upd_counts(&chain[..]);
             let mut builder = Self::with_capacity(keys, vals, upds);
             for mut chunk in chain.drain(..) {
                 builder.push(&mut chunk);
             }
 
-            builder.done(description)
+            builder.done()
         }
     }
 
diff --git a/differential-dataflow/src/trace/implementations/spine_fueled.rs b/differential-dataflow/src/trace/implementations/spine_fueled.rs
index e7a612738..b1a6590e8 100644
--- a/differential-dataflow/src/trace/implementations/spine_fueled.rs
+++ b/differential-dataflow/src/trace/implementations/spine_fueled.rs
@@ -9,15 +9,15 @@
 //! This spine is represented as a list of layers, where each element in the list is either
 //!
 //!   1. MergeState::Vacant  empty
-//!   2. MergeState::Single  a single batch
-//!   3. MergeState::Double  a pair of batches
+//!   2. MergeState::Single  a single span
+//!   3. MergeState::Double  a pair of spans
 //!
-//! Each "batch" has the option to be `None`, indicating a non-batch that nonetheless acts
+//! Each "span" has the option to be `None`, indicating a non-span that nonetheless acts
 //! as a number of updates proportionate to the level at which it exists (for bookkeeping).
 //!
-//! Each of the batches at layer i contains at most 2^i elements. The sequence of batches
-//! should have the upper bound of one match the lower bound of the next. Batches may be
-//! logically empty, with matching upper and lower bounds, as a bookkeeping mechanism.
+//! Each of the spans at layer i contains at most 2^i elements. The sequence of spans
+//! should have the upper bound of one match the lower bound of the next. Spans may carry
+//! no updates, with matching upper and lower bounds, as a bookkeeping mechanism.
 //!
 //! Each batch at layer i is treated as if it contains exactly 2^i elements, even though it
 //! may actually contain fewer elements. This allows us to decouple the physical representation
@@ -68,31 +68,42 @@
 //! should still extract fuel from new updates even though they have completed, at least until they
 //! have paid back any "debt" to higher layers by continuing to provide fuel as updates arrive.
 
-
 use std::rc::Rc;
 
+use crate::lattice::Lattice;
 use crate::logging::Logger;
-use crate::trace::{Batch, ExertionLogic, Trace, TraceReader};
+use crate::trace::{Span, Description, ExertionLogic, Trace, TraceReader};
 
 use ::timely::dataflow::operators::generic::OperatorInfo;
-use ::timely::progress::{Antichain, frontier::AntichainRef};
+use ::timely::progress::{Antichain, Timestamp, frontier::AntichainRef};
 use ::timely::order::PartialOrder;
 
-/// The requirements this spine imposes on its batches, beyond [`Batch`].
+/// The requirements this spine imposes on the batches its spans carry.
 ///
-/// This is an opinion of this spine, not a property of batches in general: batches must
-/// support progressive (fuel-limited) merging through a [`Merger`]. Other trace
-/// implementations may want to merge differently, or not at all, which is why this
-/// requirement lives here rather than on the common [`Batch`] trait.
-pub trait SpineBatch : Batch {
+/// These are opinions of this spine, not properties of batches in general: a batch must
+/// support progressive (fuel-limited) merging through a [`Merger`], and must report its
+/// size, which drives the spine's geometric layering and its logging.
+pub trait SpineBatch : Sized {
+    /// The timestamp type of the batch's updates.
+    type Time: Timestamp + Lattice;
+
     /// A type used to progressively merge batches.
     type Merger: Merger<Self>;
+
+    /// The number of updates in the batch.
+    ///
+    /// A span with nothing in it is meant to carry no batch at all rather than an empty one,
+    /// so this should be positive. The spine does not rely on that: it asks this method
+    /// rather than asking whether a span carries a batch, so a producer that hands it an
+    /// empty batch costs an extra merge rather than behaving differently from the absent
+    /// case.
+    fn len(&self) -> usize;
 }
 
 /// Represents a merge in progress.
 ///
 /// Constructing a merger begins the merge of two consecutive batches. Exercising it
-/// eventually produces the same result that merging the batches outright would, but
+/// eventually produces the same result that merging them outright would, but
 /// does so in a measured fashion, which avoids latency spikes when a large merge needs
 /// to happen.
 pub trait Merger<Output: SpineBatch> {
@@ -104,16 +115,18 @@ pub trait Merger<Output: SpineBatch> {
     /// If `fuel` is non-zero after the call, the merging is complete and
     /// one should call `done` to extract the merged results.
     fn work(&mut self, source1: &Output, source2: &Output, fuel: &mut isize);
-    /// Extracts merged results.
+    /// Extracts merged results, absent if the merge cancelled to nothing.
     ///
     /// This method should only be called after `work` has been called and
     /// has not brought `fuel` to zero. Otherwise, the merge is still in
     /// progress.
-    fn done(self) -> Output;
+    fn done(self) -> Option<Output>;
 }
 
 impl<B: SpineBatch> SpineBatch for Rc<B> {
+    type Time = B::Time;
     type Merger = RcMerger<B>;
+    fn len(&self) -> usize { (**self).len() }
 }
 
 /// Wrapper type for merging reference counted batches.
@@ -122,7 +135,17 @@ pub struct RcMerger<B: SpineBatch> { merger: B::Merger }
 impl<B: SpineBatch> Merger<Rc<B>> for RcMerger<B> {
     fn new(source1: &Rc<B>, source2: &Rc<B>, compaction_frontier: AntichainRef<B::Time>) -> Self { RcMerger { merger: B::Merger::new(source1, source2, compaction_frontier) } }
     fn work(&mut self, source1: &Rc<B>, source2: &Rc<B>, fuel: &mut isize) { self.merger.work(source1, source2, fuel) }
-    fn done(self) -> Rc<B> { Rc::new(self.merger.done()) }
+    fn done(self) -> Option<Rc<B>> { self.merger.done().map(Rc::new) }
+}
+
+/// The number of updates in a span: its batch's length, or zero when it carries none.
+///
+/// This is how the spine asks whether a span has updates. `Span::has_updates` answers the
+/// weaker question of whether a batch is *present*, which agrees with this only for
+/// producers that report absence when they built nothing; the spine can measure instead,
+/// and does.
+fn span_len<B: SpineBatch>(span: &Span<B::Time, B>) -> usize {
+    span.inner.as_ref().map(|b| b.len()).unwrap_or(0)
 }
 
 /// An append-only collection of update tuples.
@@ -136,7 +159,7 @@ pub struct Spine<B: SpineBatch> {
     logical_frontier: Antichain<B::Time>,   // Times after which the trace must accumulate correctly.
     physical_frontier: Antichain<B::Time>,  // Times after which the trace must be able to subset its inputs.
     merging: Vec<MergeState<B>>,            // Several possibly shared collections of updates.
-    pending: Vec<B>,                        // Batches at times in advance of `frontier`.
+    pending: Vec<Span<B::Time, B>>,        // Spans at times in advance of `frontier`.
     upper: Antichain<B::Time>,
     effort: usize,
     activator: Option<timely::scheduling::activate::Activator>,
@@ -151,7 +174,7 @@ impl<B: SpineBatch+Clone+'static> TraceReader for Spine<B> {
     type Time = B::Time;
     type Batch = B;
 
-    fn batches_through(&mut self, upper: AntichainRef<Self::Time>) -> Option<Vec<Self::Batch>> {
+    fn spans_through(&mut self, upper: AntichainRef<Self::Time>) -> Option<Vec<Span<Self::Time, B>>> {
 
         // If `upper` is the minimum frontier, we can return an empty cursor.
         // This can happen with operators that are written to expect the ability to acquire cursors
@@ -175,7 +198,6 @@ impl<B: SpineBatch+Clone+'static> TraceReader for Spine<B> {
 
         // Check that `upper` is greater or equal to `self.physical_frontier`.
         // Otherwise, the cut could be in `self.merging` and it is user error anyhow.
-        // assert!(upper.iter().all(|t1| self.physical_frontier.iter().any(|t2| t2.less_equal(t1))));
         assert!(PartialOrder::less_equal(&self.physical_frontier.borrow(), &upper));
 
         let mut storage = Vec::new();
@@ -184,16 +206,16 @@ impl<B: SpineBatch+Clone+'static> TraceReader for Spine<B> {
             match merge_state {
                 MergeState::Double(variant) => {
                     match variant {
-                        MergeVariant::InProgress(batch1, batch2, _) => {
-                            if !batch1.is_empty() {
+                        MergeVariant::InProgress(batch1, batch2, _, _) => {
+                            if span_len(batch1) > 0 {
                                 storage.push(batch1.clone());
                             }
-                            if !batch2.is_empty() {
+                            if span_len(batch2) > 0 {
                                 storage.push(batch2.clone());
                             }
                         },
                         MergeVariant::Complete(Some((batch, _))) => {
-                            if !batch.is_empty() {
+                            if span_len(batch) > 0 {
                                 storage.push(batch.clone());
                             }
                         }
@@ -201,7 +223,7 @@ impl<B: SpineBatch+Clone+'static> TraceReader for Spine<B> {
                     }
                 },
                 MergeState::Single(Some(batch)) => {
-                    if !batch.is_empty() {
+                    if span_len(batch) > 0 {
                         storage.push(batch.clone());
                     }
                 },
@@ -212,7 +234,7 @@ impl<B: SpineBatch+Clone+'static> TraceReader for Spine<B> {
 
         for batch in self.pending.iter() {
 
-            if !batch.is_empty() {
+            if span_len(batch) > 0 {
 
                 // For a non-empty `batch`, it is a catastrophic error if `upper`
                 // requires some-but-not-all of the updates in the batch. We can
@@ -226,7 +248,7 @@ impl<B: SpineBatch+Clone+'static> TraceReader for Spine<B> {
                 let include_upper = PartialOrder::less_equal(&batch.upper().borrow(), &upper);
 
                 if include_lower != include_upper && upper != batch.lower().borrow() {
-                    panic!("`batches_through`: `upper` straddles batch");
+                    panic!("`spans_through`: `upper` straddles batch");
                 }
 
                 // include pending batches
@@ -257,10 +279,10 @@ impl<B: SpineBatch+Clone+'static> TraceReader for Spine<B> {
     fn get_physical_compaction(&mut self) -> AntichainRef<'_, B::Time> { self.physical_frontier.borrow() }
 
     #[inline]
-    fn map_batches<F: FnMut(&Self::Batch)>(&self, mut f: F) {
+    fn map_spans<F: FnMut(&Span<Self::Time, B>)>(&self, mut f: F) {
         for batch in self.merging.iter().rev() {
             match batch {
-                MergeState::Double(MergeVariant::InProgress(batch1, batch2, _)) => { f(batch1); f(batch2); },
+                MergeState::Double(MergeVariant::InProgress(batch1, batch2, _, _)) => { f(batch1); f(batch2); },
                 MergeState::Double(MergeVariant::Complete(Some((batch, _)))) => { f(batch) },
                 MergeState::Single(Some(batch)) => { f(batch) },
                 _ => { },
@@ -272,8 +294,6 @@ impl<B: SpineBatch+Clone+'static> TraceReader for Spine<B> {
     }
 }
 
-// A trace implementation for any key type that can be borrowed from or converted into `Key`.
-// TODO: Almost all this implementation seems to be generic with respect to the trace and batch types.
 impl<B: SpineBatch+Clone+'static> Trace for Spine<B> {
     fn new(
         info: ::timely::dataflow::operators::generic::OperatorInfo,
@@ -313,31 +333,31 @@ impl<B: SpineBatch+Clone+'static> Trace for Spine<B> {
         self.exert_logic = Some(logic);
     }
 
-    // Ideally, this method acts as insertion of `batch`, even if we are not yet able to begin
-    // merging the batch. This means it is a good time to perform amortized work proportional
-    // to the size of batch.
-    fn insert(&mut self, batch: Self::Batch) {
+    // Ideally, this method acts as insertion of `span`, even if we are not yet able to begin
+    // merging its batch. This means it is a good time to perform amortized work proportional
+    // to the size of that batch.
+    fn insert(&mut self, span: Span<Self::Time, B>) {
 
         // Log the introduction of a batch.
         self.logger.as_ref().map(|l| l.log(crate::logging::BatchEvent {
             operator: self.operator.global_id,
-            length: batch.len()
+            length: span_len(&span)
         }));
 
-        assert!(batch.lower() != batch.upper());
-        assert_eq!(batch.lower(), &self.upper);
+        assert!(span.lower() != span.upper());
+        assert_eq!(span.lower(), &self.upper);
 
-        self.upper.clone_from(batch.upper());
+        self.upper.clone_from(span.upper());
 
-        // TODO: Consolidate or discard empty batches.
-        self.pending.push(batch);
+        // TODO: Consolidate or discard spans with no updates.
+        self.pending.push(span);
         self.consider_merges();
     }
 
     /// Completes the trace with a final empty batch.
     fn close(&mut self) {
         if !self.upper.borrow().is_empty() {
-            self.insert(B::empty(self.upper.clone(), Antichain::new()));
+            self.insert(Span::empty(self.upper.clone(), Antichain::new()));
         }
     }
 }
@@ -359,23 +379,23 @@ impl<B: SpineBatch> Spine<B> {
                     MergeState::Single(Some(batch)) => {
                         logger.log(crate::logging::DropEvent {
                             operator: self.operator.global_id,
-                            length: batch.len(),
+                            length: span_len(&batch),
                         });
                     },
-                    MergeState::Double(MergeVariant::InProgress(batch1, batch2, _)) => {
+                    MergeState::Double(MergeVariant::InProgress(batch1, batch2, _, _)) => {
                         logger.log(crate::logging::DropEvent {
                             operator: self.operator.global_id,
-                            length: batch1.len(),
+                            length: span_len(&batch1),
                         });
                         logger.log(crate::logging::DropEvent {
                             operator: self.operator.global_id,
-                            length: batch2.len(),
+                            length: span_len(&batch2),
                         });
                     },
                     MergeState::Double(MergeVariant::Complete(Some((batch, _)))) => {
                         logger.log(crate::logging::DropEvent {
                             operator: self.operator.global_id,
-                            length: batch.len(),
+                            length: span_len(&batch),
                         });
                     }
                     _ => { },
@@ -384,7 +404,7 @@ impl<B: SpineBatch> Spine<B> {
             for batch in self.pending.drain(..) {
                 logger.log(crate::logging::DropEvent {
                     operator: self.operator.global_id,
-                    length: batch.len(),
+                    length: span_len(&batch),
                 });
             }
         }
@@ -451,7 +471,6 @@ impl<B: SpineBatch> Spine<B> {
         // TODO: Consider merging pending batches before introducing them.
         // TODO: We could use a `VecDeque` here to draw from the front and append to the back.
         while !self.pending.is_empty() && PartialOrder::less_equal(self.pending[0].upper(), &self.physical_frontier)
-            //   self.physical_frontier.iter().all(|t1| self.pending[0].upper().iter().any(|t2| t2.less_equal(t1)))
         {
             // Batch can be taken in optimized insertion.
             // Otherwise it is inserted normally at the end of the method.
@@ -460,7 +479,7 @@ impl<B: SpineBatch> Spine<B> {
             // If `batch` and the most recently inserted batch are both empty, we can just fuse them.
             // We can also replace a structurally empty batch with this empty batch, preserving the
             // apparent record count but now with non-trivial lower and upper bounds.
-            if batch.as_ref().unwrap().len() == 0 {
+            if span_len(batch.as_ref().unwrap()) == 0 {
                 if let Some(position) = self.merging.iter().position(|m| !m.is_vacant()) {
                     if self.merging[position].is_single() && self.merging[position].len() == 0 {
                         self.insert_at(batch.take(), position);
@@ -472,7 +491,7 @@ impl<B: SpineBatch> Spine<B> {
 
             // Normal insertion for the batch.
             if let Some(batch) = batch {
-                let index = batch.len().next_power_of_two();
+                let index = span_len(&batch).next_power_of_two();
                 self.introduce_batch(Some(batch), index.trailing_zeros() as usize);
             }
         }
@@ -490,7 +509,7 @@ impl<B: SpineBatch> Spine<B> {
     /// The level indication is often related to the size of the batch, but
     /// it can also be used to artificially fuel the computation by supplying
     /// empty batches at non-trivial indices, to move merges along.
-    pub fn introduce_batch(&mut self, batch: Option<B>, batch_index: usize) {
+    pub fn introduce_batch(&mut self, batch: Option<Span<B::Time, B>>, batch_index: usize) {
 
         // Step 0.  Determine an amount of fuel to use for the computation.
         //
@@ -641,7 +660,7 @@ impl<B: SpineBatch> Spine<B> {
     ///
     /// This is a non-public internal method that can panic if we try and insert into a
     /// layer which already contains two batches (and is still in the process of merging).
-    fn insert_at(&mut self, batch: Option<B>, index: usize) {
+    fn insert_at(&mut self, batch: Option<Span<B::Time, B>>, index: usize) {
         // Ensure the spine is large enough.
         while self.merging.len() <= index {
             self.merging.push(MergeState::Vacant);
@@ -658,8 +677,8 @@ impl<B: SpineBatch> Spine<B> {
                     crate::logging::MergeEvent {
                         operator: self.operator.global_id,
                         scale: index,
-                        length1: old.as_ref().map(|b| b.len()).unwrap_or(0),
-                        length2: batch.as_ref().map(|b| b.len()).unwrap_or(0),
+                        length1: old.as_ref().map(span_len).unwrap_or(0),
+                        length2: batch.as_ref().map(span_len).unwrap_or(0),
                         complete: None,
                     }
                 ));
@@ -673,7 +692,7 @@ impl<B: SpineBatch> Spine<B> {
     }
 
     /// Completes and extracts what ever is at layer `index`.
-    fn complete_at(&mut self, index: usize) -> Option<B> {
+    fn complete_at(&mut self, index: usize) -> Option<Span<B::Time, B>> {
         if let Some((merged, inputs)) = self.merging[index].complete() {
             if let Some((input1, input2)) = inputs {
                 // Log the completion of a merge from existing parts.
@@ -681,9 +700,9 @@ impl<B: SpineBatch> Spine<B> {
                     crate::logging::MergeEvent {
                         operator: self.operator.global_id,
                         scale: index,
-                        length1: input1.len(),
-                        length2: input2.len(),
-                        complete: Some(merged.len()),
+                        length1: span_len(&input1),
+                        length2: span_len(&input2),
+                        complete: Some(span_len(&merged)),
                     }
                 ));
             }
@@ -762,28 +781,33 @@ impl<B: SpineBatch> Spine<B> {
 
 /// Describes the state of a layer.
 ///
-/// A layer can be empty, contain a single batch, or contain a pair of batches
-/// that are in the process of merging into a batch for the next layer.
+/// A layer can be empty, contain a single span, or contain a pair of spans
+/// that are in the process of merging into a span for the next layer.
+///
+/// Note the two distinct kinds of nothing here: `Single(None)` is a *structural*
+/// absence, a stand-in for virtual updates with no description at all, used for
+/// fuel bookkeeping; a present span carrying no batch is a *recorded* update-free
+/// interval of time, with a real description.
 enum MergeState<B: SpineBatch> {
     /// An empty layer, containing no updates.
     Vacant,
-    /// A layer containing a single batch.
+    /// A layer containing a single span.
     ///
-    /// The `None` variant is used to represent a structurally empty batch present
+    /// The `None` variant is used to represent a structurally empty layer present
     /// to ensure the progress of maintenance work.
-    Single(Option<B>),
-    /// A layer containing two batches, in the process of merging.
+    Single(Option<Span<B::Time, B>>),
+    /// A layer containing two spans, in the process of merging.
     Double(MergeVariant<B>),
 }
 
-impl<B: SpineBatch<Time: Eq>> MergeState<B> {
+impl<B: SpineBatch> MergeState<B> {
 
     /// The number of actual updates contained in the level.
     fn len(&self) -> usize {
         match self {
-            MergeState::Single(Some(b)) => b.len(),
-            MergeState::Double(MergeVariant::InProgress(b1,b2,_)) => b1.len() + b2.len(),
-            MergeState::Double(MergeVariant::Complete(Some((b, _)))) => b.len(),
+            MergeState::Single(Some(b)) => span_len(b),
+            MergeState::Double(MergeVariant::InProgress(b1,b2,_,_)) => span_len(b1) + span_len(b2),
+            MergeState::Double(MergeVariant::Complete(Some((b, _)))) => span_len(b),
             _ => 0,
         }
     }
@@ -811,7 +835,7 @@ impl<B: SpineBatch<Time: Eq>> MergeState<B> {
     /// with the `is_complete()` method.
     ///
     /// There is the additional option of input batches.
-    fn complete(&mut self) -> Option<(B, Option<(B, B)>)>  {
+    fn complete(&mut self) -> Option<(Span<B::Time, B>, Option<(Span<B::Time, B>, Span<B::Time, B>)>)>  {
         match std::mem::replace(self, MergeState::Vacant) {
             MergeState::Vacant => None,
             MergeState::Single(batch) => batch.map(|b| (b, None)),
@@ -854,16 +878,28 @@ impl<B: SpineBatch<Time: Eq>> MergeState<B> {
     /// batch to the upper frontier of the new batch.
     ///
     /// Either batch may be `None` which corresponds to a structurally
-    /// empty batch whose upper and lower froniers are equal. This
+    /// empty batch whose upper and lower frontiers are equal. This
     /// option exists purely for bookkeeping purposes, and no computation
     /// is performed to merge the two batches.
-    fn begin_merge(batch1: Option<B>, batch2: Option<B>, compaction_frontier: AntichainRef<B::Time>) -> MergeState<B> {
+    fn begin_merge(batch1: Option<Span<B::Time, B>>, batch2: Option<Span<B::Time, B>>, compaction_frontier: AntichainRef<B::Time>) -> MergeState<B> {
         let variant =
         match (batch1, batch2) {
             (Some(batch1), Some(batch2)) => {
                 assert!(batch1.upper() == batch2.lower());
-                let merger = <B::Merger as Merger<B>>::new(&batch1, &batch2, compaction_frontier);
-                MergeVariant::InProgress(batch1, batch2, merger)
+                let since = batch1.desc.since().join(batch2.desc.since()).join(&compaction_frontier.to_owned());
+                let description = Description::new(batch1.lower().clone(), batch2.upper().clone(), since);
+                match (&batch1.inner, &batch2.inner) {
+                    (Some(source1), Some(source2)) => {
+                        let merger = B::Merger::new(source1, source2, description.since().borrow());
+                        MergeVariant::InProgress(batch1, batch2, description, merger)
+                    }
+                    // With at most one side carrying updates there is nothing to merge, and the
+                    // surviving updates' times are not advanced by the compaction frontier.
+                    _ => {
+                        let inner = batch1.inner.or(batch2.inner);
+                        MergeVariant::Complete(Some((Span::new(description, inner), None)))
+                    }
+                }
             }
             (None, Some(x)) => MergeVariant::Complete(Some((x, None))),
             (Some(x), None) => MergeVariant::Complete(Some((x, None))),
@@ -876,9 +912,13 @@ impl<B: SpineBatch<Time: Eq>> MergeState<B> {
 
 enum MergeVariant<B: SpineBatch> {
     /// Describes an actual in-progress merge between two non-trivial batches.
-    InProgress(B, B, <B as SpineBatch>::Merger),
+    ///
+    /// Beyond the two source batches, this records the description their merge
+    /// will bear (their composed interval, with the compaction frontier as its
+    /// `since`) and the merger itself.
+    InProgress(Span<B::Time, B>, Span<B::Time, B>, Description<B::Time>, B::Merger),
     /// A merge that requires no further work. May or may not represent a non-trivial batch.
-    Complete(Option<(B, Option<(B, B)>)>),
+    Complete(Option<(Span<B::Time, B>, Option<(Span<B::Time, B>, Span<B::Time, B>)>)>),
 }
 
 impl<B: SpineBatch> MergeVariant<B> {
@@ -887,7 +927,7 @@ impl<B: SpineBatch> MergeVariant<B> {
     ///
     /// The result is either `None`, for structurally empty batches,
     /// or a batch and optionally input batches from which it derived.
-    fn complete(mut self) -> Option<(B, Option<(B, B)>)> {
+    fn complete(mut self) -> Option<(Span<B::Time, B>, Option<(Span<B::Time, B>, Span<B::Time, B>)>)> {
         let mut fuel = isize::MAX;
         self.work(&mut fuel);
         if let MergeVariant::Complete(batch) = self { batch }
@@ -900,13 +940,14 @@ impl<B: SpineBatch> MergeVariant<B> {
     /// This allows the caller to manage the released resources.
     fn work(&mut self, fuel: &mut isize) {
         let variant = std::mem::replace(self, MergeVariant::Complete(None));
-        if let MergeVariant::InProgress(b1,b2,mut merge) = variant {
-            merge.work(&b1,&b2,fuel);
+        if let MergeVariant::InProgress(b1, b2, description, mut merge) = variant {
+            merge.work(b1.inner.as_ref().unwrap(), b2.inner.as_ref().unwrap(), fuel);
             if *fuel > 0 {
-                *self = MergeVariant::Complete(Some((merge.done(), Some((b1,b2)))));
+                let inner = merge.done();
+                *self = MergeVariant::Complete(Some((Span::new(description, inner), Some((b1, b2)))));
             }
             else {
-                *self = MergeVariant::InProgress(b1,b2,merge);
+                *self = MergeVariant::InProgress(b1, b2, description, merge);
             }
         }
         else {
diff --git a/differential-dataflow/src/trace/mod.rs b/differential-dataflow/src/trace/mod.rs
index 7dea2a76b..9b57c229c 100644
--- a/differential-dataflow/src/trace/mod.rs
+++ b/differential-dataflow/src/trace/mod.rs
@@ -27,6 +27,42 @@ pub use self::description::Description;
 /// A type used to express how much effort a trace should exert even in the absence of updates.
 pub type ExertionLogic = std::sync::Arc<dyn for<'a> Fn(&'a [(usize, usize, usize)])->Option<usize>+Send+Sync>;
 
+/// An interval of a trace's history: a description of the times it covers, and the batch of
+/// updates within it, absent exactly when there are none.
+///
+/// The interval is never empty, but the batch may be missing; a span records that its times
+/// happened and brought no updates.
+#[derive(Clone, Debug)]
+pub struct Span<T, B> {
+    /// The lower and upper bounds of contained update times, and the compaction frontier.
+    pub desc: Description<T>,
+    /// The updates within the interval; absent exactly when there are none.
+    pub inner: Option<B>,
+}
+
+impl<T, B> Span<T, B> {
+    /// A span from a description and the batch within it, absent when there are no updates.
+    pub fn new(desc: Description<T>, inner: Option<B>) -> Self { Self { desc, inner } }
+    /// All times in the span are greater or equal to an element of `lower`.
+    pub fn lower(&self) -> &Antichain<T> { self.desc.lower() }
+    /// All times in the span are not greater or equal to any element of `upper`.
+    pub fn upper(&self) -> &Antichain<T> { self.desc.upper() }
+    /// True if the span carries a batch of updates.
+    ///
+    /// This is about the updates, not the interval, which is never empty.
+    pub fn has_updates(&self) -> bool { self.inner.is_some() }
+}
+
+impl<T: Timestamp, B> Span<T, B> {
+    /// A span over the indicated interval carrying no updates.
+    pub fn empty(lower: Antichain<T>, upper: Antichain<T>) -> Self {
+        Self { desc: Description::new(lower, upper, Antichain::from_elem(T::minimum())), inner: None }
+    }
+}
+
+/// The span type of a trace: [`Span`] instantiated at the trace's time and batch.
+pub type SpanOf<Tr> = Span<<Tr as TraceReader>::Time, <Tr as TraceReader>::Batch>;
+
 /// A trace whose contents may be read.
 ///
 /// This is a restricted interface to the more general `Trace` trait, which extends this trait with further methods
@@ -40,20 +76,32 @@ pub trait TraceReader {
     /// bound its contents and to drive compaction.
     type Time: Timestamp + Lattice;
 
-    /// The type of an immutable collection of updates.
-    type Batch:
-        'static +
-        Clone +
-        BatchReader<Time = Self::Time>;
+    /// The batches of updates the trace's spans carry.
+    ///
+    /// A span is [`Span<Self::Time, Self::Batch>`](Span), pairing a description with a batch
+    /// when its interval brought any updates. The trace has no opinion on how a batch is read:
+    /// operators that want cursors add a [`Navigable`] bound of their own, and operators that
+    /// read batches some other way add none.
+    type Batch: 'static + Clone;
 
-    /// Acquires the non-empty sequence of batches covering updates at times not greater or equal to an
+    /// Acquires the non-empty sequence of spans covering updates at times not greater or equal to an
     /// element of `upper`.
     ///
-    /// This method is expected to work if called with an `upper` that (i) was an observed bound in batches from
+    /// This method is expected to work if called with an `upper` that (i) was an observed bound in spans from
     /// the trace, and (ii) the trace has not been advanced beyond `upper`. Practically, the implementation should
-    /// be expected to look for a "clean cut" using `upper`, and if it finds such a cut can return the batches. This
-    /// should allow `upper` such as `&[]`, used to acquire all batches, though it is difficult to imagine other uses.
-    fn batches_through(&mut self, upper: AntichainRef<Self::Time>) -> Option<Vec<Self::Batch>>;
+    /// be expected to look for a "clean cut" using `upper`, and if it finds such a cut can return the spans. This
+    /// should allow `upper` such as `&[]`, used to acquire all spans, though it is difficult to imagine other uses.
+    fn spans_through(&mut self, upper: AntichainRef<Self::Time>) -> Option<Vec<Span<Self::Time, Self::Batch>>>;
+
+    /// Acquires the batches of the spans covering times not greater or equal to an element
+    /// of `upper`.
+    ///
+    /// Spans with no updates contribute nothing, so this is what callers taking cursors want;
+    /// [`spans_through`](Self::spans_through) is for the drivers that also need the spans'
+    /// descriptions.
+    fn batches_through(&mut self, upper: AntichainRef<Self::Time>) -> Option<Vec<Self::Batch>> {
+        Some(self.spans_through(upper)?.into_iter().filter_map(|b| b.inner).collect())
+    }
 
     /// Advances the frontier that constrains logical compaction.
     ///
@@ -98,17 +146,17 @@ pub trait TraceReader {
 
     /// Reports the physical compaction frontier.
     ///
-    /// All batches containing updates beyond this frontier will not be merged with other batches. This allows
-    /// the caller to acquire the batches through any frontier beyond the physical compaction frontier, with the
-    /// `batches_through()` method. This functionality is primarily of interest to the `join` operator, and any
+    /// All spans containing updates beyond this frontier will not be merged with other spans. This allows
+    /// the caller to acquire the spans through any frontier beyond the physical compaction frontier, with the
+    /// `spans_through()` method. This functionality is primarily of interest to the `join` operator, and any
     /// other operators who need to take notice of the physical structure of update batches.
     fn get_physical_compaction(&mut self) -> AntichainRef<'_, Self::Time>;
 
-    /// Maps logic across the non-empty sequence of batches in the trace.
+    /// Maps logic across the non-empty sequence of spans in the trace.
     ///
     /// This is currently used only to extract historical data to prime late-starting operators who want to reproduce
-    /// the stream of batches moving past the trace.
-    fn map_batches<F: FnMut(&Self::Batch)>(&self, f: F);
+    /// the stream of spans moving past the trace.
+    fn map_spans<F: FnMut(&Span<Self::Time, Self::Batch>)>(&self, f: F);
 
     /// Reads the upper frontier of committed times.
     ///
@@ -117,21 +165,21 @@ pub trait TraceReader {
     fn read_upper(&mut self, target: &mut Antichain<Self::Time>) {
         target.clear();
         target.insert(<Self::Time as timely::progress::Timestamp>::minimum());
-        self.map_batches(|batch| {
-            target.clone_from(batch.upper());
+        self.map_spans(|span| {
+            target.clone_from(span.upper());
         });
     }
 
-    /// Advances `upper` by any empty batches.
+    /// Advances `upper` across any spans with no updates.
     ///
-    /// An empty batch whose `batch.lower` bound equals the current
-    /// contents of `upper` will advance `upper` to `batch.upper`.
-    /// Taken across all batches, this should advance `upper` across
-    /// empty batch regions.
+    /// A span carrying no updates whose `lower` bound equals the current
+    /// contents of `upper` will advance `upper` to its `upper`.
+    /// Taken across all spans, this should advance `upper` across
+    /// update-free regions.
     fn advance_upper(&mut self, upper: &mut Antichain<Self::Time>) {
-        self.map_batches(|batch| {
-            if batch.is_empty() && batch.lower() == upper {
-                upper.clone_from(batch.upper());
+        self.map_spans(|span| {
+            if !span.has_updates() && span.lower() == upper {
+                upper.clone_from(span.upper());
             }
         });
     }
@@ -141,8 +189,8 @@ pub trait TraceReader {
 /// An append-only collection of `(key, val, time, diff)` tuples.
 ///
 /// The trace itself is opinionated only about `Time`, which bounds its contents and drives its compaction.
-/// Key, value, and diff opinions live on the batches' cursors, and are reached through [`Navigable`].
-pub trait Trace : TraceReader<Batch: Batch> {
+/// Key, value, and diff opinions live on the batches, which the trace does not constrain.
+pub trait Trace : TraceReader {
 
     /// Allocates a new empty trace.
     fn new(
@@ -161,58 +209,24 @@ pub trait Trace : TraceReader<Batch: Batch> {
     /// updates to perform, or `None` if no work is required.
     fn set_exert_logic(&mut self, logic: ExertionLogic);
 
-    /// Introduces a batch of updates to the trace.
+    /// Introduces a span of updates to the trace.
     ///
-    /// Batches describe the time intervals they contain, and they should be added to the trace in contiguous
-    /// intervals. If a batch arrives with a lower bound that does not equal the upper bound of the most recent
-    /// addition, the trace will add an empty batch. It is an error to then try to populate that region of time.
+    /// Spans describe the time intervals they contain, and they should be added to the trace in contiguous
+    /// intervals. If a span arrives with a lower bound that does not equal the upper bound of the most recent
+    /// addition, the trace will add a span with no updates. It is an error to then try to populate that region
+    /// of time.
     ///
-    /// This restriction could be relaxed, especially if we discover ways in which batch interval order could
+    /// This restriction could be relaxed, especially if we discover ways in which span interval order could
     /// commute. For now, the trace should complain, to the extent that it cares about contiguous intervals.
-    fn insert(&mut self, batch: Self::Batch);
+    fn insert(&mut self, span: Span<Self::Time, Self::Batch>);
 
-    /// Introduces an empty batch concluding the trace.
+    /// Introduces an update-free span concluding the trace.
     ///
-    /// This method should be logically equivalent to introducing an empty batch whose lower frontier equals
-    /// the upper frontier of the most recently introduced batch, and whose upper frontier is empty.
+    /// This method should be logically equivalent to introducing a span with no updates whose lower frontier
+    /// equals the upper frontier of the most recently introduced span, and whose upper frontier is empty.
     fn close(&mut self);
 }
 
-/// A batch of updates whose contents may be read.
-///
-/// This is a restricted interface to batches of updates, which support the reading of the batch's contents,
-/// but do not expose ways to construct the batches. This trait is appropriate for views of the batch, and is
-/// especially useful for views derived from other sources in ways that prevent the construction of batches
-/// from the type of data in the view (for example, filtered views, or views with extended time coordinates).
-pub trait BatchReader : Sized {
-
-    /// The timestamp type of the batch's updates.
-    type Time: Timestamp + Lattice;
-
-    /// The number of updates in the batch.
-    fn len(&self) -> usize;
-    /// True if the batch is empty.
-    fn is_empty(&self) -> bool { self.len() == 0 }
-    /// Describes the times of the updates in the batch.
-    fn description(&self) -> &Description<Self::Time>;
-
-    /// All times in the batch are greater or equal to an element of `lower`.
-    fn lower(&self) -> &Antichain<Self::Time> { self.description().lower() }
-    /// All times in the batch are not greater or equal to any element of `upper`.
-    fn upper(&self) -> &Antichain<Self::Time> { self.description().upper() }
-}
-
-/// An immutable collection of updates.
-///
-/// This trait asks only that batches can be minted empty over an indicated interval,
-/// which trace maintenance uses to pad out otherwise empty intervals of time. Opinions
-/// about how batches merge belong to individual trace implementations (for example
-/// [`SpineBatch`](crate::trace::implementations::spine_fueled::SpineBatch)).
-pub trait Batch : BatchReader + Sized {
-    /// Produce an empty batch over the indicated interval.
-    fn empty(lower: Antichain<Self::Time>, upper: Antichain<Self::Time>) -> Self;
-}
-
 /// Functionality for collecting and batching updates.
 ///
 /// Accepts containers of type `Output` via [`PushInto`] and produces output batches of the same
@@ -256,15 +270,15 @@ pub trait Builder: Sized {
     ///
     /// Adds all elements from `chunk` to the builder and leaves `chunk` in an undefined state.
     fn push(&mut self, chunk: &mut Self::Input);
-    /// Completes building and returns the batch.
-    fn done(self, description: Description<Self::Time>) -> Self::Output;
+    /// Completes building and returns the batch, absent if no updates were pushed.
+    fn done(self) -> Option<Self::Output>;
 
-    /// Builds a batch from a chain of updates corresponding to the indicated lower and upper bounds.
+    /// Builds a batch from a chain of updates.
     ///
     /// This method relies on the chain only containing updates greater or equal to the lower frontier,
-    /// and not greater or equal to the upper frontier, as encoded in the description. Chains must also
-    /// be sorted and consolidated.
-    fn seal(chain: &mut Vec<Self::Input>, description: Description<Self::Time>) -> Self::Output;
+    /// and not greater or equal to the upper frontier, of the interval the caller means to describe.
+    /// Chains must also be sorted and consolidated.
+    fn seal(chain: &mut Vec<Self::Input>) -> Option<Self::Output>;
 }
 
 /// Blanket implementations for reference counted batches.
@@ -272,10 +286,9 @@ pub mod rc_blanket_impls {
 
     use std::rc::Rc;
 
-    use timely::progress::Antichain;
-    use super::{Batch, BatchReader, Builder, Navigable, Cursor, Description};
+    use super::{Navigable, Cursor};
 
-    impl<B: BatchReader + Navigable> Navigable for Rc<B> {
+    impl<B: Navigable> Navigable for Rc<B> {
         /// The type used to enumerate the batch's contents.
         type Cursor = RcBatchCursor<B::Cursor>;
         /// Acquires a cursor to the batch's contents.
@@ -284,15 +297,6 @@ pub mod rc_blanket_impls {
         }
     }
 
-    impl<B: BatchReader> BatchReader for Rc<B> {
-
-        type Time = B::Time;
-        /// The number of updates in the batch.
-        fn len(&self) -> usize { (**self).len() }
-        /// Describes the times of the updates in the batch.
-        fn description(&self) -> &Description<Self::Time> { (**self).description() }
-    }
-
     /// Wrapper to provide cursor to nested scope.
     pub struct RcBatchCursor<C> {
         cursor: C,
@@ -346,27 +350,4 @@ pub mod rc_blanket_impls {
         #[inline] fn rewind_vals(&mut self, storage: &Self::Storage) { self.cursor.rewind_vals(storage) }
     }
 
-    /// An immutable collection of updates.
-    impl<B: Batch> Batch for Rc<B> {
-        fn empty(lower: Antichain<Self::Time>, upper: Antichain<Self::Time>) -> Self {
-            Rc::new(B::empty(lower, upper))
-        }
-    }
-
-    /// Wrapper type for building reference counted batches.
-    pub struct RcBuilder<B: Builder> { builder: B }
-
-    /// Functionality for building batches from ordered update sequences.
-    impl<B: Builder> Builder for RcBuilder<B> {
-        type Input = B::Input;
-        type Time = B::Time;
-        type Output = Rc<B::Output>;
-        fn with_capacity(keys: usize, vals: usize, upds: usize) -> Self { RcBuilder { builder: B::with_capacity(keys, vals, upds) } }
-        fn push(&mut self, input: &mut Self::Input) { self.builder.push(input) }
-        fn done(self, description: Description<Self::Time>) -> Rc<B::Output> { Rc::new(self.builder.done(description)) }
-        fn seal(chain: &mut Vec<Self::Input>, description: Description<Self::Time>) -> Self::Output {
-            Rc::new(B::seal(chain, description))
-        }
-    }
-
 }
diff --git a/differential-dataflow/src/trace/wrappers/enter.rs b/differential-dataflow/src/trace/wrappers/enter.rs
index b168ab6e6..9109f3dca 100644
--- a/differential-dataflow/src/trace/wrappers/enter.rs
+++ b/differential-dataflow/src/trace/wrappers/enter.rs
@@ -1,11 +1,12 @@
 //! Wrappers to provide trace access to nested scopes.
 
-// use timely::progress::nested::product::Product;
+use std::marker::PhantomData;
+
 use timely::progress::timestamp::Refines;
 use timely::progress::{Antichain, frontier::AntichainRef};
 
 use crate::lattice::Lattice;
-use crate::trace::{BatchReader, Description, TraceReader};
+use crate::trace::{Span, Description, TraceReader};
 
 /// Wrapper to provide trace to nested scope.
 pub struct TraceEnter<Tr: TraceReader, TInner> {
@@ -24,17 +25,31 @@ impl<Tr: TraceReader + Clone, TInner> Clone for TraceEnter<Tr, TInner> {
     }
 }
 
+/// Converts a description of outer times to one of inner times.
+pub fn enter_description<T: timely::progress::Timestamp, TInner: Refines<T>+Lattice>(desc: &Description<T>) -> Description<TInner> {
+    let lower: Vec<_> = desc.lower().elements().iter().map(|x| TInner::to_inner(x.clone())).collect();
+    let upper: Vec<_> = desc.upper().elements().iter().map(|x| TInner::to_inner(x.clone())).collect();
+    let since: Vec<_> = desc.since().elements().iter().map(|x| TInner::to_inner(x.clone())).collect();
+    Description::new(Antichain::from(lower), Antichain::from(upper), Antichain::from(since))
+}
+
+/// Converts an outer span to an inner one: the description enters the scope, and the batch is
+/// wrapped so that its readers do the same.
+pub fn enter_span<T: timely::progress::Timestamp, TInner: Refines<T>+Lattice, B>(span: Span<T, B>) -> Span<TInner, BatchEnter<B, TInner>> {
+    Span::new(enter_description(&span.desc), span.inner.map(BatchEnter::make_from))
+}
+
 impl<Tr, TInner> TraceReader for TraceEnter<Tr, TInner>
 where
     Tr: TraceReader,
     TInner: Refines<Tr::Time>+Lattice,
 {
-    type Batch = BatchEnter<Tr::Batch, TInner>;
     type Time = TInner;
+    type Batch = BatchEnter<Tr::Batch, TInner>;
 
-    fn map_batches<F: FnMut(&Self::Batch)>(&self, mut f: F) {
-        self.trace.map_batches(|batch| {
-            f(&Self::Batch::make_from(batch.clone()));
+    fn map_spans<F: FnMut(&Span<TInner, Self::Batch>)>(&self, mut f: F) {
+        self.trace.map_spans(|span| {
+            f(&enter_span(span.clone()));
         })
     }
 
@@ -68,13 +83,13 @@ where
         self.stash2.borrow()
     }
 
-    fn batches_through(&mut self, upper: AntichainRef<TInner>) -> Option<Vec<Self::Batch>> {
+    fn spans_through(&mut self, upper: AntichainRef<TInner>) -> Option<Vec<Span<TInner, Self::Batch>>> {
         self.stash1.clear();
         for time in upper.iter() {
             self.stash1.insert(time.clone().to_outer());
         }
-        let storage = self.trace.batches_through(self.stash1.borrow())?;
-        Some(storage.into_iter().map(|batch| BatchEnter::make_from(batch)).collect())
+        let storage = self.trace.spans_through(self.stash1.borrow())?;
+        Some(storage.into_iter().map(enter_span).collect())
     }
 }
 
@@ -94,21 +109,11 @@ where
 }
 
 
-/// Wrapper to provide batch to nested scope.
+/// Wrapper to provide a batch to a nested scope.
 #[derive(Clone)]
 pub struct BatchEnter<B, TInner> {
     batch: B,
-    description: Description<TInner>,
-}
-
-impl<B, TInner> BatchReader for BatchEnter<B, TInner>
-where
-    B: BatchReader,
-    TInner: Refines<B::Time>+Lattice,
-{
-    type Time = TInner;
-    fn len(&self) -> usize { self.batch.len() }
-    fn description(&self) -> &Description<TInner> { &self.description }
+    phantom: PhantomData<TInner>,
 }
 
 impl<B, TInner> BatchEnter<B, TInner> {
@@ -118,22 +123,9 @@ impl<B, TInner> BatchEnter<B, TInner> {
     /// whole of the wrapper's read-side semantics, and any reader of the wrapped batch must
     /// apply it.
     pub fn inner(&self) -> &B { &self.batch }
-}
 
-impl<B, TInner> BatchEnter<B, TInner>
-where
-    B: BatchReader,
-    TInner: Refines<B::Time>+Lattice,
-{
-    /// Makes a new batch wrapper
+    /// Makes a new wrapper
     pub fn make_from(batch: B) -> Self {
-        let lower: Vec<_> = batch.description().lower().elements().iter().map(|x| TInner::to_inner(x.clone())).collect();
-        let upper: Vec<_> = batch.description().upper().elements().iter().map(|x| TInner::to_inner(x.clone())).collect();
-        let since: Vec<_> = batch.description().since().elements().iter().map(|x| TInner::to_inner(x.clone())).collect();
-
-        BatchEnter {
-            batch,
-            description: Description::new(Antichain::from(lower), Antichain::from(upper), Antichain::from(since))
-        }
+        BatchEnter { batch, phantom: PhantomData }
     }
 }
diff --git a/differential-dataflow/src/trace/wrappers/frontier.rs b/differential-dataflow/src/trace/wrappers/frontier.rs
index 1c00362cf..2aa5756d9 100644
--- a/differential-dataflow/src/trace/wrappers/frontier.rs
+++ b/differential-dataflow/src/trace/wrappers/frontier.rs
@@ -8,7 +8,7 @@
 
 use timely::progress::{Antichain, frontier::AntichainRef};
 
-use crate::trace::{BatchReader, Description, TraceReader};
+use crate::trace::{Span, TraceReader};
 use crate::lattice::Lattice;
 
 /// Wrapper to provide trace to nested scope.
@@ -33,12 +33,18 @@ impl<Tr: TraceReader + Clone> Clone for TraceFrontier<Tr> {
 impl<Tr: TraceReader> TraceReader for TraceFrontier<Tr> {
 
     type Time = Tr::Time;
-    type Batch = BatchFrontier<Tr::Batch>;
+    type Batch = BatchFrontier<Tr::Batch, Tr::Time>;
 
-    fn map_batches<F: FnMut(&Self::Batch)>(&self, mut f: F) {
+    fn map_spans<F: FnMut(&Span<Tr::Time, Self::Batch>)>(&self, mut f: F) {
         let since = self.since.borrow();
         let until = self.until.borrow();
-        self.trace.map_batches(|batch| f(&Self::Batch::make_from(batch.clone(), since, until)))
+        self.trace.map_spans(|span| {
+            let wrapped = Span::new(
+                span.desc.clone(),
+                span.inner.clone().map(|b| BatchFrontier::make_from(b, since, until)),
+            );
+            f(&wrapped)
+        })
     }
 
     fn set_logical_compaction(&mut self, frontier: AntichainRef<'_, Tr::Time>) { self.trace.set_logical_compaction(frontier) }
@@ -47,11 +53,13 @@ impl<Tr: TraceReader> TraceReader for TraceFrontier<Tr> {
     fn set_physical_compaction(&mut self, frontier: AntichainRef<'_, Tr::Time>) { self.trace.set_physical_compaction(frontier) }
     fn get_physical_compaction(&mut self) -> AntichainRef<'_, Tr::Time> { self.trace.get_physical_compaction() }
 
-    fn batches_through(&mut self, upper: AntichainRef<'_, Tr::Time>) -> Option<Vec<Self::Batch>> {
-        let storage = self.trace.batches_through(upper)?;
+    fn spans_through(&mut self, upper: AntichainRef<'_, Tr::Time>) -> Option<Vec<Span<Tr::Time, Self::Batch>>> {
+        let storage = self.trace.spans_through(upper)?;
         let since = self.since.borrow();
         let until = self.until.borrow();
-        Some(storage.into_iter().map(|batch| BatchFrontier::make_from(batch, since, until)).collect())
+        Some(storage.into_iter().map(|span| {
+            Span::new(span.desc, span.inner.map(|b| BatchFrontier::make_from(b, since, until)))
+        }).collect())
     }
 }
 
@@ -67,23 +75,19 @@ impl<Tr: TraceReader> TraceFrontier<Tr> {
 }
 
 
-/// Wrapper to provide batch to nested scope.
+/// Wrapper to restrict a batch's times to a frontier range.
 #[derive(Clone)]
-pub struct BatchFrontier<B: BatchReader> {
+pub struct BatchFrontier<B, T> {
     batch: B,
-    since: Antichain<B::Time>,
-    until: Antichain<B::Time>,
+    since: Antichain<T>,
+    until: Antichain<T>,
 }
 
-impl<B: BatchReader> BatchReader for BatchFrontier<B> {
-    type Time = B::Time;
-    fn len(&self) -> usize { self.batch.len() }
-    fn description(&self) -> &Description<B::Time> { self.batch.description() }
-}
-
-impl<B: BatchReader> BatchFrontier<B> {
-    /// Makes a new batch wrapper
-    pub fn make_from(batch: B, since: AntichainRef<B::Time>, until: AntichainRef<B::Time>) -> Self {
+impl<B, T> BatchFrontier<B, T> {
+    /// Makes a new wrapper
+    pub fn make_from(batch: B, since: AntichainRef<T>, until: AntichainRef<T>) -> Self
+    where T: Clone,
+    {
         BatchFrontier {
             batch,
             since: since.to_owned(),
@@ -104,7 +108,9 @@ impl<B: BatchReader> BatchFrontier<B> {
     /// should be presented at all: times at or after `until` are suppressed, even when they are
     /// part of a batch that spans `until`.
     #[inline]
-    pub fn advance_time(&self, time: &mut B::Time) -> bool {
+    pub fn advance_time(&self, time: &mut T) -> bool
+    where T: Lattice + timely::progress::Timestamp,
+    {
         time.advance_by(self.since.borrow());
         !self.until.less_equal(time)
     }
diff --git a/differential-dataflow/tests/int_proxy.rs b/differential-dataflow/tests/int_proxy.rs
index 1d8947492..f55ad2d4e 100644
--- a/differential-dataflow/tests/int_proxy.rs
+++ b/differential-dataflow/tests/int_proxy.rs
@@ -29,13 +29,13 @@ use differential_dataflow::trace::chunk::vec::{
 use differential_dataflow::trace::chunk::ChunkBatch;
 use differential_dataflow::trace::cursor::Cursor;
 use differential_dataflow::trace::implementations::ContainerChunker;
-use differential_dataflow::trace::{Description, Navigable};
+use differential_dataflow::trace::{Navigable};
 use differential_dataflow::AsCollection;
 
-type Batch<K, V, T, R> = Rc<ChunkBatch<VecChunk<K, V, T, R>>>;
+type Span<K, V, T, R> = Rc<ChunkBatch<VecChunk<K, V, T, R>>>;
 
 /// Read a `u64`-keyed batch, dropping the hash key; returns `(value, time, diff)`.
-fn hread<KV, T, R>(batches: &[Batch<u64, KV, T, R>]) -> Vec<(KV, T, R)>
+fn hread<KV, T, R>(batches: &[Span<u64, KV, T, R>]) -> Vec<(KV, T, R)>
 where
     KV: Ord + Clone + 'static,
     T: Lattice + Timestamp,
@@ -60,7 +60,7 @@ where
 }
 
 /// Build a HASH-KEYED input batch from `((K, V), T, R)` rows: `((hash(K), (K, V)), T, R)`.
-fn hbatch<K, V, T, R>(rows: Vec<((K, V), T, R)>, lower: T, upper: T) -> Batch<u64, (K, V), T, R>
+fn hbatch<K, V, T, R>(rows: Vec<((K, V), T, R)>, _lower: T, _upper: T) -> Span<u64, (K, V), T, R>
 where
     K: Hashable + Ord + Clone + 'static,
     K::Output: Into<u64>,
@@ -75,8 +75,7 @@ where
     for u in hrows {
         chunk.push_into(u);
     }
-    let desc = Description::new(Antichain::from_elem(lower), Antichain::from_elem(upper), Antichain::from_elem(T::minimum()));
-    Rc::new(ChunkBatch::new(vec![chunk], desc))
+    Rc::new(ChunkBatch::new(vec![chunk]))
 }
 
 fn max_logic(_k: &u64, input: &[(u64, i64)], current: &mut Vec<(u64, i64)>, updates: &mut Vec<(u64, i64)>) {
@@ -97,7 +96,7 @@ fn reduce_one_retire() {
         &Antichain::from_elem(0u64), &Antichain::from_elem(1u64), &Antichain::from_elem(0u64),
     );
     assert!(frontier.is_empty());
-    let out: Vec<_> = produced.into_iter().flat_map(|b| hread(&[b])).collect();
+    let out: Vec<_> = produced.into_iter().filter_map(|b| b.inner).flat_map(|b| hread(&[b])).collect();
     // Output values are `(key, max)`: (7,5) and (9,2).
     assert_eq!(out, vec![((7u64, 5u64), 0u64, 1i64), ((9, 2), 0, 1)]);
 }
@@ -126,7 +125,7 @@ fn reduce_collision_correct() {
         vec![], vec![], vec![input],
         &Antichain::from_elem(0u64), &Antichain::from_elem(1u64), &Antichain::from_elem(0u64),
     );
-    let out: Vec<_> = produced.into_iter().flat_map(|b| hread(&[b])).collect();
+    let out: Vec<_> = produced.into_iter().filter_map(|b| b.inner).flat_map(|b| hread(&[b])).collect();
     assert_eq!(out, vec![((Collide(1), 9u64), 0u64, 1i64), ((Collide(2), 9), 0, 1)], "collision must not merge keys");
 }
 
@@ -269,7 +268,7 @@ fn reduce_collision_across_retires() {
         vec![], vec![], vec![b0.clone()],
         &Antichain::from_elem(0u64), &Antichain::from_elem(1u64), &Antichain::from_elem(0u64),
     );
-    let out0: Vec<_> = p0.into_iter().flat_map(|b| hread(&[b])).collect();
+    let out0: Vec<_> = p0.into_iter().filter_map(|b| b.inner).flat_map(|b| hread(&[b])).collect();
     assert_eq!(out0, vec![((Collide(1), 5u64), 0u64, 1i64), ((Collide(2), 7), 0, 1)], "retire 1");
 
     // Retire 2: a novel update to the LOWER key only, so the id order is [C1(hist), C2(hist), C1(novel)].
@@ -277,14 +276,14 @@ fn reduce_collision_across_retires() {
         let mut t2 = ProxyReduceTactic::new(VecReduceBackend::new(logic));
         let b = hbatch::<Collide, u64, u64, i64>(vec![((Collide(1), 5), 0, 1), ((Collide(2), 7), 0, 1)], 0, 1);
         let (p, _) = t2.retire(vec![], vec![], vec![b], &Antichain::from_elem(0u64), &Antichain::from_elem(1u64), &Antichain::from_elem(0u64));
-        p.into_iter().collect()
+        p.into_iter().filter_map(|b| b.inner).collect()
     };
     let b1 = hbatch::<Collide, u64, u64, i64>(vec![((Collide(1), 9), 1, 1)], 1, 2);
     let (p1, _f) = tactic.retire(
         vec![b0], out_batches, vec![b1],
         &Antichain::from_elem(1u64), &Antichain::from_elem(2u64), &Antichain::from_elem(1u64),
     );
-    let out1: Vec<_> = p1.into_iter().flat_map(|b| hread(&[b])).collect();
+    let out1: Vec<_> = p1.into_iter().filter_map(|b| b.inner).flat_map(|b| hread(&[b])).collect();
     // C1's max rises 5 -> 9; C2 is untouched and must NOT be disturbed.
     assert_eq!(out1, vec![((Collide(1), 5u64), 1u64, -1i64), ((Collide(1), 9), 1, 1)], "retire 2 must not disturb C2");
 }
@@ -360,7 +359,7 @@ fn reduce_collision_multiwindow() {
         vec![], vec![], vec![input],
         &Antichain::from_elem(0u64), &Antichain::from_elem(1u64), &Antichain::from_elem(0u64),
     );
-    let mut out: Vec<_> = produced.into_iter().flat_map(|b| hread(&[b])).collect();
+    let mut out: Vec<_> = produced.into_iter().filter_map(|b| b.inner).flat_map(|b| hread(&[b])).collect();
     out.sort();
     let want: Vec<_> = (0..5u64).map(|k| ((Bucket(k), 10 * k + 1), 0u64, 1i64)).collect();
     assert_eq!(out, want, "each real key keeps its own maximum");
@@ -388,7 +387,7 @@ fn reduce_collision_fastpath_endpoints() {
         vec![], vec![], vec![b0.clone()],
         &Antichain::from_elem(0u64), &Antichain::from_elem(1u64), &Antichain::from_elem(0u64),
     );
-    let outs: Vec<_> = p0.into_iter().collect();
+    let outs: Vec<_> = p0.into_iter().filter_map(|b| b.inner).collect();
     assert_eq!(outs.iter().flat_map(|b| hread(std::slice::from_ref(b))).collect::<Vec<_>>(),
                vec![((Collide(1), 5u64), 0u64, 1i64)], "retire 1: only C1 emits");
 
@@ -397,7 +396,7 @@ fn reduce_collision_fastpath_endpoints() {
         vec![b0], outs, vec![b1],
         &Antichain::from_elem(1u64), &Antichain::from_elem(2u64), &Antichain::from_elem(1u64),
     );
-    let out1: Vec<_> = p1.into_iter().flat_map(|b| hread(&[b])).collect();
+    let out1: Vec<_> = p1.into_iter().filter_map(|b| b.inner).flat_map(|b| hread(&[b])).collect();
     // C1's values are {5, 6}: the max becomes 6. C2's 900 belongs to a different real key.
     assert_eq!(out1, vec![((Collide(1), 5u64), 1u64, -1i64), ((Collide(1), 6), 1, 1)],
                "C2's value must not enter C1's reduction");
@@ -433,7 +432,7 @@ fn reduce_seed_survives_cancellation() {
         vec![], vec![], vec![b0.clone()],
         &Antichain::from_elem(0u64), &Antichain::from_elem(1u64), &Antichain::from_elem(0u64),
     );
-    let outs: Vec<_> = p0.into_iter().collect();
+    let outs: Vec<_> = p0.into_iter().filter_map(|b| b.inner).collect();
     assert_eq!(
         outs.iter().flat_map(|b| hread(std::slice::from_ref(b))).collect::<Vec<_>>(),
         vec![((7u64, 3u64), 0u64, 1i64)],
@@ -448,6 +447,6 @@ fn reduce_seed_survives_cancellation() {
         vec![b0], outs, vec![b1],
         &Antichain::from_elem(1u64), &Antichain::from_elem(2u64), &Antichain::from_elem(1u64),
     );
-    let out1: Vec<_> = p1.into_iter().flat_map(|b| hread(&[b])).collect();
+    let out1: Vec<_> = p1.into_iter().filter_map(|b| b.inner).flat_map(|b| hread(&[b])).collect();
     assert_eq!(out1, vec![((7u64, 3u64), 1u64, -1i64)], "the stale output must be retracted");
 }
diff --git a/differential-dataflow/tests/trace.rs b/differential-dataflow/tests/trace.rs
index 2b263113f..49d9a5ca0 100644
--- a/differential-dataflow/tests/trace.rs
+++ b/differential-dataflow/tests/trace.rs
@@ -3,7 +3,7 @@ use timely::dataflow::operators::generic::OperatorInfo;
 use timely::progress::{Antichain, frontier::AntichainRef};
 
 use differential_dataflow::trace::implementations::{ValBatcher, ValBuilder, ValSpine};
-use differential_dataflow::trace::{Trace, TraceReader, Batcher, Builder};
+use differential_dataflow::trace::{Span, Trace, TraceReader, Batcher, Builder};
 use differential_dataflow::trace::cursor::{Cursor, cursor_list};
 
 type IntegerTrace = ValSpine<u64, u64, usize, i64>;
@@ -24,7 +24,7 @@ fn get_trace() -> ValSpine<u64, u64, usize, i64> {
         let batch_ts = &[1, 2, 3];
         for i in batch_ts {
             let (mut chain, description) = batcher.seal(Antichain::from_elem(*i));
-            trace.insert(IntegerBuilder::seal(&mut chain, description));
+            trace.insert(Span::new(description, IntegerBuilder::seal(&mut chain).map(Into::into)));
         }
     }
     trace
@@ -34,11 +34,11 @@ fn get_trace() -> ValSpine<u64, u64, usize, i64> {
 fn test_trace() {
     let mut trace = get_trace();
 
-    let (mut cursor1, storage1) = cursor_list(trace.batches_through(AntichainRef::new(&[1])).unwrap());
+    let (mut cursor1, storage1) = cursor_list(trace.spans_through(AntichainRef::new(&[1])).unwrap().into_iter().filter_map(|b| b.inner).collect());
     let vec_1 = cursor1.to_vec(&storage1, |k| k.clone(), |v| v.clone());
     assert_eq!(vec_1, vec![((1, 2), vec![(0, 1)])]);
 
-    let (mut cursor2, storage2) = cursor_list(trace.batches_through(AntichainRef::new(&[2])).unwrap());
+    let (mut cursor2, storage2) = cursor_list(trace.spans_through(AntichainRef::new(&[2])).unwrap().into_iter().filter_map(|b| b.inner).collect());
     let vec_2 = cursor2.to_vec(&storage2, |k| k.clone(), |v| v.clone());
     println!("--> {:?}", vec_2);
     assert_eq!(vec_2, vec![
@@ -46,15 +46,15 @@ fn test_trace() {
                ((2, 3), vec![(1, 1)]),
     ]);
 
-    let (mut cursor3, storage3) = cursor_list(trace.batches_through(AntichainRef::new(&[3])).unwrap());
+    let (mut cursor3, storage3) = cursor_list(trace.spans_through(AntichainRef::new(&[3])).unwrap().into_iter().filter_map(|b| b.inner).collect());
     let vec_3 = cursor3.to_vec(&storage3, |k| k.clone(), |v| v.clone());
     assert_eq!(vec_3, vec![
                ((1, 2), vec![(0, 1)]),
                ((2, 3), vec![(1, 1), (2, -1)]),
     ]);
 
-    let batches = trace.batches_through(Antichain::new().borrow()).unwrap();
-    let (mut cursor4, storage4) = cursor_list(batches);
+    let batches = trace.spans_through(Antichain::new().borrow()).unwrap();
+    let (mut cursor4, storage4) = cursor_list(batches.into_iter().filter_map(|b| b.inner).collect());
     let vec_4 = cursor4.to_vec(&storage4, |k| k.clone(), |v| v.clone());
     assert_eq!(vec_4, vec_3);
 }
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index f1ee2a07d..c155a9303 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -33,7 +33,7 @@ use differential_dataflow::{ExchangeData, VecCollection, AsCollection, Hashable}
 use differential_dataflow::difference::Semigroup;
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::operators::arrange::Arranged;
-use differential_dataflow::trace::{BatchReader, BatchCursor, BatchDiff, BatchVal, Cursor, Navigable, TraceReader};
+use differential_dataflow::trace::{BatchCursor, BatchDiff, BatchVal, Cursor, Navigable, TraceReader};
 use differential_dataflow::trace::cursor::cursor_list;
 use differential_dataflow::consolidation::{consolidate, consolidate_updates};
 use differential_dataflow::trace::implementations::BatchContainer;
@@ -43,12 +43,12 @@ use timely::dataflow::operators::CapabilitySet;
 /// An implementation suitable to define half-join behavior among its referenced types.
 ///
 /// The implementor can half-join streams of `C0` with batches `B`, producing output streams of `C1`.
-pub trait HalfJoinTactic<B: BatchReader, C0, C1> {
-    /// Converts a list of chunks and a list of batches to a list of outputs, each with a time suitable as a capability.
+pub trait HalfJoinTactic<T, B, C0, C1> {
+    /// Converts a list of chunks and a list of batch payloads to a list of outputs, each with a time suitable as a capability.
     ///
     /// The `lower` argument lower bounds the times in `chunks`, and may be used to load `batches`
     /// compacted, or to bound the arrangement times the join must consider.
-    fn prep(&mut self, chunks: Vec<C0>, batches: Vec<B>, lower: Antichain<B::Time>) -> Box<dyn Iterator<Item = (C1, B::Time)>>;
+    fn prep(&mut self, chunks: Vec<C0>, batches: Vec<B>, lower: Antichain<T>) -> Box<dyn Iterator<Item = (C1, T)>>;
 }
 
 /// A type capable of accepting containers of updates, and carving them out by time.
@@ -100,7 +100,7 @@ where
     P: ParallelizationContract<Tr::Time, CIn>,
     Y: Fn(std::time::Instant, usize) -> bool + 'static,
     Bat: Batcher<Tr::Time, CIn, CMid> + 'static,
-    Tac: HalfJoinTactic<Tr::Batch, CMid, C> + 'static,
+    Tac: HalfJoinTactic<Tr::Time, Tr::Batch, CMid, C> + 'static,
     CIn: Container,
     C: Container + 'static,
 {
@@ -314,8 +314,10 @@ pub mod cursors {
         half_join_with_tactic(stream.inner, arrangement, pact, frontier_func, yield_function, batcher, tactic)
     }
 
-    /// The cursor of a batch.
+    /// The cursor of a batch payload.
     type BCursor<B> = <B as Navigable>::Cursor;
+    /// The time type of a batch payload's cursor.
+    type BTime<B> = <<B as Navigable>::Cursor as Cursor>::Time;
 
     /// The conventional cursor-based [`HalfJoinTactic`].
     ///
@@ -338,18 +340,17 @@ pub mod cursors {
         }
     }
 
-    impl<K, V, R, B, L, CB> HalfJoinTactic<B, Vec<((K, V, B::Time), B::Time, R)>, CB::Container> for CursorTactic<K, V, R, B, L, CB>
+    impl<K, V, R, B, L, CB> HalfJoinTactic<BTime<B>, B, Vec<((K, V, BTime<B>), BTime<B>, R)>, CB::Container> for CursorTactic<K, V, R, B, L, CB>
     where
-        B: BatchReader + Navigable + 'static,
-        BCursor<B>: Cursor<Time = B::Time>,
+        B: Navigable + 'static,
         <BCursor<B> as Cursor>::KeyContainer: BatchContainer<Owned = K>,
         K: Ord + 'static,
         V: Ord + 'static,
         R: 'static,
-        L: for<'a> FnMut(&mut CB, &K, &V, <BCursor<B> as Cursor>::Val<'a>, &B::Time, &R, &mut Vec<(B::Time, <BCursor<B> as Cursor>::Diff)>) + 'static,
+        L: for<'a> FnMut(&mut CB, &K, &V, <BCursor<B> as Cursor>::Val<'a>, &BTime<B>, &R, &mut Vec<(BTime<B>, <BCursor<B> as Cursor>::Diff)>) + 'static,
         CB: ContainerBuilder,
     {
-        fn prep(&mut self, chunks: Vec<Vec<((K, V, B::Time), B::Time, R)>>, batches: Vec<B>, lower: Antichain<B::Time>) -> Box<dyn Iterator<Item = (CB::Container, B::Time)>> {
+        fn prep(&mut self, chunks: Vec<Vec<((K, V, BTime<B>), BTime<B>, R)>>, batches: Vec<B>, lower: Antichain<BTime<B>>) -> Box<dyn Iterator<Item = (CB::Container, BTime<B>)>> {
             // The batcher releases updates in time order, but the cursor is walked in data order.
             let mut updates: Vec<_> = chunks.into_iter().flatten().collect();
             updates.sort_by(|(d1, t1, _), (d2, t2, _)| (d1, t1).cmp(&(d2, t2)));
diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
index 8b1d3efd7..385ee9918 100644
--- a/interactive/src/backend/corgi.rs
+++ b/interactive/src/backend/corgi.rs
@@ -313,7 +313,8 @@ impl Backend for CorgiBackend {
                     input.for_each(|cap, data| {
                         let mut session = output.session(&cap);
                         for batch in data.iter() {
-                            for ch in batch.chunks.iter().filter(|c| c.len() > 0) {
+                            let Some(payload) = batch.inner.as_ref() else { continue };
+                            for ch in payload.chunks.iter().filter(|c| c.len() > 0) {
                                 let mut c = CorgiContainer {
                                     // Drop the arrangement's leading identifier lane: edges carry
                                     // the key the program wrote, so `$0` indexes what it always did.
diff --git a/interactive/src/corgi/chunk.rs b/interactive/src/corgi/chunk.rs
index 84440c987..d3aa17318 100644
--- a/interactive/src/corgi/chunk.rs
+++ b/interactive/src/corgi/chunk.rs
@@ -27,7 +27,6 @@ use timely::progress::frontier::AntichainRef;
 
 use differential_dataflow::difference::Semigroup;
 use differential_dataflow::trace::chunk::{pack, Chunk, ChunkBatch};
-use differential_dataflow::trace::Description;
 
 use corgi::arrange::{compare_at, compare_idx, gather, gather_lanes, group_bounds, sort_perm};
 use corgi::Value as CValue;
@@ -430,17 +429,17 @@ where
 /// Build a `ChunkBatch<CorgiChunk>` from corgi key/val COLUMNS directly (no transcode): sort +
 /// consolidate into one chunk, then `settle`. The column-native egress the reduce backend seals its
 /// output with (it resolves proxy ids to real columns by `gather` and hands them here).
-pub fn columns_to_batch<T, R>(keys: CValue, vals: CValue, times: Vec<T>, diffs: Vec<R>, description: Description<T>) -> ChunkBatch<CorgiChunk<T, R>>
+pub fn columns_to_batch<T, R>(keys: CValue, vals: CValue, times: Vec<T>, diffs: Vec<R>) -> ChunkBatch<CorgiChunk<T, R>>
 where
     T: ColTime,
     R: Semigroup + Clone + 'static,
 {
     let chunk = CorgiChunk::from_columns(keys, vals, times, diffs);
-    settle_one(chunk, description)
+    settle_one(chunk)
 }
 
 /// Grade one chunk into a `ChunkBatch` (shared tail of `rows_to_batch`/`columns_to_batch`).
-fn settle_one<T, R>(chunk: CorgiChunk<T, R>, description: Description<T>) -> ChunkBatch<CorgiChunk<T, R>>
+fn settle_one<T, R>(chunk: CorgiChunk<T, R>) -> ChunkBatch<CorgiChunk<T, R>>
 where
     T: ColTime,
     R: Semigroup + Clone + 'static,
@@ -449,7 +448,7 @@ where
     if chunk.len_() > 0 { input.push_back(chunk); }
     let mut output = VecDeque::new();
     CorgiChunk::settle(&mut input, true, &mut output);
-    ChunkBatch::new(output.into(), description)
+    ChunkBatch::new(output.into())
 }
 
 /// A column-native arrange **chunker**: turns input `CorgiContainer`s into sorted+consolidated
@@ -618,8 +617,7 @@ where
 mod test {
     use super::*;
     use differential_dataflow::trace::chunk::{ChunkBatchMerger, is_graded};
-    use differential_dataflow::trace::Description;
-    use differential_dataflow::trace::implementations::spine_fueled::Merger;
+        use differential_dataflow::trace::implementations::spine_fueled::Merger;
     use std::collections::BTreeMap;
 
     fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
@@ -662,8 +660,7 @@ mod test {
         m.retain(|_, d| *d != 0);
         let all: Vec<((u64, u64), u64, i64)> = m.into_iter().map(|((kv, t), d)| (kv, t, d)).collect();
         let chunks: Vec<_> = all.chunks(sz.max(1)).map(chunk).collect();
-        let desc = Description::new(Antichain::from_elem(0u64), Antichain::from_elem(10u64), Antichain::from_elem(0u64));
-        ChunkBatch::new(chunks, desc)
+        ChunkBatch::new(chunks)
     }
 
     #[test]
@@ -692,8 +689,12 @@ mod test {
                 if fuel > 0 { break; }
             }
             let result = merger.done();
-            assert!(is_graded(&result.chunks), "ungraded: {:?}", result.chunks.iter().map(Chunk::len).collect::<Vec<_>>());
-            assert_eq!(read_batch(&result), reference(&u1, &u2, f), "u1={u1:?}\nu2={u2:?}\nf={f}");
+            let chunks: &[CorgiChunk<u64, i64>] = result.as_ref().map_or(&[], |b| &b.chunks[..]);
+            assert!(is_graded(chunks), "ungraded: {:?}", chunks.iter().map(Chunk::len).collect::<Vec<_>>());
+            let want = reference(&u1, &u2, f);
+            // A merge that cancels to nothing reports an absent payload.
+            assert_eq!(result.is_none(), want.is_empty(), "absence must track emptiness\nu1={u1:?}\nu2={u2:?}\nf={f}");
+            assert_eq!(result.as_ref().map_or_else(BTreeMap::new, read_batch), want, "u1={u1:?}\nu2={u2:?}\nf={f}");
         }
     }
 }
diff --git a/interactive/src/corgi/join.rs b/interactive/src/corgi/join.rs
index 71df9d95d..27c6c454e 100644
--- a/interactive/src/corgi/join.rs
+++ b/interactive/src/corgi/join.rs
@@ -70,7 +70,7 @@ impl<T: ColTime> CorgiJoinBackend<T> {
     }
 }
 
-impl<T: ColTime> ProxyJoinBackend<CBatch<T>, CBatch<T>> for CorgiJoinBackend<T> {
+impl<T: ColTime> ProxyJoinBackend<T, CBatch<T>, CBatch<T>> for CorgiJoinBackend<T> {
     type R0 = Diff;
     type R1 = Diff;
     type ROut = Diff;
@@ -78,7 +78,7 @@ impl<T: ColTime> ProxyJoinBackend<CBatch<T>, CBatch<T>> for CorgiJoinBackend<T>
 
     fn advance(
         &mut self,
-        instance: &JoinInstance<CBatch<T>, CBatch<T>>,
+        instance: &JoinInstance<T, CBatch<T>, CBatch<T>>,
         from: &mut Option<u64>,
         bridge0: &mut ProxyBridge<T, Diff>,
         bridge1: &mut ProxyBridge<T, Diff>,
@@ -117,7 +117,7 @@ impl<T: ColTime> ProxyJoinBackend<CBatch<T>, CBatch<T>> for CorgiJoinBackend<T>
 
     fn cross(
         &mut self,
-        instance: &JoinInstance<CBatch<T>, CBatch<T>>,
+        instance: &JoinInstance<T, CBatch<T>, CBatch<T>>,
         matches: &mut JoinMatches<T, Diff>,
         output: &mut Vec<CorgiContainer<T, Diff>>,
     ) {
@@ -768,8 +768,6 @@ fn leaf_merge<'a, T: ColTime>(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use differential_dataflow::trace::Description;
-    use timely::progress::Antichain;
 
     fn batch(rows: &[(u64, u64, u64)]) -> CBatch<u64> {
         let keys = CValue::Prod(vec![
@@ -783,14 +781,7 @@ mod tests {
         // these together before `cross` has a chance to compare their keys.
         let vals = CValue::u64(vec![0; rows.len()]);
         let chunk = CorgiChunk::from_columns(keys, vals, vec![0; rows.len()], vec![1; rows.len()]);
-        Rc::new(ChunkBatch::new(
-            vec![chunk],
-            Description::new(
-                Antichain::from_elem(0),
-                Antichain::from_elem(1),
-                Antichain::from_elem(0),
-            ),
-        ))
+        Rc::new(ChunkBatch::new(vec![chunk]))
     }
 
     fn backend() -> CorgiJoinBackend<u64> {
@@ -802,7 +793,7 @@ mod tests {
 
     fn cross_bridges(
         backend: &mut CorgiJoinBackend<u64>,
-        instance: &JoinInstance<CBatch<u64>, CBatch<u64>>,
+        instance: &JoinInstance<u64, CBatch<u64>, CBatch<u64>>,
         left: &ProxyBridge<u64, Diff>,
         right: &ProxyBridge<u64, Diff>,
     ) -> usize {
diff --git a/interactive/src/corgi/reduce.rs b/interactive/src/corgi/reduce.rs
index 9f7104c46..0289de1e6 100644
--- a/interactive/src/corgi/reduce.rs
+++ b/interactive/src/corgi/reduce.rs
@@ -73,9 +73,8 @@ pub struct CorgiReduceBackend<T> {
     /// Input `value_id → row` in `in_vals` for the current window (reduce-time resolution; first row
     /// wins, so equal values — which share a content-hash `value_id` — resolve to one representative).
     in_index: IdMap,
-    /// Output batch for `begin`/`emit`/`finish`: the batch description, and the accumulated
-    /// output rows `(key row, value row, time, diff)` (pool indices, gathered into columns at `finish`).
-    description: Option<Description<T>>,
+    /// Output rows for `begin`/`emit`/`finish`: the accumulated
+    /// `(key row, value row, time, diff)` (pool indices, gathered into columns at `finish`).
     rows: (Vec<usize>, Vec<usize>, Vec<T>, Vec<Diff>),
     /// Key-resolution pool for the current retire: `key_hash → row index` into the concatenation of
     /// `key_blocks` (representative keys from the input + output presentations).
@@ -96,7 +95,6 @@ impl<T> CorgiReduceBackend<T> {
             reducer,
             in_vals: CValue::Unit(0),
             in_index: IdMap::default(),
-            description: None,
             rows: (Vec::new(), Vec::new(), Vec::new(), Vec::new()),
             key_index: IdMap::default(),
             key_blocks: Vec::new(),
@@ -525,21 +523,20 @@ where
     }
 }
 
-impl<T> ProxyReduceBackend<CBatch<T>, CBatch<T>> for CorgiReduceBackend<T>
+impl<T> ProxyReduceBackend<T, CBatch<T>, CBatch<T>> for CorgiReduceBackend<T>
 where
     T: ColTime + Ord,
 {
     type RIn = Diff;
     type ROut = Diff;
 
-    fn begin(&mut self, description: Description<T>) {
+    fn begin(&mut self, _description: Description<T>) {
         // Open the output session for this retire; reset the per-retire resolution pools.
         self.reset_pools();
-        self.description = Some(description);
         self.rows = (Vec::new(), Vec::new(), Vec::new(), Vec::new());
     }
 
-    fn next_window(&mut self, instance: &ReduceInstance<'_, CBatch<T>, CBatch<T>>, changed: &[u64], from: &mut Option<u64>, window: &mut ReduceWindow<T, Diff, Diff>) {
+    fn next_window(&mut self, instance: &ReduceInstance<'_, T, CBatch<T>, CBatch<T>>, changed: &[u64], from: &mut Option<u64>, window: &mut ReduceWindow<T, Diff, Diff>) {
         // Single window: present the WHOLE key space at once, and report it covered. This is NOT a
         // deferred refinement — bounded windows were measured and rejected: at WINDOW = 1<<14, scc
         // (100 rounds x batch 100) cost 84.4s against 63.7s, a 33% regression, while peak RSS
@@ -669,15 +666,15 @@ where
         }
     }
 
-    fn finish(&mut self) -> CBatch<T> {
+    fn finish(&mut self) -> Option<CBatch<T>> {
         // Seal the batch: gather the accumulated (key, val) pool rows into columns, one CorgiChunk batch.
         let key_pool = concat_columns(&self.key_blocks);
         let val_pool = concat_columns(&self.val_blocks);
-        let desc = self.description.take().expect("finish without begin");
         let (krows, vrows, times, diffs) = std::mem::take(&mut self.rows);
+        if times.is_empty() { return None; }
         let keys = gather(&key_pool, &krows);
         let vals = gather(&val_pool, &vrows);
-        Rc::new(columns_to_batch(keys, vals, times, diffs, desc))
+        Some(Rc::new(columns_to_batch(keys, vals, times, diffs)))
     }
 }