diff --git a/differential-dataflow/benches/chunk_bench.rs b/differential-dataflow/benches/chunk_bench.rs
index 073fec3e3..140610a24 100644
--- a/differential-dataflow/benches/chunk_bench.rs
+++ b/differential-dataflow/benches/chunk_bench.rs
@@ -26,7 +26,7 @@ use differential_dataflow::trace::chunk::{merge_chains, Chunk, NavigableChunk};
 use differential_dataflow::trace::chunk::vec::VecChunk;
 use differential_dataflow::columnar::trace::ColChunk;
 use differential_dataflow::trace::cursor::Cursor;
-use differential_dataflow::trace::implementations::merge_batcher::chunker::ContainerChunker;
+use differential_dataflow::batcher::merge::chunker::ContainerChunker;
 
 /// A global allocator that tracks currently-resident bytes, so we can snapshot
 /// the heap footprint of a built chunk chain.
diff --git a/differential-dataflow/examples/spines.rs b/differential-dataflow/examples/spines.rs
index ac10400dc..17732826c 100644
--- a/differential-dataflow/examples/spines.rs
+++ b/differential-dataflow/examples/spines.rs
@@ -81,7 +81,7 @@ fn main() {
                     use differential_dataflow::Hashable;
                     use differential_dataflow::columnar::trace::{Spine, ColChunk};
                     use differential_dataflow::trace::chunk::ChunkBatcher;
-                    use differential_dataflow::trace::implementations::merge_batcher::chunker::ContainerChunker;
+                    use differential_dataflow::batcher::merge::chunker::ContainerChunker;
                     use differential_dataflow::operators::arrange::arrangement::arrange_core;
                     use timely::dataflow::channels::pact::Exchange;
 
diff --git a/differential-dataflow/src/trace/implementations/merge_batcher/chunker.rs b/differential-dataflow/src/batcher/merge/chunker.rs
similarity index 96%
rename from differential-dataflow/src/trace/implementations/merge_batcher/chunker.rs
rename to differential-dataflow/src/batcher/merge/chunker.rs
index 7925e75ed..75d5c1c64 100644
--- a/differential-dataflow/src/trace/implementations/merge_batcher/chunker.rs
+++ b/differential-dataflow/src/batcher/merge/chunker.rs
@@ -1,4 +1,4 @@
-//! Organizes streams of data into sorted chunks for a merge batcher.
+//! Organizes streams of data into sorted chunks for a [`MergeBatcher`](super::MergeBatcher).
 
 use std::collections::VecDeque;
 
diff --git a/differential-dataflow/src/batcher/merge/mod.rs b/differential-dataflow/src/batcher/merge/mod.rs
new file mode 100644
index 000000000..4884e4c9d
--- /dev/null
+++ b/differential-dataflow/src/batcher/merge/mod.rs
@@ -0,0 +1,466 @@
+//! A `Batcher` implementation based on merge sort.
+//!
+//! The `MergeBatcher` requires a "merger" that implements the [`Merger`] trait, which provides
+//! hooks for manipulating sorted "chains" of chunks as needed by the merge batcher: merging
+//! chunks and also splitting them apart based on time.
+//!
+//! Raw input containers are fed to the batcher via [`Batcher::insert`], which chunks them with
+//! its `Chu` before merging: forming sorted, consolidated chunks is the first stage of the
+//! batcher's own work rather than something a caller arranges.
+
+pub mod chunker;
+
+use timely::container::{ContainerBuilder, PushInto};
+use timely::progress::frontier::AntichainRef;
+use timely::progress::{frontier::Antichain, Timestamp};
+
+use crate::logging::{BatcherEvent, Logger};
+use crate::batcher::Batcher;
+
+/// Creates batches from chunks of sorted, consolidated tuples.
+///
+/// Chunking input is `Chu`'s business, merging chunks is `M`'s, and sealing the extracted chain
+/// into a batch is `S`'s; the batcher's own work is the geometric ladder of chains and the
+/// carve-by-frontier.
+pub struct MergeBatcher<Chu, M: Merger, S> {
+    /// Melds input containers into sorted, consolidated chunks.
+    chunker: Chu,
+    /// Sorted, consolidated chains, each paired with its cached summed update count.
+    ///
+    /// The cached count is the chain's *merge weight*: the geometric ladder weighs
+    /// chains by updates, not chunk counts, since regrading decouples the two. A
+    /// chain is immutable until merged, so the weight is computed once at push.
+    ///
+    /// Do not push/pop directly but use the corresponding functions ([`Self::chain_push`]/[`Self::chain_pop`]).
+    chains: Vec<(usize, Vec<M::Chunk>)>,
+    /// Stash of empty chunks, recycled through the merging process.
+    stash: Vec<M::Chunk>,
+    /// Merges consolidated chunks, and extracts the subset of an update chain that lies in an interval of time.
+    merger: M,
+    /// The lower-bound frontier of the data, after the last call to extract.
+    frontier: Antichain<M::Time>,
+    /// Logger for size accounting.
+    logger: Option<Logger>,
+    /// Timely operator ID.
+    operator_id: usize,
+    /// Seals each extracted chain into a batch.
+    sealer: std::marker::PhantomData<S>,
+}
+
+impl<C, Chu, M, S> Batcher<C> for MergeBatcher<Chu, M, S>
+where
+    M: Merger<Time: Timestamp>,
+    Chu: ContainerBuilder<Container = M::Chunk> + for<'a> PushInto<&'a mut C>,
+    S: Sealer<M::Chunk>,
+{
+    type Time = M::Time;
+    type Output = S::Output;
+
+    fn insert(&mut self, container: &mut C) {
+        self.chunker.push_into(container);
+        while let Some(chunk) = self.chunker.extract().map(std::mem::take) {
+            self.insert_chain(vec![chunk]);
+        }
+    }
+
+    // Extraction means finding those updates with times not greater or equal to any time in
+    // `upper`. All updates must have time greater or equal to the previously used `upper`, by
+    // assumption that after extracting from a batcher we receive no more updates with times not
+    // greater or equal to `upper`.
+    fn extract<'a>(&'a mut self, upper: AntichainRef<'_, M::Time>) -> (Option<S::Output>, AntichainRef<'a, M::Time>) {
+        // Flush whatever the chunker is still accumulating: a partial final chunk would
+        // otherwise never reach the merge ladder.
+        while let Some(chunk) = self.chunker.finish().map(std::mem::take) {
+            self.insert_chain(vec![chunk]);
+        }
+
+        // Merge all remaining chains into a single chain.
+        while self.chains.len() > 1 {
+            let list1 = self.chain_pop().unwrap();
+            let list2 = self.chain_pop().unwrap();
+            let merged = self.merge_by(list1, list2);
+            self.chain_push(merged);
+        }
+        let merged = self.chain_pop().unwrap_or_default();
+
+        // Extract readied data.
+        let mut kept = Vec::new();
+        let mut readied = Vec::new();
+        self.frontier.clear();
+
+        self.merger.extract(merged, upper, &mut self.frontier, &mut readied, &mut kept, &mut self.stash);
+
+        if !kept.is_empty() {
+            self.chain_push(kept);
+        }
+
+        self.stash.clear();
+
+        (S::seal(&mut readied), self.frontier.borrow())
+    }
+}
+
+impl<Chu: Default, M: Merger, S> MergeBatcher<Chu, M, S> {
+    /// Allocates a new empty batcher.
+    ///
+    /// The logger and operator identifier are used to report the batcher's memory footprint,
+    /// attributed to the operator that owns it.
+    pub fn new(logger: Option<Logger>, operator_id: usize) -> Self {
+        Self {
+            logger,
+            operator_id,
+            merger: M::default(),
+            chunker: Chu::default(),
+            chains: Vec::new(),
+            stash: Vec::new(),
+            frontier: Antichain::new(),
+            sealer: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<Chu, M: Merger, S> MergeBatcher<Chu, M, S> {
+    /// Insert a chain and maintain chain properties: Chains are geometrically sized
+    /// (by summed updates) and ordered by decreasing update weight.
+    fn insert_chain(&mut self, chain: Vec<M::Chunk>) {
+        if !chain.is_empty() {
+            self.chain_push(chain);
+            while self.chains.len() > 1 && (self.chains[self.chains.len() - 1].0 >= self.chains[self.chains.len() - 2].0 / 2) {
+                let list1 = self.chain_pop().unwrap();
+                let list2 = self.chain_pop().unwrap();
+                let merged = self.merge_by(list1, list2);
+                self.chain_push(merged);
+            }
+        }
+    }
+
+    // merges two sorted input lists into one sorted output list.
+    fn merge_by(&mut self, list1: Vec<M::Chunk>, list2: Vec<M::Chunk>) -> Vec<M::Chunk> {
+        // TODO: `list1` and `list2` get dropped; would be better to reuse?
+        let mut output = Vec::with_capacity(list1.len() + list2.len());
+        self.merger.merge(list1, list2, &mut output, &mut self.stash);
+
+        output
+    }
+
+    /// Pop a chain and account size changes.
+    #[inline]
+    fn chain_pop(&mut self) -> Option<Vec<M::Chunk>> {
+        let (_weight, chain) = self.chains.pop()?;
+        self.account(chain.iter().map(Self::record), -1);
+        Some(chain)
+    }
+
+    /// Push a chain and account size changes.
+    ///
+    /// Caches the chain's summed update count alongside it for the ladder.
+    #[inline]
+    fn chain_push(&mut self, chain: Vec<M::Chunk>) {
+        let weight = chain.iter().map(M::len).sum();
+        self.account(chain.iter().map(Self::record), 1);
+        self.chains.push((weight, chain));
+    }
+
+    /// The `(records, size, capacity, allocations)` logger tuple for one chunk,
+    /// assembled from the two focused `Merger` methods.
+    #[inline]
+    fn record(chunk: &M::Chunk) -> (usize, usize, usize, usize) {
+        let (size, capacity, allocations) = M::allocation(chunk);
+        (M::len(chunk), size, capacity, allocations)
+    }
+
+    /// Account size changes. Only performs work if a logger exists.
+    ///
+    /// Calculate the size based on the iterator passed along, with each attribute
+    /// multiplied by `diff`. Usually, one wants to pass 1 or -1 as the diff.
+    #[inline]
+    fn account<I: IntoIterator<Item = (usize, usize, usize, usize)>>(&self, items: I, diff: isize) {
+        if let Some(logger) = &self.logger {
+            let (mut records, mut size, mut capacity, mut allocations) = (0isize, 0isize, 0isize, 0isize);
+            for (records_, size_, capacity_, allocations_) in items {
+                records = records.saturating_add_unsigned(records_);
+                size = size.saturating_add_unsigned(size_);
+                capacity = capacity.saturating_add_unsigned(capacity_);
+                allocations = allocations.saturating_add_unsigned(allocations_);
+            }
+            logger.log(BatcherEvent {
+                operator: self.operator_id,
+                records_diff: records * diff,
+                size_diff: size * diff,
+                capacity_diff: capacity * diff,
+                allocations_diff: allocations * diff,
+            })
+        }
+    }
+}
+
+impl<Chu, M: Merger, S> Drop for MergeBatcher<Chu, M, S> {
+    fn drop(&mut self) {
+        // Cleanup chain to retract accounting information.
+        while self.chain_pop().is_some() {}
+    }
+}
+
+/// A trait to describe interesting moments in a merge batcher.
+pub trait Merger: Default {
+    /// The internal representation of chunks of data.
+    type Chunk: Default;
+    /// The type of time in frontiers to extract updates.
+    type Time;
+    /// Merge chains into an output chain.
+    fn merge(&mut self, list1: Vec<Self::Chunk>, list2: Vec<Self::Chunk>, output: &mut Vec<Self::Chunk>, stash: &mut Vec<Self::Chunk>);
+    /// Extract ready updates based on the `upper` frontier.
+    fn extract(
+        &mut self,
+        merged: Vec<Self::Chunk>,
+        upper: AntichainRef<Self::Time>,
+        frontier: &mut Antichain<Self::Time>,
+        readied: &mut Vec<Self::Chunk>,
+        kept: &mut Vec<Self::Chunk>,
+        stash: &mut Vec<Self::Chunk>,
+    );
+
+    /// The number of updates in a chunk.
+    ///
+    /// Drives the geometric ladder (chains are weighed by summed updates, not chunk
+    /// counts, since regrading decouples the two) and the `records` field of the
+    /// size logger.
+    fn len(chunk: &Self::Chunk) -> usize;
+
+    /// Backing-allocation figures for a chunk: `(size, capacity, allocations)`, for
+    /// the size logger's memory telemetry.
+    ///
+    /// Defaults to zero — most chunk types do not track this. Override to report
+    /// real figures (e.g. Materialize's memory accounting).
+    fn allocation(_chunk: &Self::Chunk) -> (usize, usize, usize) { (0, 0, 0) }
+}
+
+/// Forms a batch from a whole chain of updates at once.
+///
+/// Named rather than a bare `fn(&mut Vec<C>) -> Option<B>` so that implementors can name the
+/// batch they produce. There is no receiver: the chain goes in and the batch comes out, leaving
+/// nowhere for an update to be retained.
+pub trait Sealer<C> {
+    /// Output batch type.
+    type Output;
+
+    /// Builds a batch from a chain of updates.
+    ///
+    /// This method relies on the chain only containing updates greater or equal to the lower frontier,
+    /// and not greater or equal to the upper frontier, of the interval the caller means to describe.
+    /// Chains must also be sorted and consolidated.
+    ///
+    /// Having the whole chain in hand, an implementor can size itself before it fills.
+    fn seal(chain: &mut Vec<C>) -> Option<Self::Output>;
+}
+
+/// A `Merger` implementation for vector update containers.
+pub mod vec {
+
+    use std::marker::PhantomData;
+    use timely::container::SizableContainer;
+    use timely::progress::frontier::{Antichain, AntichainRef};
+    use timely::PartialOrder;
+    use crate::batcher::merge::Merger;
+
+    /// A `Merger` implementation for `Vec<(D, T, R)>` that drains owned inputs.
+    pub struct VecMerger<D, T, R> {
+        _marker: PhantomData<(D, T, R)>,
+    }
+
+    impl<D, T, R> Default for VecMerger<D, T, R> {
+        fn default() -> Self { Self { _marker: PhantomData } }
+    }
+
+    impl<D, T, R> VecMerger<D, T, R> {
+        /// The target capacity for output buffers, as a power of two.
+        ///
+        /// This amount is used to size vectors, where vectors not exactly this capacity are dropped.
+        /// If this is mis-set, there is the potential for more memory churn than anticipated.
+        fn target_capacity() -> usize {
+            timely::container::buffer::default_capacity::<(D, T, R)>().next_power_of_two()
+        }
+        /// Acquire a buffer with the target capacity.
+        fn empty(&self, stash: &mut Vec<Vec<(D, T, R)>>) -> Vec<(D, T, R)> {
+            let target = Self::target_capacity();
+            let mut container = stash.pop().unwrap_or_default();
+            container.clear();
+            // Reuse if at target; otherwise allocate fresh.
+            if container.capacity() != target {
+                container = Vec::with_capacity(target);
+            }
+            container
+        }
+        /// Refill `queue` from `iter` if empty. Recycles drained queues into `stash`.
+        fn refill(queue: &mut std::collections::VecDeque<(D, T, R)>, iter: &mut impl Iterator<Item = Vec<(D, T, R)>>, stash: &mut Vec<Vec<(D, T, R)>>) {
+            if queue.is_empty() {
+                let target = Self::target_capacity();
+                if stash.len() < 2 {
+                    let mut recycled = Vec::from(std::mem::take(queue));
+                    recycled.clear();
+                    if recycled.capacity() == target {
+                        stash.push(recycled);
+                    }
+                }
+                if let Some(chunk) = iter.next() {
+                    *queue = std::collections::VecDeque::from(chunk);
+                }
+            }
+        }
+    }
+
+    impl<D, T, R> Merger for VecMerger<D, T, R>
+    where
+        D: Ord + Clone + 'static,
+        T: Ord + Clone + PartialOrder + 'static,
+        R: crate::difference::Semigroup + 'static,
+    {
+        type Chunk = Vec<(D, T, R)>;
+        type Time = T;
+
+        fn merge(
+            &mut self,
+            list1: Vec<Vec<(D, T, R)>>,
+            list2: Vec<Vec<(D, T, R)>>,
+            output: &mut Vec<Vec<(D, T, R)>>,
+            stash: &mut Vec<Vec<(D, T, R)>>,
+        ) {
+            use std::cmp::Ordering;
+            use std::collections::VecDeque;
+
+            let mut iter1 = list1.into_iter();
+            let mut iter2 = list2.into_iter();
+            let mut q1 = VecDeque::<(D,T,R)>::from(iter1.next().unwrap_or_default());
+            let mut q2 = VecDeque::<(D,T,R)>::from(iter2.next().unwrap_or_default());
+
+            let mut result = self.empty(stash);
+
+            // Merge while both queues are non-empty.
+            while let (Some((d1, t1, _)), Some((d2, t2, _))) = (q1.front(), q2.front()) {
+                match (d1, t1).cmp(&(d2, t2)) {
+                    Ordering::Less => {
+                        result.push(q1.pop_front().unwrap());
+                    }
+                    Ordering::Greater => {
+                        result.push(q2.pop_front().unwrap());
+                    }
+                    Ordering::Equal => {
+                        let (d, t, mut r1) = q1.pop_front().unwrap();
+                        let (_, _, r2) = q2.pop_front().unwrap();
+                        r1.plus_equals(&r2);
+                        if !r1.is_zero() {
+                            result.push((d, t, r1));
+                        }
+                    }
+                }
+
+                if result.at_capacity() {
+                    output.push(std::mem::take(&mut result));
+                    result = self.empty(stash);
+                }
+
+                // Refill emptied queues from their chains.
+                if q1.is_empty() { Self::refill(&mut q1, &mut iter1, stash); }
+                if q2.is_empty() { Self::refill(&mut q2, &mut iter2, stash); }
+            }
+
+            // Push partial result and remaining data from both sides.
+            if !result.is_empty() { output.push(result); }
+            for q in [q1, q2] {
+                if !q.is_empty() { output.push(Vec::from(q)); }
+            }
+            output.extend(iter1);
+            output.extend(iter2);
+        }
+
+        fn extract(
+            &mut self,
+            merged: Vec<Vec<(D, T, R)>>,
+            upper: AntichainRef<T>,
+            frontier: &mut Antichain<T>,
+            ship: &mut Vec<Vec<(D, T, R)>>,
+            kept: &mut Vec<Vec<(D, T, R)>>,
+            stash: &mut Vec<Vec<(D, T, R)>>,
+        ) {
+            let mut keep = self.empty(stash);
+            let mut ready = self.empty(stash);
+
+            for mut chunk in merged {
+                // Go update-by-update to swap out full containers.
+                for (data, time, diff) in chunk.drain(..) {
+                    if upper.less_equal(&time) {
+                        frontier.insert_with(&time, |time| time.clone());
+                        keep.push((data, time, diff));
+                    } else {
+                        ready.push((data, time, diff));
+                    }
+                    if keep.at_capacity() {
+                        kept.push(std::mem::take(&mut keep));
+                        keep = self.empty(stash);
+                    }
+                    if ready.at_capacity() {
+                        ship.push(std::mem::take(&mut ready));
+                        ready = self.empty(stash);
+                    }
+                }
+                // Recycle the now-empty chunk if it has the right capacity.
+                if chunk.capacity() == Self::target_capacity() {
+                    stash.push(chunk);
+                }
+            }
+            if !keep.is_empty() { kept.push(keep); }
+            if !ready.is_empty() { ship.push(ready); }
+        }
+
+        fn len(chunk: &Vec<(D, T, R)>) -> usize { chunk.len() }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use timely::progress::frontier::Antichain;
+    use crate::batcher::Batcher;
+    use super::{MergeBatcher, Sealer};
+    use super::vec::VecMerger;
+    use crate::batcher::merge::chunker::ContainerChunker;
+
+    type In = Vec<((u64, ()), u64, i64)>;
+    type Bt = MergeBatcher<ContainerChunker<In>, VecMerger<(u64, ()), u64, i64>, TestSealer>;
+
+    struct TestSealer;
+
+    impl Sealer<In> for TestSealer {
+        type Output = Vec<In>;
+
+        fn seal(chain: &mut Vec<In>) -> Option<Self::Output> {
+            (!chain.is_empty()).then(|| std::mem::take(chain))
+        }
+    }
+
+    /// The sealed frontier must reflect the POST-CONSOLIDATION set of distinct kept times:
+    /// two chains carry cancelling updates at a kept time (`t=5`), plus a survivor at a later
+    /// kept time (`t=7`). After `extract(upper=[3])` the frontier must be `{7}` — `(100, 5)` nets
+    /// to zero and needs no capability. (A per-chain extract that folds the frontier before
+    /// consolidating would wrongly report `{5}`.)
+    #[test]
+    fn frontier_is_post_consolidation() {
+        let mut b = Bt::new(None, 0);
+        b.chain_push(vec![vec![((100u64, ()), 5u64, 1i64), ((200u64, ()), 7u64, 1i64)]]);
+        b.chain_push(vec![vec![((100u64, ()), 5u64, -1i64)]]);
+        let (_, retained) = Batcher::<In>::extract(&mut b, Antichain::from_elem(3).borrow());
+        let got: Vec<u64> = retained.iter().cloned().collect();
+        assert_eq!(got, vec![7u64],
+            "frontier held a capability at t=5, which consolidates to zero (got {got:?})");
+    }
+
+    /// Sanity: with no cross-chain cancellation, the frontier is the minimal kept time.
+    #[test]
+    fn frontier_survivor_minimum() {
+        let mut b = Bt::new(None, 0);
+        b.chain_push(vec![vec![((100u64, ()), 5u64, 1i64)]]);
+        b.chain_push(vec![vec![((200u64, ()), 7u64, 1i64)]]);
+        let (_, retained) = Batcher::<In>::extract(&mut b, Antichain::from_elem(3).borrow());
+        let got: Vec<u64> = retained.iter().cloned().collect();
+        assert_eq!(got, vec![5u64]);
+    }
+}
diff --git a/differential-dataflow/src/batcher/mod.rs b/differential-dataflow/src/batcher/mod.rs
new file mode 100644
index 000000000..d5e7a629a
--- /dev/null
+++ b/differential-dataflow/src/batcher/mod.rs
@@ -0,0 +1,37 @@
+//! Traits and implementations for forming batches from streams of updates.
+
+use timely::progress::frontier::AntichainRef;
+
+pub mod merge;
+
+/// A type capable of accepting containers of updates, and carving them out by time as batches.
+///
+/// Updates are accepted as `C0`, the containers that arrive on the dataflow edge, and released as
+/// `Output`, whatever the implementor means by a batch. The two need not agree: an implementor
+/// staging updates in a form of its own can release that form directly, and one whose batch is a
+/// sequence of chunks names a sequence as its output.
+///
+/// The implementor determines the meaning of extraction by a frontier; it is not required to be by
+/// antichain partial order.
+pub trait Batcher<C0> {
+    /// The timestamps by which updates are carved out.
+    type Time;
+    /// The batches released by extraction.
+    type Output;
+
+    /// Takes the updates in `container`, leaving it in an undefined state.
+    ///
+    /// The implementor decides whether to claim the container's allocation or to drain it and
+    /// leave the allocation with the caller, who is free to reuse the container either way.
+    fn insert(&mut self, container: &mut C0);
+    /// Extracts the updates `upper` unblocks as a batch, and lower bounds the times of those retained.
+    ///
+    /// What `upper` unblocks is the implementor's to decide. It can be based on the antichain up
+    /// set, or it can be based on the total order of times (as used in delta join constructions).
+    /// Absent a batch, `upper` unblocked no updates.
+    ///
+    /// The reported lower bound should accurately reflect the times of all accepted updates that
+    /// have not been extracted. Over approximation can result in stalling dataflows, and under
+    /// approximation is simply incorrect.
+    fn extract<'a>(&'a mut self, upper: AntichainRef<'_, Self::Time>) -> (Option<Self::Output>, AntichainRef<'a, Self::Time>);
+}
diff --git a/differential-dataflow/src/collection.rs b/differential-dataflow/src/collection.rs
index abe41b3fc..356f1346f 100644
--- a/differential-dataflow/src/collection.rs
+++ b/differential-dataflow/src/collection.rs
@@ -965,7 +965,7 @@ pub mod vec {
         /// and provide the function `reify` to produce owned keys and values..
         pub fn consolidate_named<Ba, Tr, F>(self, name: &str, batcher: impl FnOnce(Option<crate::logging::Logger>, usize) -> Ba, reify: F) -> Self
         where
-            Ba: crate::trace::Batcher<Vec<((D, ()), T, R)>, Time = T, Output: Into<Tr::Batch>> + 'static,
+            Ba: crate::batcher::Batcher<Vec<((D, ()), T, R)>, Time = T, Output: Into<Tr::Batch>> + 'static,
             Tr: crate::trace::Trace<Batch: Navigable, Time=T>+'static,
             for<'a> BatchCursor<Tr>: Cursor<Time=Tr::Time, Diff=R>,
             F: Fn(BatchKey<'_, Tr>, BatchVal<'_, Tr>) -> D + 'static,
@@ -1036,7 +1036,7 @@ pub mod vec {
         /// directly.
         pub fn arrange<Ba, Tr>(self, batcher: impl FnOnce(Option<crate::logging::Logger>, usize) -> Ba) -> Arranged<'scope, TraceAgent<Tr>>
         where
-            Ba: crate::trace::Batcher<Vec<((K, V), T, R)>, Time = T, Output: Into<Tr::Batch>> + 'static,
+            Ba: crate::batcher::Batcher<Vec<((K, V), T, R)>, Time = T, Output: Into<Tr::Batch>> + 'static,
             Tr: crate::trace::Trace<Time=T> + 'static,
         {
             self.arrange_named::<Ba, Tr>("Arrange", batcher)
@@ -1045,7 +1045,7 @@ pub mod vec {
         /// As [`Collection::arrange`] but with the ability to name the operator.
         pub fn arrange_named<Ba, Tr>(self, name: &str, batcher: impl FnOnce(Option<crate::logging::Logger>, usize) -> Ba) -> Arranged<'scope, TraceAgent<Tr>>
         where
-            Ba: crate::trace::Batcher<Vec<((K, V), T, R)>, Time = T, Output: Into<Tr::Batch>> + 'static,
+            Ba: crate::batcher::Batcher<Vec<((K, V), T, R)>, Time = T, Output: Into<Tr::Batch>> + 'static,
             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());
diff --git a/differential-dataflow/src/lib.rs b/differential-dataflow/src/lib.rs
index 81db82af7..26a74c4f8 100644
--- a/differential-dataflow/src/lib.rs
+++ b/differential-dataflow/src/lib.rs
@@ -96,6 +96,7 @@ pub mod hashable;
 pub mod operators;
 pub mod algorithms;
 pub mod lattice;
+pub mod batcher;
 pub mod trace;
 pub mod input;
 pub mod difference;
diff --git a/differential-dataflow/src/operators/arrange/arrangement.rs b/differential-dataflow/src/operators/arrange/arrangement.rs
index c553aeac5..75eba8177 100644
--- a/differential-dataflow/src/operators/arrange/arrangement.rs
+++ b/differential-dataflow/src/operators/arrange/arrangement.rs
@@ -32,7 +32,8 @@ use crate::{Data, VecCollection, AsCollection};
 use crate::difference::Semigroup;
 use crate::lattice::Lattice;
 use crate::logging::Logger;
-use crate::trace::{self, Description, SpanOf, Trace, TraceReader, Navigable, Batcher, Builder, Cursor, BatchCursor, BatchDiff, BatchKey, BatchVal, BatchValOwn};
+use crate::batcher::Batcher;
+use crate::trace::{self, Description, SpanOf, Trace, TraceReader, Navigable, Builder, Cursor, BatchCursor, BatchDiff, BatchKey, BatchVal, BatchValOwn};
 
 use trace::wrappers::enter::{TraceEnter, enter_span};
 
diff --git a/differential-dataflow/src/operators/cursor/history.rs b/differential-dataflow/src/operators/cursor/history.rs
new file mode 100644
index 000000000..f4592b7de
--- /dev/null
+++ b/differential-dataflow/src/operators/cursor/history.rs
@@ -0,0 +1,73 @@
+//! Loading adapters between cursors and value histories.
+
+use crate::lattice::Lattice;
+use crate::operators::history::{EditList, HistoryReplay, ValueHistory};
+use crate::trace::Cursor;
+
+/// Walks the cursor's values at the current key into `target`, advancing times by `meet` if supplied.
+fn load_values<'a, V, T, D, C>(
+    target: &mut EditList<V, T, D>,
+    cursor: &mut C,
+    storage: &'a C::Storage,
+    meet: Option<&T>,
+)
+where
+    V: Copy + Ord,
+    T: Ord + Clone + Lattice,
+    D: crate::difference::Semigroup,
+    C: Cursor<Val<'a> = V, Time = T, Diff = D>,
+{
+    while let Some(val) = cursor.get_val(storage) {
+        cursor.map_times(storage, |time, diff| {
+            let mut time = C::owned_time(time);
+            if let Some(meet) = meet { time.join_assign(meet); }
+            target.push(time, C::owned_diff(diff));
+        });
+        target.seal(val);
+        cursor.step_val(storage);
+    }
+}
+
+/// Loads the cursor's values at its current key into `history`.
+///
+/// This avoids a redundant seek in the merge-join inner loop, where the cursor is positioned by the upstream merge step.
+pub(super) fn load_current<'a, V, T, D, C>(
+    history: &mut ValueHistory<V, T, D>,
+    cursor: &mut C,
+    storage: &'a C::Storage,
+    meet: Option<&T>,
+)
+where
+    V: Copy + Ord,
+    T: Ord + Clone + Lattice,
+    D: crate::difference::Semigroup,
+    C: Cursor<Val<'a> = V, Time = T, Diff = D>,
+{
+    history.clear();
+    load_values(history.edits_mut(), cursor, storage, meet);
+}
+
+/// Loads and replays a specified key.
+///
+/// If the key is absent, the replayed history will be empty.
+pub(super) fn replay_key<'a, 'history, V, T, D, C>(
+    history: &'history mut ValueHistory<V, T, D>,
+    cursor: &mut C,
+    storage: &'a C::Storage,
+    key: C::Key<'a>,
+    meet: Option<&T>,
+) -> HistoryReplay<'history, V, T, D>
+where
+    V: Copy + Ord,
+    T: Ord + Clone + Lattice,
+    D: crate::difference::Semigroup,
+    C: Cursor<Val<'a> = V, Time = T, Diff = D>,
+{
+    history.clear();
+    cursor.seek_key(storage, key);
+    if cursor.get_key(storage) == Some(key) {
+        cursor.rewind_vals(storage);
+        load_values(history.edits_mut(), cursor, storage, meet);
+    }
+    history.replay()
+}
diff --git a/differential-dataflow/src/operators/cursor/join.rs b/differential-dataflow/src/operators/cursor/join.rs
new file mode 100644
index 000000000..cf4e41326
--- /dev/null
+++ b/differential-dataflow/src/operators/cursor/join.rs
@@ -0,0 +1,317 @@
+//! Cursor-based join implementation.
+
+use std::cell::RefCell;
+use std::cmp::Ordering;
+use std::collections::VecDeque;
+use std::rc::Rc;
+
+use timely::ContainerBuilder;
+use timely::dataflow::Stream;
+use timely::progress::Timestamp;
+
+use super::history::load_current;
+use crate::lattice::Lattice;
+use crate::operators::arrange::Arranged;
+use crate::operators::history::ValueHistory;
+use crate::operators::join::{Fresh, JoinTactic, join_with_tactic};
+use crate::trace::{BatchCursor, BatchDiff, BatchVal, Cursor, Navigable, TraceReader};
+use crate::trace::cursor::cursor_list;
+use crate::trace::implementations::containers::BatchContainer;
+
+/// An equijoin of two traces, sharing a common key type.
+///
+/// This method exists to provide join functionality without opinions on the specific input types, keys and values,
+/// that should be presented. The two traces here can have arbitrary key and value types, which can be unsized and
+/// even potentially unrelated to the input collection data. Importantly, the key and value types could be generic
+/// associated types (GATs) of the traces, and we would seemingly struggle to frame these types as trait arguments.
+///
+/// The implementation produces a caller-specified container. Implementations can use [`AsCollection`] to wrap the
+/// output stream in a collection.
+///
+/// The "correctness" of this method depends heavily on the behavior of the supplied `result` function.
+///
+/// [`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,
+    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>, Time = Tr1::Time>,
+    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, CursorTactic::<Tr1::Batch, Tr2::Batch, _, CB>::new(result))
+}
+
+
+/// The conventional cursor-based [`JoinTactic`].
+///
+/// It builds a [`CursorList`](crate::trace::cursor::CursorList) over each input batch list and plays the merge-join out at whatever rate
+/// the driver's fuel allows. Each prepared unit joins a `B0`-side cursor against a `B1`-side cursor,
+/// emitting `(val0, val1)` to `logic` and yielding the output containers `logic` fills. `logic` is
+/// shared across all outstanding units (an `Rc<RefCell<_>>`), preserving the single mutable-state
+/// semantics of one closure threaded through every match — each unit is a self-contained `'static`
+/// iterator, so it cannot borrow the tactic.
+///
+/// It is parameterized by the builder `CB` into which `logic` pushes output; the [`JoinTactic`] it
+/// implements is over the container `CB` yields (`CB::Container`).
+pub struct CursorTactic<B0, B1, L, CB>
+where
+    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)>,
+}
+
+impl<B0, B1, L, CB> CursorTactic<B0, B1, L, CB>
+where
+    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 {
+        CursorTactic { logic: Rc::new(RefCell::new(logic)), _marker: std::marker::PhantomData }
+    }
+}
+
+impl<B0, B1, L, CB> JoinTactic<<B0::Cursor as Cursor>::Time, B0, B1, CB::Container> for CursorTactic<B0, B1, L, CB>
+where
+    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::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::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
+        // at or beyond `meet`, so the joined time is too), so it is purely a consolidation: it pays off
+        // when the accumulated side carries times below `meet`, and is a wasted scan when it does not. A
+        // more precise rule would skip the scan when the side is already entirely at or beyond `meet`,
+        // but detecting that needs both frontiers, not just `lower`: a batch's times lie at or beyond
+        // both its `lower` and its `since`, so the side is entirely beyond `meet` exactly when
+        // `meet <= lower` or `meet <= since`. A fresh batch is caught by `lower` (its `since` is
+        // `minimum`), a compacted trace by `since` (its `lower` is `minimum`); checking `lower` alone
+        // would wrongly advance a compacted trace whose times are all already at or beyond `meet`. We
+        // keep the simpler fresh-based choice and accept the occasional no-op scan.
+        let (cursor1, storage1) = cursor_list(input0);
+        let (cursor2, storage2) = cursor_list(input1);
+        let (advance1, advance2) = match fresh {
+            Fresh::Input0 => (false, true),
+            Fresh::Input1 => (true, false),
+        };
+        Box::new(DeferredIter {
+            cursor1,
+            storage1,
+            cursor2,
+            storage2,
+            meet,
+            advance1,
+            advance2,
+            logic: Rc::clone(&self.logic),
+            builder: CB::default(),
+            ready: VecDeque::new(),
+            done: false,
+        })
+    }
+}
+
+/// Deferred join computation, as an iterator of output containers.
+///
+/// The structure wraps cursors which allow us to play out join computation at whatever rate we like.
+/// This allows us to avoid producing and buffering massive amounts of data, without giving the timely
+/// dataflow system a chance to run operators that can consume and aggregate the data. Each `next` plays
+/// the merge-join forward until the builder yields a container (or the cursors run dry), matching the
+/// former per-unit `work` loop but suspending at container boundaries rather than under a fuel budget:
+/// the driver stops pulling once its budget is spent and resumes the same iterator next activation.
+struct DeferredIter<T, C1, C2, L, CB>
+where
+    T: Timestamp+Lattice,
+    C1: Cursor<Time=T>,
+    C2: for<'a> Cursor<Key<'a>=C1::Key<'a>, Time=T>,
+    CB: ContainerBuilder,
+{
+    cursor1: C1,
+    storage1: C1::Storage,
+    cursor2: C2,
+    storage2: C2::Storage,
+    /// The capability's time, at which this unit's output ships; the lower envelope for consolidation.
+    meet: T,
+    /// Whether to advance each side's history by `meet` before consolidation.
+    advance1: bool,
+    advance2: bool,
+    /// The output closure, shared across all outstanding units.
+    logic: Rc<RefCell<L>>,
+    /// The builder `logic` fills; drained into `ready` as containers complete.
+    builder: CB,
+    /// Completed containers awaiting a `next` call.
+    ready: VecDeque<CB::Container>,
+    done: bool,
+}
+
+impl<T, C1, C2, L, CB> Iterator for DeferredIter<T, C1, C2, L, CB>
+where
+    T: Timestamp+Lattice,
+    C1: Cursor<Time=T>,
+    C2: for<'a> Cursor<Key<'a>=C1::Key<'a>, Time=T>,
+    CB: ContainerBuilder<Container: Default>,
+    L: for<'a> FnMut(C1::Key<'a>, C1::Val<'a>, C2::Val<'a>, T, &C1::Diff, &C2::Diff, &mut CB),
+{
+    type Item = CB::Container;
+
+    /// Play the merge-join forward until a container is ready, or the cursors run dry.
+    #[inline(never)]
+    fn next(&mut self) -> Option<CB::Container> {
+        // Serve any container completed on an earlier call first.
+        if let Some(container) = self.ready.pop_front() { return Some(container); }
+        if self.done { return None; }
+
+        // The accumulated side is advanced by `meet` to consolidate its history; the fresh side is left,
+        // as its times already lie at or beyond `meet`. The choice was fixed per side at construction,
+        // from which input carried the fresh batch.
+        let meet1 = if self.advance1 { Some(&self.meet) } else { None };
+        let meet2 = if self.advance2 { Some(&self.meet) } else { None };
+
+        let storage1 = &self.storage1;
+        let storage2 = &self.storage2;
+        let cursor1 = &mut self.cursor1;
+        let cursor2 = &mut self.cursor2;
+        let builder = &mut self.builder;
+        let ready = &mut self.ready;
+        let mut logic = self.logic.borrow_mut();
+        let logic = &mut *logic;
+
+        let mut thinker = JoinThinker::new();
+        let mut exhausted = false;
+
+        while ready.is_empty() {
+            match (cursor1.get_key(storage1), cursor2.get_key(storage2)) {
+                (Some(key1), Some(key2)) => match key1.cmp(&key2) {
+                    Ordering::Less => cursor1.seek_key(storage1, key2),
+                    Ordering::Greater => cursor2.seek_key(storage2, key1),
+                    Ordering::Equal => {
+
+                        load_current(&mut thinker.history1, cursor1, storage1, meet1);
+                        load_current(&mut thinker.history2, cursor2, storage2, meet2);
+
+                        thinker.think(|v1,v2,t,r1,r2| {
+                            logic(key1, v1, v2, t, r1, r2, builder);
+                        });
+
+                        cursor1.step_key(storage1);
+                        cursor2.step_key(storage2);
+
+                        thinker.history1.clear();
+                        thinker.history2.clear();
+
+                        // Move any completed containers aside; we yield them one at a time.
+                        while let Some(container) = builder.extract() {
+                            // Avoiding the mem::take would require a non-iterator trait.
+                            ready.push_back(std::mem::take(container));
+                        }
+                    }
+                },
+                // One side is exhausted; no further keys can match.
+                _ => { exhausted = true; break; }
+            }
+        }
+
+        if exhausted {
+            self.done = true;
+            // Flush the final partial container.
+            while let Some(container) = builder.finish() {
+                // Avoiding the mem::take would require a non-iterator trait.
+                ready.push_back(std::mem::take(container));
+            }
+        }
+
+        ready.pop_front()
+    }
+}
+
+struct JoinThinker<V1, V2, T, D1, D2> {
+    pub history1: ValueHistory<V1, T, D1>,
+    pub history2: ValueHistory<V2, T, D2>,
+}
+
+impl<V1, V2, T, D1, D2> JoinThinker<V1, V2, T, D1, D2>
+where
+    V1: Copy + Ord,
+    V2: Copy + Ord,
+    T: Ord + Clone + Lattice,
+    D1: Clone + crate::difference::Semigroup,
+    D2: Clone + crate::difference::Semigroup,
+{
+    fn new() -> Self {
+        JoinThinker {
+            history1: ValueHistory::new(),
+            history2: ValueHistory::new(),
+        }
+    }
+
+    fn think<F: FnMut(V1, V2, T, &D1, &D2)>(&mut self, mut results: F) {
+
+        // for reasonably sized edits, do the dead-simple thing.
+        if self.history1.edit_len() < 10 || self.history2.edit_len() < 10 {
+            self.history1.map_edits(|v1, t1, d1| {
+                self.history2.map_edits(|v2, t2, d2| {
+                    results(v1, v2, t1.join(t2), d1, d2);
+                })
+            })
+        }
+        else {
+
+            let mut replay1 = self.history1.replay();
+            let mut replay2 = self.history2.replay();
+
+            // TODO: It seems like there is probably a good deal of redundant `advance_buffer_by`
+            //       in here. If a time is ever repeated, for example, the call will be identical
+            //       and accomplish nothing. If only a single record has been added, it may not
+            //       be worth the time to collapse (advance, re-sort) the data when a linear scan
+            //       is sufficient.
+
+            while !replay1.is_done() && !replay2.is_done() {
+
+                if replay1.time().unwrap().cmp(replay2.time().unwrap()) == ::std::cmp::Ordering::Less {
+                    replay2.advance_buffer_by(replay1.meet().unwrap());
+                    for &((val2, ref time2), ref diff2) in replay2.buffer().iter() {
+                        let (val1, time1, diff1) = replay1.edit().unwrap();
+                        results(val1, val2, time1.join(time2), diff1, diff2);
+                    }
+                    replay1.step();
+                }
+                else {
+                    replay1.advance_buffer_by(replay2.meet().unwrap());
+                    for &((val1, ref time1), ref diff1) in replay1.buffer().iter() {
+                        let (val2, time2, diff2) = replay2.edit().unwrap();
+                        results(val1, val2, time1.join(time2), diff1, diff2);
+                    }
+                    replay2.step();
+                }
+            }
+
+            while !replay1.is_done() {
+                replay2.advance_buffer_by(replay1.meet().unwrap());
+                for &((val2, ref time2), ref diff2) in replay2.buffer().iter() {
+                    let (val1, time1, diff1) = replay1.edit().unwrap();
+                    results(val1, val2, time1.join(time2), diff1, diff2);
+                }
+                replay1.step();
+            }
+            while !replay2.is_done() {
+                replay1.advance_buffer_by(replay2.meet().unwrap());
+                for &((val1, ref time1), ref diff1) in replay1.buffer().iter() {
+                    let (val2, time2, diff2) = replay2.edit().unwrap();
+                    results(val1, val2, time1.join(time2), diff1, diff2);
+                }
+                replay2.step();
+            }
+        }
+    }
+}
diff --git a/differential-dataflow/src/operators/cursor/mod.rs b/differential-dataflow/src/operators/cursor/mod.rs
new file mode 100644
index 000000000..1fb8f2615
--- /dev/null
+++ b/differential-dataflow/src/operators/cursor/mod.rs
@@ -0,0 +1,6 @@
+//! Operator implementations based on cursor traversal.
+
+mod history;
+
+pub mod join;
+pub mod reduce;
diff --git a/differential-dataflow/src/operators/cursor/reduce.rs b/differential-dataflow/src/operators/cursor/reduce.rs
new file mode 100644
index 000000000..0f11a39f4
--- /dev/null
+++ b/differential-dataflow/src/operators/cursor/reduce.rs
@@ -0,0 +1,563 @@
+//! Cursor-based reduce implementation.
+
+use std::marker::PhantomData;
+
+use timely::progress::{Antichain, Timestamp};
+
+use crate::Data;
+use crate::operators::arrange::{Arranged, TraceAgent};
+use crate::operators::reduce::{ReduceTactic, reduce_with_tactic, sort_dedup};
+use crate::trace::{Span, BatchCursor, BatchDiff, BatchVal, BatchValOwn, Builder, Cursor, Description, Navigable, Trace, TraceReader};
+use crate::trace::cursor::cursor_list;
+use crate::trace::implementations::containers::BatchContainer;
+
+/// The time type of the updates' cursor: the time coordinate the tactic works in.
+type TimeOf<B> = <<B as Navigable>::Cursor as Cursor>::Time;
+
+/// A key-wise reduction of values in an input trace.
+///
+/// This method exists to provide reduce functionality without opinions about qualifying trace types.
+///
+/// The `logic` closure is expected to take a key, accumulated input, and tentative accumulated output,
+/// and populate its final argument with whatever it feels to be appopriate updates. The behavior and
+/// correctness of the implementation rely on this making sense, and e.g. ideally the updates would if
+/// applied to the tentative output bring it in line with some function applied to the input.
+///
+/// The `push` closure is expected to clear its first argument, then populate it with the key and drain
+/// the value updates, as appropriate for the container. It is critical that it clear the container as
+/// the operator has no ability to do this otherwise, and failing to do so represents a leak from one
+/// 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,
+    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: Into<Tr2::Batch>, Input: Default> + 'static,
+    L: FnMut(KC::ReadItem<'_>, &[(BatchVal<'_, Tr1>, BatchDiff<Tr1>)], &mut Vec<(BatchValOwn<Tr2>, BatchDiff<Tr2>)>, &mut Vec<(BatchValOwn<Tr2>, BatchDiff<Tr2>)>)+'static,
+    P: FnMut(&mut Bu::Input, KC::ReadItem<'_>, &mut Vec<(BatchValOwn<Tr2>, Tr2::Time, BatchDiff<Tr2>)>) + 'static,
+{
+    reduce_with_tactic(trace, name, CursorTactic::<Tr1::Batch, Tr2::Batch, Bu, L, P>::new(logic, push))
+}
+/// The conventional cursor-based [`ReduceTactic`].
+///
+/// It builds a [`CursorList`](crate::trace::cursor::CursorList) over the input, output, and new-batch
+/// updates and replays them together per key, applying `logic` and shaping output with `push`. It holds
+/// the outstanding synthetic interesting `(key, time)` moments across activations, and reasons only
+/// about times: capabilities are the driver's concern.
+
+/// The conventional cursor-based [`ReduceTactic`].
+pub struct CursorTactic<B1, B2, Bu, L, P>
+where
+    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,
+    // Outstanding `(key, time)` synthetic interesting moments, sorted by `(key, time)`, and the
+    // buffers into which we assemble the next round's moments.
+    pending_keys: <B1::Cursor as Cursor>::KeyContainer,
+    pending_time: <B1::Cursor as Cursor>::TimeContainer,
+    next_pending_keys: <B1::Cursor as Cursor>::KeyContainer,
+    next_pending_time: <B1::Cursor as Cursor>::TimeContainer,
+    // Buffers reused across activations.
+    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: 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 {
+        CursorTactic {
+            logic,
+            push,
+            pending_keys: <B1::Cursor as Cursor>::KeyContainer::with_capacity(0),
+            pending_time: <B1::Cursor as Cursor>::TimeContainer::with_capacity(0),
+            next_pending_keys: <B1::Cursor as Cursor>::KeyContainer::with_capacity(0),
+            next_pending_time: <B1::Cursor as Cursor>::TimeContainer::with_capacity(0),
+            interesting_times: Vec::new(),
+            new_interesting_times: Vec::new(),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<B1, B2, Bu, L, P> ReduceTactic<TimeOf<B1>, B1, B2> for CursorTactic<B1, B2, Bu, L, P>
+where
+    B1: Navigable,
+    B2: Navigable,
+    for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = TimeOf<B1>>,
+    Bu: Builder<Time = TimeOf<B1>, Output: Into<B2>, Input: Default>,
+    L: FnMut(<B1::Cursor as Cursor>::Key<'_>, &[(<B1::Cursor as Cursor>::Val<'_>, <B1::Cursor as Cursor>::Diff)], &mut Vec<(<B2::Cursor as Cursor>::ValOwn, <B2::Cursor as Cursor>::Diff)>, &mut Vec<(<B2::Cursor as Cursor>::ValOwn, <B2::Cursor as Cursor>::Diff)>),
+    P: FnMut(&mut Bu::Input, <B1::Cursor as Cursor>::Key<'_>, &mut Vec<(<B2::Cursor as Cursor>::ValOwn, 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<TimeOf<B1>>,
+        upper: &Antichain<TimeOf<B1>>,
+        held: &Antichain<TimeOf<B1>>,
+    ) -> (Option<Span<TimeOf<B1>, B2>>, Antichain<TimeOf<B1>>)
+    {
+        let mut produced = None;
+
+        // We have compute needs only if we hold a time in the interval [lower, upper); otherwise we
+        // could not transmit outputs even if they were (incorrectly) non-zero, and we leave the held
+        // times unchanged.
+        if held.elements().iter().any(|time| !upper.less_equal(time)) {
+
+            // cursors for navigating input, output, and new-batch updates.
+            let (mut source_cursor, ref source_storage) = cursor_list(source_batches);
+            let (mut output_cursor, ref output_storage) = cursor_list(output_batches);
+            let (mut batch_cursor, ref batch_storage) = cursor_list(input_batches);
+
+            // 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, TimeOf<B1>, <B2::Cursor as Cursor>::Diff)>::new();
+            let mut builder = Bu::default();
+            // Temporary staging for output building.
+            let mut buffer = Bu::Input::default();
+
+            // Reuseable state for performing the computation.
+            let mut thinker = history_replay::HistoryReplayer::new();
+
+            // March through the keys we must work on, merging `batch_cursor` and pending keys.
+            // The interesting moments need to be in the interval to prompt work.
+            let mut pending_pos = 0;
+            while batch_cursor.key_valid(batch_storage) || pending_pos < self.pending_keys.len() {
+
+                // Determine the next key we will work on; could be synthetic, could be from a batch.
+                let key1 = self.pending_keys.get(pending_pos);
+                let key2 = batch_cursor.get_key(batch_storage);
+                let key = match (key1, key2) {
+                    (Some(key1), Some(key2)) => ::std::cmp::min(key1, key2),
+                    (Some(key1), None)       => key1,
+                    (None, Some(key2))       => key2,
+                    (None, None)             => unreachable!(),
+                };
+
+                // Populate `interesting_times` with interesting times not beyond `upper`.
+                // TODO: This could just be `pending_time` and indexes within `lower .. upper`.
+                let prior_pos = pending_pos;
+                self.interesting_times.clear();
+                while self.pending_keys.get(pending_pos) == Some(key) {
+                    let owned_time = <B1::Cursor as Cursor>::owned_time(self.pending_time.index(pending_pos));
+                    if !upper.less_equal(&owned_time) { self.interesting_times.push(owned_time); }
+                    pending_pos += 1;
+                }
+
+                // tidy up times, removing redundancy.
+                sort_dedup(&mut self.interesting_times);
+
+                // If there are new updates, or pending times, we must investigate!
+                if batch_cursor.get_key(batch_storage) == Some(key) || !self.interesting_times.is_empty() {
+
+                    // do the per-key computation.
+                    thinker.compute(
+                        key,
+                        (&mut source_cursor, source_storage),
+                        (&mut output_cursor, output_storage),
+                        (&mut batch_cursor, batch_storage),
+                        &self.interesting_times,
+                        &mut self.logic,
+                        upper,
+                        &mut output_updates,
+                        held.elements(),
+                        &mut self.new_interesting_times,
+                    );
+
+                    // Advance the cursor if this key, so that the loop's validity check registers the work as done.
+                    if batch_cursor.get_key(batch_storage) == Some(key) { batch_cursor.step_key(batch_storage); }
+
+                    // Merge novel pending times with any prior pending times we did not process.
+                    // TODO: This could be a merge, not a sort_dedup, because both lists should be sorted.
+                    for pos in prior_pos .. pending_pos {
+                        let owned_time = <B1::Cursor as Cursor>::owned_time(self.pending_time.index(pos));
+                        if upper.less_equal(&owned_time) { self.new_interesting_times.push(owned_time); }
+                    }
+                    sort_dedup(&mut self.new_interesting_times);
+                    for time in self.new_interesting_times.drain(..) {
+                        self.next_pending_keys.push_ref(key);
+                        self.next_pending_time.push_own(&time);
+                    }
+
+                    // Sort the buffer by value and move into the builder.
+                    // TODO: This makes assumptions about at least one of (i) the stability of `sort_by`,
+                    //       (ii) that the buffer is time-ordered, and (iii) that the builders accept
+                    //       arbitrarily ordered times.
+                    output_updates.sort_by(|x,y| x.0.cmp(&y.0));
+                    (self.push)(&mut buffer, key, &mut output_updates);
+                    output_updates.clear();
+                    builder.push(&mut buffer);
+                }
+                else {
+                    // copy over the pending key and times.
+                    for pos in prior_pos .. pending_pos {
+                        self.next_pending_keys.push_ref(self.pending_keys.index(pos));
+                        self.next_pending_time.push_ref(self.pending_time.index(pos));
+                    }
+                }
+            }
+            // Drop to avoid lifetime issues that would lock `pending_{keys, time}`.
+            drop(thinker);
+
+            // 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(<TimeOf<B1> as Timestamp>::minimum()));
+            produced = Some(Span::new(description, builder.done().map(Into::into)));
+
+            // Refresh pending keys and times.
+            self.pending_keys.clear(); std::mem::swap(&mut self.next_pending_keys, &mut self.pending_keys);
+            self.pending_time.clear(); std::mem::swap(&mut self.next_pending_time, &mut self.pending_time);
+
+            // Compute the new frontier of interesting times for the operator to hold.
+            let mut frontier = Antichain::<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);
+            }
+
+            (produced, frontier)
+        }
+        else {
+            // No work: leave the held times unchanged, so the driver's downgrade is a no-op.
+            (produced, held.clone())
+        }
+    }
+}
+
+
+/// Implementation based on replaying historical and new updates together.
+mod history_replay {
+
+    use timely::progress::Antichain;
+
+    use crate::lattice::Lattice;
+    use crate::operators::cursor::history::replay_key;
+    use crate::operators::history::ValueHistory;
+    use crate::trace::Cursor;
+
+    use crate::operators::reduce::sort_dedup;
+
+    /// The `HistoryReplayer` is a compute strategy based on moving through existing inputs, interesting times, etc in
+    /// time order, maintaining consolidated representations of updates with respect to future interesting times.
+    pub struct HistoryReplayer<V1, V2, V, T, D1, D2> {
+        input_history: ValueHistory<V1, T, D1>,
+        output_history: ValueHistory<V2, T, D2>,
+        batch_history: ValueHistory<V1, T, D1>,
+        input_buffer: Vec<(V1, D1)>,
+        output_buffer: Vec<(V, D2)>,
+        update_buffer: Vec<(V, D2)>,
+        output_produced: Vec<((V, T), D2)>,
+        synth_times: Vec<T>,
+        meets: Vec<T>,
+        times_current: Vec<T>,
+        temporary: Vec<T>,
+    }
+
+    impl<V1, V2, V, T, D1, D2> HistoryReplayer<V1, V2, V, T, D1, D2>
+    where
+        V1: Copy + Ord,
+        V2: Copy + Ord,
+        V: Clone + Ord,
+        T: Ord + Clone + Lattice,
+        D1: Clone + crate::difference::Semigroup,
+        D2: Clone + crate::difference::Semigroup,
+    {
+        pub fn new() -> Self {
+            HistoryReplayer {
+                input_history: ValueHistory::new(),
+                output_history: ValueHistory::new(),
+                batch_history: ValueHistory::new(),
+                input_buffer: Vec::new(),
+                output_buffer: Vec::new(),
+                update_buffer: Vec::new(),
+                output_produced: Vec::new(),
+                synth_times: Vec::new(),
+                meets: Vec::new(),
+                times_current: Vec::new(),
+                temporary: Vec::new(),
+            }
+        }
+        #[inline(never)]
+        pub fn compute<'a, K, C1, C2, C3, L>(
+            &mut self,
+            key: K,
+            (source_cursor, source_storage): (&mut C1, &'a C1::Storage),
+            (output_cursor, output_storage): (&mut C2, &'a C2::Storage),
+            (batch_cursor, batch_storage): (&mut C3, &'a C3::Storage),
+            times: &Vec<T>,
+            logic: &mut L,
+            upper_limit: &Antichain<T>,
+            outputs: &mut Vec<(V, T, D2)>,
+            held: &[T],
+            new_interesting: &mut Vec<T>)
+        where
+            C1: Cursor<Key<'a> = K, Val<'a> = V1, Time = T, Diff = D1>,
+            C2: Cursor<Key<'a> = K, Val<'a> = V2, ValOwn = V, Time = T, Diff = D2>,
+            C3: Cursor<Key<'a> = K, Val<'a> = V1, Time = T, Diff = D1>,
+            K: Copy + Ord,
+            L: FnMut(K, &[(V1, D1)], &mut Vec<(V, D2)>, &mut Vec<(V, D2)>),
+        {
+
+            // The work we need to perform is at times defined principally by the contents of `batch_cursor`
+            // and `times`, respectively "new work we just received" and "old times we were warned about".
+            //
+            // Our first step is to identify these times, so that we can use them to restrict the amount of
+            // information we need to recover from `input` and `output`; as all times of interest will have
+            // some time from `batch_cursor` or `times`, we can compute their meet and advance all other
+            // loaded times by performing the lattice `join` with this value.
+
+            // Load the batch contents.
+            let mut batch_replay = replay_key(&mut self.batch_history, batch_cursor, batch_storage, key, None);
+
+            // We determine the meet of times we must reconsider (those from `batch` and `times`). This meet
+            // can be used to advance other historical times, which may consolidate their representation. As
+            // a first step, we determine the meets of each *suffix* of `times`, which we will use as we play
+            // history forward.
+
+            self.meets.clear();
+            self.meets.extend(times.iter().cloned());
+            for index in (1 .. self.meets.len()).rev() {
+                self.meets[index-1] = self.meets[index-1].meet(&self.meets[index]);
+            }
+
+            // Determine the meet of times in `batch` and `times`.
+            let mut meet = None;
+            update_meet(&mut meet, self.meets.get(0));
+            update_meet(&mut meet, batch_replay.meet());
+
+            // Having determined the meet, we can load the input and output histories, where we
+            // advance all times by joining them with `meet`. The resulting times are more compact
+            // and guaranteed to accumulate identically for times greater or equal to `meet`.
+
+            // Load the input and output histories.
+            let mut input_replay =
+            replay_key(&mut self.input_history, source_cursor, source_storage, key, meet.as_ref());
+            let mut output_replay =
+            replay_key(&mut self.output_history, output_cursor, output_storage, key, meet.as_ref());
+
+            self.synth_times.clear();
+            self.times_current.clear();
+            self.output_produced.clear();
+
+            // The frontier of times we may still consider.
+            // Derived from frontiers of our update histories, supplied times, and synthetic times.
+
+            let mut times_slice = &times[..];
+            let mut meets_slice = &self.meets[..];
+
+            // We have candidate times from `batch` and `times`, as well as times identified by either
+            // `input` or `output`. Finally, we may have synthetic times produced as the join of times
+            // we consider in the course of evaluation. As long as any of these times exist, we need to
+            // keep examining times.
+            while let Some(next_time) = [   batch_replay.time(),
+                                            times_slice.first(),
+                                            input_replay.time(),
+                                            output_replay.time(),
+                                            self.synth_times.last(),
+                                        ].into_iter().flatten().min().cloned() {
+
+                // Advance input and output history replayers. This marks applicable updates as active.
+                input_replay.step_while_time_is(&next_time);
+                output_replay.step_while_time_is(&next_time);
+
+                // One of our goals is to determine if `next_time` is "interesting", meaning whether we
+                // have any evidence that we should re-evaluate the user logic at this time. For a time
+                // to be "interesting" it would need to be the join of times that include either a time
+                // from `batch`, `times`, or `synth`. Neither `input` nor `output` times are sufficient.
+
+                // Advance batch history, and capture whether an update exists at `next_time`.
+                let mut interesting = batch_replay.step_while_time_is(&next_time);
+                if interesting { if let Some(meet) = meet.as_ref() { batch_replay.advance_buffer_by(meet); } }
+
+                // advance both `synth_times` and `times_slice`, marking this time interesting if in either.
+                while self.synth_times.last() == Some(&next_time) {
+                    // We don't know enough about `next_time` to avoid putting it in to `times_current`.
+                    // TODO: If we knew that the time derived from a canceled batch update, we could remove the time.
+                    self.times_current.push(self.synth_times.pop().expect("failed to pop from synth_times")); // <-- TODO: this could be a min-heap.
+                    interesting = true;
+                }
+                while times_slice.first() == Some(&next_time) {
+                    // We know nothing about why we were warned about `next_time`, and must include it to scare future times.
+                    self.times_current.push(times_slice[0].clone());
+                    times_slice = &times_slice[1..];
+                    meets_slice = &meets_slice[1..];
+                    interesting = true;
+                }
+
+                // Times could also be interesting if an interesting time is less than them, as they would join
+                // and become the time itself. They may not equal the current time because whatever frontier we
+                // are tracking may not have advanced far enough.
+                // TODO: `batch_history` may or may not be super compact at this point, and so this check might
+                //       yield false positives if not sufficiently compact. Maybe we should look into this and see.
+                interesting = interesting || batch_replay.buffer().iter().any(|&((_, ref t),_)| t.less_equal(&next_time));
+                interesting = interesting || self.times_current.iter().any(|t| t.less_equal(&next_time));
+
+                // We should only process times that are not in advance of `upper_limit`.
+                //
+                // We have no particular guarantee that known times will not be in advance of `upper_limit`.
+                // We may have the guarantee that synthetic times will not be, as we test against the limit
+                // before we add the time to `synth_times`.
+                if !upper_limit.less_equal(&next_time) {
+
+                    // DETERMINATION (times only). Determine synthetic interesting times.
+                    //
+                    // Synthetic interesting times are produced differently for interesting and uninteresting
+                    // times. An uninteresting time must join with an interesting time to become interesting,
+                    // which means joins with `self.batch_history` and  `self.times_current`. I think we can
+                    // skip `self.synth_times` as we haven't gotten to them yet, but we will and they will be
+                    // joined against everything.
+
+                    // Any time, even uninteresting times, must be joined with the current accumulation of
+                    // batch times as well as the current accumulation of `times_current`.
+                    self.temporary.extend(batch_replay.buffer().iter().map(|((_,time),_)| time).filter(|time| !time.less_equal(&next_time)).map(|time| time.join(&next_time)));
+                    self.temporary.extend(self.times_current.iter().filter(|time| !time.less_equal(&next_time)).map(|time| time.join(&next_time)));
+
+                    // An interesting time additionally joins with `input` and `output` history and this round's
+                    // produced output: it carries the seed, so those joins stay interesting (an uninteresting
+                    // time does not, as `input`/`output` times are not themselves seeds). We advance the buffers
+                    // by `meet` first, exactly as evaluation reads them below; by join preservation the advanced
+                    // and unadvanced times spawn the same synthetics, so this matches the pre-split behavior.
+                    if interesting {
+                        if let Some(meet) = meet.as_ref() { input_replay.advance_buffer_by(meet) };
+                        if let Some(meet) = meet.as_ref() { output_replay.advance_buffer_by(meet) };
+                        self.temporary.extend(input_replay.buffer().iter().map(|((_,time),_)| time).filter(|time| !time.less_equal(&next_time)).map(|time| time.join(&next_time)));
+                        self.temporary.extend(output_replay.buffer().iter().map(|((_,time),_)| time).filter(|time| !time.less_equal(&next_time)).map(|time| time.join(&next_time)));
+                        self.temporary.extend(self.output_produced.iter().map(|((_,time),_)| time).filter(|time| !time.less_equal(&next_time)).map(|time| time.join(&next_time)));
+                    }
+                    sort_dedup(&mut self.temporary);
+
+                    // Introduce synthetic times, and re-organize if we add any.
+                    let synth_len = self.synth_times.len();
+                    for time in self.temporary.drain(..) {
+                        // We can either service `join` now, or must delay for the future.
+                        if upper_limit.less_equal(&time) {
+                            debug_assert!(held.iter().any(|t| t.less_equal(&time)));
+                            new_interesting.push(time);
+                        }
+                        else {
+                            self.synth_times.push(time);
+                        }
+                    }
+                    if self.synth_times.len() > synth_len {
+                        self.synth_times.sort_by(|x,y| y.cmp(x));
+                        self.synth_times.dedup();
+                    }
+
+                    // EVALUATION (values only).
+                    // We should re-evaluate the computation if this is an interesting time.
+                    // If the time is uninteresting (and our logic is sound) it is not possible for there to be
+                    // output produced. This sounds like a good test to have for debug builds!
+                    if interesting {
+
+                        // Assemble the input collection at `next_time`. (`self.input_buffer` cleared just after use).
+                        // The buffers were advanced by `meet` in the determination step above.
+                        debug_assert!(self.input_buffer.is_empty());
+                        for ((value, time), diff) in input_replay.buffer().iter() {
+                            if time.less_equal(&next_time) { self.input_buffer.push((*value, diff.clone())); }
+                        }
+                        for ((value, time), diff) in batch_replay.buffer().iter() {
+                            if time.less_equal(&next_time) { self.input_buffer.push((*value, diff.clone())); }
+                        }
+                        crate::consolidation::consolidate(&mut self.input_buffer);
+
+                        // Assemble the output collection at `next_time`. (`self.output_buffer` cleared just after use).
+                        for ((value, time), diff) in output_replay.buffer().iter() {
+                            if time.less_equal(&next_time) { self.output_buffer.push((C2::owned_val(*value), diff.clone())); }
+                        }
+                        for ((value, time), diff) in self.output_produced.iter() {
+                            if time.less_equal(&next_time) { self.output_buffer.push(((*value).to_owned(), diff.clone())); }
+                        }
+                        crate::consolidation::consolidate(&mut self.output_buffer);
+
+                        // Apply user logic if non-empty input or output and see what happens!
+                        if !self.input_buffer.is_empty() || !self.output_buffer.is_empty() {
+                            logic(key, &self.input_buffer[..], &mut self.output_buffer, &mut self.update_buffer);
+                            self.input_buffer.clear();
+                            self.output_buffer.clear();
+
+                            // Having subtracted output updates from user output, consolidate the results to determine
+                            // if there is anything worth reporting. Note: this also orders the results by value, so
+                            // that could make the above merging plan even easier.
+                            //
+                            // Stash produced updates into both capability-indexed buffers and `output_produced`.
+                            // The two locations are important, in that we will compact `output_produced` as we move
+                            // through times, but we cannot compact the output buffers because we need their actual
+                            // times.
+                            crate::consolidation::consolidate(&mut self.update_buffer);
+                            if !self.update_buffer.is_empty() {
+
+                                // We *should* be able to find a capability for `next_time`. Any thing else would
+                                // indicate a logical error somewhere along the way; either we release a capability
+                                // we should have kept, or we have computed the output incorrectly (or both!)
+                                assert!(held.iter().any(|time| time.less_equal(&next_time)), "failed to find capability");
+                                for (val, diff) in self.update_buffer.drain(..) {
+                                    self.output_produced.push(((val.clone(), next_time.clone()), diff.clone()));
+                                    outputs.push((val, next_time.clone(), diff));
+                                }
+
+                                // Advance times in `self.output_produced` and consolidate the representation.
+                                // NOTE: We only do this when we add records; it could be that there are situations
+                                //       where we want to consolidate even without changes (because an initially
+                                //       large collection can now be collapsed).
+                                if let Some(meet) = meet.as_ref() { for entry in &mut self.output_produced { (entry.0).1.join_assign(meet); } }
+                                crate::consolidation::consolidate(&mut self.output_produced);
+                            }
+                        }
+                    }
+                }
+                else if interesting {
+                    // We cannot process `next_time` now, and must delay it.
+                    //
+                    // I think we are probably only here because of an uninteresting time declared interesting,
+                    // as initial interesting times are filtered to be in interval, and synthetic times are also
+                    // filtered before introducing them to `self.synth_times`.
+                    new_interesting.push(next_time.clone());
+                    debug_assert!(held.iter().any(|t| t.less_equal(&next_time)))
+                }
+
+                // Update `meet` to track the meet of each source of times.
+                meet = None;
+                update_meet(&mut meet, batch_replay.meet());
+                update_meet(&mut meet, input_replay.meet());
+                update_meet(&mut meet, output_replay.meet());
+                for time in self.synth_times.iter() { update_meet(&mut meet, Some(time)); }
+                update_meet(&mut meet, meets_slice.first());
+
+                // Update `times_current` by the frontier.
+                if let Some(meet) = meet.as_ref() {
+                    for time in self.times_current.iter_mut() {
+                        *time = time.join(meet);
+                    }
+                }
+
+                sort_dedup(&mut self.times_current);
+            }
+
+            // Normalize the representation of `new_interesting`, deduplicating and ordering.
+            sort_dedup(new_interesting);
+        }
+    }
+
+    /// Updates an optional meet by an optional time.
+    fn update_meet<T: Lattice+Clone>(meet: &mut Option<T>, other: Option<&T>) {
+        if let Some(time) = other {
+            if let Some(meet) = meet.as_mut() { meet.meet_assign(time); }
+            else { *meet = Some(time.clone()); }
+        }
+    }
+}
diff --git a/differential-dataflow/src/operators/history.rs b/differential-dataflow/src/operators/history.rs
new file mode 100644
index 000000000..c21386dc4
--- /dev/null
+++ b/differential-dataflow/src/operators/history.rs
@@ -0,0 +1,187 @@
+//! Shared organization and replay of value histories.
+
+use crate::lattice::Lattice;
+
+/// An accumulation of (value, time, diff) updates.
+pub struct EditList<V, T, D> {
+    values: Vec<(V, usize)>,
+    edits: Vec<(T, D)>,
+}
+
+impl<V: Copy, T: Ord + Lattice, D: crate::difference::Semigroup> EditList<V, T, D> {
+    /// Creates an empty list of edits.
+    #[inline]
+    fn new() -> Self {
+        EditList {
+            values: Vec::new(),
+            edits: Vec::new(),
+        }
+    }
+    /// Clears the list of edits.
+    #[inline]
+    pub fn clear(&mut self) {
+        self.values.clear();
+        self.edits.clear();
+    }
+    fn len(&self) -> usize { self.edits.len() }
+    /// Inserts a new edit for an as-yet undetermined value.
+    #[inline]
+    pub fn push(&mut self, time: T, diff: D) {
+        // TODO: Could attempt "insertion-sort" like behavior here, where we collapse if possible.
+        self.edits.push((time, diff));
+    }
+    /// Associates all edits pushed since the previous `seal_value` call with `value`.
+    #[inline]
+    pub fn seal(&mut self, value: V) {
+        let prev = self.values.last().map(|x| x.1).unwrap_or(0);
+        crate::consolidation::consolidate_from(&mut self.edits, prev);
+        if self.edits.len() > prev {
+            self.values.push((value, self.edits.len()));
+        }
+    }
+    fn map<F: FnMut(V, &T, &D)>(&self, mut logic: F) {
+        for index in 0 .. self.values.len() {
+            let lower = if index == 0 { 0 } else { self.values[index-1].1 };
+            let upper = self.values[index].1;
+            for edit in lower .. upper {
+                logic(self.values[index].0, &self.edits[edit].0, &self.edits[edit].1);
+            }
+        }
+    }
+}
+
+/// A loaded, time-ordered replay of one key's `(value, time, diff)` edits, with meet-advanced
+/// buffer collapse — the shared machinery under replay-based tactics.
+/// Its local contract: after
+/// `advance_buffer_by(meet)` with the meet of the un-replayed times, the buffer is consolidated
+/// and replay cost stays linear in edits rather than quadratic.
+pub struct ValueHistory<V, T, D> {
+    edits: EditList<V, T, D>,
+    history: Vec<(T, T, usize, usize)>,     // (time, meet, value_index, edit_offset)
+    buffer: Vec<((V, T), D)>,               // where we accumulate / collapse updates.
+}
+
+impl<V: Copy + Ord, T: Ord + Clone + Lattice, D: crate::difference::Semigroup> ValueHistory<V, T, D> {
+    /// Creates an empty history.
+    pub fn new() -> Self {
+        ValueHistory {
+            edits: EditList::new(),
+            history: Vec::new(),
+            buffer: Vec::new(),
+        }
+    }
+    /// Discards all loaded state (capacity retained).
+    pub fn clear(&mut self) {
+        self.edits.clear();
+        self.history.clear();
+        self.buffer.clear();
+    }
+
+    pub(in crate::operators) fn edits_mut(&mut self) -> &mut EditList<V, T, D> {
+        &mut self.edits
+    }
+
+    pub(in crate::operators) fn edit_len(&self) -> usize {
+        self.edits.len()
+    }
+
+    pub(in crate::operators) fn map_edits<F: FnMut(V, &T, &D)>(&self, logic: F) {
+        self.edits.map(logic)
+    }
+
+    /// Organizes history based on current contents of edits (sort + suffix meets).
+    fn build(&mut self) {
+        self.buffer.clear();
+        self.history.clear();
+        for value_index in 0 .. self.edits.values.len() {
+            let lower = if value_index > 0 { self.edits.values[value_index-1].1 } else { 0 };
+            let upper = self.edits.values[value_index].1;
+            for edit_index in lower .. upper {
+                let time = self.edits.edits[edit_index].0.clone();
+                self.history.push((time.clone(), time, value_index, edit_index));
+            }
+        }
+
+        self.history.sort_by(|x,y| y.cmp(x));
+        self.history.iter_mut().reduce(|prev, cur| { cur.1.meet_assign(&prev.1); cur });
+    }
+
+    /// Organizes history based on current contents of edits, returning a fresh replay.
+    pub(in crate::operators) fn replay<'history>(&'history mut self) -> HistoryReplay<'history, V, T, D> {
+        self.build();
+        HistoryReplay { replay: self }
+    }
+
+    /// Loads `edits` from a plain iterator (grouped by consecutive value — the presentation
+    /// order), advancing each time by `advance_by` if supplied, then organizes. This is the
+    /// iterator ingestion path: the `int_proxy` tactics present `(value_id, time, diff)` runs
+    /// directly and share this machinery instead of re-implementing it.
+    /// Ungrouped input is still correct, only less compact.
+    pub fn load_iter(&mut self, edits: impl Iterator<Item = (V, T, D)>, advance_by: Option<&T>) {
+        self.edits.clear();
+        let mut cur: Option<V> = None;
+        for (v, mut time, diff) in edits {
+            if cur != Some(v) {
+                if let Some(pv) = cur { self.edits.seal(pv); }
+                cur = Some(v);
+            }
+            if let Some(m) = advance_by { time.join_assign(m); }
+            self.edits.push(time, diff);
+        }
+        if let Some(pv) = cur { self.edits.seal(pv); }
+        self.build();
+    }
+}
+
+impl<V: Copy + Ord, T: Ord + Clone + Lattice, D: Clone + crate::difference::Semigroup> ValueHistory<V, T, D> {
+    /// The next (least) un-replayed time.
+    pub fn time(&self) -> Option<&T> { self.history.last().map(|x| &x.0) }
+    /// The meet of all un-replayed times.
+    pub fn meet(&self) -> Option<&T> { self.history.last().map(|x| &x.1) }
+    /// The next un-replayed edit, as `(value, time, diff)`.
+    pub fn edit(&self) -> Option<(V, &T, &D)> {
+        self.history.last().map(|&(ref t, _, v, e)| (self.edits.values[v].0, t, &self.edits.edits[e].1))
+    }
+    /// The buffered (stepped-in, advanced, consolidated) edits.
+    pub fn buffer(&self) -> &[((V, T), D)] { &self.buffer[..] }
+    /// Move the next edit into the buffer.
+    pub fn step(&mut self) {
+        let (time, _, value_index, edit_offset) = self.history.pop().unwrap();
+        self.buffer.push(((self.edits.values[value_index].0, time), self.edits.edits[edit_offset].1.clone()));
+    }
+    /// Step edits while the next time equals `time`; true iff any did.
+    pub fn step_while_time_is(&mut self, time: &T) -> bool {
+        let mut found = false;
+        while self.time() == Some(time) { found = true; self.step(); }
+        found
+    }
+    /// Step edits while the next time is `<= time` in the TOTAL order (a superset of the
+    /// partially-ordered downset; readers filter the buffer by `less_equal` themselves).
+    pub fn step_through(&mut self, time: &T) {
+        while self.time().is_some_and(|t| t <= time) { self.step(); }
+    }
+    /// Advance buffered times by `meet` and consolidate — the collapse that keeps replay linear.
+    pub fn advance_buffer_by(&mut self, meet: &T) {
+        for element in self.buffer.iter_mut() { (element.0).1.join_assign(meet); }
+        crate::consolidation::consolidate(&mut self.buffer);
+    }
+    /// True when every edit has been replayed.
+    pub fn is_done(&self) -> bool { self.history.is_empty() }
+}
+
+pub(in crate::operators) struct HistoryReplay<'history, V, T, D> {
+    replay: &'history mut ValueHistory<V, T, D>,
+}
+
+// A `HistoryReplay` is a thin handle over a `ValueHistory`.
+// The replay machinery lives on `ValueHistory` itself, and these methods forward to it.
+impl<'history, V: Copy + Ord, T: Ord + Clone + Lattice, D: Clone + crate::difference::Semigroup> HistoryReplay<'history, V, T, D> {
+    pub(in crate::operators) fn time(&self) -> Option<&T> { self.replay.time() }
+    pub(in crate::operators) fn meet(&self) -> Option<&T> { self.replay.meet() }
+    pub(in crate::operators) fn edit(&self) -> Option<(V, &T, &D)> { self.replay.edit() }
+    pub(in crate::operators) fn buffer(&self) -> &[((V, T), D)] { self.replay.buffer() }
+    pub(in crate::operators) fn step(&mut self) { self.replay.step() }
+    pub(in crate::operators) fn step_while_time_is(&mut self, time: &T) -> bool { self.replay.step_while_time_is(time) }
+    pub(in crate::operators) fn advance_buffer_by(&mut self, meet: &T) { self.replay.advance_buffer_by(meet) }
+    pub(in crate::operators) fn is_done(&self) -> bool { self.replay.is_done() }
+}
diff --git a/differential-dataflow/src/operators/int_proxy/history.rs b/differential-dataflow/src/operators/int_proxy/history.rs
index 905614ac0..83d8369fc 100644
--- a/differential-dataflow/src/operators/int_proxy/history.rs
+++ b/differential-dataflow/src/operators/int_proxy/history.rs
@@ -1,5 +1,4 @@
 //! Time-ordered replay of proxy update histories, with meet-advancement.
 
 /// A value history suitable for integer proxy values.
