diff --git a/differential-dataflow/examples/cursors.rs b/differential-dataflow/examples/cursors.rs
index 8dcfc739d..f4038b65c 100644
--- a/differential-dataflow/examples/cursors.rs
+++ b/differential-dataflow/examples/cursors.rs
@@ -94,7 +94,7 @@ 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 (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..5732e019b 100644
--- a/differential-dataflow/examples/multitemporal.rs
+++ b/differential-dataflow/examples/multitemporal.rs
@@ -100,7 +100,7 @@ fn main() {
                                 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 (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/src/algorithms/graphs/bfs.rs b/differential-dataflow/src/algorithms/graphs/bfs.rs
index 1a419b8a5..8667deeaa 100644
--- a/differential-dataflow/src/algorithms/graphs/bfs.rs
+++ b/differential-dataflow/src/algorithms/graphs/bfs.rs
@@ -25,7 +25,7 @@ use crate::operators::arrange::Arranged;
 pub fn bfs_arranged<'scope, N, Tr>(edges: Arranged<'scope, Tr>, roots: VecCollection<'scope, Tr::Time, N>) -> VecCollection<'scope, Tr::Time, (N, u32)>
 where
     N: ExchangeData+Hash,
-    Tr: TraceReader<Batch: Navigable>+Clone+'static,
+    Tr: TraceReader<Payload: Navigable>+Clone+'static,
     for<'a> BatchCursor<Tr>: Cursor<Key<'a>=&'a N, Val<'a>=&'a N, Time=Tr::Time, Diff=isize>,
 {
     // initialize roots as reaching themselves at distance 0
diff --git a/differential-dataflow/src/algorithms/graphs/bijkstra.rs b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
index 4d2034382..ffdf55ee4 100644
--- a/differential-dataflow/src/algorithms/graphs/bijkstra.rs
+++ b/differential-dataflow/src/algorithms/graphs/bijkstra.rs
@@ -40,7 +40,7 @@ pub fn bidijkstra_arranged<'scope, N, Tr>(
 ) -> VecCollection<'scope, Tr::Time, ((N,N), u32)>
 where
     N: ExchangeData+Hash,
-    Tr: TraceReader<Batch: Navigable>+Clone+'static,
+    Tr: TraceReader<Payload: Navigable>+Clone+'static,
     for<'a> BatchCursor<Tr>: Cursor<Key<'a>=&'a N, Val<'a>=&'a N, Time=Tr::Time, Diff=isize>,
 {
     let outer = forward.stream.scope();
diff --git a/differential-dataflow/src/algorithms/graphs/propagate.rs b/differential-dataflow/src/algorithms/graphs/propagate.rs
index a691b3279..e865233ef 100644
--- a/differential-dataflow/src/algorithms/graphs/propagate.rs
+++ b/differential-dataflow/src/algorithms/graphs/propagate.rs
@@ -58,7 +58,7 @@ where
     R: Multiply<R, Output=R>,
     R: From<i8>,
     L: ExchangeData,
-    Tr: TraceReader<Batch: Navigable, Time: Hash>+Clone+'static,
+    Tr: TraceReader<Payload: Navigable, Time: Hash>+Clone+'static,
     for<'a> BatchCursor<Tr>: Cursor<Key<'a>=&'a N, Val<'a>=&'a N, Time=Tr::Time, Diff=R>,
     F: Fn(&L)->u64+Clone+'static,
 {
diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index b01b92ca6..1236586a4 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -783,9 +783,9 @@ pub mod vec {
         /// ```
         pub fn reduce_abelian<L, Bu, T2>(self, name: &str, mut logic: L) -> Arranged<'scope, TraceAgent<T2>>
         where
-            T2: Trace<Batch: Navigable, Time=T>+'static,
+            T2: Trace<Payload: 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 = crate::trace::BatchOf<T2>> + 'static,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(V, BatchDiff<T2>)>)+'static,
         {
             self.reduce_core::<_,Bu,T2>(name, move |key, input, output, change| {
@@ -803,9 +803,9 @@ pub mod vec {
         pub fn reduce_core<L, Bu, T2>(self, name: &str, logic: L) -> Arranged<'scope, TraceAgent<T2>>
         where
             V: Clone+'static,
-            T2: Trace<Batch: Navigable, Time=T>+'static,
+            T2: Trace<Payload: 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 = crate::trace::BatchOf<T2>> + '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))
@@ -966,9 +966,9 @@ pub mod vec {
         pub fn consolidate_named<Ba, Bu, Tr, F>(self, name: &str, reify: F) -> Self
         where
             Ba: crate::trace::Batcher<Output=Vec<((D, ()), T, R)>, Time=T> + 'static,
-            Tr: crate::trace::Trace<Batch: Navigable, Time=T>+'static,
+            Tr: crate::trace::Trace<Payload: 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=crate::trace::BatchOf<Tr>>,
             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 = crate::trace::BatchOf<Tr>>,
             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 = crate::trace::BatchOf<Tr>>,
             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());
@@ -1244,7 +1244,7 @@ pub mod vec {
         /// ```
         pub fn join_core<Tr2,I,L,R2> (self, stream2: Arranged<'scope, Tr2>, result: L) -> Collection<'scope, T,I::Item,<R as Multiply<R2>>::Output>
         where
-            Tr2: crate::trace::TraceReader<Batch: Navigable, Time=T>+Clone+'static,
+            Tr2: crate::trace::TraceReader<Payload: Navigable, Time=T>+Clone+'static,
             for<'a> BatchCursor<Tr2>: Cursor<Key<'a>=&'a K>,
             // Pin the cursor diff to a named param `R2`: a `Multiply` bound on a projection does not
             // connect to its use-site (the solver normalizes the use but not the bound's subject).
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..3e7ac3ee0 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();
@@ -798,7 +791,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 +807,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 +824,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 +855,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..2db1177e7 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::{Batch, Trace, TraceReader};
 
 use timely::scheduling::Activator;
 
@@ -38,7 +38,7 @@ pub struct TraceAgent<Tr: TraceReader> {
 impl<Tr: TraceReader> TraceReader for TraceAgent<Tr> {
 
     type Time = Tr::Time;
-    type Batch = Tr::Batch;
+    type Payload = Tr::Payload;
 
     fn set_logical_compaction(&mut self, frontier: AntichainRef<Tr::Time>) {
         // This method does not enforce that `frontier` is greater or equal to `self.logical_compaction`.
@@ -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>> {
+    fn batches_through(&mut self, frontier: AntichainRef<'_, Tr::Time>) -> Option<Vec<Batch<Tr::Time, Tr::Payload>>> {
         self.trace.borrow_mut().trace.batches_through(frontier)
     }
-    fn map_batches<F: FnMut(&Self::Batch)>(&self, f: F) { self.trace.borrow().trace.map_batches(f) }
+    fn map_batches<F: FnMut(&Batch<Tr::Time, Tr::Payload>)>(&self, f: F) { self.trace.borrow().trace.map_batches(f) }
 }
 
 impl<Tr: TraceReader> TraceAgent<Tr> {
@@ -441,7 +441,11 @@ impl<Tr: TraceReader+'static> TraceAgent<Tr> {
                                     TraceReplayInstruction::Batch(batch, hint) => {
                                         if !hint.is_empty() && !batch.is_empty() {
                                             let delayed = capabilities.delayed_stamp(&hint);
-                                            output.session(&delayed).give(BatchFrontier::make_from(batch, since.borrow(), until.borrow()));
+                                            let wrapped = Batch::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..0cb441c0c 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, BatchOf, Trace, TraceReader, Navigable, Batcher, Builder, Cursor, BatchCursor, BatchDiff, BatchKey, BatchVal, BatchValOwn};
 
-use trace::wrappers::enter::{TraceEnter, BatchEnter,};
+use trace::wrappers::enter::{TraceEnter, enter_batch};
 
 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<BatchOf<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(|bw| enter_batch(bw)),
             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(BatchOf<Tr>) -> I+'static,
     {
         self.stream.unary(Pipeline, "AsContainer", move |_,_| move |input, output| {
             input.for_each(|time, data| {
@@ -120,7 +120,7 @@ impl<'scope, Tr: TraceReader> Arranged<'scope, Tr> {
     /// 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>>
         where
-            Tr::Batch: Navigable,
+            Tr::Payload: Navigable,
             BatchCursor<Tr>: Cursor<Time = Tr::Time>,
             L: FnMut(BatchKey<'_, Tr>, BatchVal<'_, Tr>) -> D+'static,
     {
@@ -140,7 +140,7 @@ impl<'scope, Tr: TraceReader> Arranged<'scope, Tr> {
     where
         K: crate::ExchangeData,
         V: crate::ExchangeData,
-        Tr::Batch: Navigable,
+        Tr::Payload: Navigable,
         BatchCursor<Tr>: Cursor<Time = Tr::Time>,
         for<'a> BatchCursor<Tr>: Cursor<Key<'a> = &'a K, Val<'a> = &'a V>,
     {
@@ -153,7 +153,7 @@ impl<'scope, Tr: TraceReader> Arranged<'scope, Tr> {
     /// filtering or flat mapping as part of the extraction.
     pub fn flat_map_ref<I, L>(self, logic: L) -> VecCollection<'scope, Tr::Time, I::Item, BatchDiff<Tr>>
         where
-            Tr::Batch: Navigable,
+            Tr::Payload: Navigable,
             BatchCursor<Tr>: Cursor<Time = Tr::Time>,
             I: IntoIterator<Item: Data>,
             L: FnMut(BatchKey<'_, Tr>, BatchVal<'_, Tr>) -> I+'static,
@@ -168,9 +168,9 @@ 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<BatchOf<Tr>>>, mut logic: L) -> VecCollection<'scope, Tr::Time, I::Item, BatchDiff<Tr>>
     where
-        Tr::Batch: Navigable,
+        Tr::Payload: Navigable,
         BatchCursor<Tr>: Cursor<Time = Tr::Time>,
         I: IntoIterator<Item: Data>,
         L: FnMut(BatchKey<'_, Tr>, BatchVal<'_, Tr>) -> I+'static,
@@ -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) {
@@ -202,13 +202,13 @@ impl<'scope, Tr: TraceReader> Arranged<'scope, Tr> {
 
 use crate::difference::Multiply;
 // Direct join implementations.
-impl<'scope, Tr1: TraceReader<Batch: Navigable>+'static> Arranged<'scope, Tr1> {
+impl<'scope, Tr1: TraceReader<Payload: Navigable>+'static> Arranged<'scope, Tr1> {
     /// A convenience method to join and produce `VecCollection` output.
     ///
     /// Avoid this method, as it is likely to evolve into one without the `VecCollection` opinion.
     pub fn join_core<Tr2,I,L,R1,R2,KC>(self, other: Arranged<'scope, Tr2>, mut result: L) -> VecCollection<'scope, Tr1::Time,I::Item,<R1 as Multiply<R2>>::Output>
     where
-        Tr2: TraceReader<Batch: Navigable, Time=Tr1::Time>+Clone+'static,
+        Tr2: TraceReader<Payload: Navigable, Time=Tr1::Time>+Clone+'static,
         // Pin the cursor diffs to named params `R1`/`R2`: a `Multiply` bound on a projection
         // does not connect to its use-site (the solver normalizes the use but not the bound's
         // subject), so we constrain plain params instead.
@@ -244,16 +244,16 @@ impl<'scope, Tr1: TraceReader<Batch: Navigable>+'static> Arranged<'scope, Tr1> {
 // Direct reduce implementations.
 use crate::difference::Abelian;
 use crate::trace::implementations::containers::BatchContainer;
-impl<'scope, Tr1: TraceReader<Batch: Navigable>+'static> Arranged<'scope, Tr1> {
+impl<'scope, Tr1: TraceReader<Payload: Navigable>+'static> Arranged<'scope, Tr1> {
     /// A direct implementation of `ReduceCore::reduce_abelian`.
     pub fn reduce_abelian<L, Bu, Tr2, KC, P>(self, name: &str, mut logic: L, push: P) -> Arranged<'scope, TraceAgent<Tr2>>
     where
-        Tr2: Trace<Batch: Navigable, Time=Tr1::Time>+'static,
+        Tr2: Trace<Payload: Navigable, Time=Tr1::Time>+'static,
         KC: BatchContainer,
         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 = BatchOf<Tr2>, 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,
     {
@@ -269,12 +269,12 @@ impl<'scope, Tr1: TraceReader<Batch: Navigable>+'static> Arranged<'scope, Tr1> {
     /// A direct implementation of `ReduceCore::reduce_core`.
     pub fn reduce_core<L, Bu, Tr2, KC, P>(self, name: &str, logic: L, push: P) -> Arranged<'scope, TraceAgent<Tr2>>
     where
-        Tr2: Trace<Batch: Navigable, Time=Tr1::Time>+'static,
+        Tr2: Trace<Payload: Navigable, Time=Tr1::Time>+'static,
         KC: BatchContainer,
         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 = BatchOf<Tr2>, 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 = BatchOf<Tr>>,
         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 = BatchOf<Tr>>,
         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 = BatchOf<Tr>>,
     Tr: Trace+'static,
 {
     // The `Arrange` operator is tasked with reacting to an advancing input
diff --git a/differential-dataflow/src/operators/arrange/mod.rs b/differential-dataflow/src/operators/arrange/mod.rs
index e864cfda3..5a2a44399 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>),
+    Batch(crate::trace::BatchOf<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..dbed4e680 100644
--- a/differential-dataflow/src/operators/arrange/upsert.rs
+++ b/differential-dataflow/src/operators/arrange/upsert.rs
@@ -132,13 +132,13 @@ pub fn arrange_from_upsert<'scope, Bu, Tr, K, V>(
 where
     K: ExchangeData+Hashable+std::hash::Hash,
     V: ExchangeData,
-    Tr: Trace<Batch: Navigable, Time: TotalOrder+ExchangeData>+'static,
+    Tr: Trace<Payload: Navigable, Time: TotalOrder+ExchangeData>+'static,
     for<'a> BatchCursor<Tr>: Cursor<
         Key<'a> = &'a K,
         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 = crate::trace::BatchOf<Tr>>,
 {
     let mut reader: Option<TraceAgent<Tr>> = None;
 
@@ -231,7 +231,7 @@ where
 
                                 // Prepare a cursor to the existing arrangement, and a batch builder for
                                 // new stuff that we add.
-                                let batches = reader_local.batches_through(Antichain::new().borrow()).unwrap();
+                                let batches = reader_local.batches_through(Antichain::new().borrow()).unwrap().into_iter().filter_map(|b| b.inner).collect();
                                 let (mut trace_cursor, trace_storage) = crate::trace::cursor::cursor_list(batches);
                                 let mut builder = Bu::new();
                                 let mut key_con = <BatchCursor<Tr> as Cursor>::KeyContainer::with_capacity(1);
diff --git a/differential-dataflow/src/operators/arrange/writer.rs b/differential-dataflow/src/operators/arrange/writer.rs
index 21761c05e..518ea7479 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, Batch, BatchOf};
 
 use super::TraceAgentQueueWriter;
 use super::TraceReplayInstruction;
@@ -52,7 +52,7 @@ impl<Tr: Trace> TraceWriter<Tr> {
     /// 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>) {
+    pub fn insert(&mut self, batch: BatchOf<Tr>, hint: timely::progress::Stamp<Tr::Time>) {
 
         // Something is wrong if not a sequence.
         if !(&self.upper == batch.lower()) {
@@ -82,9 +82,11 @@ impl<Tr: Trace> TraceWriter<Tr> {
     }
 
     /// Inserts an empty batch up to `upper`.
+    ///
+    /// An empty batch is a description with no payload; anyone can construct one.
     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(Batch::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..115f5e1da 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 {
@@ -54,7 +54,7 @@ where
 
 impl<'scope, K, Tr> CountTotal<'scope, Tr::Time, K, BatchDiff<Tr>> for Arranged<'scope, Tr>
 where
-    Tr: TraceReader<Batch: Navigable, Time: TotalOrder> + Clone + 'static,
+    Tr: TraceReader<Payload: Navigable, Time: TotalOrder> + Clone + 'static,
     for<'a> BatchCursor<Tr>: Cursor<
         Key<'a> = &'a K,
         Val<'a> = &'a (),
@@ -96,8 +96,8 @@ where
 
                     let mut session = output.session(&caps);
 
-                    let (mut batch_cursor, batch_storage) = crate::trace::cursor::cursor_list(batch_storage);
-                    let (mut trace_cursor, trace_storage) = crate::trace::cursor::cursor_list(trace.batches_through(lower_limit.borrow()).unwrap());
+                    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().into_iter().filter_map(|b| b.inner).collect());
 
                     while let Some(key) = batch_cursor.get_key(&batch_storage) {
                         let mut count: Option<BatchDiff<Tr>> = None;
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..62e935e8f 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::{Batch, 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 payload of the batch it described,
+    /// or `None` when the batch 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<Batch<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(Batch::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..d1bf4eba6 100644
--- a/differential-dataflow/src/operators/int_proxy/vec_backend.rs
+++ b/differential-dataflow/src/operators/int_proxy/vec_backend.rs
@@ -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..22ffa419a 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,14 @@ 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> {
-    /// Prepare the join of two lists of batches into an iterator of output containers.
+pub trait JoinTactic<T, B0, B1, C> {
+    /// Prepare the join of two lists of batch payloads 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>>;
+    /// The inputs are payloads only: empty batches have nothing to join, and the caller retains their
+    /// descriptions for its own frontier accounting. 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: T) -> Box<dyn Iterator<Item = C>>;
 }
 
 /// Which input contributed the freshly-arrived batch of a deferred join unit.
@@ -62,8 +64,8 @@ pub enum Fresh {
 /// [`AsCollection`]: crate::collection::AsCollection
 pub fn join_traces<'scope, Tr1, Tr2, KC, L, CB>(arranged1: Arranged<'scope, Tr1>, arranged2: Arranged<'scope, Tr2>, name: &str, result: L) -> Stream<'scope, Tr1::Time, CB::Container>
 where
-    Tr1: TraceReader<Batch: Navigable>+'static,
-    Tr2: TraceReader<Batch: Navigable, Time = Tr1::Time>+'static,
+    Tr1: TraceReader<Payload: Navigable>+'static,
+    Tr2: TraceReader<Payload: Navigable, Time = Tr1::Time>+'static,
     KC: BatchContainer,
     BatchCursor<Tr1>: Cursor<Time = Tr1::Time, KeyContainer = KC>,
     for<'a> BatchCursor<Tr1>: Cursor<Key<'a> = KC::ReadItem<'a>>,
@@ -71,7 +73,7 @@ where
     L: FnMut(KC::ReadItem<'_>,BatchVal<'_, Tr1>,BatchVal<'_, Tr2>,Tr1::Time,&BatchDiff<Tr1>,&BatchDiff<Tr2>,&mut CB)+'static,
     CB: ContainerBuilder<Container: Default> + 'static,
 {
-    join_with_tactic(arranged1, arranged2, name, cursors::CursorTactic::<Tr1::Batch, Tr2::Batch, _, CB>::new(result))
+    join_with_tactic(arranged1, arranged2, name, cursors::CursorTactic::<Tr1::Payload, Tr2::Payload, _, CB>::new(result))
 }
 
 /// Drives an equijoin of two traces using a supplied [`JoinTactic`].
@@ -84,7 +86,7 @@ pub fn join_with_tactic<'scope, Tr1, Tr2, T, C>(arranged1: Arranged<'scope, Tr1>
 where
     Tr1: TraceReader+'static,
     Tr2: TraceReader<Time = Tr1::Time>+'static,
-    T: JoinTactic<Tr1::Batch, Tr2::Batch, C>+'static,
+    T: JoinTactic<Tr1::Time, Tr1::Payload, Tr2::Payload, C>+'static,
     C: Container + 'static,
 {
     // Rename traces for symmetry from here on out.
@@ -161,13 +163,15 @@ where
 
         // Load up deferred work joining each captured `trace2` batch against `trace1`.
         for batch2 in batch2_list.into_iter() {
+            // Empty batches carry no payload, and have nothing to join.
+            let Some(payload2) = 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();
+            let trace1_storage = trace1.batches_through(acknowledged1.borrow()).unwrap().into_iter().filter_map(|b| b.inner).collect();
             // 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![payload2], Fresh::Input1, capability.time().clone());
             todo1.push_back((CapabilitySet::from_elem(capability.clone()), work));
         }
 
@@ -222,11 +226,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(payload1) = 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 trace2_storage = trace2.batches_through(acknowledged2.borrow()).unwrap().into_iter().filter_map(|b| b.inner).collect();
+                                let work = tactic.prep(vec![payload1], trace2_storage, Fresh::Input0, meet.clone().expect("non-empty stamp"));
                                 todo0.push_back((capability.clone(), work));
                             }
 
@@ -276,11 +280,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(payload2) = 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 trace1_storage = trace1.batches_through(acknowledged1.borrow()).unwrap().into_iter().filter_map(|b| b.inner).collect();
+                                let work = tactic.prep(trace1_storage, vec![payload2], Fresh::Input1, meet.clone().expect("non-empty stamp"));
                                 todo1.push_back((capability.clone(), work));
                             }
 
@@ -407,10 +411,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 +421,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 +431,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..7995dd6a7 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::{Batch, BatchCursor, BatchDiff, BatchKey, BatchOf, 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 a payload's 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<Batch<T, B2>>, Antichain<T>);
 }
 
 /// A key-wise reduction of values in an input trace.
@@ -88,17 +91,17 @@ pub trait ReduceTactic<B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
 /// key's computation to another, and will likely introduce non-determinism.
 pub fn reduce_trace<'scope, Tr1, Bu, Tr2, KC, L, P>(trace: Arranged<'scope, Tr1>, name: &str, logic: L, push: P) -> Arranged<'scope, TraceAgent<Tr2>>
 where
-    Tr1: TraceReader<Batch: Navigable> + 'static,
-    Tr2: Trace<Batch: Navigable, Time = Tr1::Time> + 'static,
+    Tr1: TraceReader<Payload: Navigable> + 'static,
+    Tr2: Trace<Payload: Navigable, Time = Tr1::Time> + 'static,
     KC: BatchContainer,
     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 = BatchOf<Tr2>, 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,
 {
-    reduce_with_tactic(trace, name, cursors::CursorTactic::<Tr1::Batch, Tr2::Batch, Bu, L, P>::new(logic, push))
+    reduce_with_tactic(trace, name, cursors::CursorTactic::<Tr1::Payload, Tr2::Payload, Bu, L, P>::new(logic, push))
 }
 
 // The model-derived reference tactic and its entry point live in `mod reference`; re-exported here
@@ -117,7 +120,7 @@ pub fn reduce_with_tactic<'scope, Tr1, Tr2, T>(trace: Arranged<'scope, Tr1>, nam
 where
     Tr1: TraceReader + 'static,
     Tr2: Trace<Time = Tr1::Time> + 'static,
-    T: ReduceTactic<Tr1::Batch, Tr2::Batch> + 'static,
+    T: ReduceTactic<Tr1::Time, Tr1::Payload, Tr2::Payload> + 'static,
 {
     let mut result_trace = None;
 
@@ -189,15 +192,15 @@ where
 
                     // Acquire the pre-existing input and output batches preceding the interval. Batch handles
                     // are cheap to clone, so we fetch them whether or not the tactic finds work to do.
-                    let source_batches = source_trace.batches_through(lower_limit.borrow()).expect("failed to acquire source batches");
-                    let output_batches = output_reader.batches_through(lower_limit.borrow()).expect("failed to acquire output batches");
+                    let source_batches = source_trace.batches_through(lower_limit.borrow()).expect("failed to acquire source batches").into_iter().filter_map(|b| b.inner).collect();
+                    let output_batches = output_reader.batches_through(lower_limit.borrow()).expect("failed to acquire output batches").into_iter().filter_map(|b| b.inner).collect();
 
                     // The times the operator currently holds capabilities for, as an antichain.
                     let held: Antichain<Tr1::Time> = capabilities.iter().map(|c| c.time().clone()).collect();
 
                     // 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!(
@@ -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 = Batch<TimeOf<B1>, 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<Batch<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,7 +424,7 @@ 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()));
+                let description = Description::new(lower.clone(), upper.clone(), Antichain::from_elem(<TimeOf<B1> as Timestamp>::minimum()));
                 produced = Some(builder.done(description));
 
                 // Refresh pending keys and times.
@@ -432,8 +432,8 @@ mod cursors {
                 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);
@@ -794,15 +794,15 @@ pub(crate) mod reference {
     /// point to build on.
     pub fn reduce_trace_reference<'scope, Tr1, Bu, Tr2, L, P>(trace: Arranged<'scope, Tr1>, name: &str, logic: L, push: P) -> Arranged<'scope, TraceAgent<Tr2>>
     where
-        Tr1: TraceReader<Batch: Navigable> + 'static,
-        Tr2: Trace<Batch: Navigable, Time = Tr1::Time> + 'static,
+        Tr1: TraceReader<Payload: Navigable> + 'static,
+        Tr2: Trace<Payload: 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 = BatchOf<Tr2>, 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,
     {
-        reduce_with_tactic(trace, name, ReferenceTactic::<Tr1::Batch, Tr2::Batch, Bu, L, P>::new(logic, push))
+        reduce_with_tactic(trace, name, ReferenceTactic::<Tr1::Payload, Tr2::Payload, Bu, L, P>::new(logic, push))
     }
 
 
@@ -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 = Batch<TimeOf<B1>, 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<Batch<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()));
+                let description = Description::new(lower.clone(), upper.clone(), Antichain::from_elem(<TimeOf<B1> as Timestamp>::minimum()));
                 produced = Some(builder.done(description));
 
                 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..2db8c73b0 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 {
@@ -100,7 +100,7 @@ where
 
 impl<'scope, K, Tr> ThresholdTotal<'scope, Tr::Time, K, BatchDiff<Tr>> for Arranged<'scope, Tr>
 where
-    Tr: TraceReader<Batch: Navigable, Time: TotalOrder> + Clone + 'static,
+    Tr: TraceReader<Payload: Navigable, Time: TotalOrder> + Clone + 'static,
     for<'a> BatchCursor<Tr>: Cursor<
         Key<'a>=&'a K,
         Val<'a>=&'a (),
@@ -146,8 +146,8 @@ where
 
                     let mut session = output.session(&caps);
 
-                    let (mut batch_cursor, batch_storage) = crate::trace::cursor::cursor_list(batch_storage);
-                    let (mut trace_cursor, trace_storage) = crate::trace::cursor::cursor_list(trace.batches_through(lower_limit.borrow()).unwrap());
+                    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().into_iter().filter_map(|b| b.inner).collect());
 
                     while let Some(key) = batch_cursor.get_key(&batch_storage) {
                         let mut count: Option<BatchDiff<Tr>> = None;
diff --git a/differential-dataflow/src/trace/chunk/mod.rs b/differential-dataflow/src/trace/chunk/mod.rs
index 6c894b85b..e97ad3697 100644
--- a/differential-dataflow/src/trace/chunk/mod.rs
+++ b/differential-dataflow/src/trace/chunk/mod.rs
@@ -57,8 +57,8 @@ 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::implementations::spine_fueled::SpineBatch;
+use crate::trace::{Batch, Description, Navigable};
+use crate::trace::implementations::spine_fueled::SpinePayload;
 use crate::trace::cursor::Cursor;
 use crate::trace::implementations::BatchContainer;
 
@@ -238,21 +238,22 @@ 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 payload: an ordered [`Chunk`] sequence whose concatenation is the batch.
+///
+/// This is pure payload; the description of the times it covers travels alongside it,
+/// in the [`Batch`] that wraps it.
 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 {
+    /// Assemble a batch payload from ordered chunks.
+    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 +264,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>
+impl<C: Chunk + Default + 'static> SpinePayload 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)
@@ -299,8 +285,8 @@ pub type ChunkBatcher<C> = crate::trace::implementations::merge_batcher::MergeBa
 /// A spine of `Rc`-shared [`ChunkBatch`]es 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 payloads.
+pub type ChunkBuilder<C> = ChunkBatchBuilder<C>;
 
 /// A cursor over a [`ChunkBatch`], merging the per-chunk cursors.
 ///
@@ -576,9 +562,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 +585,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,
@@ -668,8 +647,7 @@ where
 
     fn done(self) -> 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)
+        ChunkBatch::new(self.settled.into())
     }
 }
 
@@ -688,7 +666,7 @@ where
 {
     type Input = C;
     type Time = C::Time;
-    type Output = ChunkBatch<C>;
+    type Output = Batch<C::Time, std::rc::Rc<ChunkBatch<C>>>;
 
     fn with_capacity(_keys: usize, _vals: usize, _upds: usize) -> Self {
         Self { input: VecDeque::new(), output: VecDeque::new() }
@@ -702,19 +680,26 @@ where
         }
     }
 
-    fn done(self, description: Description<C::Time>) -> ChunkBatch<C> {
+    fn done(self, description: Description<C::Time>) -> 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, description)
     }
 
-    fn seal(chain: &mut Vec<C>, description: Description<C::Time>) -> ChunkBatch<C> {
+    fn seal(chain: &mut Vec<C>, description: Description<C::Time>) -> 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)), description)
     }
 }
 
+/// Wraps settled chunks and a description as a batch, with an absent payload when empty.
+fn wrap<C: Chunk>(chunks: Vec<C>, description: Description<C::Time>) -> Batch<C::Time, std::rc::Rc<ChunkBatch<C>>> {
+    let inner = if chunks.is_empty() { None } else { Some(std::rc::Rc::new(ChunkBatch::new(chunks))) };
+    Batch::new(description, inner)
+}
+
 /// 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..40175f81f 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)> {
@@ -714,21 +707,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 +767,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..d930f9e70 100644
--- a/differential-dataflow/src/trace/cursor/mod.rs
+++ b/differential-dataflow/src/trace/cursor/mod.rs
@@ -33,8 +33,8 @@ pub trait Navigable {
     fn cursor(&self) -> Self::Cursor;
 }
 
-/// The cursor type for a trace's batches.
-pub type BatchCursor<Tr> = <<Tr as crate::trace::TraceReader>::Batch as Navigable>::Cursor;
+/// The cursor type for a trace's batch payloads.
+pub type BatchCursor<Tr> = <<Tr as crate::trace::TraceReader>::Payload as Navigable>::Cursor;
 
 /// The borrowed key type of a trace's batch cursor.
 pub type BatchKey<'a, Tr> = <BatchCursor<Tr> as Cursor>::Key<'a>;
@@ -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 a sequence of batch payloads.
 ///
-/// 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 payloads 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>(payloads: Vec<B>) -> (CursorList<B::Cursor>, Vec<B>) {
+    let cursors = payloads.iter().map(|payload| payload.cursor()).collect::<Vec<_>>();
+    let cursor = CursorList::new(cursors, &payloads);
+    (cursor, payloads)
 }
 
 /// 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/ord_neu.rs b/differential-dataflow/src/trace/implementations/ord_neu.rs
index e58271a60..69e43a7e9 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,18 @@ 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)>>>;
+///
+/// The builder emits `Rc`-shared payloads directly; there is no separate wrapping layer.
+pub type RcOrdValBuilder<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)>>>;
+///
+/// The builder emits `Rc`-shared payloads directly; there is no separate wrapping layer.
+pub type RcOrdKeyBuilder<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.
@@ -244,12 +247,13 @@ pub mod layers {
 pub mod val_batch {
 
     use std::marker::PhantomData;
+    use std::rc::Rc;
     use serde::{Deserialize, Serialize};
     use timely::container::PushInto;
     use timely::progress::{Antichain, frontier::AntichainRef};
 
-    use crate::trace::{Batch, BatchReader, Builder, Cursor, Description};
-    use crate::trace::implementations::spine_fueled::{SpineBatch, Merger};
+    use crate::trace::{Batch, Builder, Cursor, Description};
+    use crate::trace::implementations::spine_fueled::{SpinePayload, Merger};
     use crate::trace::implementations::{BatchContainer, BuilderInput};
     use crate::trace::implementations::layout;
 
@@ -273,10 +277,11 @@ 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.
+    /// An immutable batch payload of 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. This is pure payload:
+    /// the description of the times it covers travels alongside it, in the
+    /// [`Batch`](crate::trace::Batch) that wraps it.
     #[derive(Serialize, Deserialize)]
     #[serde(bound = "
         L::KeyContainer: Serialize + for<'a> Deserialize<'a>,
@@ -288,8 +293,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,38 +316,14 @@ pub mod val_batch {
         }
     }
 
-    impl<L: Layout> BatchReader for OrdValBatch<L> {
-
+    impl<L: Layout> SpinePayload 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>;
-
-        fn begin_merge(&self, other: &Self, compaction_frontier: AntichainRef<layout::Time<L>>) -> Self::Merger {
-            OrdValMerger::new(self, other, compaction_frontier)
-        }
-    }
-
-    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.
@@ -355,25 +334,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;
 
@@ -385,7 +354,7 @@ 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(),
             }
         }
@@ -393,7 +362,6 @@ pub mod val_batch {
             OrdValBatch {
                 updates: self.staging.total(),
                 storage: self.result,
-                description: self.description,
             }
         }
         fn work(&mut self, source1: &OrdValBatch<L>, source2: &OrdValBatch<L>, fuel: &mut isize) {
@@ -558,7 +526,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));
             }
         }
@@ -665,7 +633,7 @@ pub mod val_batch {
 
         type Input = CI;
         type Time = layout::Time<L>;
-        type Output = OrdValBatch<L>;
+        type Output = Batch<layout::Time<L>, Rc<OrdValBatch<L>>>;
 
         fn with_capacity(keys: usize, vals: usize, upds: usize) -> Self {
             Self {
@@ -713,14 +681,15 @@ pub mod val_batch {
         }
 
         #[inline(never)]
-        fn done(mut self, description: Description<Self::Time>) -> OrdValBatch<L> {
+        fn done(mut self, description: Description<Self::Time>) -> 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(),
+            let updates = self.staging.total();
+            let payload = OrdValBatch {
+                updates,
                 storage: self.result,
-                description,
-            }
+            };
+            Batch::new(description, if updates > 0 { Some(Rc::new(payload)) } else { None })
         }
 
         fn seal(chain: &mut Vec<Self::Input>, description: Description<Self::Time>) -> Self::Output {
@@ -739,12 +708,13 @@ pub mod val_batch {
 pub mod key_batch {
 
     use std::marker::PhantomData;
+    use std::rc::Rc;
     use serde::{Deserialize, Serialize};
     use timely::container::PushInto;
     use timely::progress::{Antichain, frontier::AntichainRef};
 
-    use crate::trace::{Batch, BatchReader, Builder, Cursor, Description};
-    use crate::trace::implementations::spine_fueled::{SpineBatch, Merger};
+    use crate::trace::{Batch, Builder, Cursor, Description};
+    use crate::trace::implementations::spine_fueled::{SpinePayload, Merger};
     use crate::trace::implementations::{BatchContainer, BuilderInput};
     use crate::trace::implementations::layout;
 
@@ -780,8 +750,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,
@@ -817,38 +785,14 @@ pub mod key_batch {
         }
     }
 
-    impl<L: Layout<ValContainer: BatchContainer<Owned: Default>>> BatchReader for OrdKeyBatch<L> {
-
+    impl<L: Layout<ValContainer: BatchContainer<Owned: Default>>> SpinePayload 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>;
-
-        fn begin_merge(&self, other: &Self, compaction_frontier: AntichainRef<layout::Time<L>>) -> Self::Merger {
-            OrdKeyMerger::new(self, other, compaction_frontier)
-        }
-    }
-
-    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.
@@ -859,26 +803,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;
 
@@ -889,7 +823,7 @@ 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(),
             }
         }
@@ -897,7 +831,6 @@ pub mod key_batch {
             OrdKeyBatch {
                 updates: self.staging.total(),
                 storage: self.result,
-                description: self.description,
                 value: OrdKeyBatch::<L>::create_value(),
             }
         }
@@ -983,7 +916,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));
             }
         }
@@ -1083,7 +1016,7 @@ pub mod key_batch {
 
         type Input = CI;
         type Time = layout::Time<L>;
-        type Output = OrdKeyBatch<L>;
+        type Output = Batch<layout::Time<L>, Rc<OrdKeyBatch<L>>>;
 
         fn with_capacity(keys: usize, _vals: usize, upds: usize) -> Self {
             Self {
@@ -1116,14 +1049,15 @@ pub mod key_batch {
         }
 
         #[inline(never)]
-        fn done(mut self, description: Description<Self::Time>) -> OrdKeyBatch<L> {
+        fn done(mut self, description: Description<Self::Time>) -> Self::Output {
             self.staging.seal(&mut self.result.upds);
-            OrdKeyBatch {
-                updates: self.staging.total(),
+            let updates = self.staging.total();
+            let payload = OrdKeyBatch {
+                updates,
                 storage: self.result,
-                description,
                 value: OrdKeyBatch::<L>::create_value(),
-            }
+            };
+            Batch::new(description, if updates > 0 { Some(Rc::new(payload)) } else { None })
         }
 
         fn seal(chain: &mut Vec<Self::Input>, description: Description<Self::Time>) -> Self::Output {
diff --git a/differential-dataflow/src/trace/implementations/spine_fueled.rs b/differential-dataflow/src/trace/implementations/spine_fueled.rs
index e3dec5693..26d44c3d7 100644
--- a/differential-dataflow/src/trace/implementations/spine_fueled.rs
+++ b/differential-dataflow/src/trace/implementations/spine_fueled.rs
@@ -1,8 +1,8 @@
 //! An append-only collection of update batches.
 //!
 //! The `Spine` is a general-purpose trace implementation based on collection and merging
-//! immutable batches of updates. It is generic with respect to the batch type, and can be
-//! instantiated for any implementor of [`SpineBatch`].
+//! immutable batches of updates. It is generic with respect to the batch payload type, and
+//! can be instantiated for any implementor of [`SpinePayload`].
 //!
 //! ## Design
 //!
@@ -68,65 +68,73 @@
 //! 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::{Batch, 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 batch payloads.
 ///
-/// 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 {
-    /// A type used to progressively merge batches.
+/// These are opinions of this spine, not properties of payloads in general: payloads
+/// must support progressive (fuel-limited) merging through a [`Merger`], and must report
+/// their size, which drives the spine's geometric layering and its logging. Descriptions
+/// are none of the payload's business: the spine computes the description of each merge
+/// result itself, from the descriptions of the inputs and the compaction frontier.
+pub trait SpinePayload : Sized {
+    /// The timestamp type of the payload's updates.
+    type Time: Timestamp + Lattice;
+
+    /// A type used to progressively merge payloads.
     type Merger: Merger<Self>;
 
-    /// Initiates the merging of consecutive batches.
+    /// The number of updates in the payload.
     ///
-    /// The result of this method can be exercised to eventually produce the same result
-    /// that a call to `self.merge(other)` would produce, but it can be done in a measured
-    /// fashion. This can help to avoid latency spikes where a large merge needs to happen.
-    fn begin_merge(&self, other: &Self, compaction_frontier: AntichainRef<Self::Time>) -> Self::Merger {
-        Self::Merger::new(self, other, compaction_frontier)
-    }
+    /// Absent payloads stand in for zero updates, so implementors should expect this
+    /// to be positive; the spine does not require it.
+    fn len(&self) -> usize;
 }
 
 /// Represents a merge in progress.
-pub trait Merger<Output: SpineBatch> {
-    /// Creates a new merger to merge the supplied batches, optionally compacting
+pub trait Merger<P: SpinePayload> {
+    /// Creates a new merger to merge the supplied payloads, optionally compacting
     /// up to the supplied frontier.
-    fn new(source1: &Output, source2: &Output, compaction_frontier: AntichainRef<Output::Time>) -> Self;
+    fn new(source1: &P, source2: &P, compaction_frontier: AntichainRef<P::Time>) -> Self;
     /// Perform some amount of work, decrementing `fuel`.
     ///
     /// 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);
+    fn work(&mut self, source1: &P, source2: &P, fuel: &mut isize);
     /// Extracts merged results.
     ///
     /// 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) -> P;
 }
 
-impl<B: SpineBatch> SpineBatch for Rc<B> {
-    type Merger = RcMerger<B>;
+impl<P: SpinePayload> SpinePayload for Rc<P> {
+    type Time = P::Time;
+    type Merger = RcMerger<P>;
+    fn len(&self) -> usize { (**self).len() }
 }
 
-/// Wrapper type for merging reference counted batches.
-pub struct RcMerger<B: SpineBatch> { merger: B::Merger }
+/// Wrapper type for merging reference counted payloads.
+pub struct RcMerger<P: SpinePayload> { merger: P::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::begin_merge(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()) }
+impl<P: SpinePayload> Merger<Rc<P>> for RcMerger<P> {
+    fn new(source1: &Rc<P>, source2: &Rc<P>, compaction_frontier: AntichainRef<P::Time>) -> Self { RcMerger { merger: P::Merger::new(source1, source2, compaction_frontier) } }
+    fn work(&mut self, source1: &Rc<P>, source2: &Rc<P>, fuel: &mut isize) { self.merger.work(source1, source2, fuel) }
+    fn done(self) -> Rc<P> { Rc::new(self.merger.done()) }
+}
+
+/// The number of updates in a batch: the payload's length, or zero when absent.
+fn batch_len<P: SpinePayload>(batch: &Batch<P::Time, P>) -> usize {
+    batch.inner.as_ref().map(|p| p.len()).unwrap_or(0)
 }
 
 /// An append-only collection of update tuples.
@@ -134,14 +142,14 @@ impl<B: SpineBatch> Merger<Rc<B>> for RcMerger<B> {
 /// A spine maintains a small number of immutable collections of update tuples, merging the collections when
 /// two have similar sizes. In this way, it allows the addition of more tuples, which may then be merged with
 /// other immutable collections.
-pub struct Spine<B: SpineBatch> {
+pub struct Spine<P: SpinePayload> {
     operator: OperatorInfo,
     logger: Option<Logger>,
-    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`.
-    upper: Antichain<B::Time>,
+    logical_frontier: Antichain<P::Time>,   // Times after which the trace must accumulate correctly.
+    physical_frontier: Antichain<P::Time>,  // Times after which the trace must be able to subset its inputs.
+    merging: Vec<MergeState<P>>,            // Several possibly shared collections of updates.
+    pending: Vec<Batch<P::Time, P>>,        // Batches at times in advance of `frontier`.
+    upper: Antichain<P::Time>,
     effort: usize,
     activator: Option<timely::scheduling::activate::Activator>,
     /// Parameters to `exert_logic`, containing tuples of `(index, count, length)`.
@@ -150,12 +158,12 @@ pub struct Spine<B: SpineBatch> {
     exert_logic: Option<ExertionLogic>,
 }
 
-impl<B: SpineBatch+Clone+'static> TraceReader for Spine<B> {
+impl<P: SpinePayload+Clone+'static> TraceReader for Spine<P> {
 
-    type Time = B::Time;
-    type Batch = B;
+    type Time = P::Time;
+    type Payload = P;
 
-    fn batches_through(&mut self, upper: AntichainRef<Self::Time>) -> Option<Vec<Self::Batch>> {
+    fn batches_through(&mut self, upper: AntichainRef<Self::Time>) -> Option<Vec<Batch<Self::Time, P>>> {
 
         // 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
@@ -179,7 +187,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();
@@ -188,7 +195,7 @@ impl<B: SpineBatch+Clone+'static> TraceReader for Spine<B> {
             match merge_state {
                 MergeState::Double(variant) => {
                     match variant {
-                        MergeVariant::InProgress(batch1, batch2, _) => {
+                        MergeVariant::InProgress(batch1, batch2, _, _) => {
                             if !batch1.is_empty() {
                                 storage.push(batch1.clone());
                             }
@@ -243,14 +250,14 @@ impl<B: SpineBatch+Clone+'static> TraceReader for Spine<B> {
         Some(storage)
     }
     #[inline]
-    fn set_logical_compaction(&mut self, frontier: AntichainRef<B::Time>) {
+    fn set_logical_compaction(&mut self, frontier: AntichainRef<P::Time>) {
         self.logical_frontier.clear();
         self.logical_frontier.extend(frontier.iter().cloned());
     }
     #[inline]
-    fn get_logical_compaction(&mut self) -> AntichainRef<'_, B::Time> { self.logical_frontier.borrow() }
+    fn get_logical_compaction(&mut self) -> AntichainRef<'_, P::Time> { self.logical_frontier.borrow() }
     #[inline]
-    fn set_physical_compaction(&mut self, frontier: AntichainRef<'_, B::Time>) {
+    fn set_physical_compaction(&mut self, frontier: AntichainRef<'_, P::Time>) {
         // We should never request to rewind the frontier.
         debug_assert!(PartialOrder::less_equal(&self.physical_frontier.borrow(), &frontier), "FAIL\tthrough frontier !<= new frontier {:?} {:?}\n", self.physical_frontier, frontier);
         self.physical_frontier.clear();
@@ -258,13 +265,13 @@ impl<B: SpineBatch+Clone+'static> TraceReader for Spine<B> {
         self.consider_merges();
     }
     #[inline]
-    fn get_physical_compaction(&mut self) -> AntichainRef<'_, B::Time> { self.physical_frontier.borrow() }
+    fn get_physical_compaction(&mut self) -> AntichainRef<'_, P::Time> { self.physical_frontier.borrow() }
 
     #[inline]
-    fn map_batches<F: FnMut(&Self::Batch)>(&self, mut f: F) {
+    fn map_batches<F: FnMut(&Batch<Self::Time, P>)>(&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) },
                 _ => { },
@@ -276,9 +283,7 @@ 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> {
+impl<P: SpinePayload+Clone+'static> Trace for Spine<P> {
     fn new(
         info: ::timely::dataflow::operators::generic::OperatorInfo,
         logging: Option<crate::logging::Logger>,
@@ -320,12 +325,12 @@ impl<B: SpineBatch+Clone+'static> Trace for Spine<B> {
     // 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) {
+    fn insert(&mut self, batch: Batch<Self::Time, P>) {
 
         // 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: batch_len(&batch)
         }));
 
         assert!(batch.lower() != batch.upper());
@@ -341,20 +346,20 @@ impl<B: SpineBatch+Clone+'static> Trace for Spine<B> {
     /// 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(Batch::empty(self.upper.clone(), Antichain::new()));
         }
     }
 }
 
 // Drop implementation allows us to log batch drops, to zero out maintained totals.
-impl<B: SpineBatch> Drop for Spine<B> {
+impl<P: SpinePayload> Drop for Spine<P> {
     fn drop(&mut self) {
         self.drop_batches();
     }
 }
 
 
-impl<B: SpineBatch> Spine<B> {
+impl<P: SpinePayload> Spine<P> {
     /// Drops and logs batches. Used in `set_logical_compaction` and drop.
     fn drop_batches(&mut self) {
         if let Some(logger) = &self.logger {
@@ -363,23 +368,23 @@ impl<B: SpineBatch> Spine<B> {
                     MergeState::Single(Some(batch)) => {
                         logger.log(crate::logging::DropEvent {
                             operator: self.operator.global_id,
-                            length: batch.len(),
+                            length: batch_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: batch_len(&batch1),
                         });
                         logger.log(crate::logging::DropEvent {
                             operator: self.operator.global_id,
-                            length: batch2.len(),
+                            length: batch_len(&batch2),
                         });
                     },
                     MergeState::Double(MergeVariant::Complete(Some((batch, _)))) => {
                         logger.log(crate::logging::DropEvent {
                             operator: self.operator.global_id,
-                            length: batch.len(),
+                            length: batch_len(&batch),
                         });
                     }
                     _ => { },
@@ -388,14 +393,14 @@ 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: batch_len(&batch),
                 });
             }
         }
     }
 }
 
-impl<B: SpineBatch> Spine<B> {
+impl<P: SpinePayload> Spine<P> {
     /// Determine the amount of effort we should exert in the absence of updates.
     ///
     /// This method prepares an iterator over batches, including the level, count, and length of each layer.
@@ -433,11 +438,11 @@ impl<B: SpineBatch> Spine<B> {
         Spine {
             operator,
             logger,
-            logical_frontier: Antichain::from_elem(<B::Time as timely::progress::Timestamp>::minimum()),
-            physical_frontier: Antichain::from_elem(<B::Time as timely::progress::Timestamp>::minimum()),
+            logical_frontier: Antichain::from_elem(<P::Time as timely::progress::Timestamp>::minimum()),
+            physical_frontier: Antichain::from_elem(<P::Time as timely::progress::Timestamp>::minimum()),
             merging: Vec::new(),
             pending: Vec::new(),
-            upper: Antichain::from_elem(<B::Time as timely::progress::Timestamp>::minimum()),
+            upper: Antichain::from_elem(<P::Time as timely::progress::Timestamp>::minimum()),
             effort,
             activator,
             exert_logic_param: Vec::default(),
@@ -455,7 +460,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.
@@ -464,7 +468,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 batch.as_ref().unwrap().is_empty() {
                 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);
@@ -476,7 +480,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 = batch_len(&batch).next_power_of_two();
                 self.introduce_batch(Some(batch), index.trailing_zeros() as usize);
             }
         }
@@ -494,7 +498,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<Batch<P::Time, P>>, batch_index: usize) {
 
         // Step 0.  Determine an amount of fuel to use for the computation.
         //
@@ -645,7 +649,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<Batch<P::Time, P>>, index: usize) {
         // Ensure the spine is large enough.
         while self.merging.len() <= index {
             self.merging.push(MergeState::Vacant);
@@ -662,8 +666,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(batch_len).unwrap_or(0),
+                        length2: batch.as_ref().map(batch_len).unwrap_or(0),
                         complete: None,
                     }
                 ));
@@ -677,7 +681,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<Batch<P::Time, P>> {
         if let Some((merged, inputs)) = self.merging[index].complete() {
             if let Some((input1, input2)) = inputs {
                 // Log the completion of a merge from existing parts.
@@ -685,9 +689,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: batch_len(&input1),
+                        length2: batch_len(&input2),
+                        complete: Some(batch_len(&merged)),
                     }
                 ));
             }
@@ -768,26 +772,31 @@ impl<B: SpineBatch> Spine<B> {
 ///
 /// 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.
-enum MergeState<B: SpineBatch> {
+///
+/// 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 batch whose `inner` is `None` is a *recorded* empty
+/// interval of time, with a real description.
+enum MergeState<P: SpinePayload> {
     /// An empty layer, containing no updates.
     Vacant,
     /// A layer containing a single batch.
     ///
     /// The `None` variant is used to represent a structurally empty batch present
     /// to ensure the progress of maintenance work.
-    Single(Option<B>),
+    Single(Option<Batch<P::Time, P>>),
     /// A layer containing two batches, in the process of merging.
-    Double(MergeVariant<B>),
+    Double(MergeVariant<P>),
 }
 
-impl<B: SpineBatch<Time: Eq>> MergeState<B> {
+impl<P: SpinePayload> MergeState<P> {
 
     /// 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)) => batch_len(b),
+            MergeState::Double(MergeVariant::InProgress(b1,b2,_,_)) => batch_len(b1) + batch_len(b2),
+            MergeState::Double(MergeVariant::Complete(Some((b, _)))) => batch_len(b),
             _ => 0,
         }
     }
@@ -815,7 +824,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<(Batch<P::Time, P>, Option<(Batch<P::Time, P>, Batch<P::Time, P>)>)>  {
         match std::mem::replace(self, MergeState::Vacant) {
             MergeState::Vacant => None,
             MergeState::Single(batch) => batch.map(|b| (b, None)),
@@ -855,19 +864,39 @@ impl<B: SpineBatch<Time: Eq>> MergeState<B> {
     /// The upper frontier of the old batch should match the lower
     /// frontier of the new batch, with the resulting batch describing
     /// their composed interval, from the lower frontier of the old
-    /// batch to the upper frontier of the new batch.
+    /// batch to the upper frontier of the new batch. The spine composes
+    /// that description here, from the input descriptions and the
+    /// compaction frontier; the payload merger is description-free.
     ///
     /// 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<Batch<P::Time, P>>, batch2: Option<Batch<P::Time, P>>, compaction_frontier: AntichainRef<P::Time>) -> MergeState<P> {
         let variant =
         match (batch1, batch2) {
             (Some(batch1), Some(batch2)) => {
                 assert!(batch1.upper() == batch2.lower());
-                let begin_merge = <B as SpineBatch>::begin_merge(&batch1, &batch2, compaction_frontier);
-                MergeVariant::InProgress(batch1, batch2, begin_merge)
+                // The result's `since` joins the input sinces with the compaction frontier:
+                // the inputs' times may already be advanced through their own sinces, and
+                // the description must not claim more history than the payload retains.
+                let since = batch1.since().join(batch2.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 = P::Merger::new(source1, source2, description.since().borrow());
+                        MergeVariant::InProgress(batch1, batch2, description, merger)
+                    }
+                    // At most one payload exists: the merge is just the union description
+                    // wrapped around whichever payload survives. Note that this forgoes the
+                    // opportunity to advance the surviving payload's times by the compaction
+                    // frontier, which a real merge would take; a one-sided "advance" could
+                    // recover it.
+                    _ => {
+                        let inner = batch1.inner.or(batch2.inner);
+                        MergeVariant::Complete(Some((Batch::new(description, inner), None)))
+                    }
+                }
             }
             (None, Some(x)) => MergeVariant::Complete(Some((x, None))),
             (Some(x), None) => MergeVariant::Complete(Some((x, None))),
@@ -878,20 +907,24 @@ impl<B: SpineBatch<Time: Eq>> MergeState<B> {
     }
 }
 
-enum MergeVariant<B: SpineBatch> {
+enum MergeVariant<P: SpinePayload> {
     /// 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 payload merger itself.
+    InProgress(Batch<P::Time, P>, Batch<P::Time, P>, Description<P::Time>, P::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<(Batch<P::Time, P>, Option<(Batch<P::Time, P>, Batch<P::Time, P>)>)>),
 }
 
-impl<B: SpineBatch> MergeVariant<B> {
+impl<P: SpinePayload> MergeVariant<P> {
 
     /// Completes and extracts the batch, unless structurally empty.
     ///
     /// 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<(Batch<P::Time, P>, Option<(Batch<P::Time, P>, Batch<P::Time, P>)>)> {
         let mut fuel = isize::MAX;
         self.work(&mut fuel);
         if let MergeVariant::Complete(batch) = self { batch }
@@ -904,13 +937,16 @@ 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)))));
+                // The merged payload may have cancelled entirely; absence records that.
+                let merged = merge.done();
+                let inner = if merged.len() > 0 { Some(merged) } else { None };
+                *self = MergeVariant::Complete(Some((Batch::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..8ee7b0f81 100644
--- a/differential-dataflow/src/trace/mod.rs
+++ b/differential-dataflow/src/trace/mod.rs
@@ -27,6 +27,52 @@ 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 immutable collection of updates: a description of the times it covers, and an
+/// optional payload of updates themselves.
+///
+/// The description records the lower and upper bounds of contained update times, and a
+/// frontier `since` through which the times may have been advanced. The payload holds
+/// the updates, and is absent exactly when there are none: an "empty batch" is pure
+/// description, and anyone can construct one (see [`Batch::empty`]) — no capability of
+/// the payload type is involved.
+///
+/// The payload type is unconstrained here. Reading its contents is the [`Navigable`]
+/// capability; anything else (merging, sizing) is the business of whichever trace
+/// implementation holds it (for example the fueled spine's
+/// [`SpinePayload`](crate::trace::implementations::spine_fueled::SpinePayload)).
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+pub struct Batch<T, B> {
+    /// The lower and upper bounds of contained update times, and the compaction frontier.
+    pub desc: Description<T>,
+    /// The updates themselves; absent exactly when there are none.
+    pub inner: Option<B>,
+}
+
+impl<T, B> Batch<T, B> {
+    /// A batch from a description and an optional payload.
+    pub fn new(desc: Description<T>, inner: Option<B>) -> Self { Self { desc, inner } }
+    /// Describes the times of the updates in the batch.
+    pub fn description(&self) -> &Description<T> { &self.desc }
+    /// All times in the batch are greater or equal to an element of `lower`.
+    pub fn lower(&self) -> &Antichain<T> { self.desc.lower() }
+    /// All times in the batch are not greater or equal to any element of `upper`.
+    pub fn upper(&self) -> &Antichain<T> { self.desc.upper() }
+    /// Times in the batch may have been advanced through this frontier.
+    pub fn since(&self) -> &Antichain<T> { self.desc.since() }
+    /// True if the batch contains no updates.
+    pub fn is_empty(&self) -> bool { self.inner.is_none() }
+}
+
+impl<T: Timestamp, B> Batch<T, B> {
+    /// An empty batch over the indicated interval: a description with no payload.
+    pub fn empty(lower: Antichain<T>, upper: Antichain<T>) -> Self {
+        Self { desc: Description::new(lower, upper, Antichain::from_elem(T::minimum())), inner: None }
+    }
+}
+
+/// The batch type of a trace: [`Batch`] instantiated at the trace's time and payload.
+pub type BatchOf<Tr> = Batch<<Tr as TraceReader>::Time, <Tr as TraceReader>::Payload>;
+
 /// 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,11 +86,13 @@ 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 payload type of the trace's batches.
+    ///
+    /// This is the storage for a batch's updates; batches themselves are
+    /// [`Batch<Self::Time, Self::Payload>`](Batch), pairing an optional payload
+    /// with a description. Reading a payload's contents is the optional
+    /// [`Navigable`] capability, required only where cursors are taken.
+    type Payload: 'static + Clone;
 
     /// Acquires the non-empty sequence of batches covering updates at times not greater or equal to an
     /// element of `upper`.
@@ -53,7 +101,7 @@ pub trait TraceReader {
     /// 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>>;
+    fn batches_through(&mut self, upper: AntichainRef<Self::Time>) -> Option<Vec<Batch<Self::Time, Self::Payload>>>;
 
     /// Advances the frontier that constrains logical compaction.
     ///
@@ -108,7 +156,7 @@ pub trait TraceReader {
     ///
     /// 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);
+    fn map_batches<F: FnMut(&Batch<Self::Time, Self::Payload>)>(&self, f: F);
 
     /// Reads the upper frontier of committed times.
     ///
@@ -142,7 +190,7 @@ pub trait TraceReader {
 ///
 /// 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> {
+pub trait Trace : TraceReader {
 
     /// Allocates a new empty trace.
     fn new(
@@ -169,7 +217,7 @@ pub trait Trace : TraceReader<Batch: Batch> {
     ///
     /// This restriction could be relaxed, especially if we discover ways in which batch 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, batch: Batch<Self::Time, Self::Payload>);
 
     /// Introduces an empty batch concluding the trace.
     ///
@@ -178,41 +226,6 @@ pub trait Trace : TraceReader<Batch: Batch> {
     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
@@ -272,10 +285,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 +296,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 +349,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..117c9f5ec 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::{Batch, 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 batch to an inner batch: the description enters the scope, and the
+/// payload is wrapped for its readers to do the same.
+pub fn enter_batch<T: timely::progress::Timestamp, TInner: Refines<T>+Lattice, P>(batch: Batch<T, P>) -> Batch<TInner, BatchEnter<P, TInner>> {
+    Batch::new(enter_description(&batch.desc), batch.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 Payload = BatchEnter<Tr::Payload, TInner>;
 
-    fn map_batches<F: FnMut(&Self::Batch)>(&self, mut f: F) {
+    fn map_batches<F: FnMut(&Batch<TInner, Self::Payload>)>(&self, mut f: F) {
         self.trace.map_batches(|batch| {
-            f(&Self::Batch::make_from(batch.clone()));
+            f(&enter_batch(batch.clone()));
         })
     }
 
@@ -68,13 +83,13 @@ where
         self.stash2.borrow()
     }
 
-    fn batches_through(&mut self, upper: AntichainRef<TInner>) -> Option<Vec<Self::Batch>> {
+    fn batches_through(&mut self, upper: AntichainRef<TInner>) -> Option<Vec<Batch<TInner, Self::Payload>>> {
         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())
+        Some(storage.into_iter().map(enter_batch).collect())
     }
 }
 
@@ -94,46 +109,23 @@ where
 }
 
 
-/// Wrapper to provide batch to nested scope.
+/// Wrapper to provide a batch payload 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> {
-    /// The wrapped batch, whose times are those of the containing scope.
+    /// The wrapped payload, whose times are those of the containing scope.
     ///
     /// Each of its times enters the nested scope as `TInner::to_inner(time)`; that rule is the
-    /// whole of the wrapper's read-side semantics, and any reader of the wrapped batch must
+    /// whole of the wrapper's read-side semantics, and any reader of the wrapped payload 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 payload 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..45fffb837 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::{Batch, 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 Payload = BatchFrontier<Tr::Payload, Tr::Time>;
 
-    fn map_batches<F: FnMut(&Self::Batch)>(&self, mut f: F) {
+    fn map_batches<F: FnMut(&Batch<Tr::Time, Self::Payload>)>(&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_batches(|batch| {
+            let wrapped = Batch::new(
+                batch.desc.clone(),
+                batch.inner.clone().map(|p| BatchFrontier::make_from(p, 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>> {
+    fn batches_through(&mut self, upper: AntichainRef<'_, Tr::Time>) -> Option<Vec<Batch<Tr::Time, Self::Payload>>> {
         let storage = self.trace.batches_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(|batch| {
+            Batch::new(batch.desc, batch.inner.map(|p| BatchFrontier::make_from(p, since, until)))
+        }).collect())
     }
 }
 
@@ -67,23 +75,19 @@ impl<Tr: TraceReader> TraceFrontier<Tr> {
 }
 
 
-/// Wrapper to provide batch to nested scope.
+/// Wrapper to provide a batch payload to a nested scope.
 #[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 payload wrapper
+    pub fn make_from(batch: B, since: AntichainRef<T>, until: AntichainRef<T>) -> Self
+    where T: Clone,
+    {
         BatchFrontier {
             batch,
             since: since.to_owned(),
@@ -91,20 +95,22 @@ impl<B: BatchReader> BatchFrontier<B> {
         }
     }
 
-    /// The wrapped batch, whose times are neither advanced nor suppressed.
+    /// The wrapped payload, whose times are neither advanced nor suppressed.
     ///
     /// Its times must be presented through [`BatchFrontier::advance_time`], which is the whole of
     /// the wrapper's read-side semantics.
     pub fn inner(&self) -> &B { &self.batch }
 
-    /// Applies the wrapper's time semantics to a time of the wrapped batch.
+    /// Applies the wrapper's time semantics to a time of the wrapped payload.
     ///
     /// The time is advanced by `since`, which accumulates the updates at or before `since` rather
     /// than presenting them partially accumulated. The method returns whether the advanced time
     /// 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..b5353ffd2 100644
--- a/differential-dataflow/tests/int_proxy.rs
+++ b/differential-dataflow/tests/int_proxy.rs
@@ -29,7 +29,7 @@ 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>>>;
@@ -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) -> Batch<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..c663c16d6 100644
--- a/differential-dataflow/tests/trace.rs
+++ b/differential-dataflow/tests/trace.rs
@@ -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.batches_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.batches_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,7 +46,7 @@ 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.batches_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)]),
@@ -54,7 +54,7 @@ fn test_trace() {
     ]);
 
     let batches = trace.batches_through(Antichain::new().borrow()).unwrap();
-    let (mut cursor4, storage4) = cursor_list(batches);
+    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/count.rs b/dogsdogsdogs/src/operators/count.rs
index 3ab2bfbb5..55f22a546 100644
--- a/dogsdogsdogs/src/operators/count.rs
+++ b/dogsdogsdogs/src/operators/count.rs
@@ -25,7 +25,7 @@ pub fn count<'scope, Tr, K, F, P, R, FF>(
     strict: bool,
 ) -> VecCollection<'scope, Tr::Time, ((P, usize, usize), Tr::Time), R>
 where
-    Tr: TraceReader<Batch: Navigable, Time: std::hash::Hash>+Clone+'static,
+    Tr: TraceReader<Payload: Navigable, Time: std::hash::Hash>+Clone+'static,
     BatchCursor<Tr>: Cursor<Time = Tr::Time, Diff = isize>,
     <BatchCursor<Tr> as Cursor>::KeyContainer: BatchContainer<Owned=K>,
     K: Hashable + ExchangeData,
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index f1ee2a07d..5b8cfd482 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::Payload, CMid, C> + 'static,
     CIn: Container,
     C: Container + 'static,
 {
@@ -146,7 +146,7 @@ where
                 if !chunks.is_empty() {
                     // The batches are handed to the tactic, which holds them for as long as the
                     // work item lives; what it joins against cannot change underneath it.
-                    let batches = trace.batches_through(Antichain::new().borrow()).unwrap();
+                    let batches = trace.batches_through(Antichain::new().borrow()).unwrap().into_iter().filter_map(|b| b.inner).collect();
                     let lower: Antichain<Tr::Time> = caps.iter().map(|c| c.time().clone()).collect();
                     let work = tactic.prep(chunks, batches, lower);
                     todo.push_back((caps.clone(), work));
@@ -235,7 +235,7 @@ pub mod cursors {
         K: Hashable + ExchangeData,
         V: ExchangeData,
         R: ExchangeData + Semigroup,
-        Tr: TraceReader<Batch: Navigable>+Clone+'static,
+        Tr: TraceReader<Payload: Navigable>+Clone+'static,
         BatchCursor<Tr>: Cursor<Time = Tr::Time>,
         <BatchCursor<Tr> as Cursor>::KeyContainer: BatchContainer<Owned=K>,
         R: Mul<BatchDiff<Tr>, Output: Semigroup>,
@@ -297,7 +297,7 @@ pub mod cursors {
         K: Hashable + ExchangeData,
         V: ExchangeData,
         R: ExchangeData + Semigroup,
-        Tr: TraceReader<Batch: Navigable>+Clone+'static,
+        Tr: TraceReader<Payload: Navigable>+Clone+'static,
         BatchCursor<Tr>: Cursor<Time = Tr::Time>,
         <BatchCursor<Tr> as Cursor>::KeyContainer: BatchContainer<Owned=K>,
         FF: Fn(&Tr::Time, &mut Antichain<Tr::Time>) + 'static,
@@ -307,15 +307,17 @@ pub mod cursors {
     {
         // Updates are staged in a `BlobList` and joined by a cursor walk; the driver owns progress.
         let batcher = BlobList::<(K, V, Tr::Time), Tr::Time, R>::new(strict);
-        let tactic = CursorTactic::<K, V, R, Tr::Batch, S, CB>::new(output_func, strict);
+        let tactic = CursorTactic::<K, V, R, Tr::Payload, S, CB>::new(output_func, strict);
         // Updates are routed by key hash, matching how `arrangement` itself is distributed.
         let route = |update: &((K, V, Tr::Time), Tr::Time, R)| (update.0).0.hashed().into();
         let pact = Exchange::new(route);
         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/dogsdogsdogs/src/operators/propose.rs b/dogsdogsdogs/src/operators/propose.rs
index bbc709fca..997e040cb 100644
--- a/dogsdogsdogs/src/operators/propose.rs
+++ b/dogsdogsdogs/src/operators/propose.rs
@@ -27,7 +27,7 @@ pub fn propose<'scope, Tr, K, F, P, V, R, FF>(
     strict: bool,
 ) -> VecCollection<'scope, Tr::Time, ((P, V), Tr::Time), <R as Mul<BatchDiff<Tr>>>::Output>
 where
-    Tr: TraceReader<Batch: Navigable, Time: std::hash::Hash>+Clone+'static,
+    Tr: TraceReader<Payload: Navigable, Time: std::hash::Hash>+Clone+'static,
     BatchCursor<Tr>: Cursor<Time = Tr::Time, ValOwn = V>,
     <BatchCursor<Tr> as Cursor>::KeyContainer: BatchContainer<Owned=K>,
     K: Hashable + ExchangeData,
diff --git a/dogsdogsdogs/src/operators/validate.rs b/dogsdogsdogs/src/operators/validate.rs
index e12832eb7..c59358d76 100644
--- a/dogsdogsdogs/src/operators/validate.rs
+++ b/dogsdogsdogs/src/operators/validate.rs
@@ -27,7 +27,7 @@ pub fn validate<'scope, Tr, K, V, F, P, R, FF>(
     strict: bool,
 ) -> VecCollection<'scope, Tr::Time, ((P, V), Tr::Time), <R as Mul<BatchDiff<Tr>>>::Output>
 where
-    Tr: TraceReader<Batch: Navigable, Time: std::hash::Hash>+Clone+'static,
+    Tr: TraceReader<Payload: Navigable, Time: std::hash::Hash>+Clone+'static,
     BatchCursor<Tr>: Cursor<Time = Tr::Time>,
     <BatchCursor<Tr> as Cursor>::KeyContainer: BatchContainer<Owned=(K,V)>,
     K: ExchangeData + std::hash::Hash,
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..99104178c 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]
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)))
     }
 }