From 61b1308dd9bb34504b64481a2c8a2952e9ed59cf Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 21 Aug 2026 17:17:11 -0400
Subject: [PATCH] Batches as data: Batch<T, B> { desc, inner: Option<B> }

An exploratory replacement of the BatchReader and Batch traits with a
concrete struct: a batch is a Description plus an optional payload,
absent exactly when there are no updates. Payloads are unconstrained;
reading them is the Navigable capability, and everything else is the
business of whichever harness holds them.

Consequences, in rough order of significance:

* Empty batches are constructible by anyone (a description with no
  payload): Batch::empty is a constructor, not a capability, and the
  minting question (TraceWriter::seal, Spine::close) dissolves.
* Rc sharing is a payload type parameter, not a forwarding-impl family:
  rc_blanket_impls shrinks to the Navigable/cursor forwarding, and
  RcBuilder disappears (builders emit Rc payloads directly). External
  Arc newtypes would need no batch impls at all.
* Description algebra hoists out of the payload mergers into the spine:
  MergeState computes each merge result's description (adjacent lower/
  upper, sinces joined with the compaction frontier), and mergers become
  pure payload mergers handed a since. A merged payload that cancels
  entirely becomes an absent payload.
* len() leaves the public batch surface: its only consumers were the
  spine's accounting and logging, so it lives on SpinePayload (the
  renamed SpineBatch), alongside the Merger opinion.
* TraceReader grows a Payload associated type; Tr::Batch becomes the
  BatchOf<Tr> alias. The join/reduce/half-join tactics take payloads
  (empty batches have nothing to join) with an explicit time parameter,
  and the drivers keep descriptions for their frontier accounting.

The two kinds of nothing remain deliberately distinct in the spine:
MergeState::Single(None) is structural fuel bookkeeping with no
description at all; Batch { inner: None } is a recorded empty interval.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 differential-dataflow/examples/cursors.rs     |   2 +-
 .../examples/multitemporal.rs                 |   2 +-
 .../src/algorithms/graphs/bfs.rs              |   2 +-
 .../src/algorithms/graphs/bijkstra.rs         |   2 +-
 .../src/algorithms/graphs/propagate.rs        |   2 +-
 differential-dataflow/src/collection.rs       |  18 +-
 .../src/columnar/collection/operators.rs      |   1 +
 .../src/columnar/trace/chunk.rs               |  17 +-
 .../src/operators/arrange/agent.rs            |  14 +-
 .../src/operators/arrange/arrangement.rs      |  42 ++--
 .../src/operators/arrange/mod.rs              |   2 +-
 .../src/operators/arrange/upsert.rs           |   6 +-
 .../src/operators/arrange/writer.rs           |   8 +-
 differential-dataflow/src/operators/count.rs  |   8 +-
 .../src/operators/int_proxy/join.rs           |  60 +++--
 .../src/operators/int_proxy/reduce.rs         |  56 ++---
 .../src/operators/int_proxy/vec_backend.rs    |  16 +-
 differential-dataflow/src/operators/join.rs   |  67 ++---
 differential-dataflow/src/operators/reduce.rs | 133 +++++-----
 .../src/operators/threshold.rs                |   8 +-
 differential-dataflow/src/trace/chunk/mod.rs  |  71 +++---
 differential-dataflow/src/trace/chunk/vec.rs  |  26 +-
 differential-dataflow/src/trace/cursor/mod.rs |  18 +-
 .../src/trace/cursor/wrappers/enter.rs        |   7 +-
 .../src/trace/cursor/wrappers/frontier.rs     |  11 +-
 .../src/trace/implementations/ord_neu.rs      | 154 ++++--------
 .../src/trace/implementations/spine_fueled.rs | 238 ++++++++++--------
 differential-dataflow/src/trace/mod.rs        | 138 +++++-----
 .../src/trace/wrappers/enter.rs               |  64 +++--
 .../src/trace/wrappers/frontier.rs            |  50 ++--
 differential-dataflow/tests/int_proxy.rs      |  27 +-
 differential-dataflow/tests/trace.rs          |   8 +-
 dogsdogsdogs/src/operators/count.rs           |   2 +-
 dogsdogsdogs/src/operators/half_join.rs       |  31 +--
 dogsdogsdogs/src/operators/propose.rs         |   2 +-
 dogsdogsdogs/src/operators/validate.rs        |   2 +-
 interactive/src/backend/corgi.rs              |   3 +-
 interactive/src/corgi/chunk.rs                |  15 +-
 interactive/src/corgi/join.rs                 |  19 +-
 interactive/src/corgi/reduce.rs               |  19 +-
 40 files changed, 628 insertions(+), 743 deletions(-)

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)))
     }
 }