-pub(in crate::operators) type IdHistory<T, R> = crate::operators::ValueHistory<u64, T, R>;
-
+pub(in crate::operators) type IdHistory<T, R> = crate::operators::history::ValueHistory<u64, T, R>;
diff --git a/differential-dataflow/src/operators/int_proxy/join.rs b/differential-dataflow/src/operators/int_proxy/join.rs
index da487276a..31986ca00 100644
--- a/differential-dataflow/src/operators/int_proxy/join.rs
+++ b/differential-dataflow/src/operators/int_proxy/join.rs
@@ -12,7 +12,7 @@ use crate::difference::{Multiply, Semigroup};
 use crate::lattice::Lattice;
 use super::ProxyBridge;
 use crate::operators::join::{Fresh, JoinTactic};
-use crate::operators::ValueHistory;
+use crate::operators::history::ValueHistory;
 
 use super::history::IdHistory;
 
diff --git a/differential-dataflow/src/operators/int_proxy/reduce.rs b/differential-dataflow/src/operators/int_proxy/reduce.rs
index 0b668680e..befb51e4a 100644
--- a/differential-dataflow/src/operators/int_proxy/reduce.rs
+++ b/differential-dataflow/src/operators/int_proxy/reduce.rs
@@ -14,7 +14,7 @@ use crate::lattice::Lattice;
 use crate::trace::{Span, Description};
 use super::ProxyBridge;
 use crate::operators::reduce::{sort_dedup, ReduceTactic};
-use crate::operators::ValueHistory;
+use crate::operators::history::ValueHistory;
 
 /// A unit of proxied reduce work, presented to the backend.
 pub struct ReduceInstance<'a, T, B1, B2> {
diff --git a/differential-dataflow/src/operators/join.rs b/differential-dataflow/src/operators/join.rs
index e249ef33b..761a500be 100644
--- a/differential-dataflow/src/operators/join.rs
+++ b/differential-dataflow/src/operators/join.rs
@@ -3,10 +3,9 @@
 //! The various `join` implementations require that the units of each collection can be multiplied, and that
 //! the multiplication distributes over addition. That is, we will repeatedly evaluate (a + b) * c as (a * c)
 //! + (b * c), and if this is not equal to the former term, little is known about the actual output.
-use std::cmp::Ordering;
 use std::collections::VecDeque;
 
-use timely::{Container, ContainerBuilder};
+use timely::Container;
 use timely::container::NoopBuilder;
 use timely::order::PartialOrder;
 use timely::progress::Timestamp;
@@ -17,15 +16,12 @@ use timely::dataflow::operators::CapabilitySet;
 
 use crate::lattice::Lattice;
 use crate::operators::arrange::Arranged;
-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;
+use crate::trace::TraceReader;
 
 /// A type that can manage the joining of lists of batches.
 ///
 /// 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
+/// yields finished containers, and how it produces them (pushing records into a [`timely::ContainerBuilder`], or
 /// otherwise) is its own concern.
 pub trait JoinTactic<T, B0, B1, C> {
     /// Prepare the join of two lists of batches into an iterator of output containers.
@@ -48,32 +44,7 @@ pub enum Fresh {
     Input1,
 }
 
-/// An equijoin of two traces, sharing a common key type.
-///
-/// This method exists to provide join functionality without opinions on the specific input types, keys and values,
-/// that should be presented. The two traces here can have arbitrary key and value types, which can be unsized and
-/// even potentially unrelated to the input collection data. Importantly, the key and value types could be generic
-/// associated types (GATs) of the traces, and we would seemingly struggle to frame these types as trait arguments.
-///
-/// The implementation produces a caller-specified container. Implementations can use [`AsCollection`] to wrap the
-/// output stream in a collection.
-///
-/// The "correctness" of this method depends heavily on the behavior of the supplied `result` function.
-///
-/// [`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,
-    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>, Time = Tr1::Time>,
-    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))
-}
+pub use crate::operators::cursor::join::join_traces;
 
 /// Drives an equijoin of two traces using a supplied [`JoinTactic`].
 ///
@@ -388,282 +359,3 @@ where
         }
     })
 }
-
-/// Cursor-based join: the conventional [`JoinTactic`] implementation and its per-batch worker.
-mod cursors {
-
-    use std::cell::RefCell;
-    use std::rc::Rc;
-
-    use super::*;
-
-    /// The conventional cursor-based [`JoinTactic`].
-    ///
-    /// It builds a [`CursorList`] over each input batch list and plays the merge-join out at whatever rate
-    /// the driver's fuel allows. Each prepared unit joins a `B0`-side cursor against a `B1`-side cursor,
-    /// emitting `(val0, val1)` to `logic` and yielding the output containers `logic` fills. `logic` is
-    /// shared across all outstanding units (an `Rc<RefCell<_>>`), preserving the single mutable-state
-    /// semantics of one closure threaded through every match — each unit is a self-contained `'static`
-    /// iterator, so it cannot borrow the tactic.
-    ///
-    /// It is parameterized by the builder `CB` into which `logic` pushes output; the [`JoinTactic`] it
-    /// implements is over the container `CB` yields (`CB::Container`).
-    pub struct CursorTactic<B0, B1, L, CB>
-    where
-        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)>,
-    }
-
-    impl<B0, B1, L, CB> CursorTactic<B0, B1, L, CB>
-    where
-        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 {
-            CursorTactic { logic: Rc::new(RefCell::new(logic)), _marker: std::marker::PhantomData }
-        }
-    }
-
-    impl<B0, B1, L, CB> JoinTactic<<B0::Cursor as Cursor>::Time, B0, B1, CB::Container> for CursorTactic<B0, B1, L, CB>
-    where
-        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::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::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
-            // at or beyond `meet`, so the joined time is too), so it is purely a consolidation: it pays off
-            // when the accumulated side carries times below `meet`, and is a wasted scan when it does not. A
-            // more precise rule would skip the scan when the side is already entirely at or beyond `meet`,
-            // but detecting that needs both frontiers, not just `lower`: a batch's times lie at or beyond
-            // both its `lower` and its `since`, so the side is entirely beyond `meet` exactly when
-            // `meet <= lower` or `meet <= since`. A fresh batch is caught by `lower` (its `since` is
-            // `minimum`), a compacted trace by `since` (its `lower` is `minimum`); checking `lower` alone
-            // would wrongly advance a compacted trace whose times are all already at or beyond `meet`. We
-            // keep the simpler fresh-based choice and accept the occasional no-op scan.
-            let (cursor1, storage1) = cursor_list(input0);
-            let (cursor2, storage2) = cursor_list(input1);
-            let (advance1, advance2) = match fresh {
-                Fresh::Input0 => (false, true),
-                Fresh::Input1 => (true, false),
-            };
-            Box::new(DeferredIter {
-                cursor1,
-                storage1,
-                cursor2,
-                storage2,
-                meet,
-                advance1,
-                advance2,
-                logic: Rc::clone(&self.logic),
-                builder: CB::default(),
-                ready: VecDeque::new(),
-                done: false,
-            })
-        }
-    }
-
-    /// Deferred join computation, as an iterator of output containers.
-    ///
-    /// The structure wraps cursors which allow us to play out join computation at whatever rate we like.
-    /// This allows us to avoid producing and buffering massive amounts of data, without giving the timely
-    /// dataflow system a chance to run operators that can consume and aggregate the data. Each `next` plays
-    /// the merge-join forward until the builder yields a container (or the cursors run dry), matching the
-    /// former per-unit `work` loop but suspending at container boundaries rather than under a fuel budget:
-    /// the driver stops pulling once its budget is spent and resumes the same iterator next activation.
-    struct DeferredIter<T, C1, C2, L, CB>
-    where
-        T: Timestamp+Lattice,
-        C1: Cursor<Time=T>,
-        C2: for<'a> Cursor<Key<'a>=C1::Key<'a>, Time=T>,
-        CB: ContainerBuilder,
-    {
-        cursor1: C1,
-        storage1: C1::Storage,
-        cursor2: C2,
-        storage2: C2::Storage,
-        /// The capability's time, at which this unit's output ships; the lower envelope for consolidation.
-        meet: T,
-        /// Whether to advance each side's history by `meet` before consolidation.
-        advance1: bool,
-        advance2: bool,
-        /// The output closure, shared across all outstanding units.
-        logic: Rc<RefCell<L>>,
-        /// The builder `logic` fills; drained into `ready` as containers complete.
-        builder: CB,
-        /// Completed containers awaiting a `next` call.
-        ready: VecDeque<CB::Container>,
-        done: bool,
-    }
-
-    impl<T, C1, C2, L, CB> Iterator for DeferredIter<T, C1, C2, L, CB>
-    where
-        T: Timestamp+Lattice,
-        C1: Cursor<Time=T>,
-        C2: for<'a> Cursor<Key<'a>=C1::Key<'a>, Time=T>,
-        CB: ContainerBuilder<Container: Default>,
-        L: for<'a> FnMut(C1::Key<'a>, C1::Val<'a>, C2::Val<'a>, T, &C1::Diff, &C2::Diff, &mut CB),
-    {
-        type Item = CB::Container;
-
-        /// Play the merge-join forward until a container is ready, or the cursors run dry.
-        #[inline(never)]
-        fn next(&mut self) -> Option<CB::Container> {
-            // Serve any container completed on an earlier call first.
-            if let Some(container) = self.ready.pop_front() { return Some(container); }
-            if self.done { return None; }
-
-            // The accumulated side is advanced by `meet` to consolidate its history; the fresh side is left,
-            // as its times already lie at or beyond `meet`. The choice was fixed per side at construction,
-            // from which input carried the fresh batch.
-            let meet1 = if self.advance1 { Some(&self.meet) } else { None };
-            let meet2 = if self.advance2 { Some(&self.meet) } else { None };
-
-            let storage1 = &self.storage1;
-            let storage2 = &self.storage2;
-            let cursor1 = &mut self.cursor1;
-            let cursor2 = &mut self.cursor2;
-            let builder = &mut self.builder;
-            let ready = &mut self.ready;
-            let mut logic = self.logic.borrow_mut();
-            let logic = &mut *logic;
-
-            let mut thinker = JoinThinker::new();
-            let mut exhausted = false;
-
-            while ready.is_empty() {
-                match (cursor1.get_key(storage1), cursor2.get_key(storage2)) {
-                    (Some(key1), Some(key2)) => match key1.cmp(&key2) {
-                        Ordering::Less => cursor1.seek_key(storage1, key2),
-                        Ordering::Greater => cursor2.seek_key(storage2, key1),
-                        Ordering::Equal => {
-
-                            thinker.history1.edits.load(cursor1, storage1, meet1);
-                            thinker.history2.edits.load(cursor2, storage2, meet2);
-
-                            thinker.think(|v1,v2,t,r1,r2| {
-                                logic(key1, v1, v2, t, r1, r2, builder);
-                            });
-
-                            cursor1.step_key(storage1);
-                            cursor2.step_key(storage2);
-
-                            thinker.history1.clear();
-                            thinker.history2.clear();
-
-                            // Move any completed containers aside; we yield them one at a time.
-                            while let Some(container) = builder.extract() {
-                                // Avoiding the mem::take would require a non-iterator trait.
-                                ready.push_back(std::mem::take(container));
-                            }
-                        }
-                    },
-                    // One side is exhausted; no further keys can match.
-                    _ => { exhausted = true; break; }
-                }
-            }
-
-            if exhausted {
-                self.done = true;
-                // Flush the final partial container.
-                while let Some(container) = builder.finish() {
-                    // Avoiding the mem::take would require a non-iterator trait.
-                    ready.push_back(std::mem::take(container));
-                }
-            }
-
-            ready.pop_front()
-        }
-    }
-
-    struct JoinThinker<V1, V2, T, D1, D2> {
-        pub history1: ValueHistory<V1, T, D1>,
-        pub history2: ValueHistory<V2, T, D2>,
-    }
-
-    impl<V1, V2, T, D1, D2> JoinThinker<V1, V2, T, D1, D2>
-    where
-        V1: Copy + Ord,
-        V2: Copy + Ord,
-        T: Ord + Clone + Lattice,
-        D1: Clone + crate::difference::Semigroup,
-        D2: Clone + crate::difference::Semigroup,
-    {
-        fn new() -> Self {
-            JoinThinker {
-                history1: ValueHistory::new(),
-                history2: ValueHistory::new(),
-            }
-        }
-
-        fn think<F: FnMut(V1, V2, T, &D1, &D2)>(&mut self, mut results: F) {
-
-            // for reasonably sized edits, do the dead-simple thing.
-            if self.history1.edits.len() < 10 || self.history2.edits.len() < 10 {
-                self.history1.edits.map(|v1, t1, d1| {
-                    self.history2.edits.map(|v2, t2, d2| {
-                        results(v1, v2, t1.join(t2), d1, d2);
-                    })
-                })
-            }
-            else {
-
-                let mut replay1 = self.history1.replay();
-                let mut replay2 = self.history2.replay();
-
-                // TODO: It seems like there is probably a good deal of redundant `advance_buffer_by`
-                //       in here. If a time is ever repeated, for example, the call will be identical
-                //       and accomplish nothing. If only a single record has been added, it may not
-                //       be worth the time to collapse (advance, re-sort) the data when a linear scan
-                //       is sufficient.
-
-                while !replay1.is_done() && !replay2.is_done() {
-
-                    if replay1.time().unwrap().cmp(replay2.time().unwrap()) == ::std::cmp::Ordering::Less {
-                        replay2.advance_buffer_by(replay1.meet().unwrap());
-                        for &((val2, ref time2), ref diff2) in replay2.buffer().iter() {
-                            let (val1, time1, diff1) = replay1.edit().unwrap();
-                            results(val1, val2, time1.join(time2), diff1, diff2);
-                        }
-                        replay1.step();
-                    }
-                    else {
-                        replay1.advance_buffer_by(replay2.meet().unwrap());
-                        for &((val1, ref time1), ref diff1) in replay1.buffer().iter() {
-                            let (val2, time2, diff2) = replay2.edit().unwrap();
-                            results(val1, val2, time1.join(time2), diff1, diff2);
-                        }
-                        replay2.step();
-                    }
-                }
-
-                while !replay1.is_done() {
-                    replay2.advance_buffer_by(replay1.meet().unwrap());
-                    for &((val2, ref time2), ref diff2) in replay2.buffer().iter() {
-                        let (val1, time1, diff1) = replay1.edit().unwrap();
-                        results(val1, val2, time1.join(time2), diff1, diff2);
-                    }
-                    replay1.step();
-                }
-                while !replay2.is_done() {
-                    replay1.advance_buffer_by(replay2.meet().unwrap());
-                    for &((val1, ref time1), ref diff1) in replay1.buffer().iter() {
-                        let (val2, time2, diff2) = replay2.edit().unwrap();
-                        results(val1, val2, time1.join(time2), diff1, diff2);
-                    }
-                    replay2.step();
-                }
-            }
-        }
-    }
-}
diff --git a/differential-dataflow/src/operators/mod.rs b/differential-dataflow/src/operators/mod.rs
index 944bfe73f..7c2f662da 100644
--- a/differential-dataflow/src/operators/mod.rs
+++ b/differential-dataflow/src/operators/mod.rs
@@ -9,6 +9,8 @@ pub use self::count::CountTotal;
 pub use self::threshold::ThresholdTotal;
 
 pub mod arrange;
+pub mod cursor;
+pub mod history;
 pub mod int_proxy;
 pub mod reduce;
 pub mod iterate;
@@ -16,272 +18,4 @@ pub mod join;
 pub mod count;
 pub mod threshold;
 
-use crate::lattice::Lattice;
-use crate::trace::Cursor;
-
-/// An accumulation of (value, time, diff) updates.
-pub struct EditList<V, T, D> {
-    values: Vec<(V, usize)>,
-    edits: Vec<(T, D)>,
-}
-
-impl<V: Copy, T: Ord + Lattice, D: crate::difference::Semigroup> EditList<V, T, D> {
-    /// Creates an empty list of edits.
-    #[inline]
-    fn new() -> Self {
-        EditList {
-            values: Vec::new(),
-            edits: Vec::new(),
-        }
-    }
-    /// Walks the cursor's vals at the current key into `self`, advancing times by `meet` if supplied.
-    ///
-    /// The cursor is assumed to be positioned at a key already; callers that need
-    /// to seek should use [`Cursor::populate_key`] (or [`ValueHistory::replay_key`])
-    /// instead. This split avoids a redundant seek in the merge-join inner loop,
-    /// where the cursor is positioned by the upstream merge step.
-    fn load<'a, C>(&mut self, cursor: &mut C, storage: &'a C::Storage, meet: Option<&T>)
-    where
-        C: Cursor<Val<'a> = V, Time = T, Diff = D>,
-    {
-        self.clear();
-        while let Some(val) = cursor.get_val(storage) {
-            cursor.map_times(storage, |time, diff| {
-                let mut t = C::owned_time(time);
-                if let Some(m) = meet { t.join_assign(m); }
-                self.push(t, C::owned_diff(diff));
-            });
-            self.seal(val);
-            cursor.step_val(storage);
-        }
-    }
-    /// Clears the list of edits.
-    #[inline]
-    pub fn clear(&mut self) {
-        self.values.clear();
-        self.edits.clear();
-    }
-    fn len(&self) -> usize { self.edits.len() }
-    /// Inserts a new edit for an as-yet undetermined value.
-    #[inline]
-    pub fn push(&mut self, time: T, diff: D) {
-        // TODO: Could attempt "insertion-sort" like behavior here, where we collapse if possible.
-        self.edits.push((time, diff));
-    }
-    /// Associates all edits pushed since the previous `seal_value` call with `value`.
-    #[inline]
-    pub fn seal(&mut self, value: V) {
-        let prev = self.values.last().map(|x| x.1).unwrap_or(0);
-        crate::consolidation::consolidate_from(&mut self.edits, prev);
-        if self.edits.len() > prev {
-            self.values.push((value, self.edits.len()));
-        }
-    }
-    fn map<F: FnMut(V, &T, &D)>(&self, mut logic: F) {
-        for index in 0 .. self.values.len() {
-            let lower = if index == 0 { 0 } else { self.values[index-1].1 };
-            let upper = self.values[index].1;
-            for edit in lower .. upper {
-                logic(self.values[index].0, &self.edits[edit].0, &self.edits[edit].1);
-            }
-        }
-    }
-}
-
-/// A loaded, time-ordered replay of one key's `(value, time, diff)` edits, with meet-advanced
-/// buffer collapse — the shared machinery under the cursor reduce and the `int_proxy` tactics.
-/// Its local contract: after
-/// `advance_buffer_by(meet)` with the meet of the un-replayed times, the buffer is consolidated
-/// and replay cost stays linear in edits rather than quadratic.
-pub struct ValueHistory<V, T, D> {
-    edits: EditList<V, T, D>,
-    history: Vec<(T, T, usize, usize)>,     // (time, meet, value_index, edit_offset)
-    buffer: Vec<((V, T), D)>,               // where we accumulate / collapse updates.
-}
-
-impl<V: Copy + Ord, T: Ord + Clone + Lattice, D: crate::difference::Semigroup> ValueHistory<V, T, D> {
-    /// An empty history, to be `load`ed.
-    pub fn new() -> Self {
-        ValueHistory {
-            edits: EditList::new(),
-            history: Vec::new(),
-            buffer: Vec::new(),
-        }
-    }
-    /// Discards all loaded state (capacity retained).
-    pub fn clear(&mut self) {
-        self.edits.clear();
-        self.history.clear();
-        self.buffer.clear();
-    }
-
-    /// Loads and replays a specified key.
-    ///
-    /// If the key is absent, the replayed history will be empty.
-    fn replay_key<'a, 'history, C>(
-        &'history mut self,
-        cursor: &mut C,
-        storage: &'a C::Storage,
-        key: C::Key<'a>,
-        meet: Option<&T>,
-    ) -> HistoryReplay<'history, V, T, D>
-    where
-        C: Cursor<Val<'a> = V, Time = T, Diff = D>,
-    {
-        self.clear();
-        cursor.populate_key(storage, key, meet, &mut self.edits);
-        self.replay()
-    }
-
-    /// Wraps the already-built, sorted `history` for a fresh walk, WITHOUT rebuilding or re-sorting
-    /// it. Valid whenever `history` is intact — e.g. after a `replay_key` whose returned replay was
-    /// only read through [`HistoryReplay::times`] (which does not step it). Used by reduce's
-    /// `reference` tactic, whose determination reads times and whose application then walks values.
-    fn walk<'history>(&'history mut self) -> HistoryReplay<'history, V, T, D> {
-        self.buffer.clear();
-        HistoryReplay { replay: self }
-    }
-
-    /// A time-only, non-destructive walk over the already-built `history` (see [`TimeReplay`]). It
-    /// reads times and their precomputed meets and accumulates only *times* into the caller-supplied
-    /// `buffer`, leaving `history` intact for a later [`walk`](Self::walk) over values. The buffer is
-    /// owned by the caller so the standard value walk pays nothing for this reference-only capability.
-    fn replay_times<'history>(&'history self, buffer: &'history mut Vec<T>) -> TimeReplay<'history, T> {
-        buffer.clear();
-        TimeReplay { history: &self.history[..], buffer }
-    }
-
-    /// Organizes history based on current contents of edits (sort + suffix meets).
-    fn build(&mut self) {
-        self.buffer.clear();
-        self.history.clear();
-        for value_index in 0 .. self.edits.values.len() {
-            let lower = if value_index > 0 { self.edits.values[value_index-1].1 } else { 0 };
-            let upper = self.edits.values[value_index].1;
-            for edit_index in lower .. upper {
-                let time = self.edits.edits[edit_index].0.clone();
-                self.history.push((time.clone(), time, value_index, edit_index));
-            }
-        }
-
-        self.history.sort_by(|x,y| y.cmp(x));
-        self.history.iter_mut().reduce(|prev, cur| { cur.1.meet_assign(&prev.1); cur });
-    }
-
-    /// Organizes history based on current contents of edits, returning a fresh replay.
-    fn replay<'history>(&'history mut self) -> HistoryReplay<'history, V, T, D> {
-        self.build();
-        HistoryReplay { replay: self }
-    }
-
-    /// Loads `edits` from a plain iterator (grouped by consecutive value — the presentation
-    /// order), advancing each time by `advance_by` if supplied, then organizes. This is the
-    /// cursor-free ingestion path: the `int_proxy` tactics present `(value_id, time, diff)`
-    /// runs directly rather than through a `Cursor`, and share this machinery instead of
-    /// re-implementing it. Ungrouped input is still correct, only less compact.
-    pub fn load_iter(&mut self, edits: impl Iterator<Item = (V, T, D)>, advance_by: Option<&T>) {
-        self.edits.clear();
-        let mut cur: Option<V> = None;
-        for (v, mut time, diff) in edits {
-            if cur != Some(v) {
-                if let Some(pv) = cur { self.edits.seal(pv); }
-                cur = Some(v);
-            }
-            if let Some(m) = advance_by { time.join_assign(m); }
-            self.edits.push(time, diff);
-        }
-        if let Some(pv) = cur { self.edits.seal(pv); }
-        self.build();
-    }
-}
-
-impl<V: Copy + Ord, T: Ord + Clone + Lattice, D: Clone + crate::difference::Semigroup> ValueHistory<V, T, D> {
-    /// The next (least) un-replayed time.
-    pub fn time(&self) -> Option<&T> { self.history.last().map(|x| &x.0) }
-    /// The meet of all un-replayed times.
-    pub fn meet(&self) -> Option<&T> { self.history.last().map(|x| &x.1) }
-    /// The next un-replayed edit, as `(value, time, diff)`.
-    pub fn edit(&self) -> Option<(V, &T, &D)> {
-        self.history.last().map(|&(ref t, _, v, e)| (self.edits.values[v].0, t, &self.edits.edits[e].1))
-    }
-    /// The buffered (stepped-in, advanced, consolidated) edits.
-    pub fn buffer(&self) -> &[((V, T), D)] { &self.buffer[..] }
-    /// Move the next edit into the buffer.
-    pub fn step(&mut self) {
-        let (time, _, value_index, edit_offset) = self.history.pop().unwrap();
-        self.buffer.push(((self.edits.values[value_index].0, time), self.edits.edits[edit_offset].1.clone()));
-    }
-    /// Step edits while the next time equals `time`; true iff any did.
-    pub fn step_while_time_is(&mut self, time: &T) -> bool {
-        let mut found = false;
-        while self.time() == Some(time) { found = true; self.step(); }
-        found
-    }
-    /// Step edits while the next time is `<= time` in the TOTAL order (a superset of the
-    /// partially-ordered downset; readers filter the buffer by `less_equal` themselves).
-    pub fn step_through(&mut self, time: &T) {
-        while self.time().is_some_and(|t| t <= time) { self.step(); }
-    }
-    /// Advance buffered times by `meet` and consolidate — the collapse that keeps replay linear.
-    pub fn advance_buffer_by(&mut self, meet: &T) {
-        for element in self.buffer.iter_mut() { (element.0).1.join_assign(meet); }
-        crate::consolidation::consolidate(&mut self.buffer);
-    }
-    /// True when every edit has been replayed.
-    pub fn is_done(&self) -> bool { self.history.is_empty() }
-}
-
-struct HistoryReplay<'history, V, T, D> {
-    replay: &'history mut ValueHistory<V, T, D>,
-}
-
-// A `HistoryReplay` is a thin cursor-facing handle over a `ValueHistory`; the replay
-// machinery lives on `ValueHistory` itself (shared with the `int_proxy` tactics), and
-// these forward to it.
-impl<'history, V: Copy + Ord, T: Ord + Clone + Lattice, D: Clone + crate::difference::Semigroup> HistoryReplay<'history, V, T, D> {
-    fn time(&self) -> Option<&T> { self.replay.time() }
-    fn meet(&self) -> Option<&T> { self.replay.meet() }
-    fn edit(&self) -> Option<(V, &T, &D)> { self.replay.edit() }
-    fn buffer(&self) -> &[((V, T), D)] { self.replay.buffer() }
-    fn step(&mut self) { self.replay.step() }
-    fn step_while_time_is(&mut self, time: &T) -> bool { self.replay.step_while_time_is(time) }
-    fn advance_buffer_by(&mut self, meet: &T) { self.replay.advance_buffer_by(meet) }
-    fn is_done(&self) -> bool { self.replay.is_done() }
-}
-
-/// A time-only, non-destructive walk over an already-built [`ValueHistory`] history.
-///
-/// It mirrors the time-facing half of [`HistoryReplay`] — `time`/`meet`/`step`/`step_while_time_is`
-/// /`advance_buffer_by`/`buffer` — but it carries only *times*, and it walks a shrinking *view* of
-/// `history` rather than popping it, so the underlying history stays intact for a later value walk.
-/// `advance_buffer_by` compacts the accumulated times by joining with `meet` and deduplicating (the
-/// time-only analogue of consolidation), which is what keeps a join-closure over these times an
-/// antichain — and hence non-quadratic.
-struct TimeReplay<'history, T> {
-    history: &'history [(T, T, usize, usize)],   // shrinking view; `last()` is the least time
-    buffer: &'history mut Vec<T>,                 // accumulated (and compacted) times seen so far
-}
-
-impl<'history, T: Ord + Clone + Lattice> TimeReplay<'history, T> {
-    fn time(&self) -> Option<&T> { self.history.last().map(|entry| &entry.0) }
-    fn meet(&self) -> Option<&T> { self.history.last().map(|entry| &entry.1) }
-    fn step(&mut self) {
-        let last = self.history.len() - 1;
-        self.buffer.push(self.history[last].0.clone());
-        self.history = &self.history[..last];
-    }
-    fn step_while_time_is(&mut self, time: &T) -> bool {
-        let mut found = false;
-        while self.time() == Some(time) {
-            found = true;
-            self.step();
-        }
-        found
-    }
-    fn advance_buffer_by(&mut self, meet: &T) {
-        for time in self.buffer.iter_mut() { time.join_assign(meet); }
-        self.buffer.sort();
-        self.buffer.dedup();
-    }
-    fn buffer(&self) -> &[T] { &self.buffer[..] }
-}
+pub use self::history::{EditList, ValueHistory};
diff --git a/differential-dataflow/src/operators/reduce.rs b/differential-dataflow/src/operators/reduce.rs
index 6d5eb734b..6a5bd0d56 100644
--- a/differential-dataflow/src/operators/reduce.rs
+++ b/differential-dataflow/src/operators/reduce.rs
@@ -9,10 +9,6 @@
 //! and the operator must determine at which times to re-evaluate the reduction. A machine-checked
 //! account of which times suffice lives in `formal/Differential/Coverage.lean`.
 
-use crate::Data;
-
-use std::marker::PhantomData;
-
 use timely::progress::frontier::Antichain;
 use timely::progress::Timestamp;
 use timely::dataflow::operators::Operator;
@@ -20,15 +16,9 @@ use timely::dataflow::operators::CapabilitySet;
 use timely::dataflow::channels::pact::Pipeline;
 
 use crate::operators::arrange::{Arranged, TraceAgent};
-use crate::trace::{Span, BatchCursor, BatchDiff, BatchKey, BatchVal, BatchValOwn, Builder, Cursor, Description, ExertionLogic, Navigable, Trace, TraceReader};
-use crate::trace::cursor::cursor_list;
-use crate::trace::implementations::containers::BatchContainer;
-
-/// The time type of the updates' cursor: the time coordinate the tactics work in.
-type TimeOf<B> = <<B as Navigable>::Cursor as Cursor>::Time;
+use crate::trace::{Span, ExertionLogic, Trace, TraceReader};
 
-/// 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
+/// Sort and deduplicate a list. Shared by the cursor and proxy tactics, which
 /// each previously carried an identical copy.
 #[inline(never)]
 pub(crate) fn sort_dedup<T: Ord>(list: &mut Vec<T>) {
@@ -76,38 +66,7 @@ pub trait ReduceTactic<T, B1, B2> {
     ) -> (Option<Span<T, B2>>, Antichain<T>);
 }
 
-/// A key-wise reduction of values in an input trace.
-///
-/// This method exists to provide reduce functionality without opinions about qualifying trace types.
-///
-/// The `logic` closure is expected to take a key, accumulated input, and tentative accumulated output,
-/// and populate its final argument with whatever it feels to be appopriate updates. The behavior and
-/// correctness of the implementation rely on this making sense, and e.g. ideally the updates would if
-/// applied to the tentative output bring it in line with some function applied to the input.
-///
-/// The `push` closure is expected to clear its first argument, then populate it with the key and drain
-/// the value updates, as appropriate for the container. It is critical that it clear the container as
-/// the operator has no ability to do this otherwise, and failing to do so represents a leak from one
-/// 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,
-    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: Into<Tr2::Batch>, Input: Default> + 'static,
-    L: FnMut(KC::ReadItem<'_>, &[(BatchVal<'_, Tr1>, BatchDiff<Tr1>)], &mut Vec<(BatchValOwn<Tr2>, BatchDiff<Tr2>)>, &mut Vec<(BatchValOwn<Tr2>, BatchDiff<Tr2>)>)+'static,
-    P: FnMut(&mut Bu::Input, KC::ReadItem<'_>, &mut Vec<(BatchValOwn<Tr2>, Tr2::Time, BatchDiff<Tr2>)>) + 'static,
-{
-    reduce_with_tactic(trace, name, cursors::CursorTactic::<Tr1::Batch, Tr2::Batch, Bu, L, P>::new(logic, push))
-}
-
-// The model-derived reference tactic and its entry point live in `mod reference`; re-exported here
-// (doc-hidden) as the sole public handle for its differential and oracle tests.
-#[doc(hidden)]
-pub use reference::reduce_trace_reference;
+pub use crate::operators::cursor::reduce::reduce_trace;
 
 /// Drives a key-wise reduction using a supplied [`ReduceTactic`].
 ///
@@ -246,994 +205,3 @@ where
 
     Arranged { stream, trace: result_trace.unwrap() }
 }
-
-/// The conventional cursor-based [`ReduceTactic`].
-///
-/// It builds a [`CursorList`](crate::trace::cursor::CursorList) over the input, output, and new-batch
-/// updates and replays them together per key, applying `logic` and shaping output with `push`. It holds
-/// the outstanding synthetic interesting `(key, time)` moments across activations, and reasons only
-/// about times: capabilities are the driver's concern.
-mod cursors {
-
-    use super::*;
-
-    /// The conventional cursor-based [`ReduceTactic`].
-    pub struct CursorTactic<B1, B2, Bu, L, P>
-    where
-        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,
-        // Outstanding `(key, time)` synthetic interesting moments, sorted by `(key, time)`, and the
-        // buffers into which we assemble the next round's moments.
-        pending_keys: <B1::Cursor as Cursor>::KeyContainer,
-        pending_time: <B1::Cursor as Cursor>::TimeContainer,
-        next_pending_keys: <B1::Cursor as Cursor>::KeyContainer,
-        next_pending_time: <B1::Cursor as Cursor>::TimeContainer,
-        // Buffers reused across activations.
-        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: 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 {
-            CursorTactic {
-                logic,
-                push,
-                pending_keys: <B1::Cursor as Cursor>::KeyContainer::with_capacity(0),
-                pending_time: <B1::Cursor as Cursor>::TimeContainer::with_capacity(0),
-                next_pending_keys: <B1::Cursor as Cursor>::KeyContainer::with_capacity(0),
-                next_pending_time: <B1::Cursor as Cursor>::TimeContainer::with_capacity(0),
-                interesting_times: Vec::new(),
-                new_interesting_times: Vec::new(),
-                _marker: PhantomData,
-            }
-        }
-    }
-
-    impl<B1, B2, Bu, L, P> ReduceTactic<TimeOf<B1>, B1, B2> for CursorTactic<B1, B2, Bu, L, P>
-    where
-        B1: Navigable,
-        B2: Navigable,
-        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = TimeOf<B1>>,
-        Bu: Builder<Time = TimeOf<B1>, Output: Into<B2>, Input: Default>,
-        L: FnMut(<B1::Cursor as Cursor>::Key<'_>, &[(<B1::Cursor as Cursor>::Val<'_>, <B1::Cursor as Cursor>::Diff)], &mut Vec<(<B2::Cursor as Cursor>::ValOwn, <B2::Cursor as Cursor>::Diff)>, &mut Vec<(<B2::Cursor as Cursor>::ValOwn, <B2::Cursor as Cursor>::Diff)>),
-        P: FnMut(&mut Bu::Input, <B1::Cursor as Cursor>::Key<'_>, &mut Vec<(<B2::Cursor as Cursor>::ValOwn, 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<TimeOf<B1>>,
-            upper: &Antichain<TimeOf<B1>>,
-            held: &Antichain<TimeOf<B1>>,
-        ) -> (Option<Span<TimeOf<B1>, B2>>, Antichain<TimeOf<B1>>)
-        {
-            let mut produced = None;
-
-            // We have compute needs only if we hold a time in the interval [lower, upper); otherwise we
-            // could not transmit outputs even if they were (incorrectly) non-zero, and we leave the held
-            // times unchanged.
-            if held.elements().iter().any(|time| !upper.less_equal(time)) {
-
-                // cursors for navigating input, output, and new-batch updates.
-                let (mut source_cursor, ref source_storage) = cursor_list(source_batches);
-                let (mut output_cursor, ref output_storage) = cursor_list(output_batches);
-                let (mut batch_cursor, ref batch_storage) = cursor_list(input_batches);
-
-                // 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, TimeOf<B1>, <B2::Cursor as Cursor>::Diff)>::new();
-                let mut builder = Bu::default();
-                // Temporary staging for output building.
-                let mut buffer = Bu::Input::default();
-
-                // Reuseable state for performing the computation.
-                let mut thinker = history_replay::HistoryReplayer::new();
-
-                // March through the keys we must work on, merging `batch_cursor` and pending keys.
-                // The interesting moments need to be in the interval to prompt work.
-                let mut pending_pos = 0;
-                while batch_cursor.key_valid(batch_storage) || pending_pos < self.pending_keys.len() {
-
-                    // Determine the next key we will work on; could be synthetic, could be from a batch.
-                    let key1 = self.pending_keys.get(pending_pos);
-                    let key2 = batch_cursor.get_key(batch_storage);
-                    let key = match (key1, key2) {
-                        (Some(key1), Some(key2)) => ::std::cmp::min(key1, key2),
-                        (Some(key1), None)       => key1,
-                        (None, Some(key2))       => key2,
-                        (None, None)             => unreachable!(),
-                    };
-
-                    // Populate `interesting_times` with interesting times not beyond `upper`.
-                    // TODO: This could just be `pending_time` and indexes within `lower .. upper`.
-                    let prior_pos = pending_pos;
-                    self.interesting_times.clear();
-                    while self.pending_keys.get(pending_pos) == Some(key) {
-                        let owned_time = <B1::Cursor as Cursor>::owned_time(self.pending_time.index(pending_pos));
-                        if !upper.less_equal(&owned_time) { self.interesting_times.push(owned_time); }
-                        pending_pos += 1;
-                    }
-
-                    // tidy up times, removing redundancy.
-                    sort_dedup(&mut self.interesting_times);
-
-                    // If there are new updates, or pending times, we must investigate!
-                    if batch_cursor.get_key(batch_storage) == Some(key) || !self.interesting_times.is_empty() {
-
-                        // do the per-key computation.
-                        thinker.compute(
-                            key,
-                            (&mut source_cursor, source_storage),
-                            (&mut output_cursor, output_storage),
-                            (&mut batch_cursor, batch_storage),
-                            &self.interesting_times,
-                            &mut self.logic,
-                            upper,
-                            &mut output_updates,
-                            held.elements(),
-                            &mut self.new_interesting_times,
-                        );
-
-                        // Advance the cursor if this key, so that the loop's validity check registers the work as done.
-                        if batch_cursor.get_key(batch_storage) == Some(key) { batch_cursor.step_key(batch_storage); }
-
-                        // Merge novel pending times with any prior pending times we did not process.
-                        // TODO: This could be a merge, not a sort_dedup, because both lists should be sorted.
-                        for pos in prior_pos .. pending_pos {
-                            let owned_time = <B1::Cursor as Cursor>::owned_time(self.pending_time.index(pos));
-                            if upper.less_equal(&owned_time) { self.new_interesting_times.push(owned_time); }
-                        }
-                        sort_dedup(&mut self.new_interesting_times);
-                        for time in self.new_interesting_times.drain(..) {
-                            self.next_pending_keys.push_ref(key);
-                            self.next_pending_time.push_own(&time);
-                        }
-
-                        // Sort the buffer by value and move into the builder.
-                        // TODO: This makes assumptions about at least one of (i) the stability of `sort_by`,
-                        //       (ii) that the buffer is time-ordered, and (iii) that the builders accept
-                        //       arbitrarily ordered times.
-                        output_updates.sort_by(|x,y| x.0.cmp(&y.0));
-                        (self.push)(&mut buffer, key, &mut output_updates);
-                        output_updates.clear();
-                        builder.push(&mut buffer);
-                    }
-                    else {
-                        // copy over the pending key and times.
-                        for pos in prior_pos .. pending_pos {
-                            self.next_pending_keys.push_ref(self.pending_keys.index(pos));
-                            self.next_pending_time.push_ref(self.pending_time.index(pos));
-                        }
-                    }
-                }
-                // Drop to avoid lifetime issues that would lock `pending_{keys, time}`.
-                drop(thinker);
-
-                // 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(<TimeOf<B1> as Timestamp>::minimum()));
-                produced = Some(Span::new(description, builder.done().map(Into::into)));
-
-                // Refresh pending keys and times.
-                self.pending_keys.clear(); std::mem::swap(&mut self.next_pending_keys, &mut self.pending_keys);
-                self.pending_time.clear(); std::mem::swap(&mut self.next_pending_time, &mut self.pending_time);
-
-                // Compute the new frontier of interesting times for the operator to hold.
-                let mut frontier = Antichain::<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);
-                }
-
-                (produced, frontier)
-            }
-            else {
-                // No work: leave the held times unchanged, so the driver's downgrade is a no-op.
-                (produced, held.clone())
-            }
-        }
-    }
-
-
-    /// Implementation based on replaying historical and new updates together.
-    mod history_replay {
-
-        use timely::progress::Antichain;
-
-        use crate::lattice::Lattice;
-        use crate::trace::Cursor;
-        use crate::operators::ValueHistory;
-
-        use crate::operators::reduce::sort_dedup;
-
-        /// The `HistoryReplayer` is a compute strategy based on moving through existing inputs, interesting times, etc in
-        /// time order, maintaining consolidated representations of updates with respect to future interesting times.
-        pub struct HistoryReplayer<V1, V2, V, T, D1, D2> {
-            input_history: ValueHistory<V1, T, D1>,
-            output_history: ValueHistory<V2, T, D2>,
-            batch_history: ValueHistory<V1, T, D1>,
-            input_buffer: Vec<(V1, D1)>,
-            output_buffer: Vec<(V, D2)>,
-            update_buffer: Vec<(V, D2)>,
-            output_produced: Vec<((V, T), D2)>,
-            synth_times: Vec<T>,
-            meets: Vec<T>,
-            times_current: Vec<T>,
-            temporary: Vec<T>,
-        }
-
-        impl<V1, V2, V, T, D1, D2> HistoryReplayer<V1, V2, V, T, D1, D2>
-        where
-            V1: Copy + Ord,
-            V2: Copy + Ord,
-            V: Clone + Ord,
-            T: Ord + Clone + Lattice,
-            D1: Clone + crate::difference::Semigroup,
-            D2: Clone + crate::difference::Semigroup,
-        {
-            pub fn new() -> Self {
-                HistoryReplayer {
-                    input_history: ValueHistory::new(),
-                    output_history: ValueHistory::new(),
-                    batch_history: ValueHistory::new(),
-                    input_buffer: Vec::new(),
-                    output_buffer: Vec::new(),
-                    update_buffer: Vec::new(),
-                    output_produced: Vec::new(),
-                    synth_times: Vec::new(),
-                    meets: Vec::new(),
-                    times_current: Vec::new(),
-                    temporary: Vec::new(),
-                }
-            }
-            #[inline(never)]
-            pub fn compute<'a, K, C1, C2, C3, L>(
-                &mut self,
-                key: K,
-                (source_cursor, source_storage): (&mut C1, &'a C1::Storage),
-                (output_cursor, output_storage): (&mut C2, &'a C2::Storage),
-                (batch_cursor, batch_storage): (&mut C3, &'a C3::Storage),
-                times: &Vec<T>,
-                logic: &mut L,
-                upper_limit: &Antichain<T>,
-                outputs: &mut Vec<(V, T, D2)>,
-                held: &[T],
-                new_interesting: &mut Vec<T>)
-            where
-                C1: Cursor<Key<'a> = K, Val<'a> = V1, Time = T, Diff = D1>,
-                C2: Cursor<Key<'a> = K, Val<'a> = V2, ValOwn = V, Time = T, Diff = D2>,
-                C3: Cursor<Key<'a> = K, Val<'a> = V1, Time = T, Diff = D1>,
-                K: Copy + Ord,
-                L: FnMut(K, &[(V1, D1)], &mut Vec<(V, D2)>, &mut Vec<(V, D2)>),
-            {
-
-                // The work we need to perform is at times defined principally by the contents of `batch_cursor`
-                // and `times`, respectively "new work we just received" and "old times we were warned about".
-                //
-                // Our first step is to identify these times, so that we can use them to restrict the amount of
-                // information we need to recover from `input` and `output`; as all times of interest will have
-                // some time from `batch_cursor` or `times`, we can compute their meet and advance all other
-                // loaded times by performing the lattice `join` with this value.
-
-                // Load the batch contents.
-                let mut batch_replay = self.batch_history.replay_key(batch_cursor, batch_storage, key, None);
-
-                // We determine the meet of times we must reconsider (those from `batch` and `times`). This meet
-                // can be used to advance other historical times, which may consolidate their representation. As
-                // a first step, we determine the meets of each *suffix* of `times`, which we will use as we play
-                // history forward.
-
-                self.meets.clear();
-                self.meets.extend(times.iter().cloned());
-                for index in (1 .. self.meets.len()).rev() {
-                    self.meets[index-1] = self.meets[index-1].meet(&self.meets[index]);
-                }
-
-                // Determine the meet of times in `batch` and `times`.
-                let mut meet = None;
-                update_meet(&mut meet, self.meets.get(0));
-                update_meet(&mut meet, batch_replay.meet());
-
-                // Having determined the meet, we can load the input and output histories, where we
-                // advance all times by joining them with `meet`. The resulting times are more compact
-                // and guaranteed to accumulate identically for times greater or equal to `meet`.
-
-                // Load the input and output histories.
-                let mut input_replay =
-                self.input_history.replay_key(source_cursor, source_storage, key, meet.as_ref());
-                let mut output_replay =
-                self.output_history.replay_key(output_cursor, output_storage, key, meet.as_ref());
-
-                self.synth_times.clear();
-                self.times_current.clear();
-                self.output_produced.clear();
-
-                // The frontier of times we may still consider.
-                // Derived from frontiers of our update histories, supplied times, and synthetic times.
-
-                let mut times_slice = &times[..];
-                let mut meets_slice = &self.meets[..];
-
-                // We have candidate times from `batch` and `times`, as well as times identified by either
-                // `input` or `output`. Finally, we may have synthetic times produced as the join of times
-                // we consider in the course of evaluation. As long as any of these times exist, we need to
-                // keep examining times.
-                while let Some(next_time) = [   batch_replay.time(),
-                                                times_slice.first(),
-                                                input_replay.time(),
-                                                output_replay.time(),
-                                                self.synth_times.last(),
-                                            ].into_iter().flatten().min().cloned() {
-
-                    // Advance input and output history replayers. This marks applicable updates as active.
-                    input_replay.step_while_time_is(&next_time);
-                    output_replay.step_while_time_is(&next_time);
-
-                    // One of our goals is to determine if `next_time` is "interesting", meaning whether we
-                    // have any evidence that we should re-evaluate the user logic at this time. For a time
-                    // to be "interesting" it would need to be the join of times that include either a time
-                    // from `batch`, `times`, or `synth`. Neither `input` nor `output` times are sufficient.
-
-                    // Advance batch history, and capture whether an update exists at `next_time`.
-                    let mut interesting = batch_replay.step_while_time_is(&next_time);
-                    if interesting { if let Some(meet) = meet.as_ref() { batch_replay.advance_buffer_by(meet); } }
-
-                    // advance both `synth_times` and `times_slice`, marking this time interesting if in either.
-                    while self.synth_times.last() == Some(&next_time) {
-                        // We don't know enough about `next_time` to avoid putting it in to `times_current`.
-                        // TODO: If we knew that the time derived from a canceled batch update, we could remove the time.
-                        self.times_current.push(self.synth_times.pop().expect("failed to pop from synth_times")); // <-- TODO: this could be a min-heap.
-                        interesting = true;
-                    }
-                    while times_slice.first() == Some(&next_time) {
-                        // We know nothing about why we were warned about `next_time`, and must include it to scare future times.
-                        self.times_current.push(times_slice[0].clone());
-                        times_slice = &times_slice[1..];
-                        meets_slice = &meets_slice[1..];
-                        interesting = true;
-                    }
-
-                    // Times could also be interesting if an interesting time is less than them, as they would join
-                    // and become the time itself. They may not equal the current time because whatever frontier we
-                    // are tracking may not have advanced far enough.
-                    // TODO: `batch_history` may or may not be super compact at this point, and so this check might
-                    //       yield false positives if not sufficiently compact. Maybe we should look into this and see.
-                    interesting = interesting || batch_replay.buffer().iter().any(|&((_, ref t),_)| t.less_equal(&next_time));
-                    interesting = interesting || self.times_current.iter().any(|t| t.less_equal(&next_time));
-
-                    // We should only process times that are not in advance of `upper_limit`.
-                    //
-                    // We have no particular guarantee that known times will not be in advance of `upper_limit`.
-                    // We may have the guarantee that synthetic times will not be, as we test against the limit
-                    // before we add the time to `synth_times`.
-                    if !upper_limit.less_equal(&next_time) {
-
-                        // DETERMINATION (times only). Determine synthetic interesting times.
-                        //
-                        // Synthetic interesting times are produced differently for interesting and uninteresting
-                        // times. An uninteresting time must join with an interesting time to become interesting,
-                        // which means joins with `self.batch_history` and  `self.times_current`. I think we can
-                        // skip `self.synth_times` as we haven't gotten to them yet, but we will and they will be
-                        // joined against everything.
-
-                        // Any time, even uninteresting times, must be joined with the current accumulation of
-                        // batch times as well as the current accumulation of `times_current`.
-                        self.temporary.extend(batch_replay.buffer().iter().map(|((_,time),_)| time).filter(|time| !time.less_equal(&next_time)).map(|time| time.join(&next_time)));
-                        self.temporary.extend(self.times_current.iter().filter(|time| !time.less_equal(&next_time)).map(|time| time.join(&next_time)));
-
-                        // An interesting time additionally joins with `input` and `output` history and this round's
-                        // produced output: it carries the seed, so those joins stay interesting (an uninteresting
-                        // time does not, as `input`/`output` times are not themselves seeds). We advance the buffers
-                        // by `meet` first, exactly as evaluation reads them below; by join preservation the advanced
-                        // and unadvanced times spawn the same synthetics, so this matches the pre-split behavior.
-                        if interesting {
-                            if let Some(meet) = meet.as_ref() { input_replay.advance_buffer_by(meet) };
-                            if let Some(meet) = meet.as_ref() { output_replay.advance_buffer_by(meet) };
-                            self.temporary.extend(input_replay.buffer().iter().map(|((_,time),_)| time).filter(|time| !time.less_equal(&next_time)).map(|time| time.join(&next_time)));
-                            self.temporary.extend(output_replay.buffer().iter().map(|((_,time),_)| time).filter(|time| !time.less_equal(&next_time)).map(|time| time.join(&next_time)));
-                            self.temporary.extend(self.output_produced.iter().map(|((_,time),_)| time).filter(|time| !time.less_equal(&next_time)).map(|time| time.join(&next_time)));
-                        }
-                        sort_dedup(&mut self.temporary);
-
-                        // Introduce synthetic times, and re-organize if we add any.
-                        let synth_len = self.synth_times.len();
-                        for time in self.temporary.drain(..) {
-                            // We can either service `join` now, or must delay for the future.
-                            if upper_limit.less_equal(&time) {
-                                debug_assert!(held.iter().any(|t| t.less_equal(&time)));
-                                new_interesting.push(time);
-                            }
-                            else {
-                                self.synth_times.push(time);
-                            }
-                        }
-                        if self.synth_times.len() > synth_len {
-                            self.synth_times.sort_by(|x,y| y.cmp(x));
-                            self.synth_times.dedup();
-                        }
-
-                        // EVALUATION (values only).
-                        // We should re-evaluate the computation if this is an interesting time.
-                        // If the time is uninteresting (and our logic is sound) it is not possible for there to be
-                        // output produced. This sounds like a good test to have for debug builds!
-                        if interesting {
-
-                            // Assemble the input collection at `next_time`. (`self.input_buffer` cleared just after use).
-                            // The buffers were advanced by `meet` in the determination step above.
-                            debug_assert!(self.input_buffer.is_empty());
-                            for ((value, time), diff) in input_replay.buffer().iter() {
-                                if time.less_equal(&next_time) { self.input_buffer.push((*value, diff.clone())); }
-                            }
-                            for ((value, time), diff) in batch_replay.buffer().iter() {
-                                if time.less_equal(&next_time) { self.input_buffer.push((*value, diff.clone())); }
-                            }
-                            crate::consolidation::consolidate(&mut self.input_buffer);
-
-                            // Assemble the output collection at `next_time`. (`self.output_buffer` cleared just after use).
-                            for ((value, time), diff) in output_replay.buffer().iter() {
-                                if time.less_equal(&next_time) { self.output_buffer.push((C2::owned_val(*value), diff.clone())); }
-                            }
-                            for ((value, time), diff) in self.output_produced.iter() {
-                                if time.less_equal(&next_time) { self.output_buffer.push(((*value).to_owned(), diff.clone())); }
-                            }
-                            crate::consolidation::consolidate(&mut self.output_buffer);
-
-                            // Apply user logic if non-empty input or output and see what happens!
-                            if !self.input_buffer.is_empty() || !self.output_buffer.is_empty() {
-                                logic(key, &self.input_buffer[..], &mut self.output_buffer, &mut self.update_buffer);
-                                self.input_buffer.clear();
-                                self.output_buffer.clear();
-
-                                // Having subtracted output updates from user output, consolidate the results to determine
-                                // if there is anything worth reporting. Note: this also orders the results by value, so
-                                // that could make the above merging plan even easier.
-                                //
-                                // Stash produced updates into both capability-indexed buffers and `output_produced`.
-                                // The two locations are important, in that we will compact `output_produced` as we move
-                                // through times, but we cannot compact the output buffers because we need their actual
-                                // times.
-                                crate::consolidation::consolidate(&mut self.update_buffer);
-                                if !self.update_buffer.is_empty() {
-
-                                    // We *should* be able to find a capability for `next_time`. Any thing else would
-                                    // indicate a logical error somewhere along the way; either we release a capability
-                                    // we should have kept, or we have computed the output incorrectly (or both!)
-                                    assert!(held.iter().any(|time| time.less_equal(&next_time)), "failed to find capability");
-                                    for (val, diff) in self.update_buffer.drain(..) {
-                                        self.output_produced.push(((val.clone(), next_time.clone()), diff.clone()));
-                                        outputs.push((val, next_time.clone(), diff));
-                                    }
-
-                                    // Advance times in `self.output_produced` and consolidate the representation.
-                                    // NOTE: We only do this when we add records; it could be that there are situations
-                                    //       where we want to consolidate even without changes (because an initially
-                                    //       large collection can now be collapsed).
-                                    if let Some(meet) = meet.as_ref() { for entry in &mut self.output_produced { (entry.0).1.join_assign(meet); } }
-                                    crate::consolidation::consolidate(&mut self.output_produced);
-                                }
-                            }
-                        }
-                    }
-                    else if interesting {
-                        // We cannot process `next_time` now, and must delay it.
-                        //
-                        // I think we are probably only here because of an uninteresting time declared interesting,
-                        // as initial interesting times are filtered to be in interval, and synthetic times are also
-                        // filtered before introducing them to `self.synth_times`.
-                        new_interesting.push(next_time.clone());
-                        debug_assert!(held.iter().any(|t| t.less_equal(&next_time)))
-                    }
-
-                    // Update `meet` to track the meet of each source of times.
-                    meet = None;
-                    update_meet(&mut meet, batch_replay.meet());
-                    update_meet(&mut meet, input_replay.meet());
-                    update_meet(&mut meet, output_replay.meet());
-                    for time in self.synth_times.iter() { update_meet(&mut meet, Some(time)); }
-                    update_meet(&mut meet, meets_slice.first());
-
-                    // Update `times_current` by the frontier.
-                    if let Some(meet) = meet.as_ref() {
-                        for time in self.times_current.iter_mut() {
-                            *time = time.join(meet);
-                        }
-                    }
-
-                    sort_dedup(&mut self.times_current);
-                }
-
-                // Normalize the representation of `new_interesting`, deduplicating and ordering.
-                sort_dedup(new_interesting);
-            }
-        }
-
-        /// Updates an optional meet by an optional time.
-        fn update_meet<T: Lattice+Clone>(meet: &mut Option<T>, other: Option<&T>) {
-            if let Some(time) = other {
-                if let Some(meet) = meet.as_mut() { meet.meet_assign(time); }
-                else { *meet = Some(time.clone()); }
-            }
-        }
-    }
-}
-
-/// A second [`ReduceTactic`], written directly from the incremental model in
-/// `formal/Differential/Model.lean`.
-///
-/// Per key it runs two phases over one cursor walk. Phase 1 (determination) computes the
-/// interesting times as the truncated join-closure over {input, output, seeds} — the model's
-/// `Reached` — advancing by meets so the synthetic set stays bounded. Phase 2 (application) walks
-/// exactly those times in order, maintaining tight input/output accumulations by meets, and emits
-/// the corrections — the model's `emit_correct`. Determination never consults the output produced
-/// this round (it finishes first), so this tactic embodies the proven algorithm exactly and is the
-/// clean subject for differential testing against [`cursors::CursorTactic`].
-pub(crate) mod reference {
-
-    use super::*;
-    use crate::lattice::Lattice;
-    use crate::operators::ValueHistory;
-
-    /// Drives a key-wise reduction with the model-derived [`ReferenceTactic`], the analogue of the
-    /// default [`super::reduce_trace`]. Same result contract; intended for differential testing of the
-    /// two tactics against each other. Re-exported (doc-hidden) from the parent module as the sole
-    /// public handle: the reference tactic is a testing and demonstration oracle, not a stable entry
-    /// 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,
-        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: Into<Tr2::Batch>, Input: Default> + 'static,
-        L: FnMut(BatchKey<'_, Tr1>, &[(BatchVal<'_, Tr1>, BatchDiff<Tr1>)], &mut Vec<(BatchValOwn<Tr2>, BatchDiff<Tr2>)>, &mut Vec<(BatchValOwn<Tr2>, BatchDiff<Tr2>)>)+'static,
-        P: FnMut(&mut Bu::Input, BatchKey<'_, Tr1>, &mut Vec<(BatchValOwn<Tr2>, Tr2::Time, BatchDiff<Tr2>)>) + 'static,
-    {
-        reduce_with_tactic(trace, name, ReferenceTactic::<Tr1::Batch, Tr2::Batch, Bu, L, P>::new(logic, push))
-    }
-
-
-    /// Updates an optional meet by an optional time.
-    fn update_meet<T: Lattice+Clone>(meet: &mut Option<T>, other: Option<&T>) {
-        if let Some(time) = other {
-            if let Some(meet) = meet.as_mut() { meet.meet_assign(time); }
-            else { *meet = Some(time.clone()); }
-        }
-    }
-
-    /// The model-derived [`ReduceTactic`]. Structurally a twin of [`cursors::CursorTactic`]; only the
-    /// per-key engine differs.
-    pub struct ReferenceTactic<B1, B2, Bu, L, P>
-    where
-        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,
-        pending_keys: <B1::Cursor as Cursor>::KeyContainer,
-        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<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: 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 {
-            ReferenceTactic {
-                logic,
-                push,
-                pending_keys: <B1::Cursor as Cursor>::KeyContainer::with_capacity(0),
-                pending_time: <B1::Cursor as Cursor>::TimeContainer::with_capacity(0),
-                next_pending_keys: <B1::Cursor as Cursor>::KeyContainer::with_capacity(0),
-                next_pending_time: <B1::Cursor as Cursor>::TimeContainer::with_capacity(0),
-                interesting_times: Vec::new(),
-                new_interesting_times: Vec::new(),
-                _marker: PhantomData,
-            }
-        }
-    }
-
-    impl<B1, B2, Bu, L, P> ReduceTactic<TimeOf<B1>, B1, B2> for ReferenceTactic<B1, B2, Bu, L, P>
-    where
-        B1: Navigable,
-        B2: Navigable,
-        for<'a> B2::Cursor: Cursor<Key<'a> = <B1::Cursor as Cursor>::Key<'a>, ValOwn: Data, Time = TimeOf<B1>>,
-        Bu: Builder<Time = TimeOf<B1>, Output: Into<B2>, Input: Default>,
-        L: FnMut(<B1::Cursor as Cursor>::Key<'_>, &[(<B1::Cursor as Cursor>::Val<'_>, <B1::Cursor as Cursor>::Diff)], &mut Vec<(<B2::Cursor as Cursor>::ValOwn, <B2::Cursor as Cursor>::Diff)>, &mut Vec<(<B2::Cursor as Cursor>::ValOwn, <B2::Cursor as Cursor>::Diff)>),
-        P: FnMut(&mut Bu::Input, <B1::Cursor as Cursor>::Key<'_>, &mut Vec<(<B2::Cursor as Cursor>::ValOwn, 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<TimeOf<B1>>,
-            upper: &Antichain<TimeOf<B1>>,
-            held: &Antichain<TimeOf<B1>>,
-        ) -> (Option<Span<TimeOf<B1>, B2>>, Antichain<TimeOf<B1>>)
-        {
-            let mut produced = None;
-
-            if held.elements().iter().any(|time| !upper.less_equal(time)) {
-
-                let (mut source_cursor, ref source_storage) = cursor_list(source_batches);
-                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, TimeOf<B1>, <B2::Cursor as Cursor>::Diff)>::new();
-                let mut builder = Bu::default();
-                let mut buffer = Bu::Input::default();
-
-                // Reuseable state for performing the computation.
-                let mut thinker = ReferenceThinker::new();
-
-                let mut pending_pos = 0;
-                while batch_cursor.key_valid(batch_storage) || pending_pos < self.pending_keys.len() {
-
-                    let key1 = self.pending_keys.get(pending_pos);
-                    let key2 = batch_cursor.get_key(batch_storage);
-                    let key = match (key1, key2) {
-                        (Some(key1), Some(key2)) => ::std::cmp::min(key1, key2),
-                        (Some(key1), None)       => key1,
-                        (None, Some(key2))       => key2,
-                        (None, None)             => unreachable!(),
-                    };
-
-                    let prior_pos = pending_pos;
-                    self.interesting_times.clear();
-                    while self.pending_keys.get(pending_pos) == Some(key) {
-                        let owned_time = <B1::Cursor as Cursor>::owned_time(self.pending_time.index(pending_pos));
-                        if !upper.less_equal(&owned_time) { self.interesting_times.push(owned_time); }
-                        pending_pos += 1;
-                    }
-
-                    sort_dedup(&mut self.interesting_times);
-
-                    if batch_cursor.get_key(batch_storage) == Some(key) || !self.interesting_times.is_empty() {
-
-                        thinker.compute(
-                            key,
-                            (&mut source_cursor, source_storage),
-                            (&mut output_cursor, output_storage),
-                            (&mut batch_cursor, batch_storage),
-                            &self.interesting_times,
-                            &mut self.logic,
-                            upper,
-                            &mut output_updates,
-                            held.elements(),
-                            &mut self.new_interesting_times,
-                        );
-
-                        if batch_cursor.get_key(batch_storage) == Some(key) { batch_cursor.step_key(batch_storage); }
-
-                        for pos in prior_pos .. pending_pos {
-                            let owned_time = <B1::Cursor as Cursor>::owned_time(self.pending_time.index(pos));
-                            if upper.less_equal(&owned_time) { self.new_interesting_times.push(owned_time); }
-                        }
-                        sort_dedup(&mut self.new_interesting_times);
-                        for time in self.new_interesting_times.drain(..) {
-                            self.next_pending_keys.push_ref(key);
-                            self.next_pending_time.push_own(&time);
-                        }
-
-                        output_updates.sort_by(|x,y| x.0.cmp(&y.0));
-                        (self.push)(&mut buffer, key, &mut output_updates);
-                        output_updates.clear();
-                        builder.push(&mut buffer);
-                    }
-                    else {
-                        for pos in prior_pos .. pending_pos {
-                            self.next_pending_keys.push_ref(self.pending_keys.index(pos));
-                            self.next_pending_time.push_ref(self.pending_time.index(pos));
-                        }
-                    }
-                }
-                drop(thinker);
-
-                let description = Description::new(lower.clone(), upper.clone(), Antichain::from_elem(<TimeOf<B1> as Timestamp>::minimum()));
-                produced = Some(Span::new(description, builder.done().map(Into::into)));
-
-                self.pending_keys.clear(); std::mem::swap(&mut self.next_pending_keys, &mut self.pending_keys);
-                self.pending_time.clear(); std::mem::swap(&mut self.next_pending_time, &mut self.pending_time);
-
-                let mut frontier = Antichain::<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);
-                }
-
-                (produced, frontier)
-            }
-            else {
-                (produced, held.clone())
-            }
-        }
-    }
-
-    /// The two-phase per-key engine.
-    ///
-    /// Phase 1 (determination) reads the input/output/seed *times* and closes them into `active`
-    /// (the interesting times) and the pended set — Model.lean's `Reached`, directly. Phase 2
-    /// (application) walks the same, still-loaded histories for *values* and emits corrections.
-    pub struct ReferenceThinker<V1, V2, V, T, D1, D2> {
-        input_history: ValueHistory<V1, T, D1>,
-        output_history: ValueHistory<V2, T, D2>,
-        batch_history: ValueHistory<V1, T, D1>,
-        input_buffer: Vec<(V1, D1)>,
-        output_buffer: Vec<(V, D2)>,
-        update_buffer: Vec<(V, D2)>,
-        output_produced: Vec<((V, T), D2)>,
-        // Phase 1 (the compacted closure): synthetic reached times still to visit, the reached times
-        // in play as join partners, scratch for the joins, and suffix-meets of the supplied times.
-        synth_times: Vec<T>,
-        times_current: Vec<T>,
-        temporary: Vec<T>,
-        meets: Vec<T>,
-        // Reusable time-only buffers for phase 1's `TimeReplay` walks. Pooled here (rather than in
-        // `ValueHistory`) so the reference tactic pays for them and the standard value walk does not.
-        batch_times: Vec<T>,
-        input_times: Vec<T>,
-        output_times: Vec<T>,
-        // The interesting (in-band reached) times, handed from phase 1 to phase 2.
-        active: Vec<T>,
-    }
-
-    impl<V1, V2, V, T, D1, D2> ReferenceThinker<V1, V2, V, T, D1, D2>
-    where
-        V1: Copy + Ord,
-        V2: Copy + Ord,
-        V: Clone + Ord,
-        T: Ord + Clone + Lattice + 'static,
-        D1: Clone + crate::difference::Semigroup,
-        D2: Clone + crate::difference::Semigroup,
-    {
-        pub fn new() -> Self {
-            ReferenceThinker {
-                input_history: ValueHistory::new(),
-                output_history: ValueHistory::new(),
-                batch_history: ValueHistory::new(),
-                input_buffer: Vec::new(),
-                output_buffer: Vec::new(),
-                update_buffer: Vec::new(),
-                output_produced: Vec::new(),
-                synth_times: Vec::new(),
-                times_current: Vec::new(),
-                temporary: Vec::new(),
-                meets: Vec::new(),
-                batch_times: Vec::new(),
-                input_times: Vec::new(),
-                output_times: Vec::new(),
-                active: Vec::new(),
-            }
-        }
-
-        #[inline(never)]
-        pub fn compute<'a, K, C1, C2, C3, L>(
-            &mut self,
-            key: K,
-            (source_cursor, source_storage): (&mut C1, &'a C1::Storage),
-            (output_cursor, output_storage): (&mut C2, &'a C2::Storage),
-            (batch_cursor, batch_storage): (&mut C3, &'a C3::Storage),
-            times: &Vec<T>,
-            logic: &mut L,
-            upper_limit: &Antichain<T>,
-            outputs: &mut Vec<(V, T, D2)>,
-                held: &[T],
-            new_interesting: &mut Vec<T>)
-        where
-            C1: Cursor<Key<'a> = K, Val<'a> = V1, Time = T, Diff = D1>,
-            C2: Cursor<Key<'a> = K, Val<'a> = V2, ValOwn = V, Time = T, Diff = D2>,
-            C3: Cursor<Key<'a> = K, Val<'a> = V1, Time = T, Diff = D1>,
-            K: Copy + Ord,
-            L: FnMut(K, &[(V1, D1)], &mut Vec<(V, D2)>, &mut Vec<(V, D2)>),
-        {
-            // ================== PHASE 1 — DETERMINATION (`Reached`, compacted) ==================
-            // The interesting times are Model.lean's `Reached` — but computed the non-quadratic way.
-            // Walk the input/output/seed times in increasing order; a time is *reached* only via a
-            // seed (a batch update, a due pending time, or a synthetic join of earlier reached times);
-            // a reached in-band time joins against the live partners to spawn more reached times, and
-            // a join beyond `upper` is pended. The live partner sets are kept an antichain by
-            // `advance_buffer_by(meet)` — coincident times collapse under the running meet — so this is
-            // the closure without the all-pairs blow-up. Time-only: `TimeReplay` reads the histories
-            // without touching values or stepping the underlying `history`, so phase 2 can walk them.
-            {
-                // Suffix-meets of the supplied (due pending) times, consumed as we pass them.
-                self.meets.clear();
-                self.meets.extend(times.iter().cloned());
-                for index in (1 .. self.meets.len()).rev() {
-                    self.meets[index-1] = self.meets[index-1].meet(&self.meets[index]);
-                }
-
-                // Build each history, then read it time-only (leaving it intact for phase 2).
-                drop(self.batch_history.replay_key(batch_cursor, batch_storage, key, None));
-                drop(self.input_history.replay_key(source_cursor, source_storage, key, None));
-                drop(self.output_history.replay_key(output_cursor, output_storage, key, None));
-                let mut batch_replay = self.batch_history.replay_times(&mut self.batch_times);
-                let mut input_replay = self.input_history.replay_times(&mut self.input_times);
-                let mut output_replay = self.output_history.replay_times(&mut self.output_times);
-
-                self.synth_times.clear();
-                self.times_current.clear();
-                self.temporary.clear();
-                self.active.clear();
-
-                let mut times_slice = &times[..];
-                let mut meets_slice = &self.meets[..];
-                let mut meet: Option<T> = None;
-
-                while let Some(next_time) = [   batch_replay.time(),
-                                                times_slice.first(),
-                                                input_replay.time(),
-                                                output_replay.time(),
-                                                self.synth_times.last(),
-                                            ].into_iter().flatten().min().cloned() {
-
-                    input_replay.step_while_time_is(&next_time);
-                    output_replay.step_while_time_is(&next_time);
-
-                    // Reached via a seed: a batch update, a due pending time, or a synthetic join.
-                    // (Input/output times alone are not reached — they are only join partners.)
-                    let mut interesting = batch_replay.step_while_time_is(&next_time);
-                    if interesting { if let Some(m) = meet.as_ref() { batch_replay.advance_buffer_by(m); } }
-                    while self.synth_times.last() == Some(&next_time) {
-                        self.times_current.push(self.synth_times.pop().unwrap());
-                        interesting = true;
-                    }
-                    while times_slice.first() == Some(&next_time) {
-                        self.times_current.push(next_time.clone());
-                        times_slice = &times_slice[1..];
-                        meets_slice = &meets_slice[1..];
-                        interesting = true;
-                    }
-                    // Absorb: a time at or above a reached time is itself reached.
-                    interesting = interesting
-                        || batch_replay.buffer().iter().any(|t| t.less_equal(&next_time))
-                        || self.times_current.iter().any(|t| t.less_equal(&next_time));
-
-                    if !upper_limit.less_equal(&next_time) {
-                        // A reached in-band time is `active`; join it against the live partners —
-                        // input/output (`joinBase`) and reached-so-far (`joinActive`) — for new times.
-                        if interesting {
-                            self.active.push(next_time.clone());
-                            if let Some(m) = meet.as_ref() { input_replay.advance_buffer_by(m); output_replay.advance_buffer_by(m); }
-                            self.temporary.extend(input_replay.buffer().iter().filter(|t| !t.less_equal(&next_time)).map(|t| t.join(&next_time)));
-                            self.temporary.extend(output_replay.buffer().iter().filter(|t| !t.less_equal(&next_time)).map(|t| t.join(&next_time)));
-                        }
-                        self.temporary.extend(batch_replay.buffer().iter().filter(|t| !t.less_equal(&next_time)).map(|t| t.join(&next_time)));
-                        self.temporary.extend(self.times_current.iter().filter(|t| !t.less_equal(&next_time)).map(|t| t.join(&next_time)));
-                        sort_dedup(&mut self.temporary);
-
-                        let synth_len = self.synth_times.len();
-                        for time in self.temporary.drain(..) {
-                            if upper_limit.less_equal(&time) { new_interesting.push(time); }  // pended
-                            else { self.synth_times.push(time); }                             // reached, later
-                        }
-                        if self.synth_times.len() > synth_len {
-                            self.synth_times.sort_by(|x,y| y.cmp(x));
-                            self.synth_times.dedup();
-                        }
-                    }
-                    else if interesting {
-                        new_interesting.push(next_time.clone());
-                    }
-
-                    // Running meet (a lower bound on every time still to visit); compact the reached
-                    // partners `times_current` with it.
-                    meet = None;
-                    update_meet(&mut meet, batch_replay.meet());
-                    update_meet(&mut meet, input_replay.meet());
-                    update_meet(&mut meet, output_replay.meet());
-                    for time in self.synth_times.iter() { update_meet(&mut meet, Some(time)); }
-                    update_meet(&mut meet, meets_slice.first());
-                    if let Some(m) = meet.as_ref() {
-                        for time in self.times_current.iter_mut() { *time = time.join(m); }
-                    }
-                    sort_dedup(&mut self.times_current);
-                }
-
-                sort_dedup(&mut self.active);
-            }
-
-            // ===================== PHASE 2 — APPLICATION (`emit_correct`) =====================
-            // Walk `self.active` in order over the SAME per-key edits (via `replay`, no cursor), keep
-            // the input/output accumulations tight by advancing to the meet of the times still to be
-            // produced, apply `logic`, and emit corrections.
-            {
-                self.meets.clear();
-                self.meets.extend(self.active.iter().cloned());
-                for index in (1 .. self.meets.len()).rev() {
-                    self.meets[index-1] = self.meets[index-1].meet(&self.meets[index]);
-                }
-
-                // Walk the histories loaded (and left intact) by phase 1 — no cursor re-read, no
-                // rebuild, no re-sort; just a fresh walk of the same sorted `history` for values.
-                let mut batch_replay = self.batch_history.walk();
-                let mut input_replay = self.input_history.walk();
-                let mut output_replay = self.output_history.walk();
-
-                self.output_produced.clear();
-
-                for index in 0 .. self.active.len() {
-                    let next_time = self.active[index].clone();
-                    let meet = self.meets[index].clone();
-
-                    // Phase 2 visits only the active times, so at each we must catch up the histories to
-                    // include every edit that will contribute to the accumulation at `next_time` (edits
-                    // at non-active times count too). `history` is sorted by the total `Ord` and `step`
-                    // pops the least, so we step the `Ord`-prefix `t <= next_time`, NOT the partial
-                    // `t.less_equal(next_time)`: the partial order interleaves with the sort, so an
-                    // `Ord`-earlier time incomparable to `next_time` would halt a `less_equal` walk early
-                    // and strand later edits that *are* `less_equal(next_time)`. Stepping the `Ord`-prefix
-                    // takes a superset; the `less_equal` filter below then selects the true `<= next_time`
-                    // edits. (Assembling with `less_equal` while stepping with `<=` is what the value-aware
-                    // cursor does via its full time-order frontier walk.)
-                    while input_replay.time().map_or(false, |t| *t <= next_time) { input_replay.step(); }
-                    while batch_replay.time().map_or(false, |t| *t <= next_time) { batch_replay.step(); }
-                    while output_replay.time().map_or(false, |t| *t <= next_time) { output_replay.step(); }
-                    input_replay.advance_buffer_by(&meet);
-                    batch_replay.advance_buffer_by(&meet);
-                    output_replay.advance_buffer_by(&meet);
-
-                    debug_assert!(self.input_buffer.is_empty());
-                    for ((value, time), diff) in input_replay.buffer().iter() {
-                        if time.less_equal(&next_time) { self.input_buffer.push((*value, diff.clone())); }
-                    }
-                    for ((value, time), diff) in batch_replay.buffer().iter() {
-                        if time.less_equal(&next_time) { self.input_buffer.push((*value, diff.clone())); }
-                    }
-                    crate::consolidation::consolidate(&mut self.input_buffer);
-
-                    for ((value, time), diff) in output_replay.buffer().iter() {
-                        if time.less_equal(&next_time) { self.output_buffer.push((C2::owned_val(*value), diff.clone())); }
-                    }
-                    for ((value, time), diff) in self.output_produced.iter() {
-                        if time.less_equal(&next_time) { self.output_buffer.push((value.clone(), diff.clone())); }
-                    }
-                    crate::consolidation::consolidate(&mut self.output_buffer);
-
-                    if !self.input_buffer.is_empty() || !self.output_buffer.is_empty() {
-                        logic(key, &self.input_buffer[..], &mut self.output_buffer, &mut self.update_buffer);
-                        self.input_buffer.clear();
-                        self.output_buffer.clear();
-
-                        crate::consolidation::consolidate(&mut self.update_buffer);
-                        if !self.update_buffer.is_empty() {
-
-                            assert!(held.iter().any(|time| time.less_equal(&next_time)), "failed to find capability");
-                            for (val, diff) in self.update_buffer.drain(..) {
-                                self.output_produced.push(((val.clone(), next_time.clone()), diff.clone()));
-                                outputs.push((val, next_time.clone(), diff));
-                            }
-
-                            for entry in &mut self.output_produced { (entry.0).1.join_assign(&meet); }
-                            crate::consolidation::consolidate(&mut self.output_produced);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/differential-dataflow/src/trace/chunk/mod.rs b/differential-dataflow/src/trace/chunk/mod.rs
index 496a79dda..977747f93 100644
--- a/differential-dataflow/src/trace/chunk/mod.rs
+++ b/differential-dataflow/src/trace/chunk/mod.rs
@@ -21,7 +21,7 @@
 //! These are the `Batcher` / `Builder` / `Spine` to hand to
 //! [`arrange_core`](crate::operators::arrange::arrangement::arrange_core), along with a
 //! chunker that forms `C` from the input stream — typically
-//! [`ContainerChunker<C>`](crate::trace::implementations::merge_batcher::chunker::ContainerChunker).
+//! [`ContainerChunker<C>`](crate::batcher::merge::chunker::ContainerChunker).
 //! Trace *maintenance* needs only [`Chunk`]; cursor-driven *consumption* of the
 //! arrangement additionally asks `C` for the [`NavigableChunk`] capability.
 //! Everything else here ([`ChunkBatch`], [`ChunkMerger`], [`ChunkBatchMerger`],
@@ -270,14 +270,14 @@ where
     fn len(&self) -> usize { self.chunks.iter().map(C::len).sum() }
 }
 
-/// A merge-batcher [`Merger`](crate::trace::implementations::merge_batcher::Merger)
+/// A merge-batcher [`Merger`](crate::batcher::merge::Merger)
 /// over chains of [`Chunk`]s.
 ///
 /// `merge` runs the whole-chain binary merger; `extract` splits by the seal frontier
 /// using [`Chunk::extract`]. The batcher consolidates equal `(data, time)` updates
 /// but does *not* advance times — time advancement is advance's job, handled later in
 /// the trace. Both settle their output, since the batcher's chains want to be graded.
-pub type ChunkBatcher<Chu, C> = crate::trace::implementations::merge_batcher::MergeBatcher<Chu, ChunkMerger<C>, ChunkBuilder<C>>;
+pub type ChunkBatcher<Chu, C> = crate::batcher::merge::MergeBatcher<Chu, ChunkMerger<C>, ChunkBuilder<C>>;
 
 /// A spine of `Rc`-shared [`ChunkBatch`]s of type `C`: the trace type for `arrange`.
 pub type ChunkSpine<C> = crate::trace::implementations::spine_fueled::Spine<std::rc::Rc<ChunkBatch<C>>>;
@@ -470,7 +470,7 @@ impl<C: NavigableChunk> Cursor for ChunkBatchCursor<C> {
     }
 }
 
-/// A merge-batcher [`Merger`](crate::trace::implementations::merge_batcher::Merger)
+/// A merge-batcher [`Merger`](crate::batcher::merge::Merger)
 /// over chains of [`Chunk`]s.
 ///
 /// `merge` runs the whole-chain binary merger; `extract` splits by the seal frontier
@@ -485,7 +485,7 @@ impl<C> Default for ChunkMerger<C> {
     fn default() -> Self { Self { _marker: std::marker::PhantomData } }
 }
 
-impl<C> crate::trace::implementations::merge_batcher::Merger for ChunkMerger<C>
+impl<C> crate::batcher::merge::Merger for ChunkMerger<C>
 where
     C: Chunk + Default + 'static,
     C::Time: Clone + timely::PartialOrder + 'static,
@@ -688,7 +688,7 @@ where
 
 }
 
-impl<C> crate::trace::implementations::merge_batcher::Sealer<C> for ChunkBatchBuilder<C>
+impl<C> crate::batcher::merge::Sealer<C> for ChunkBatchBuilder<C>
 where
     C: Chunk + Default + 'static,
     C::Time: timely::progress::Timestamp,
diff --git a/differential-dataflow/src/trace/chunk/vec.rs b/differential-dataflow/src/trace/chunk/vec.rs
index df9c6c51e..e0969d57f 100644
--- a/differential-dataflow/src/trace/chunk/vec.rs
+++ b/differential-dataflow/src/trace/chunk/vec.rs
@@ -53,7 +53,7 @@ impl<K, V, T, R> Default for VecChunk<K, V, T, R> {
 pub type ChunkSpine<K, V, T, R> = super::ChunkSpine<VecChunk<K, V, T, R>>;
 /// Merge batcher over `VecChunk`s; a `ContainerChunker<VecChunk>` at the
 /// `arrange_core` callsite forms the chunks it merges (via the container traits below).
-pub type ChunkBatcher<K, V, T, R> = super::ChunkBatcher<crate::trace::implementations::ContainerChunker<VecChunk<K, V, T, R>>, VecChunk<K, V, T, R>>;
+pub type ChunkBatcher<K, V, T, R> = super::ChunkBatcher<crate::batcher::merge::chunker::ContainerChunker<VecChunk<K, V, T, R>>, VecChunk<K, V, T, R>>;
 /// Batch builder.
 pub type ChunkBuilder<K, V, T, R> = super::ChunkBuilder<VecChunk<K, V, T, R>>;
 
diff --git a/differential-dataflow/src/trace/cursor/mod.rs b/differential-dataflow/src/trace/cursor/mod.rs
index c82a2be41..6d26f9228 100644
--- a/differential-dataflow/src/trace/cursor/mod.rs
+++ b/differential-dataflow/src/trace/cursor/mod.rs
@@ -136,28 +136,6 @@ pub trait Cursor {
     /// Rewinds the cursor to the first value for current key.
     fn rewind_vals(&mut self, storage: &Self::Storage);
 
-    /// Loads `target` with all updates associated with the supplied `key`.
-    ///
-    /// First `target` is cleared, and then if we find `key` we populated it with each of its `(val, time, diff)` updates.
-    /// If `meet` is supplied, the time is joined with each `time` in the updates, to advance the times before consolidation.
-    fn populate_key<'a>(&mut self, storage: &'a Self::Storage, key: Self::Key<'a>, meet: Option<&Self::Time>, target: &mut crate::operators::EditList<Self::Val<'a>, Self::Time, Self::Diff>) {
-        target.clear();
-        self.seek_key(storage, key);
-        if self.get_key(storage) == Some(key) {
-            self.rewind_vals(storage);
-            while let Some(val) = self.get_val(storage) {
-                self.map_times(storage, |time, diff| {
-                    use crate::lattice::Lattice;
-                    let mut time = Self::owned_time(time);
-                    if let Some(meet) = meet { time.join_assign(meet); }
-                    target.push(time, Self::owned_diff(diff))
-                });
-                target.seal(val);
-                self.step_val(storage);
-            }
-        }
-    }
-
     /// Rewinds the cursor and outputs its contents to a Vec
     fn to_vec<K, IK, V, IV>(&mut self, storage: &Self::Storage, into_key: IK, into_val: IV) -> Vec<((K, V), Vec<(Self::Time, Self::Diff)>)>
     where
diff --git a/differential-dataflow/src/trace/implementations/merge_batcher/mod.rs b/differential-dataflow/src/trace/implementations/merge_batcher/mod.rs
index 1f9182630..02375efcf 100644
--- a/differential-dataflow/src/trace/implementations/merge_batcher/mod.rs
+++ b/differential-dataflow/src/trace/implementations/merge_batcher/mod.rs
@@ -1,457 +1,3 @@
-//! A `Batcher` implementation based on merge sort.
-//!
-//! The `MergeBatcher` requires a "merger" that implements the [`Merger`] trait, which provides
-//! hooks for manipulating sorted "chains" of chunks as needed by the merge batcher: merging
-//! chunks and also splitting them apart based on time.
-//!
-//! Raw input containers are fed to the batcher via [`Batcher::insert`], which chunks them with
-//! its `Chu` before merging: forming sorted, consolidated chunks is the first stage of the
-//! batcher's own work rather than something a caller arranges.
+//! Compatibility re-exports for the merge batcher implementation.
 
-pub mod chunker;
-
-use timely::container::{ContainerBuilder, PushInto};
-use timely::progress::frontier::AntichainRef;
-use timely::progress::{frontier::Antichain, Timestamp};
-
-use crate::logging::{BatcherEvent, Logger};
-use crate::trace::Batcher;
-
-/// Creates batches from chunks of sorted, consolidated tuples.
-///
-/// Chunking input is `Chu`'s business, merging chunks is `M`'s, and sealing the extracted chain
-/// into a batch is `S`'s; the batcher's own work is the geometric ladder of chains and the
-/// carve-by-frontier.
-pub struct MergeBatcher<Chu, M: Merger, S> {
-    /// Melds input containers into sorted, consolidated chunks.
-    chunker: Chu,
-    /// Sorted, consolidated chains, each paired with its cached summed update count.
-    ///
-    /// The cached count is the chain's *merge weight*: the geometric ladder weighs
-    /// chains by updates, not chunk counts, since regrading decouples the two. A
-    /// chain is immutable until merged, so the weight is computed once at push.
-    ///
-    /// Do not push/pop directly but use the corresponding functions ([`Self::chain_push`]/[`Self::chain_pop`]).
-    chains: Vec<(usize, Vec<M::Chunk>)>,
-    /// Stash of empty chunks, recycled through the merging process.
-    stash: Vec<M::Chunk>,
-    /// Merges consolidated chunks, and extracts the subset of an update chain that lies in an interval of time.
-    merger: M,
-    /// The lower-bound frontier of the data, after the last call to extract.
-    frontier: Antichain<M::Time>,
-    /// Logger for size accounting.
-    logger: Option<Logger>,
-    /// Timely operator ID.
-    operator_id: usize,
-    /// Seals each extracted chain into a batch.
-    sealer: std::marker::PhantomData<S>,
-}
-
-impl<C, Chu, M, S> Batcher<C> for MergeBatcher<Chu, M, S>
-where
-    M: Merger<Time: Timestamp>,
-    Chu: ContainerBuilder<Container = M::Chunk> + for<'a> PushInto<&'a mut C>,
-    S: Sealer<M::Chunk>,
-{
-    type Time = M::Time;
-    type Output = S::Output;
-
-    fn insert(&mut self, container: &mut C) {
-        self.chunker.push_into(container);
-        while let Some(chunk) = self.chunker.extract().map(std::mem::take) {
-            self.insert_chain(vec![chunk]);
-        }
-    }
-
-    // Extraction means finding those updates with times not greater or equal to any time in
-    // `upper`. All updates must have time greater or equal to the previously used `upper`, by
-    // assumption that after extracting from a batcher we receive no more updates with times not
-    // greater or equal to `upper`.
-    fn extract<'a>(&'a mut self, upper: AntichainRef<'_, M::Time>) -> (Option<S::Output>, AntichainRef<'a, M::Time>) {
-        // Flush whatever the chunker is still accumulating: a partial final chunk would
-        // otherwise never reach the merge ladder.
-        while let Some(chunk) = self.chunker.finish().map(std::mem::take) {
-            self.insert_chain(vec![chunk]);
-        }
-
-        // Merge all remaining chains into a single chain.
-        while self.chains.len() > 1 {
-            let list1 = self.chain_pop().unwrap();
-            let list2 = self.chain_pop().unwrap();
-            let merged = self.merge_by(list1, list2);
-            self.chain_push(merged);
-        }
-        let merged = self.chain_pop().unwrap_or_default();
-
-        // Extract readied data.
-        let mut kept = Vec::new();
-        let mut readied = Vec::new();
-        self.frontier.clear();
-
-        self.merger.extract(merged, upper, &mut self.frontier, &mut readied, &mut kept, &mut self.stash);
-
-        if !kept.is_empty() {
-            self.chain_push(kept);
-        }
-
-        self.stash.clear();
-
-        (S::seal(&mut readied), self.frontier.borrow())
-    }
-}
-
-impl<Chu: Default, M: Merger, S> MergeBatcher<Chu, M, S> {
-    /// Allocates a new empty batcher.
-    ///
-    /// The logger and operator identifier are used to report the batcher's memory footprint,
-    /// attributed to the operator that owns it.
-    pub fn new(logger: Option<Logger>, operator_id: usize) -> Self {
-        Self {
-            logger,
-            operator_id,
-            merger: M::default(),
-            chunker: Chu::default(),
-            chains: Vec::new(),
-            stash: Vec::new(),
-            frontier: Antichain::new(),
-            sealer: std::marker::PhantomData,
-        }
-    }
-}
-
-impl<Chu, M: Merger, S> MergeBatcher<Chu, M, S> {
-    /// Insert a chain and maintain chain properties: Chains are geometrically sized
-    /// (by summed updates) and ordered by decreasing update weight.
-    fn insert_chain(&mut self, chain: Vec<M::Chunk>) {
-        if !chain.is_empty() {
-            self.chain_push(chain);
-            while self.chains.len() > 1 && (self.chains[self.chains.len() - 1].0 >= self.chains[self.chains.len() - 2].0 / 2) {
-                let list1 = self.chain_pop().unwrap();
-                let list2 = self.chain_pop().unwrap();
-                let merged = self.merge_by(list1, list2);
-                self.chain_push(merged);
-            }
-        }
-    }
-
-    // merges two sorted input lists into one sorted output list.
-    fn merge_by(&mut self, list1: Vec<M::Chunk>, list2: Vec<M::Chunk>) -> Vec<M::Chunk> {
-        // TODO: `list1` and `list2` get dropped; would be better to reuse?
-        let mut output = Vec::with_capacity(list1.len() + list2.len());
-        self.merger.merge(list1, list2, &mut output, &mut self.stash);
-
-        output
-    }
-
-    /// Pop a chain and account size changes.
-    #[inline]
-    fn chain_pop(&mut self) -> Option<Vec<M::Chunk>> {
-        let (_weight, chain) = self.chains.pop()?;
-        self.account(chain.iter().map(Self::record), -1);
-        Some(chain)
-    }
-
-    /// Push a chain and account size changes.
-    ///
-    /// Caches the chain's summed update count alongside it for the ladder.
-    #[inline]
-    fn chain_push(&mut self, chain: Vec<M::Chunk>) {
-        let weight = chain.iter().map(M::len).sum();
-        self.account(chain.iter().map(Self::record), 1);
-        self.chains.push((weight, chain));
-    }
-
-    /// The `(records, size, capacity, allocations)` logger tuple for one chunk,
-    /// assembled from the two focused `Merger` methods.
-    #[inline]
-    fn record(chunk: &M::Chunk) -> (usize, usize, usize, usize) {
-        let (size, capacity, allocations) = M::allocation(chunk);
-        (M::len(chunk), size, capacity, allocations)
-    }
-
-    /// Account size changes. Only performs work if a logger exists.
-    ///
-    /// Calculate the size based on the iterator passed along, with each attribute
-    /// multiplied by `diff`. Usually, one wants to pass 1 or -1 as the diff.
-    #[inline]
-    fn account<I: IntoIterator<Item = (usize, usize, usize, usize)>>(&self, items: I, diff: isize) {
-        if let Some(logger) = &self.logger {
-            let (mut records, mut size, mut capacity, mut allocations) = (0isize, 0isize, 0isize, 0isize);
-            for (records_, size_, capacity_, allocations_) in items {
-                records = records.saturating_add_unsigned(records_);
-                size = size.saturating_add_unsigned(size_);
-                capacity = capacity.saturating_add_unsigned(capacity_);
-                allocations = allocations.saturating_add_unsigned(allocations_);
-            }
-            logger.log(BatcherEvent {
-                operator: self.operator_id,
-                records_diff: records * diff,
-                size_diff: size * diff,
-                capacity_diff: capacity * diff,
-                allocations_diff: allocations * diff,
-            })
-        }
-    }
-}
-
-impl<Chu, M: Merger, S> Drop for MergeBatcher<Chu, M, S> {
-    fn drop(&mut self) {
-        // Cleanup chain to retract accounting information.
-        while self.chain_pop().is_some() {}
-    }
-}
-
-/// A trait to describe interesting moments in a merge batcher.
-pub trait Merger: Default {
-    /// The internal representation of chunks of data.
-    type Chunk: Default;
-    /// The type of time in frontiers to extract updates.
-    type Time;
-    /// Merge chains into an output chain.
-    fn merge(&mut self, list1: Vec<Self::Chunk>, list2: Vec<Self::Chunk>, output: &mut Vec<Self::Chunk>, stash: &mut Vec<Self::Chunk>);
-    /// Extract ready updates based on the `upper` frontier.
-    fn extract(
-        &mut self,
-        merged: Vec<Self::Chunk>,
-        upper: AntichainRef<Self::Time>,
-        frontier: &mut Antichain<Self::Time>,
-        readied: &mut Vec<Self::Chunk>,
-        kept: &mut Vec<Self::Chunk>,
-        stash: &mut Vec<Self::Chunk>,
-    );
-
-    /// The number of updates in a chunk.
-    ///
-    /// Drives the geometric ladder (chains are weighed by summed updates, not chunk
-    /// counts, since regrading decouples the two) and the `records` field of the
-    /// size logger.
-    fn len(chunk: &Self::Chunk) -> usize;
-
-    /// Backing-allocation figures for a chunk: `(size, capacity, allocations)`, for
-    /// the size logger's memory telemetry.
-    ///
-    /// Defaults to zero — most chunk types do not track this. Override to report
-    /// real figures (e.g. Materialize's memory accounting).
-    fn allocation(_chunk: &Self::Chunk) -> (usize, usize, usize) { (0, 0, 0) }
-}
-
-/// Forms a batch from a whole chain of updates at once.
-///
-/// Named rather than a bare `fn(&mut Vec<C>) -> Option<B>` so that implementors can name the
-/// batch they produce. There is no receiver: the chain goes in and the batch comes out, leaving
-/// nowhere for an update to be retained.
-pub trait Sealer<C> {
-    /// Output batch type.
-    type Output;
-
-    /// Builds a batch from a chain of updates.
-    ///
-    /// This method relies on the chain only containing updates greater or equal to the lower frontier,
-    /// and not greater or equal to the upper frontier, of the interval the caller means to describe.
-    /// Chains must also be sorted and consolidated.
-    ///
-    /// Having the whole chain in hand, an implementor can size itself before it fills.
-    fn seal(chain: &mut Vec<C>) -> Option<Self::Output>;
-}
-
-/// A `Merger` implementation for vector update containers.
-pub mod vec {
-
-    use std::marker::PhantomData;
-    use timely::container::SizableContainer;
-    use timely::progress::frontier::{Antichain, AntichainRef};
-    use timely::PartialOrder;
-    use crate::trace::implementations::merge_batcher::Merger;
-
-    /// A `Merger` implementation for `Vec<(D, T, R)>` that drains owned inputs.
-    pub struct VecMerger<D, T, R> {
-        _marker: PhantomData<(D, T, R)>,
-    }
-
-    impl<D, T, R> Default for VecMerger<D, T, R> {
-        fn default() -> Self { Self { _marker: PhantomData } }
-    }
-
-    impl<D, T, R> VecMerger<D, T, R> {
-        /// The target capacity for output buffers, as a power of two.
-        ///
-        /// This amount is used to size vectors, where vectors not exactly this capacity are dropped.
-        /// If this is mis-set, there is the potential for more memory churn than anticipated.
-        fn target_capacity() -> usize {
-            timely::container::buffer::default_capacity::<(D, T, R)>().next_power_of_two()
-        }
-        /// Acquire a buffer with the target capacity.
-        fn empty(&self, stash: &mut Vec<Vec<(D, T, R)>>) -> Vec<(D, T, R)> {
-            let target = Self::target_capacity();
-            let mut container = stash.pop().unwrap_or_default();
-            container.clear();
-            // Reuse if at target; otherwise allocate fresh.
-            if container.capacity() != target {
-                container = Vec::with_capacity(target);
-            }
-            container
-        }
-        /// Refill `queue` from `iter` if empty. Recycles drained queues into `stash`.
-        fn refill(queue: &mut std::collections::VecDeque<(D, T, R)>, iter: &mut impl Iterator<Item = Vec<(D, T, R)>>, stash: &mut Vec<Vec<(D, T, R)>>) {
-            if queue.is_empty() {
-                let target = Self::target_capacity();
-                if stash.len() < 2 {
-                    let mut recycled = Vec::from(std::mem::take(queue));
-                    recycled.clear();
-                    if recycled.capacity() == target {
-                        stash.push(recycled);
-                    }
-                }
-                if let Some(chunk) = iter.next() {
-                    *queue = std::collections::VecDeque::from(chunk);
-                }
-            }
-        }
-    }
-
-    impl<D, T, R> Merger for VecMerger<D, T, R>
-    where
-        D: Ord + Clone + 'static,
-        T: Ord + Clone + PartialOrder + 'static,
-        R: crate::difference::Semigroup + 'static,
-    {
-        type Chunk = Vec<(D, T, R)>;
-        type Time = T;
-
-        fn merge(
-            &mut self,
-            list1: Vec<Vec<(D, T, R)>>,
-            list2: Vec<Vec<(D, T, R)>>,
-            output: &mut Vec<Vec<(D, T, R)>>,
-            stash: &mut Vec<Vec<(D, T, R)>>,
-        ) {
-            use std::cmp::Ordering;
-            use std::collections::VecDeque;
-
-            let mut iter1 = list1.into_iter();
-            let mut iter2 = list2.into_iter();
-            let mut q1 = VecDeque::<(D,T,R)>::from(iter1.next().unwrap_or_default());
-            let mut q2 = VecDeque::<(D,T,R)>::from(iter2.next().unwrap_or_default());
-
-            let mut result = self.empty(stash);
-
-            // Merge while both queues are non-empty.
-            while let (Some((d1, t1, _)), Some((d2, t2, _))) = (q1.front(), q2.front()) {
-                match (d1, t1).cmp(&(d2, t2)) {
-                    Ordering::Less => {
-                        result.push(q1.pop_front().unwrap());
-                    }
-                    Ordering::Greater => {
-                        result.push(q2.pop_front().unwrap());
-                    }
-                    Ordering::Equal => {
-                        let (d, t, mut r1) = q1.pop_front().unwrap();
-                        let (_, _, r2) = q2.pop_front().unwrap();
-                        r1.plus_equals(&r2);
-                        if !r1.is_zero() {
-                            result.push((d, t, r1));
-                        }
-                    }
-                }
-
-                if result.at_capacity() {
-                    output.push(std::mem::take(&mut result));
-                    result = self.empty(stash);
-                }
-
-                // Refill emptied queues from their chains.
-                if q1.is_empty() { Self::refill(&mut q1, &mut iter1, stash); }
-                if q2.is_empty() { Self::refill(&mut q2, &mut iter2, stash); }
-            }
-
-            // Push partial result and remaining data from both sides.
-            if !result.is_empty() { output.push(result); }
-            for q in [q1, q2] {
-                if !q.is_empty() { output.push(Vec::from(q)); }
-            }
-            output.extend(iter1);
-            output.extend(iter2);
-        }
-
-        fn extract(
-            &mut self,
-            merged: Vec<Vec<(D, T, R)>>,
-            upper: AntichainRef<T>,
-            frontier: &mut Antichain<T>,
-            ship: &mut Vec<Vec<(D, T, R)>>,
-            kept: &mut Vec<Vec<(D, T, R)>>,
-            stash: &mut Vec<Vec<(D, T, R)>>,
-        ) {
-            let mut keep = self.empty(stash);
-            let mut ready = self.empty(stash);
-
-            for mut chunk in merged {
-                // Go update-by-update to swap out full containers.
-                for (data, time, diff) in chunk.drain(..) {
-                    if upper.less_equal(&time) {
-                        frontier.insert_with(&time, |time| time.clone());
-                        keep.push((data, time, diff));
-                    } else {
-                        ready.push((data, time, diff));
-                    }
-                    if keep.at_capacity() {
-                        kept.push(std::mem::take(&mut keep));
-                        keep = self.empty(stash);
-                    }
-                    if ready.at_capacity() {
-                        ship.push(std::mem::take(&mut ready));
-                        ready = self.empty(stash);
-                    }
-                }
-                // Recycle the now-empty chunk if it has the right capacity.
-                if chunk.capacity() == Self::target_capacity() {
-                    stash.push(chunk);
-                }
-            }
-            if !keep.is_empty() { kept.push(keep); }
-            if !ready.is_empty() { ship.push(ready); }
-        }
-
-        fn len(chunk: &Vec<(D, T, R)>) -> usize { chunk.len() }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use timely::progress::frontier::Antichain;
-    use crate::trace::Batcher;
-    use super::MergeBatcher;
-    use super::vec::VecMerger;
-    use crate::trace::implementations::ord_neu::VecOrdKeyBuilder;
-    use crate::trace::implementations::merge_batcher::chunker::ContainerChunker;
-
-    type In = Vec<((u64, ()), u64, i64)>;
-    type Bt = MergeBatcher<ContainerChunker<In>, VecMerger<(u64, ()), u64, i64>, VecOrdKeyBuilder<u64, u64, i64>>;
-
-    /// The sealed frontier must reflect the POST-CONSOLIDATION set of distinct kept times:
-    /// two chains carry cancelling updates at a kept time (`t=5`), plus a survivor at a later
-    /// kept time (`t=7`). After `extract(upper=[3])` the frontier must be `{7}` — `(100, 5)` nets
-    /// to zero and needs no capability. (A per-chain extract that folds the frontier before
-    /// consolidating would wrongly report `{5}`.)
-    #[test]
-    fn frontier_is_post_consolidation() {
-        let mut b = Bt::new(None, 0);
-        b.chain_push(vec![vec![((100u64, ()), 5u64, 1i64), ((200u64, ()), 7u64, 1i64)]]);
-        b.chain_push(vec![vec![((100u64, ()), 5u64, -1i64)]]);
-        let (_, retained) = Batcher::<In>::extract(&mut b, Antichain::from_elem(3).borrow());
-        let got: Vec<u64> = retained.iter().cloned().collect();
-        assert_eq!(got, vec![7u64],
-            "frontier held a capability at t=5, which consolidates to zero (got {got:?})");
-    }
-
-    /// Sanity: with no cross-chain cancellation, the frontier is the minimal kept time.
-    #[test]
-    fn frontier_survivor_minimum() {
-        let mut b = Bt::new(None, 0);
-        b.chain_push(vec![vec![((100u64, ()), 5u64, 1i64)]]);
-        b.chain_push(vec![vec![((200u64, ()), 7u64, 1i64)]]);
-        let (_, retained) = Batcher::<In>::extract(&mut b, Antichain::from_elem(3).borrow());
-        let got: Vec<u64> = retained.iter().cloned().collect();
-        assert_eq!(got, vec![5u64]);
-    }
-}
+pub use crate::batcher::merge::{MergeBatcher, Merger, Sealer, chunker, vec};
diff --git a/differential-dataflow/src/trace/implementations/mod.rs b/differential-dataflow/src/trace/implementations/mod.rs
index 57e35deb1..00b85eedf 100644
--- a/differential-dataflow/src/trace/implementations/mod.rs
+++ b/differential-dataflow/src/trace/implementations/mod.rs
@@ -44,7 +44,7 @@ pub mod merge_batcher;
 pub mod ord_neu;
 
 // Opinionated takes on default spines.
-pub use self::merge_batcher::chunker::ContainerChunker;
+pub use crate::batcher::merge::chunker::ContainerChunker;
 pub use self::ord_neu::OrdValSpine as ValSpine;
 pub use self::ord_neu::OrdValBatcher as ValBatcher;
 pub use self::ord_neu::VecOrdValBuilder as ValBuilder;
diff --git a/differential-dataflow/src/trace/implementations/ord_neu.rs b/differential-dataflow/src/trace/implementations/ord_neu.rs
index fa4136892..88fa4d446 100644
--- a/differential-dataflow/src/trace/implementations/ord_neu.rs
+++ b/differential-dataflow/src/trace/implementations/ord_neu.rs
@@ -11,9 +11,9 @@
 use std::rc::Rc;
 
 use crate::trace::implementations::spine_fueled::Spine;
-use crate::trace::implementations::merge_batcher::chunker::ContainerChunker;
-use crate::trace::implementations::merge_batcher::MergeBatcher;
-use crate::trace::implementations::merge_batcher::vec::VecMerger;
+use crate::batcher::merge::chunker::ContainerChunker;
+use crate::batcher::merge::MergeBatcher;
+use crate::batcher::merge::vec::VecMerger;
 
 use super::{Layout, Vector};
 
@@ -694,7 +694,7 @@ pub mod val_batch {
 
     }
 
-    impl<L, CI> crate::trace::implementations::merge_batcher::Sealer<CI> for OrdValBuilder<L, CI>
+    impl<L, CI> crate::batcher::merge::Sealer<CI> for OrdValBuilder<L, CI>
     where
         L: for<'a> Layout<
             KeyContainer: PushInto<CI::Key<'a>>,
@@ -728,7 +728,7 @@ pub mod key_batch {
     use crate::trace::implementations::spine_fueled::{SpineBatch, Merger};
     use crate::trace::implementations::BatchContainer;
     use crate::trace::implementations::layout;
-    use crate::trace::implementations::merge_batcher::Sealer;
+    use crate::batcher::merge::Sealer;
 
     use super::{Layout, Upds, layers::UpdsBuilder, BuilderInput};
 
diff --git a/differential-dataflow/src/trace/mod.rs b/differential-dataflow/src/trace/mod.rs
index f4cd5fd26..a6a8a521b 100644
--- a/differential-dataflow/src/trace/mod.rs
+++ b/differential-dataflow/src/trace/mod.rs
@@ -21,6 +21,7 @@ pub use self::cursor::Cursor;
 pub use self::cursor::Navigable;
 pub use self::cursor::{BatchCursor, BatchKey, BatchVal, BatchValOwn, BatchDiff, BatchDiffGat, BatchTimeGat};
 pub use self::description::Description;
+pub use crate::batcher::Batcher;
 
 /// 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>;
@@ -225,38 +226,6 @@ pub trait Trace : TraceReader {
     fn close(&mut self);
 }
 
-/// A type capable of accepting containers of updates, and carving them out by time as batches.
-///
-/// Updates are accepted as `C0`, the containers that arrive on the dataflow edge, and released as
-/// `Output`, whatever the implementor means by a batch. The two need not agree: an implementor
-/// staging updates in a form of its own can release that form directly, and one whose batch is a
-/// sequence of chunks names a sequence as its output.
-///
-/// The implementor determines the meaning of extraction by a frontier; it is not required to be by
-/// antichain partial order.
-pub trait Batcher<C0> {
-    /// The timestamps by which updates are carved out.
-    type Time;
-    /// The batches released by extraction.
-    type Output;
-
-    /// Takes the updates in `container`, leaving it in an undefined state.
-    ///
-    /// The implementor decides whether to claim the container's allocation or to drain it and
-    /// leave the allocation with the caller, who is free to reuse the container either way.
-    fn insert(&mut self, container: &mut C0);
-    /// Extracts the updates `upper` unblocks as a batch, and lower bounds the times of those retained.
-    ///
-    /// What `upper` unblocks is the implementor's to decide. It can be based on the antichain up
-    /// set, or it can be based on the total order of times (as used in delta join constructions).
-    /// Absent a batch, `upper` unblocked no updates.
-    ///
-    /// The reported lower bound should accurately reflect the times of all accepted updates that
-    /// have not been extracted. Over approximation can result in stalling dataflows, and under
-    /// approximation is simply incorrect.
-    fn extract<'a>(&'a mut self, upper: AntichainRef<'_, Self::Time>) -> (Option<Self::Output>, AntichainRef<'a, Self::Time>);
-}
-
 /// Functionality for building batches from ordered update sequences.
 ///
 /// `Default` is the empty builder; a builder discovers its output as it is pushed, and so has
diff --git a/differential-dataflow/tests/reduce_oracle.rs b/differential-dataflow/tests/reduce_oracle.rs
new file mode 100644
index 000000000..f1130532e
--- /dev/null
+++ b/differential-dataflow/tests/reduce_oracle.rs
@@ -0,0 +1,163 @@
+//! Checks reduce against from-scratch accumulation at product-ordered times.
+//!
+//! The queries cover the full grid of times the input draws from.
+
+use std::collections::BTreeMap;
+
+use rand::{Rng, SeedableRng, StdRng};
+
+use timely::PartialOrder;
+use timely::dataflow::operators::capture::{Capture, Extract};
+use timely::dataflow::operators::vec::unordered_input::UnorderedInput;
+
+use differential_dataflow::AsCollection;
+
+use pair::Pair;
+type Time = Pair<u64, u64>;
+
+fn count(_key: &u64, input: &[(&u64, isize)], output: &mut Vec<(i64, isize)>) {
+    output.push((input.len() as i64, 1));
+}
+fn sum(_key: &u64, input: &[(&u64, isize)], output: &mut Vec<(i64, isize)>) {
+    let s: i64 = input.iter().map(|(v, d)| **v as i64 * *d as i64).sum();
+    output.push((s, 1));
+}
+fn min(_key: &u64, input: &[(&u64, isize)], output: &mut Vec<(i64, isize)>) {
+    if let Some(m) = input.iter().map(|(v, _)| **v).min() {
+        output.push((m as i64, 1));
+    }
+}
+
+type Logic = fn(&u64, &[(&u64, isize)], &mut Vec<(i64, isize)>);
+
+// A random input: `((key, val), Pair(a, b), diff)`, diffs ±1 so updates cancel.
+fn random_input(seed: usize, n: usize, keys: u64, vals: u64, span: u64) -> Vec<((u64, u64), Time, isize)> {
+    let s: &[usize] = &[seed, 7, 13, 29];
+    let mut rng: StdRng = SeedableRng::from_seed(s);
+    (0..n).map(|_| {
+        let k = rng.gen_range(0, keys);
+        let v = rng.gen_range(0, vals);
+        let t = Pair::new(rng.gen_range(0, span), rng.gen_range(0, span));
+        let d = if rng.gen::<bool>() { 1 } else { -1 };
+        ((k, v), t, d)
+    }).collect()
+}
+
+// Compare reduce with a from-scratch `f(acc(input))` at each queried time.
+
+#[test] fn oracle_count() { for s in 0..15 { oracle(s, count); } }
+#[test] fn oracle_sum()   { for s in 0..15 { oracle(s, sum); } }
+#[test] fn oracle_min()   { for s in 0..15 { oracle(s, min); } }
+
+fn oracle(seed: usize, logic: Logic) {
+    let span = 6u64;
+    let updates = random_input(seed, 300, 10, 8, span);
+
+    // Capture the reduce output as `((key, out_val), time, diff)` updates.
+    let (send, recv) = std::sync::mpsc::channel();
+    let send = std::sync::Arc::new(std::sync::Mutex::new(send));
+    let drive = updates.clone();
+    timely::execute_directly(move |worker| {
+        let send = send.lock().unwrap().clone();
+        let (mut input, capability) = worker.dataflow::<Time, _, _>(|scope| {
+            let ((input, capability), stream) = scope.new_unordered_input::<((u64, u64), Time, isize)>();
+            let collection = stream.as_collection();
+            let out = collection.reduce(logic);
+            out.inner.capture_into(send);
+            (input, capability)
+        });
+        for u in drive { input.activate().session(&capability).give(u); }
+        drop(capability);
+    });
+    let output: Vec<((u64, i64), Time, isize)> =
+        recv.extract().into_iter().flat_map(|(_, batch)| batch).collect();
+
+    // Everything is finalized, so `acc(output, q) == f(acc(input, q))` must hold at every `q`. All
+    // times in play lie on the `span × span` grid, so query every grid point (plus one beyond, to
+    // catch updates the reduce should not have produced): a set closed under `join`, unlike e.g.
+    // the pairwise joins of the input and output times.
+    let times: Vec<Time> =
+        (0 .. span + 1).flat_map(|a| (0 .. span + 1).map(move |b| Pair::new(a, b))).collect();
+
+    for q in &times {
+        // expected: per key, f applied to the accumulated input at `q`.
+        let mut expected: BTreeMap<(u64, i64), i64> = BTreeMap::new();
+        let mut per_key: BTreeMap<u64, BTreeMap<u64, isize>> = BTreeMap::new();
+        for ((k, v), t, d) in &updates {
+            if t.less_equal(q) { *per_key.entry(*k).or_default().entry(*v).or_default() += *d; }
+        }
+        for (k, vals) in &per_key {
+            let acc: Vec<(&u64, isize)> = vals.iter().filter(|(_, d)| **d != 0).map(|(v, d)| (v, *d)).collect();
+            if acc.is_empty() { continue; }
+            let mut out = Vec::new();
+            logic(k, &acc, &mut out);
+            for (ov, od) in out { *expected.entry((*k, ov)).or_default() += od as i64; }
+        }
+        expected.retain(|_, d| *d != 0);
+
+        // actual: the accumulated reduce output at `q`.
+        let mut actual: BTreeMap<(u64, i64), i64> = BTreeMap::new();
+        for ((k, ov), t, d) in &output {
+            if t.less_equal(q) { *actual.entry((*k, *ov)).or_default() += *d as i64; }
+        }
+        actual.retain(|_, d| *d != 0);
+
+        assert_eq!(expected, actual, "seed {seed} at time {q:?}");
+    }
+}
+
+/// A minimal product-order (partially ordered) timestamp, so the harness exercises the synthetic
+/// interesting-times determination. Copied from `examples/multitemporal.rs`.
+mod pair {
+
+    #[derive(Hash, Default, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)]
+    pub struct Pair<S, T> { pub first: S, pub second: T }
+
+    impl<S, T> Pair<S, T> {
+        pub fn new(first: S, second: T) -> Self { Pair { first, second } }
+    }
+
+    use timely::order::PartialOrder;
+    impl<S: PartialOrder, T: PartialOrder> PartialOrder for Pair<S, T> {
+        fn less_equal(&self, other: &Self) -> bool {
+            self.first.less_equal(&other.first) && self.second.less_equal(&other.second)
+        }
+    }
+
+    use timely::progress::timestamp::Refines;
+    impl<S: Timestamp, T: Timestamp> Refines<()> for Pair<S, T> {
+        fn to_inner(_outer: ()) -> Self { Self::minimum() }
+        fn to_outer(self) -> () { () }
+        fn summarize(_summary: <Self>::Summary) -> () { () }
+    }
+
+    use timely::progress::PathSummary;
+    impl<S: Timestamp, T: Timestamp> PathSummary<Pair<S,T>> for () {
+        fn results_in(&self, timestamp: &Pair<S, T>) -> Option<Pair<S,T>> { Some(timestamp.clone()) }
+        fn followed_by(&self, other: &Self) -> Option<Self> { Some(other.clone()) }
+    }
+
+    use timely::progress::Timestamp;
+    impl<S: Timestamp, T: Timestamp> Timestamp for Pair<S, T> {
+        fn minimum() -> Self { Pair { first: S::minimum(), second: T::minimum() }}
+        type Summary = ();
+    }
+
+    use differential_dataflow::lattice::Lattice;
+    impl<S: Lattice, T: Lattice> Lattice for Pair<S, T> {
+        fn join(&self, other: &Self) -> Self {
+            Pair { first: self.first.join(&other.first), second: self.second.join(&other.second) }
+        }
+        fn meet(&self, other: &Self) -> Self {
+            Pair { first: self.first.meet(&other.first), second: self.second.meet(&other.second) }
+        }
+    }
+
+    use std::fmt::{Formatter, Error, Debug};
+    use serde::{Deserialize, Serialize};
+    impl<TOuter: Debug, TInner: Debug> Debug for Pair<TOuter, TInner> {
+        fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
+            f.write_str(&format!("({:?}, {:?})", self.first, self.second))
+        }
+    }
+}
diff --git a/differential-dataflow/tests/reduce_reference.rs b/differential-dataflow/tests/reduce_reference.rs
deleted file mode 100644
index 6046660ae..000000000
--- a/differential-dataflow/tests/reduce_reference.rs
+++ /dev/null
@@ -1,409 +0,0 @@
-//! Test harness for the model-derived `reference` reduce tactic. Four things:
-//!
-//! * `differential_*` — run the default (cursor) reduce and the `reference` reduce on the SAME random
-//!   input and `assert_eq` their outputs at every time. The drift detector: if either tactic changes
-//!   behavior, it fails. Inputs use `Pair<u64,u64>` (product / partial order, so joins and synthetic
-//!   times occur) with diffs ±1 (so updates cancel — the corner where the value-blind reference could
-//!   over-derive).
-//!
-//! * `oracle_*` — run one tactic and check its output against a from-scratch recomputation of
-//!   `f(accumulated input)` at many times. The correctness check: it does not rely on the two tactics
-//!   agreeing, so it catches bugs in code they share (the driver, `ValueHistory`, …). It is the
-//!   executable form of `formal/Differential/Model.lean`'s stream-correctness statement.
-//!
-//! * `bfs_*` — an iterative BFS (product time via iteration; a real computation shape) computed both
-//!   ways over a graph that grows and shrinks; another differential check.
-//!
-//! * `scc_*` — strongly connected components: two nested product-timed fixpoints (edge trimming around
-//!   iterative label propagation), so the reduce runs at three nested time coordinates. This depth is
-//!   what exposed the phase-2 catch-up walk stepping the partial-order `less_equal` set instead of the
-//!   total-`Ord` prefix (see the note at that walk in `operators/reduce.rs`); the two-coordinate shapes
-//!   above never reached it.
-
-use std::collections::BTreeMap;
-
-use rand::{Rng, SeedableRng, StdRng};
-
-use timely::PartialOrder;
-use timely::dataflow::operators::capture::{Capture, Extract};
-use timely::dataflow::operators::vec::unordered_input::UnorderedInput;
-
-use differential_dataflow::{AsCollection, Data, ExchangeData, Hashable};
-use differential_dataflow::VecCollection;
-use differential_dataflow::difference::{Abelian, Semigroup};
-use differential_dataflow::input::Input;
-use differential_dataflow::lattice::Lattice;
-use differential_dataflow::operators::*;
-use differential_dataflow::operators::arrange::{Arranged, TraceAgent};
-use differential_dataflow::operators::reduce::reduce_trace_reference;
-use differential_dataflow::trace::implementations::{ValBuilder, ValSpine};
-
-use pair::Pair;
-type Time = Pair<u64, u64>;
-
-// ---- the reduce logics under test (plain `fn`s, so they are `Copy` and can feed both tactics) ----
-
-fn count(_key: &u64, input: &[(&u64, isize)], output: &mut Vec<(i64, isize)>) {
-    output.push((input.len() as i64, 1));
-}
-fn sum(_key: &u64, input: &[(&u64, isize)], output: &mut Vec<(i64, isize)>) {
-    let s: i64 = input.iter().map(|(v, d)| **v as i64 * *d as i64).sum();
-    output.push((s, 1));
-}
-fn min(_key: &u64, input: &[(&u64, isize)], output: &mut Vec<(i64, isize)>) {
-    if let Some(m) = input.iter().map(|(v, _)| **v).min() {
-        output.push((m as i64, 1));
-    }
-}
-
-type Logic = fn(&u64, &[(&u64, isize)], &mut Vec<(i64, isize)>);
-
-// Stand-alone equivalent of the default `reduce`, driven by the model-derived reference tactic. The
-// library exposes only the low-level, doc-hidden `reduce_trace_reference`; this helper supplies the
-// same arrange / abelian-negate / as_collection glue `reduce_named` uses, so the tests compare the
-// two tactics without the reference living on the public `Collection`/`Arranged` API.
-fn reduce_reference<'scope, Ti, K, V, R, V2, R2, L>(
-    collection: VecCollection<'scope, Ti, (K, V), R>,
-    mut logic: L,
-) -> VecCollection<'scope, Ti, (K, V2), R2>
-where
-    Ti: timely::progress::Timestamp + Lattice + Ord,
-    K: ExchangeData + Hashable,
-    V: ExchangeData,
-    R: ExchangeData + Semigroup,
-    V2: Data,
-    R2: Ord + Abelian + 'static,
-    L: FnMut(&K, &[(&V, R)], &mut Vec<(V2, R2)>) + 'static,
-{
-    // Bind the input arrangement to an explicitly-typed local so `Tr1` is concrete going into
-    // `reduce_trace_reference` (otherwise its output-key bound is checked before the argument pins it).
-    let arranged: Arranged<'scope, TraceAgent<ValSpine<K, V, Ti, R>>> =
-        collection.arrange_by_key_named("Arrange: ReduceReference");
-
-    // The closure params are annotated to the concrete `&K` / `&V` / owned-output types (rather than
-    // left to infer the cursor's `Key<'_>` projection) so the coercion to the user's `&K` logic
-    // normalizes here, exactly as the default `reduce_named` gets for free by passing its logic through.
-    reduce_trace_reference::<TraceAgent<ValSpine<K, V, Ti, R>>, ValBuilder<K, V2, Ti, R2>, ValSpine<K, V2, Ti, R2>, _, _>(
-        arranged,
-        "ReduceReference",
-        move |key: &K, input: &[(&V, R)], output: &mut Vec<(V2, R2)>, change: &mut Vec<(V2, R2)>| {
-            if !input.is_empty() { logic(key, input, change); }
-            change.extend(output.drain(..).map(|(x, mut d)| { d.negate(); (x, d) }));
-            differential_dataflow::consolidation::consolidate(change);
-        },
-        |vec, key: &K, upds| { vec.clear(); vec.extend(upds.drain(..).map(|(v, t, r)| ((key.clone(), v), t, r))); },
-    )
-    .as_collection(|k, v| (k.clone(), v.clone()))
-}
-
-// A random input: `((key, val), Pair(a, b), diff)`, diffs ±1 so updates cancel.
-fn random_input(seed: usize, n: usize, keys: u64, vals: u64, span: u64) -> Vec<((u64, u64), Time, isize)> {
-    let s: &[usize] = &[seed, 7, 13, 29];
-    let mut rng: StdRng = SeedableRng::from_seed(s);
-    (0..n).map(|_| {
-        let k = rng.gen_range(0, keys);
-        let v = rng.gen_range(0, vals);
-        let t = Pair::new(rng.gen_range(0, span), rng.gen_range(0, span));
-        let d = if rng.gen::<bool>() { 1 } else { -1 };
-        ((k, v), t, d)
-    }).collect()
-}
-
-// ======================= differential: cursor vs reference, all times =======================
-
-#[test] fn differential_count() { for s in 0..25 { differential(s, count); } }
-#[test] fn differential_sum()   { for s in 0..25 { differential(s, sum); } }
-#[test] fn differential_min()   { for s in 0..25 { differential(s, min); } }
-
-fn differential(seed: usize, logic: Logic) {
-    let span = 6u64;
-    let updates = random_input(seed, 400, 12, 8, span);
-    timely::execute_directly(move |worker| {
-        let (mut input, capability) = worker.dataflow::<Time, _, _>(|scope| {
-            let ((input, capability), stream) = scope.new_unordered_input::<((u64, u64), Time, isize)>();
-            let collection = stream.as_collection();
-            let via_cursor    = collection.clone().reduce(logic);
-            let via_reference = reduce_reference(collection, logic);
-            via_cursor.assert_eq(via_reference);
-            (input, capability)
-        });
-        for u in updates { input.activate().session(&capability).give(u); }
-        drop(capability); // release the input frontier so everything finalizes
-    });
-}
-
-// ======================= oracle: a tactic vs from-scratch f(acc input) =======================
-
-#[test] fn oracle_cursor_count()    { for s in 0..15 { oracle(s, false, count); } }
-#[test] fn oracle_reference_count() { for s in 0..15 { oracle(s, true,  count); } }
-#[test] fn oracle_reference_sum()   { for s in 0..15 { oracle(s, true,  sum); } }
-#[test] fn oracle_reference_min()   { for s in 0..15 { oracle(s, true,  min); } }
-
-fn oracle(seed: usize, reference: bool, logic: Logic) {
-    let span = 6u64;
-    let updates = random_input(seed, 300, 10, 8, span);
-
-    // Capture the reduce output as `((key, out_val), time, diff)` updates.
-    let (send, recv) = std::sync::mpsc::channel();
-    let send = std::sync::Arc::new(std::sync::Mutex::new(send));
-    let drive = updates.clone();
-    timely::execute_directly(move |worker| {
-        let send = send.lock().unwrap().clone();
-        let (mut input, capability) = worker.dataflow::<Time, _, _>(|scope| {
-            let ((input, capability), stream) = scope.new_unordered_input::<((u64, u64), Time, isize)>();
-            let collection = stream.as_collection();
-            let out = if reference { reduce_reference(collection, logic) } else { collection.reduce(logic) };
-            out.inner.capture_into(send);
-            (input, capability)
-        });
-        for u in drive { input.activate().session(&capability).give(u); }
-        drop(capability);
-    });
-    let output: Vec<((u64, i64), Time, isize)> =
-        recv.extract().into_iter().flat_map(|(_, batch)| batch).collect();
-
-    // Everything is finalized, so `acc(output, q) == f(acc(input, q))` must hold at every `q`. Check
-    // at a rich set: all input times, all output times, and their pairwise joins (where reduce's
-    // output can change).
-    let mut times: Vec<Time> = Vec::new();
-    times.extend(updates.iter().map(|(_, t, _)| t.clone()));
-    times.extend(output.iter().map(|(_, t, _)| t.clone()));
-    let base = times.clone();
-    for a in &base { for b in &base { times.push(a.join(b)); } }
-    times.sort(); times.dedup();
-
-    for q in &times {
-        // expected: per key, f applied to the accumulated input at `q`.
-        let mut expected: BTreeMap<(u64, i64), i64> = BTreeMap::new();
-        let mut per_key: BTreeMap<u64, BTreeMap<u64, isize>> = BTreeMap::new();
-        for ((k, v), t, d) in &updates {
-            if t.less_equal(q) { *per_key.entry(*k).or_default().entry(*v).or_default() += *d; }
-        }
-        for (k, vals) in &per_key {
-            let acc: Vec<(&u64, isize)> = vals.iter().filter(|(_, d)| **d != 0).map(|(v, d)| (v, *d)).collect();
-            if acc.is_empty() { continue; }
-            let mut out = Vec::new();
-            logic(k, &acc, &mut out);
-            for (ov, od) in out { *expected.entry((*k, ov)).or_default() += od as i64; }
-        }
-        expected.retain(|_, d| *d != 0);
-
-        // actual: the accumulated reduce output at `q`.
-        let mut actual: BTreeMap<(u64, i64), i64> = BTreeMap::new();
-        for ((k, ov), t, d) in &output {
-            if t.less_equal(q) { *actual.entry((*k, *ov)).or_default() += *d as i64; }
-        }
-        actual.retain(|_, d| *d != 0);
-
-        assert_eq!(expected, actual, "seed {seed} reference {reference} at time {q:?}");
-    }
-}
-
-// ======================= iterative BFS differential (a real shape) =======================
-
-#[test] fn bfs_tiny_a()   { bfs_differential(6, 10, 4, &[1, 2, 3, 4]); }
-#[test] fn bfs_tiny_b()   { bfs_differential(5, 8, 5, &[5, 6, 7, 8]); }
-#[test] fn bfs_30_60_20() { bfs_differential(30, 60, 20, &[1, 2, 3, 4]); }
-#[test] fn bfs_15_40_30() { bfs_differential(15, 40, 30, &[5, 6, 7, 8]); }
-#[test] fn bfs_sweep() {
-    for s in 0u8 .. 12 { bfs_differential(40, 120, 30, &[s as usize, (s as usize) + 7, 13, 29]); }
-    for s in 0u8 .. 6  { bfs_differential(60, 200, 25, &[3, (s as usize) + 1, (s as usize) * 5 + 2, 11]); }
-}
-
-type Node = usize;
-type Edge = (Node, Node);
-
-fn bfs_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize]) {
-    let mut rng1: StdRng = SeedableRng::from_seed(seed);
-    let mut rng2: StdRng = SeedableRng::from_seed(seed);
-    let mut edge_list: Vec<((usize, usize), usize, isize)> = Vec::new();
-    for _ in 0 .. edges { edge_list.push(((rng1.gen_range(0, nodes), rng1.gen_range(0, nodes)), 0, 1)); }
-    for round in 1 .. rounds {
-        edge_list.push(((rng1.gen_range(0, nodes), rng1.gen_range(0, nodes)), round, 1));
-        edge_list.push(((rng2.gen_range(0, nodes), rng2.gen_range(0, nodes)), round, -1));
-    }
-    let root_list = vec![(1usize, 0usize, 1isize)];
-
-    timely::execute_directly(move |worker| {
-        let mut roots_list = root_list.clone();
-        let mut edges_list = edge_list.clone();
-        let (mut roots, mut edges) = worker.dataflow::<usize, _, _>(|scope| {
-            let (root_input, roots) = scope.new_collection();
-            let (edge_input, edges) = scope.new_collection();
-            let via_cursor    = bfs(edges.clone(), roots.clone(), false);
-            let via_reference = bfs(edges, roots, true);
-            via_cursor.assert_eq(via_reference);
-            (root_input, edge_input)
-        });
-        roots_list.sort_by(|x, y| y.1.cmp(&x.1));
-        edges_list.sort_by(|x, y| y.1.cmp(&x.1));
-        let mut round = 0;
-        while !roots_list.is_empty() || !edges_list.is_empty() {
-            while roots_list.last().map(|x| x.1) == Some(round) { let (n, _, d) = roots_list.pop().unwrap(); roots.update(n, d); }
-            while edges_list.last().map(|x| x.1) == Some(round) { let ((s, t), _, d) = edges_list.pop().unwrap(); edges.update((s, t), d); }
-            round += 1;
-            roots.advance_to(round);
-            edges.advance_to(round);
-        }
-    });
-}
-
-fn bfs<'scope, T>(edges: VecCollection<'scope, T, Edge>, roots: VecCollection<'scope, T, Node>, reference: bool) -> VecCollection<'scope, T, (Node, usize)>
-where
-    T: timely::progress::Timestamp + Lattice + Ord,
-{
-    let nodes = roots.map(|x| (x, 0));
-    nodes.clone().iterate(|scope, inner| {
-        let edges = edges.enter(scope);
-        let nodes = nodes.enter(scope);
-        let combined = inner.join_map(edges, |_k, l, d| (*d, l + 1)).concat(nodes);
-        if reference {
-            reduce_reference(combined, |_, s, t| t.push((*s[0].0, 1)))
-        } else {
-            combined.reduce(|_, s, t| t.push((*s[0].0, 1)))
-        }
-    })
-}
-
-// ===================== iterative SCC differential (a deeper shape) =====================
-// SCC nests two Product-timed fixpoints: an outer edge-trimming loop and, inside each trim, an
-// iterative label propagation whose `reduce` is the tactic under test. The doubly-nested product
-// time produces far more synthetic interesting times than BFS, over joins / concats / filters.
-
-#[test] fn scc_tiny_a() { scc_differential(6, 12, 4, &[1, 2, 3, 4]); }
-#[test] fn scc_tiny_b() { scc_differential(8, 16, 4, &[5, 6, 7, 8]); }
-#[test] fn scc_12_24()  { scc_differential(12, 24, 5, &[2, 4, 6, 8]); }
-#[test] fn scc_sweep()  { for s in 0u8 .. 6 { scc_differential(15, 30, 5, &[s as usize, (s as usize) + 7, 13, 29]); } }
-
-fn scc_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize]) {
-    let mut rng1: StdRng = SeedableRng::from_seed(seed);
-    let mut rng2: StdRng = SeedableRng::from_seed(seed);
-    let mut edge_list: Vec<((usize, usize), usize, isize)> = Vec::new();
-    for _ in 0 .. edges { edge_list.push(((rng1.gen_range(0, nodes), rng1.gen_range(0, nodes)), 0, 1)); }
-    for round in 1 .. rounds {
-        edge_list.push(((rng1.gen_range(0, nodes), rng1.gen_range(0, nodes)), round, 1));
-        edge_list.push(((rng2.gen_range(0, nodes), rng2.gen_range(0, nodes)), round, -1));
-    }
-
-    timely::execute_directly(move |worker| {
-        let mut edges_list = edge_list.clone();
-        let mut edges = worker.dataflow::<usize, _, _>(|scope| {
-            let (edge_input, edges) = scope.new_collection();
-            let via_cursor    = scc(edges.clone(), false);
-            let via_reference = scc(edges, true);
-            via_cursor.assert_eq(via_reference);
-            edge_input
-        });
-        edges_list.sort_by(|x, y| y.1.cmp(&x.1));
-        let mut round = 0;
-        while !edges_list.is_empty() {
-            while edges_list.last().map(|x| x.1) == Some(round) { let ((s, t), _, d) = edges_list.pop().unwrap(); edges.update((s, t), d); }
-            round += 1;
-            edges.advance_to(round);
-        }
-    });
-}
-
-// The subset of edges within a strongly connected component, mirroring
-// `algorithms::graphs::scc::strongly_connected` but with the propagation `reduce` swappable.
-fn scc<'scope, T>(graph: VecCollection<'scope, T, Edge>, reference: bool) -> VecCollection<'scope, T, Edge>
-where
-    T: timely::progress::Timestamp + Lattice + Ord,
-{
-    let graph2 = graph.clone();
-    graph.iterate(move |scope, inner| {
-        let edges = graph2.enter(scope);
-        let trans = edges.clone().map(|(a, b)| (b, a));
-        let trimmed = trim_edges(inner, edges, reference);
-        trim_edges(trimmed, trans, reference)
-    })
-}
-
-// Keep only edges whose endpoints propagate to the same label; run twice (forward then transposed)
-// this converges on the SCC edges.
-fn trim_edges<'scope, T>(cycle: VecCollection<'scope, T, Edge>, edges: VecCollection<'scope, T, Edge>, reference: bool) -> VecCollection<'scope, T, Edge>
-where
-    T: timely::progress::Timestamp + Lattice + Ord,
-{
-    let nodes = edges.clone().map(|(_a, b)| (b, b));
-    let labels = propagate(cycle, nodes, reference);
-    edges.join_map(labels.clone(), |&src, &dst, &l1| (dst, (src, l1)))
-         .join_map(labels, |&dst, &(src, l1), &l2| ((src, dst), (l1, l2)))
-         .filter(|(_, (l1, l2))| l1 == l2)
-         .map(|((src, dst), _)| (dst, src))
-}
-
-// Forward min-label propagation along `edges` from per-node seed labels; the inner `reduce` (min
-// label per node) is the tactic under test.
-fn propagate<'scope, T>(edges: VecCollection<'scope, T, Edge>, nodes: VecCollection<'scope, T, (Node, Node)>, reference: bool) -> VecCollection<'scope, T, (Node, Node)>
-where
-    T: timely::progress::Timestamp + Lattice + Ord,
-{
-    let seed = nodes.clone();
-    nodes.filter(|_| false).iterate(move |scope, inner| {
-        let edges = edges.enter(scope);
-        let seed = seed.enter(scope);
-        let combined = inner.join_map(edges, |&_n, &l, &d| (d, l)).concat(seed);
-        if reference {
-            reduce_reference(combined, |_, s, t| t.push((*s[0].0, 1)))
-        } else {
-            combined.reduce(|_, s, t| t.push((*s[0].0, 1)))
-        }
-    })
-}
-
-/// A minimal product-order (partially ordered) timestamp, so the harness exercises the synthetic
-/// interesting times determination is about. Copied from `examples/multitemporal.rs`.
-mod pair {
-
-    #[derive(Hash, Default, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)]
-    pub struct Pair<S, T> { pub first: S, pub second: T }
-
-    impl<S, T> Pair<S, T> {
-        pub fn new(first: S, second: T) -> Self { Pair { first, second } }
-    }
-
-    use timely::order::PartialOrder;
-    impl<S: PartialOrder, T: PartialOrder> PartialOrder for Pair<S, T> {
-        fn less_equal(&self, other: &Self) -> bool {
-            self.first.less_equal(&other.first) && self.second.less_equal(&other.second)
-        }
-    }
-
-    use timely::progress::timestamp::Refines;
-    impl<S: Timestamp, T: Timestamp> Refines<()> for Pair<S, T> {
-        fn to_inner(_outer: ()) -> Self { Self::minimum() }
-        fn to_outer(self) -> () { () }
-        fn summarize(_summary: <Self>::Summary) -> () { () }
-    }
-
-    use timely::progress::PathSummary;
-    impl<S: Timestamp, T: Timestamp> PathSummary<Pair<S,T>> for () {
-        fn results_in(&self, timestamp: &Pair<S, T>) -> Option<Pair<S,T>> { Some(timestamp.clone()) }
-        fn followed_by(&self, other: &Self) -> Option<Self> { Some(other.clone()) }
-    }
-
-    use timely::progress::Timestamp;
-    impl<S: Timestamp, T: Timestamp> Timestamp for Pair<S, T> {
-        fn minimum() -> Self { Pair { first: S::minimum(), second: T::minimum() }}
-        type Summary = ();
-    }
-
-    use differential_dataflow::lattice::Lattice;
-    impl<S: Lattice, T: Lattice> Lattice for Pair<S, T> {
-        fn join(&self, other: &Self) -> Self {
-            Pair { first: self.first.join(&other.first), second: self.second.join(&other.second) }
-        }
-        fn meet(&self, other: &Self) -> Self {
-            Pair { first: self.first.meet(&other.first), second: self.second.meet(&other.second) }
-        }
-    }
-
-    use std::fmt::{Formatter, Error, Debug};
-    use serde::{Deserialize, Serialize};
-    impl<TOuter: Debug, TInner: Debug> Debug for Pair<TOuter, TInner> {
-        fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
-            f.write_str(&format!("({:?}, {:?})", self.first, self.second))
-        }
-    }
-}
diff --git a/differential-dataflow/tests/trace.rs b/differential-dataflow/tests/trace.rs
index 1fd9129f5..be9196d2f 100644
--- a/differential-dataflow/tests/trace.rs
+++ b/differential-dataflow/tests/trace.rs
@@ -2,7 +2,8 @@ use timely::dataflow::operators::generic::OperatorInfo;
 use timely::progress::{Antichain, frontier::AntichainRef};
 
 use differential_dataflow::trace::implementations::{ValBatcher, ValSpine};
-use differential_dataflow::trace::{Description, Span, Trace, TraceReader, Batcher};
+use differential_dataflow::batcher::Batcher;
+use differential_dataflow::trace::{Description, Span, Trace, TraceReader};
 use differential_dataflow::trace::cursor::{Cursor, cursor_list};
 
 type IntegerTrace = ValSpine<u64, u64, usize, i64>;
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index 588a6f571..72ceb53e5 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -33,7 +33,8 @@ 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::{BatchCursor, BatchDiff, BatchVal, Batcher, Cursor, Navigable, TraceReader};
+use differential_dataflow::batcher::Batcher;
+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;