diff --git a/Cargo.lock b/Cargo.lock
index 629bcc067ae1e..c9d5350de753c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3313,8 +3313,7 @@ checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
 [[package]]
 name = "differential-dataflow"
 version = "0.25.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2677690d1dfbf4d8427eef2fdcf350ab0b258d3be20d01dd37dca07ca6f50bcc"
+source = "git+https://github.com/TimelyDataflow/differential-dataflow?branch=master-next#8fd9cae7631fb4baad912be39f39a835fcee61ba"
 dependencies = [
  "columnar",
  "columnation",
@@ -3328,8 +3327,7 @@ dependencies = [
 [[package]]
 name = "differential-dogs3"
 version = "0.25.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52c9eee4acc936da45f096424617c91df981c619a92f3f8b4b2a324db7969b34"
+source = "git+https://github.com/TimelyDataflow/differential-dataflow?branch=master-next#8fd9cae7631fb4baad912be39f39a835fcee61ba"
 dependencies = [
  "differential-dataflow",
  "serde",
@@ -11091,7 +11089,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "03da047801ff44bb6a4d407d4860c05fd70bb81714e6b2f3812603d5b145b042"
 dependencies = [
  "heck",
- "itertools 0.14.0",
+ "itertools 0.10.5",
  "log",
  "multimap",
  "petgraph",
@@ -11112,7 +11110,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b570b25f7617e43d59005d0990ccb79e950a423952cea19671b7a876da390adf"
 dependencies = [
  "anyhow",
- "itertools 0.14.0",
+ "itertools 0.10.5",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
@@ -13523,8 +13521,7 @@ dependencies = [
 [[package]]
 name = "timely"
 version = "0.31.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ced05836c8e471cc85b5a12fbbe9a72568d98ea3b5a79e4a965918bc002108d9"
+source = "git+https://github.com/TimelyDataflow/timely-dataflow#4eb3ee09681c209ebcaeced73548a9fbf8e1c71e"
 dependencies = [
  "bincode",
  "byteorder",
@@ -13543,14 +13540,12 @@ dependencies = [
 [[package]]
 name = "timely_bytes"
 version = "0.31.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad328384fad249cbe20f742d842ee9e3d2c6086bcde6277fb11bb154f21fb92e"
+source = "git+https://github.com/TimelyDataflow/timely-dataflow#4eb3ee09681c209ebcaeced73548a9fbf8e1c71e"
 
 [[package]]
 name = "timely_communication"
 version = "0.31.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe397622e1c1957f3486efa0f706908b245c6ee73e7634ddaaf72f48bb3687dc"
+source = "git+https://github.com/TimelyDataflow/timely-dataflow#4eb3ee09681c209ebcaeced73548a9fbf8e1c71e"
 dependencies = [
  "byteorder",
  "columnar",
@@ -13564,14 +13559,12 @@ dependencies = [
 [[package]]
 name = "timely_container"
 version = "0.31.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de8c518a66e00ef8af9e9fae7e01b7d2628b970948f32855dfc89e503403ff5a"
+source = "git+https://github.com/TimelyDataflow/timely-dataflow#4eb3ee09681c209ebcaeced73548a9fbf8e1c71e"
 
 [[package]]
 name = "timely_logging"
 version = "0.31.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ae9187f19aec95c932196b95c1981708090d9c35213ae266d7bac0f32432886"
+source = "git+https://github.com/TimelyDataflow/timely-dataflow#4eb3ee09681c209ebcaeced73548a9fbf8e1c71e"
 dependencies = [
  "timely_container",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 27422005f8eb2..7c12acc1e9781 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -686,6 +686,12 @@ iceberg-storage-opendal = { git = "https://github.com/MaterializeInc/iceberg-rus
 # Hopefully we can upstream these changes eventually.
 # Additionally we keep the apache crates updated to latest versions.
 duckdb = { git = "https://github.com/MaterializeInc/duckdb-rs.git", rev = "752c7efe2582" }
+# Build against the next differential-dataflow, which pins timely by git in turn.
+#
+# `branch` is not reproducible: pin a `rev` (or a release) before this merges.
+differential-dataflow = { git = "https://github.com/TimelyDataflow/differential-dataflow", branch = "master-next" }
+differential-dogs3 = { git = "https://github.com/TimelyDataflow/differential-dataflow", branch = "master-next" }
+timely = { git = "https://github.com/TimelyDataflow/timely-dataflow" }
 
 
 # BEGIN LINT CONFIG
diff --git a/src/compute/benches/columnar_merge_batcher_row.rs b/src/compute/benches/columnar_merge_batcher_row.rs
index d0e7a1cab09a2..fa1f3150eb147 100644
--- a/src/compute/benches/columnar_merge_batcher_row.rs
+++ b/src/compute/benches/columnar_merge_batcher_row.rs
@@ -28,17 +28,17 @@
 //! consume the same pre-built [`Column<Tuple>`] inputs so the chunker
 //! sees identical input shape.
 
-use std::mem::size_of;
-
 use criterion::{BatchSize, BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
-use differential_dataflow::trace::Batcher;
-use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
+use differential_dataflow::batcher::Batcher;
+use differential_dataflow::trace::implementations::merge_batcher::Merger;
 use mz_ore::cast::{CastFrom, CastLossy, ReinterpretCast};
 use mz_repr::{Datum, Row};
 use mz_timely_util::columnar::Column;
 use mz_timely_util::columnar::batcher::{Chunker, ColumnChunker, ColumnMerger};
 use mz_timely_util::columnation::{ColInternalMerger, ColumnationStack};
+use mz_timely_util::operator::ConsolidatingBatcher;
 use rand::{Rng, SeedableRng, rngs::StdRng};
+use std::mem::size_of;
 use timely::container::ContainerBuilder;
 use timely::container::PushInto;
 use timely::progress::Antichain;
@@ -48,18 +48,6 @@ type Time = u64;
 type Diff = i64;
 type Tuple = (Data, Time, Diff);
 
-/// Legacy path: input is `Column<Tuple>`, chunker produces
-/// `ColumnationStack<Tuple>` chunks, merger operates on those.
-type ColumnationBatcher = MergeBatcher<ColInternalMerger<Data, Time, Diff>>;
-/// Chunker feeding [`ColumnationBatcher`].
-type ColumnationBatcherChunker = Chunker<ColumnationStack<Tuple>>;
-
-/// All-`Column` path: input is `Column<Tuple>`, chunker produces
-/// `Column<Tuple>` chunks, merger operates on those.
-type ColumnBatcher = MergeBatcher<ColumnMerger<Data, Time, Diff>>;
-/// Chunker feeding [`ColumnBatcher`].
-type ColumnBatcherChunker = ColumnChunker<Tuple>;
-
 /// Per-side payload-byte targets. Element counts are derived from
 /// [`ROW_PAYLOAD_BYTES`]. Same shape as [`columnar_merger_row`] so
 /// numbers can be cross-referenced.
@@ -193,31 +181,21 @@ fn rounds_to_columns(rounds: &[Vec<Tuple>]) -> Vec<Column<Tuple>> {
         .collect()
 }
 
-/// Run a fresh `B` over a clone of `prebuilt_rounds`, pushing each round
-/// then sealing at `+inf` so all data flows through extract. Generic over
-/// `B::Output` because the columnation path produces `ColumnationStack`
-/// chunks while the column path produces `Column` chunks; the no-op
-/// builder accommodates either.
-fn drive_batcher<B, Chu>(prebuilt_rounds: &[Column<Tuple>])
+/// Run a fresh `Chu`/`M` batcher over a clone of `prebuilt_rounds`, inserting each round then
+/// extracting at `+inf` so all data flows through the merge ladder.
+fn drive_batcher<Chu, M>(prebuilt_rounds: &[Column<Tuple>])
 where
-    B: Batcher<Time = Time>,
-    Chu: ContainerBuilder<Container = B::Output> + for<'a> PushInto<&'a mut Column<Tuple>>,
-    B::Output: 'static,
+    M: Merger<Time = Time>,
+    Chu: ContainerBuilder<Container = M::Chunk> + for<'a> PushInto<&'a mut Column<Tuple>>,
+    ConsolidatingBatcher<Chu, M>: Batcher<Column<Tuple>, Time = Time>,
 {
-    let mut batcher = B::new(None, 0);
-    let mut chunker = Chu::default();
+    let mut batcher = ConsolidatingBatcher::<Chu, M>::new(None, 0);
     for round in prebuilt_rounds {
         let mut col = round.clone();
-        chunker.push_into(&mut col);
-        while let Some(chunk) = chunker.extract() {
-            batcher.push_into(std::mem::take(chunk));
-        }
-    }
-    while let Some(chunk) = chunker.finish() {
-        batcher.push_into(std::mem::take(chunk));
+        batcher.insert(&mut col);
     }
     let upper = Antichain::from_elem(Time::MAX);
-    let _ = batcher.seal(upper);
+    let _ = batcher.extract(upper.borrow());
 }
 
 fn bench_batcher(c: &mut Criterion) {
@@ -266,7 +244,10 @@ fn bench_batcher(c: &mut Criterion) {
                 bencher.iter_batched(
                     || prebuilt.clone(),
                     |rounds| {
-                        drive_batcher::<ColumnationBatcher, ColumnationBatcherChunker>(&rounds)
+                        drive_batcher::<
+                            Chunker<ColumnationStack<Tuple>>,
+                            ColInternalMerger<Data, Time, Diff>,
+                        >(&rounds)
                     },
                     BatchSize::LargeInput,
                 );
@@ -275,7 +256,11 @@ fn bench_batcher(c: &mut Criterion) {
             group.bench_with_input(BenchmarkId::new("column", &id), &(), |bencher, _| {
                 bencher.iter_batched(
                     || prebuilt.clone(),
-                    |rounds| drive_batcher::<ColumnBatcher, ColumnBatcherChunker>(&rounds),
+                    |rounds| {
+                        drive_batcher::<ColumnChunker<Tuple>, ColumnMerger<Data, Time, Diff>>(
+                            &rounds,
+                        )
+                    },
                     BatchSize::LargeInput,
                 );
             });
diff --git a/src/compute/src/arrangement/manager.rs b/src/compute/src/arrangement/manager.rs
index 0ae01feae3337..9ef0d9c892c0d 100644
--- a/src/compute/src/arrangement/manager.rs
+++ b/src/compute/src/arrangement/manager.rs
@@ -9,16 +9,15 @@
 
 //! Management of arrangements across dataflows.
 
-use std::any::Any;
-use std::collections::BTreeMap;
-use std::rc::Rc;
-use std::time::Instant;
-
 use differential_dataflow::lattice::antichain_join;
 use differential_dataflow::operators::arrange::{Arranged, ShutdownButton, TraceAgent};
-use differential_dataflow::trace::TraceReader;
 use differential_dataflow::trace::wrappers::frontier::TraceFrontier;
+use differential_dataflow::trace::{Span, TraceReader};
 use mz_repr::{Diff, GlobalId, Timestamp};
+use std::any::Any;
+use std::collections::BTreeMap;
+use std::rc::Rc;
+use std::time::Instant;
 use timely::PartialOrder;
 use timely::dataflow::Scope;
 use timely::dataflow::operators::CapabilitySet;
@@ -165,6 +164,13 @@ where
     type Time = Tr::Time;
     type Batch = Tr::Batch;
 
+    fn spans_through(
+        &mut self,
+        upper: AntichainRef<Self::Time>,
+    ) -> Option<Vec<Span<Self::Time, Self::Batch>>> {
+        self.trace.spans_through(upper)
+    }
+
     fn batches_through(&mut self, upper: AntichainRef<Self::Time>) -> Option<Vec<Self::Batch>> {
         self.trace.batches_through(upper)
     }
@@ -204,8 +210,8 @@ where
         self.trace.get_physical_compaction()
     }
 
-    fn map_batches<F: FnMut(&Self::Batch)>(&self, f: F) {
-        self.trace.map_batches(f)
+    fn map_spans<F: FnMut(&Span<Self::Time, Self::Batch>)>(&self, f: F) {
+        self.trace.map_spans(f)
     }
 }
 
diff --git a/src/compute/src/compute_state.rs b/src/compute/src/compute_state.rs
index b19c8d8044c65..f3a1da3d3435e 100644
--- a/src/compute/src/compute_state.rs
+++ b/src/compute/src/compute_state.rs
@@ -5,15 +5,6 @@
 
 //! Worker-local state for compute timely instances.
 
-use std::any::Any;
-use std::cell::RefCell;
-use std::cmp::Ordering;
-use std::collections::{BTreeMap, BTreeSet, VecDeque};
-use std::num::NonZeroUsize;
-use std::rc::Rc;
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-
 use differential_dataflow::Hashable;
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::trace::TraceReader;
@@ -56,6 +47,14 @@ use mz_storage_types::sources::SourceData;
 use mz_storage_types::time_dependence::TimeDependence;
 use mz_txn_wal::operator::TxnsContext;
 use mz_txn_wal::txn_cache::TxnsCache;
+use std::any::Any;
+use std::cell::RefCell;
+use std::cmp::Ordering;
+use std::collections::{BTreeMap, BTreeSet, VecDeque};
+use std::num::NonZeroUsize;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
 use timely::dataflow::operators::probe;
 use timely::order::PartialOrder;
 use timely::progress::frontier::Antichain;
@@ -67,6 +66,7 @@ use uuid::Uuid;
 use crate::arrangement::manager::{TraceBundle, TraceManager};
 use crate::compute_state::peek_budget::InlineBudget;
 use crate::compute_state::peek_metrics::{IndexPeekMetrics, PeekWalkMetrics};
+
 pub(crate) use crate::compute_state::peek_offload::PeekPermits;
 use crate::compute_state::peek_offload::{OffloadConfig, OffloadedPeek};
 use crate::compute_state::peek_scan::{
@@ -76,7 +76,7 @@ use crate::logging;
 use crate::logging::compute::{CollectionLogging, ComputeEvent, PeekEvent};
 use crate::logging::initialize::LoggingTraces;
 use crate::metrics::{CollectionMetrics, WorkerMetrics};
-use crate::render::{LinearJoinSpec, StartSignal};
+use crate::render::StartSignal;
 use crate::server::{ComputeInstanceContext, ResponseSender};
 
 mod error_scan;
@@ -221,7 +221,6 @@ pub struct ComputeState {
     /// Max size in bytes of any result.
     max_result_size: u64,
     /// Specification for rendering linear joins.
-    pub linear_join_spec: LinearJoinSpec,
     /// Metrics for this worker.
     pub metrics: WorkerMetrics,
     /// A process-global handle to tracing configuration.
@@ -337,7 +336,6 @@ impl ComputeState {
             txns_ctx,
             command_history,
             max_result_size: u64::MAX,
-            linear_join_spec: Default::default(),
             metrics,
             tracing_handle,
             context,
@@ -390,8 +388,6 @@ impl ComputeState {
 
         let config = &self.worker_config;
 
-        self.linear_join_spec = LinearJoinSpec::from_config(config);
-
         if ENABLE_LGALLOC.get(config) {
             if let Some(path) = &self.context.scratch_directory {
                 let clear_bytes = LGALLOC_SLOW_CLEAR_BYTES.get(config);
diff --git a/src/compute/src/compute_state/error_scan.rs b/src/compute/src/compute_state/error_scan.rs
index ce93100bb617e..84ebf8085cd09 100644
--- a/src/compute/src/compute_state/error_scan.rs
+++ b/src/compute/src/compute_state/error_scan.rs
@@ -6,12 +6,13 @@
 //! An index peek's walk over its error trace, the phase that runs before
 //! [`PeekResultIterator`](super::peek_result_iterator::PeekResultIterator) walks the ok trace.
 
-use std::time::{Duration, Instant};
-
+use differential_dataflow::trace::cursor::cursor_list;
 use differential_dataflow::trace::{Cursor, TraceReader};
 use mz_compute_client::protocol::response::PeekError;
 use mz_repr::{Diff, GlobalId, Timestamp};
+use std::time::{Duration, Instant};
 use timely::order::PartialOrder;
+use timely::progress::Antichain;
 use tracing::error;
 
 use crate::arrangement::manager::PaddedTrace;
@@ -55,7 +56,10 @@ impl ErrorScan {
     /// supply through [`ErrorScan::set_row_iteration_limit`] before each step.
     pub(super) fn new(errs: &mut ErrsHandle) -> Self {
         let scan_start = Instant::now();
-        let (cursor, storage) = errs.cursor();
+        let batches = errs
+            .batches_through(Antichain::new().borrow())
+            .expect("trace is not compacted beyond the empty frontier");
+        let (cursor, storage) = cursor_list(batches);
         let mut scan = Self::from_cursor(cursor, storage);
         scan.scan_time = scan_start.elapsed();
         scan
diff --git a/src/compute/src/compute_state/error_scan/tests.rs b/src/compute/src/compute_state/error_scan/tests.rs
index 509e96440b670..26078e4599332 100644
--- a/src/compute/src/compute_state/error_scan/tests.rs
+++ b/src/compute/src/compute_state/error_scan/tests.rs
@@ -9,17 +9,16 @@
 
 //! Tests of the fueled walk over a peek's error trace.
 
+use differential_dataflow::batcher::Batcher;
+use differential_dataflow::trace::Navigable;
 use differential_dataflow::trace::cursor::CursorList;
-use differential_dataflow::trace::{Batcher, Builder, Navigable};
 use mz_expr::EvalError;
-use mz_timely_util::columnation::ColumnationStack;
-use timely::container::PushInto;
+use mz_timely_util::columnation::ColumnationChunker;
 use timely::progress::Antichain;
 
-use crate::render::errors::DataflowErrorSer;
-use crate::typedefs::{ErrBatcher, ErrBuilder, ErrSpine};
-
 use super::*;
+use crate::render::errors::DataflowErrorSer;
+use crate::typedefs::{ErrBatcher, ErrSpine};
 
 /// The time at which the peeks in these tests read.
 pub(crate) const PEEK_TIMESTAMP: Timestamp = Timestamp::new(1);
@@ -36,24 +35,24 @@ pub(crate) fn error(index: usize) -> DataflowErrorSer {
 }
 
 /// Builds a single batch holding `updates`, covering `[0, Timestamp::MAX)`.
+///
+/// Absent when `updates` consolidates to nothing, which is how an interval with no updates is
+/// represented.
 pub(crate) fn error_batch(
     updates: ErrorUpdates,
-) -> <ErrSpine<Timestamp, Diff> as TraceReader>::Batch {
-    let mut batcher = ErrBatcher::<Timestamp, Diff>::new(None, 0);
-    let mut chunk = ColumnationStack::with_capacity(updates.len());
-    for update in updates {
-        chunk.push_into(update);
-    }
-    batcher.push_into(chunk);
-    let (mut chain, description) = batcher.seal(Antichain::from_elem(Timestamp::MAX));
-    ErrBuilder::<Timestamp, Diff>::seal(&mut chain, description)
+) -> Option<<ErrSpine<Timestamp, Diff> as TraceReader>::Batch> {
+    let mut updates: Vec<_> = updates.into_iter().collect();
+    let mut batcher = ErrBatcher::<Timestamp, Diff, ColumnationChunker<_>>::new(None, 0);
+    batcher.insert(&mut updates);
+    let (batch, _frontier) = batcher.extract(Antichain::from_elem(Timestamp::MAX).borrow());
+    batch
 }
 
 /// Builds a walk over a single-batch error trace holding `updates`, bounded by
 /// `row_iteration_limit`.
 pub(crate) fn error_scan(updates: ErrorUpdates, row_iteration_limit: Option<usize>) -> ErrorScan {
-    let storage = vec![error_batch(updates)];
-    let cursor = CursorList::new(vec![storage[0].cursor()], &storage);
+    let storage: Vec<_> = error_batch(updates).into_iter().collect();
+    let cursor = CursorList::new(storage.iter().map(Navigable::cursor).collect(), &storage);
     let mut scan = ErrorScan::from_cursor(cursor, storage);
     scan.set_row_iteration_limit(row_iteration_limit);
     scan
diff --git a/src/compute/src/compute_state/index_peek_tests.rs b/src/compute/src/compute_state/index_peek_tests.rs
index 408ea0c004915..2d8c8b017ac66 100644
--- a/src/compute/src/compute_state/index_peek_tests.rs
+++ b/src/compute/src/compute_state/index_peek_tests.rs
@@ -10,23 +10,23 @@
 //! Tests of the inline index-peek driver, and the fixtures a peek scan is tested over.
 
 use differential_dataflow::operators::arrange::TraceAgent;
-use differential_dataflow::trace::{Batcher, Builder, Trace};
+use differential_dataflow::trace::{Batcher, Trace};
+use differential_dataflow::trace::{Description, Span};
 use mz_expr::RowSetFinishing;
 use mz_ore::cast::CastFrom;
 use mz_repr::{Datum, Diff, RelationDesc, SqlScalarType};
-use mz_row_spine::{RowRowBatcher, RowRowBuilder, RowRowSpine};
-use mz_timely_util::columnation::ColumnationStack;
-use timely::container::PushInto;
+use mz_row_spine::{RowRowBatcher, RowRowSpine};
+use mz_timely_util::columnation::ColumnationChunker;
 use timely::dataflow::operators::generic::OperatorInfo;
-
-use crate::metrics::ComputeMetrics;
-use crate::server::ComputeRuntimeRole;
-use crate::typedefs::{ErrAgent, ErrSpine, RowRowAgent};
+use timely::progress::Stamp;
 
 use super::error_scan::tests::{
     ErrorUpdates, PEEK_TIMESTAMP, cancelling, error, error_batch, holding,
 };
 use super::*;
+use crate::metrics::ComputeMetrics;
+use crate::server::ComputeRuntimeRole;
+use crate::typedefs::{ErrAgent, ErrSpine, RowRowAgent};
 
 /// The collection the peeks in these tests read.
 pub(crate) const TARGET_ID: GlobalId = GlobalId::User(1);
@@ -50,13 +50,23 @@ const STASH_EVERYTHING: StashBounds = StashBounds {
 /// The writer is dropped here, which seals the trace to the empty frontier. That is what lets
 /// `TraceReader::cursor` hand out a cursor covering every batch, which is the only way a peek
 /// reads a trace.
-fn agent<Tr>(batch: Tr::Batch) -> TraceAgent<Tr>
+fn agent<Tr>(batch: Option<Tr::Batch>) -> TraceAgent<Tr>
 where
     Tr: Trace<Time = Timestamp> + 'static,
 {
     let info = OperatorInfo::new(0, 0, [].into());
     let (agent, mut writer) = TraceAgent::new(Tr::new(info.clone(), None, None), info, None);
-    writer.insert(batch, Some(Timestamp::MIN));
+    writer.insert(
+        Span::new(
+            Description::new(
+                Antichain::from_elem(Timestamp::MIN),
+                Antichain::from_elem(Timestamp::MAX),
+                Antichain::from_elem(Timestamp::MIN),
+            ),
+            batch,
+        ),
+        Stamp::from_elem(Timestamp::MIN),
+    );
     agent
 }
 
@@ -76,14 +86,13 @@ pub(crate) fn trivial_finishing() -> RowSetFinishing {
 /// The ok trace of an index holding one update per key in `keys`, all at [`Timestamp::MIN`] so
 /// that every one of them is visible at [`PEEK_TIMESTAMP`]. The values are empty.
 fn oks_trace(keys: &[Row]) -> RowRowAgent<Timestamp, Diff> {
-    let mut chunk = ColumnationStack::with_capacity(keys.len());
-    for key in keys {
-        chunk.push_into(((key.clone(), Row::default()), Timestamp::MIN, Diff::ONE));
-    }
-    let mut batcher = RowRowBatcher::<Timestamp, Diff>::new(None, 0);
-    batcher.push_into(chunk);
-    let (mut chain, description) = batcher.seal(Antichain::from_elem(Timestamp::MAX));
-    let batch = RowRowBuilder::<Timestamp, Diff>::seal(&mut chain, description);
+    let mut updates: Vec<_> = keys
+        .iter()
+        .map(|key| ((key.clone(), Row::default()), Timestamp::MIN, Diff::ONE))
+        .collect();
+    let mut batcher = RowRowBatcher::<Timestamp, Diff, ColumnationChunker<_>>::new(None, 0);
+    batcher.insert(&mut updates);
+    let (batch, _frontier) = batcher.extract(Antichain::from_elem(Timestamp::MAX).borrow());
     agent::<RowRowSpine<Timestamp, Diff>>(batch)
 }
 
diff --git a/src/compute/src/compute_state/peek_result_iterator.rs b/src/compute/src/compute_state/peek_result_iterator.rs
index bdee736776a92..d402886cd25fc 100644
--- a/src/compute/src/compute_state/peek_result_iterator.rs
+++ b/src/compute/src/compute_state/peek_result_iterator.rs
@@ -5,17 +5,17 @@
 
 //! Code for extracting a peek result out of compute state/an arrangement.
 
-use std::iter::FusedIterator;
-use std::num::NonZeroI64;
-use std::ops::Range;
-
-use differential_dataflow::trace::cursor::{BatchCursor, BatchKey, CursorList};
+use differential_dataflow::trace::cursor::{BatchCursor, BatchKey, CursorList, cursor_list};
 use differential_dataflow::trace::implementations::BatchContainer;
 use differential_dataflow::trace::{Cursor, Navigable, TraceReader};
 use mz_compute_client::protocol::response::PeekError;
 use mz_repr::fixed_length::ExtendDatums;
 use mz_repr::{DatumVec, Diff, GlobalId, Row, RowArena};
+use std::iter::FusedIterator;
+use std::num::NonZeroI64;
+use std::ops::Range;
 use timely::order::PartialOrder;
+use timely::progress::Antichain;
 
 use crate::compute_state::PeekRowIterationTracker;
 
@@ -193,7 +193,11 @@ where
         row_iteration_limit: Option<usize>,
         rows_iterated: usize,
     ) -> Self {
-        let (cursor, storage) = trace_reader.cursor();
+        // `TraceReader` no longer builds cursors; take the batches and assemble one.
+        let batches = trace_reader
+            .batches_through(Antichain::new().borrow())
+            .expect("trace is not compacted beyond the empty frontier");
+        let (cursor, storage) = cursor_list(batches);
         Self::from_cursor(
             target_id,
             map_filter_project,
diff --git a/src/compute/src/compute_state/peek_result_iterator/tests.rs b/src/compute/src/compute_state/peek_result_iterator/tests.rs
index a27ec1ba39ede..291717237c8c1 100644
--- a/src/compute/src/compute_state/peek_result_iterator/tests.rs
+++ b/src/compute/src/compute_state/peek_result_iterator/tests.rs
@@ -9,13 +9,12 @@
 
 //! Tests of the fueled cursor walk that produces an index peek's rows.
 
+use differential_dataflow::batcher::Batcher;
+use differential_dataflow::trace::Navigable;
 use differential_dataflow::trace::cursor::CursorList;
-use differential_dataflow::trace::implementations::ord_neu::OrdValBatcher;
-use differential_dataflow::trace::{Batcher, Builder, Navigable};
 use mz_expr::{EvalError, MirScalarExpr};
 use mz_repr::{Datum, ReprScalarType, Row, Timestamp};
-use mz_row_spine::{ArcOrdValBuilder, ArcOrdValSpine};
-use timely::container::PushInto;
+use mz_row_spine::{ArcOrdValBatcher, ArcOrdValSpine};
 use timely::progress::Antichain;
 
 use super::*;
@@ -28,14 +27,17 @@ fn row(value: u8) -> Row {
 
 /// Builds a single-batch trace holding `keys`, and a cursor over it.
 fn trace(keys: &[Row]) -> (TraceCursor<TestTrace>, TraceStorage<TestTrace>) {
-    let updates: Vec<((Row, Row), Timestamp, Diff)> = keys
+    let mut updates: Vec<((Row, Row), Timestamp, Diff)> = keys
         .iter()
         .map(|key| ((key.clone(), Row::default()), Timestamp::MIN, Diff::ONE))
         .collect();
-    let mut batcher = OrdValBatcher::<Row, Row, Timestamp, Diff>::new(None, 0);
-    batcher.push_into(updates);
-    let (mut chain, description) = batcher.seal(Antichain::from_elem(Timestamp::MAX));
-    let batch = ArcOrdValBuilder::<Row, Row, Timestamp, Diff>::seal(&mut chain, description);
+    let mut batcher = ArcOrdValBatcher::<Row, Row, Timestamp, Diff>::new(None, 0);
+    Batcher::<Vec<((Row, Row), Timestamp, Diff)>>::insert(&mut batcher, &mut updates);
+    let (batch, _frontier) = Batcher::<Vec<((Row, Row), Timestamp, Diff)>>::extract(
+        &mut batcher,
+        Antichain::from_elem(Timestamp::MAX).borrow(),
+    );
+    let batch = batch.expect("updates were pushed, so the batch is non-empty");
     let storage = vec![batch];
     let cursor = CursorList::new(vec![storage[0].cursor()], &storage);
     (cursor, storage)
diff --git a/src/compute/src/compute_state/peek_scan/tests.rs b/src/compute/src/compute_state/peek_scan/tests.rs
index 7858c62847ca5..07c5fe5210baf 100644
--- a/src/compute/src/compute_state/peek_scan/tests.rs
+++ b/src/compute/src/compute_state/peek_scan/tests.rs
@@ -9,17 +9,17 @@
 
 //! Tests of the budgeted scan that answers an index peek.
 
+use differential_dataflow::batcher::Batcher;
+use differential_dataflow::trace::Navigable;
 use differential_dataflow::trace::cursor::CursorList;
-use differential_dataflow::trace::implementations::ord_neu::OrdValBatcher;
-use differential_dataflow::trace::{Batcher, Builder, Navigable};
 use mz_expr::row::RowCollection;
 use mz_expr::{ColumnOrder, RowSetFinishing};
 use mz_ore::num::NonNeg;
 use mz_repr::Datum;
-use mz_row_spine::{ArcOrdValBuilder, ArcOrdValSpine};
-use timely::container::PushInto;
+use mz_row_spine::{ArcOrdValBatcher, ArcOrdValSpine};
 use timely::progress::Antichain;
 
+use super::*;
 use crate::arrangement::manager::{PaddedTrace, TraceBundle};
 use crate::compute_state::error_scan::tests::PEEK_TIMESTAMP;
 use crate::compute_state::index_peek_tests::{
@@ -27,8 +27,6 @@ use crate::compute_state::index_peek_tests::{
 };
 use crate::typedefs::RowRowAgent;
 
-use super::*;
-
 type TestTrace = ArcOrdValSpine<Row, Row, Timestamp, Diff>;
 
 /// The ok-trace handle a peek reads through, as [`TraceBundle::oks_errs_mut`] hands it out.
@@ -86,14 +84,17 @@ fn ok_iterator(keys: &[Row]) -> PeekResultIterator<TestTrace> {
 
 /// A walk over an ok trace holding `copies` of each of `keys`.
 fn ok_iterator_with_copies(keys: &[Row], copies: Diff) -> PeekResultIterator<TestTrace> {
-    let updates: Vec<((Row, Row), Timestamp, Diff)> = keys
+    let mut updates: Vec<((Row, Row), Timestamp, Diff)> = keys
         .iter()
         .map(|key| ((key.clone(), Row::default()), Timestamp::MIN, copies))
         .collect();
-    let mut batcher = OrdValBatcher::<Row, Row, Timestamp, Diff>::new(None, 0);
-    batcher.push_into(updates);
-    let (mut chain, description) = batcher.seal(Antichain::from_elem(Timestamp::MAX));
-    let batch = ArcOrdValBuilder::<Row, Row, Timestamp, Diff>::seal(&mut chain, description);
+    let mut batcher = ArcOrdValBatcher::<Row, Row, Timestamp, Diff>::new(None, 0);
+    Batcher::<Vec<((Row, Row), Timestamp, Diff)>>::insert(&mut batcher, &mut updates);
+    let (batch, _frontier) = Batcher::<Vec<((Row, Row), Timestamp, Diff)>>::extract(
+        &mut batcher,
+        Antichain::from_elem(Timestamp::MAX).borrow(),
+    );
+    let batch = batch.expect("updates were pushed, so the batch is non-empty");
     let storage = vec![batch];
     let cursor = CursorList::new(vec![storage[0].cursor()], &storage);
     // The cursor's key is the only datum. The values are empty.
diff --git a/src/compute/src/extensions/arrange.rs b/src/compute/src/extensions/arrange.rs
index b06e1a56790b7..6e9c33e737502 100644
--- a/src/compute/src/extensions/arrange.rs
+++ b/src/compute/src/extensions/arrange.rs
@@ -7,22 +7,22 @@
 // the Business Source License, use of this software will be governed
 // by the Apache License, Version 2.0.
 
-use std::collections::BTreeMap;
-use std::rc::Rc;
-use std::sync::{Arc, Weak};
-
+use differential_dataflow::batcher::Batcher;
 use differential_dataflow::difference::Semigroup;
 use differential_dataflow::lattice::Lattice;
+use differential_dataflow::logging::Logger;
 use differential_dataflow::operators::arrange::arrangement::arrange_core;
 use differential_dataflow::operators::arrange::{Arranged, TraceAgent};
-use differential_dataflow::trace::implementations::spine_fueled::Spine;
-use differential_dataflow::trace::{Batch, Batcher, Builder, Trace, TraceReader};
+use differential_dataflow::trace::implementations::spine_fueled::{Spine, SpineBatch};
+use differential_dataflow::trace::{Trace, TraceReader};
 use differential_dataflow::{Collection, Data, ExchangeData, Hashable, VecCollection};
 use mz_compute_types::dyncfgs::{ENABLE_COLUMN_PAGED_BATCHER, ENABLE_COLUMNAR_MERGE_BATCHER};
 use mz_dyncfg::ConfigSet;
 use mz_row_spine::ArcBatch;
+use std::collections::BTreeMap;
+use std::rc::Rc;
+use std::sync::{Arc, Weak};
 use timely::Container;
-use timely::container::{ContainerBuilder, PushInto};
 use timely::dataflow::Stream;
 use timely::dataflow::channels::pact::{Exchange, ParallelizationContract, Pipeline};
 use timely::dataflow::operators::Operator;
@@ -38,10 +38,8 @@ use crate::typedefs::{
 
 /// Which merge batcher an arrange site should instantiate.
 ///
-/// The three parameters `mz_arrange_core` takes are one unit, not three
-/// knobs: the chunker's container and the builder's input are both pinned to
-/// `Batcher::Output`, so the chunker and builder follow from the batcher and
-/// a call site has to spell out a whole arm per variant.
+/// The batcher names its own chunker and builder, so a call site spells out one
+/// type per variant rather than three that have to agree.
 pub enum ArrangementBatcher {
     /// `Chunker<ColumnationStack<_>>` + `Col2ValBatcher` + `RowRowBuilder`.
     /// Chains are columnation stacks.
@@ -74,30 +72,38 @@ impl ArrangementBatcher {
 }
 
 /// Extension trait to arrange data.
-pub trait MzArrange<'scope>: MzArrangeCore<'scope> {
+pub trait MzArrange<'scope, C>: MzArrangeCore<'scope, C>
+where
+    C: Container + Clone + 'static,
+{
     /// Arranges a stream of `(Key, Val)` updates by `Key` into a trace of type `Tr`.
     ///
     /// This operator arranges a stream of values into a shared trace, whose contents it maintains.
     /// This trace is current for all times marked completed in the output stream, and probing this stream
     /// is the correct way to determine that times in the shared trace are committed.
-    fn mz_arrange<Chu, Ba, Bu, Tr>(self, name: &str) -> Arranged<'scope, TraceAgent<Tr>>
+    fn mz_arrange<Ba, Tr>(
+        self,
+        name: &str,
+        batcher: impl FnOnce(Option<Logger>, usize) -> Ba + 'static,
+    ) -> Arranged<'scope, TraceAgent<Tr>>
     where
-        Ba: Batcher<Time = Self::Timestamp> + 'static,
-        Chu: ContainerBuilder<Container = Ba::Output>
-            + for<'a> PushInto<&'a mut Self::Input>
-            + 'static,
-        Bu: Builder<Time = Self::Timestamp, Input = Ba::Output, Output = Tr::Batch>,
-        Tr: Trace + TraceReader<Time = Self::Timestamp> + 'static,
-        Tr::Batch: Batch,
+        Ba: Batcher<C, Time = Self::Timestamp> + 'static,
+        <Ba as Batcher<C>>::Output: Into<Tr::Batch>,
+        Tr: Trace<Time = Self::Timestamp> + 'static,
         Arranged<'scope, TraceAgent<Tr>>: ArrangementSize;
 }
 
 /// Extension trait to arrange data.
-pub trait MzArrangeCore<'scope> {
+///
+/// The input container is a trait parameter rather than an associated type: every batcher bound
+/// has to name it, and a projection through an associated type does not normalize inside a
+/// method's where clause.
+pub trait MzArrangeCore<'scope, C>
+where
+    C: Container + Clone + 'static,
+{
     /// The current scope.
     type Timestamp: Timestamp + Lattice;
-    /// The data input container type.
-    type Input: Container + Clone + 'static;
 
     /// Arranges a stream of `(Key, Val)` updates by `Key` into a trace of type `Tr`. Partitions
     /// the data according to `pact`.
@@ -105,101 +111,91 @@ pub trait MzArrangeCore<'scope> {
     /// This operator arranges a stream of values into a shared trace, whose contents it maintains.
     /// This trace is current for all times marked completed in the output stream, and probing this stream
     /// is the correct way to determine that times in the shared trace are committed.
-    fn mz_arrange_core<P, Chu, Ba, Bu, Tr>(
+    fn mz_arrange_core<P, Ba, Tr>(
         self,
         pact: P,
         name: &str,
+        batcher: impl FnOnce(Option<Logger>, usize) -> Ba + 'static,
     ) -> Arranged<'scope, TraceAgent<Tr>>
     where
-        P: ParallelizationContract<Self::Timestamp, Self::Input>,
-        Ba: Batcher<Time = Self::Timestamp> + 'static,
-        Chu: ContainerBuilder<Container = Ba::Output>
-            + for<'a> PushInto<&'a mut Self::Input>
-            + 'static,
-        Bu: Builder<Time = Self::Timestamp, Input = Ba::Output, Output = Tr::Batch>,
-        Tr: Trace + TraceReader<Time = Self::Timestamp> + 'static,
-        Tr::Batch: Batch,
+        P: ParallelizationContract<Self::Timestamp, C>,
+        Ba: Batcher<C, Time = Self::Timestamp> + 'static,
+        <Ba as Batcher<C>>::Output: Into<Tr::Batch>,
+        Tr: Trace<Time = Self::Timestamp> + 'static,
         Arranged<'scope, TraceAgent<Tr>>: ArrangementSize;
 }
 
-impl<'scope, T, C> MzArrangeCore<'scope> for Stream<'scope, T, C>
+impl<'scope, T, C> MzArrangeCore<'scope, C> for Stream<'scope, T, C>
 where
     T: Timestamp + Lattice,
     C: Container + Clone + 'static,
 {
     type Timestamp = T;
-    type Input = C;
 
-    fn mz_arrange_core<P, Chu, Ba, Bu, Tr>(
+    fn mz_arrange_core<P, Ba, Tr>(
         self,
         pact: P,
         name: &str,
+        batcher: impl FnOnce(Option<Logger>, usize) -> Ba + 'static,
     ) -> Arranged<'scope, TraceAgent<Tr>>
     where
-        P: ParallelizationContract<T, Self::Input>,
-        Ba: Batcher<Time = T> + 'static,
-        Chu: ContainerBuilder<Container = Ba::Output>
-            + for<'a> PushInto<&'a mut Self::Input>
-            + 'static,
-        Bu: Builder<Time = T, Input = Ba::Output, Output = Tr::Batch>,
-        Tr: Trace + TraceReader<Time = T> + 'static,
-        Tr::Batch: Batch,
+        P: ParallelizationContract<T, C>,
+        Ba: Batcher<C, Time = T> + 'static,
+        <Ba as Batcher<C>>::Output: Into<Tr::Batch>,
+        Tr: Trace<Time = T> + 'static,
         Arranged<'scope, TraceAgent<Tr>>: ArrangementSize,
     {
         // Allow access to `arrange_named` because we're within Mz's wrapper.
         #[allow(clippy::disallowed_methods)]
-        arrange_core::<_, _, Chu, Ba, Bu, _>(self, pact, name).log_arrangement_size()
+        arrange_core::<_, _, Ba, _>(self, pact, name, batcher).log_arrangement_size()
     }
 }
 
-impl<'scope, T, K, V, R> MzArrange<'scope> for VecCollection<'scope, T, (K, V), R>
+impl<'scope, T, K, V, R> MzArrange<'scope, Vec<((K, V), T, R)>>
+    for VecCollection<'scope, T, (K, V), R>
 where
     T: Timestamp + Lattice,
     K: ExchangeData + Hashable,
     V: ExchangeData,
     R: ExchangeData,
 {
-    fn mz_arrange<Chu, Ba, Bu, Tr>(self, name: &str) -> Arranged<'scope, TraceAgent<Tr>>
+    fn mz_arrange<Ba, Tr>(
+        self,
+        name: &str,
+        batcher: impl FnOnce(Option<Logger>, usize) -> Ba + 'static,
+    ) -> Arranged<'scope, TraceAgent<Tr>>
     where
-        Ba: Batcher<Time = T> + 'static,
-        Chu: ContainerBuilder<Container = Ba::Output>
-            + for<'a> PushInto<&'a mut Self::Input>
-            + 'static,
-        Bu: Builder<Time = T, Input = Ba::Output, Output = Tr::Batch>,
-        Tr: Trace + TraceReader<Time = T> + 'static,
-        Tr::Batch: Batch,
+        Ba: Batcher<Vec<((K, V), T, R)>, Time = T> + 'static,
+        <Ba as Batcher<Vec<((K, V), T, R)>>>::Output: Into<Tr::Batch>,
+        Tr: Trace<Time = T> + 'static,
         Arranged<'scope, TraceAgent<Tr>>: ArrangementSize,
     {
         let exchange = Exchange::new(move |update: &((K, V), T, R)| (update.0).0.hashed().into());
-        self.mz_arrange_core::<_, Chu, Ba, Bu, _>(exchange, name)
+        self.mz_arrange_core::<_, Ba, _>(exchange, name, batcher)
     }
 }
 
-impl<'scope, T, C> MzArrangeCore<'scope> for Collection<'scope, T, C>
+impl<'scope, T, C> MzArrangeCore<'scope, C> for Collection<'scope, T, C>
 where
     T: Timestamp + Lattice,
     C: Container + Clone + 'static,
 {
     type Timestamp = T;
-    type Input = C;
 
-    fn mz_arrange_core<P, Chu, Ba, Bu, Tr>(
+    fn mz_arrange_core<P, Ba, Tr>(
         self,
         pact: P,
         name: &str,
+        batcher: impl FnOnce(Option<Logger>, usize) -> Ba + 'static,
     ) -> Arranged<'scope, TraceAgent<Tr>>
     where
-        P: ParallelizationContract<T, Self::Input>,
-        Ba: Batcher<Time = T> + 'static,
-        Chu: ContainerBuilder<Container = Ba::Output>
-            + for<'a> PushInto<&'a mut Self::Input>
-            + 'static,
-        Bu: Builder<Time = T, Input = Ba::Output, Output = Tr::Batch>,
-        Tr: Trace + TraceReader<Time = T> + 'static,
-        Tr::Batch: Batch,
+        P: ParallelizationContract<T, C>,
+        Ba: Batcher<C, Time = T> + 'static,
+        <Ba as Batcher<C>>::Output: Into<Tr::Batch>,
+        Tr: Trace<Time = T> + 'static,
         Arranged<'scope, TraceAgent<Tr>>: ArrangementSize,
     {
-        self.inner.mz_arrange_core::<_, Chu, Ba, Bu, _>(pact, name)
+        self.inner.mz_arrange_core::<_, Ba, _>(pact, name, batcher)
     }
 }
 
@@ -218,55 +214,51 @@ impl<'scope, T: Timestamp, K, R: Semigroup> From<VecCollection<'scope, T, K, R>>
     }
 }
 
-impl<'scope, T, K, R> MzArrange<'scope> for KeyCollection<'scope, T, K, R>
+impl<'scope, T, K, R> MzArrange<'scope, Vec<((K, ()), T, R)>> for KeyCollection<'scope, T, K, R>
 where
     T: Timestamp + Lattice,
     K: ExchangeData + Hashable,
     R: ExchangeData,
 {
-    fn mz_arrange<Chu, Ba, Bu, Tr>(self, name: &str) -> Arranged<'scope, TraceAgent<Tr>>
+    fn mz_arrange<Ba, Tr>(
+        self,
+        name: &str,
+        batcher: impl FnOnce(Option<Logger>, usize) -> Ba + 'static,
+    ) -> Arranged<'scope, TraceAgent<Tr>>
     where
-        Ba: Batcher<Time = T> + 'static,
-        Chu: ContainerBuilder<Container = Ba::Output>
-            + for<'a> PushInto<&'a mut Self::Input>
-            + 'static,
-        Bu: Builder<Time = T, Input = Ba::Output, Output = Tr::Batch>,
-        Tr: Trace + TraceReader<Time = T> + 'static,
-        Tr::Batch: Batch,
+        Ba: Batcher<Vec<((K, ()), T, R)>, Time = T> + 'static,
+        <Ba as Batcher<Vec<((K, ()), T, R)>>>::Output: Into<Tr::Batch>,
+        Tr: Trace<Time = T> + 'static,
         Arranged<'scope, TraceAgent<Tr>>: ArrangementSize,
     {
-        self.0.map(|d| (d, ())).mz_arrange::<Chu, Ba, Bu, _>(name)
+        self.0.map(|d| (d, ())).mz_arrange::<Ba, _>(name, batcher)
     }
 }
 
-impl<'scope, T, K, R> MzArrangeCore<'scope> for KeyCollection<'scope, T, K, R>
+impl<'scope, T, K, R> MzArrangeCore<'scope, Vec<((K, ()), T, R)>> for KeyCollection<'scope, T, K, R>
 where
     T: Timestamp + Lattice,
     K: Clone + 'static,
     R: Clone + 'static,
 {
     type Timestamp = T;
-    type Input = Vec<((K, ()), T, R)>;
 
-    fn mz_arrange_core<P, Chu, Ba, Bu, Tr>(
+    fn mz_arrange_core<P, Ba, Tr>(
         self,
         pact: P,
         name: &str,
+        batcher: impl FnOnce(Option<Logger>, usize) -> Ba + 'static,
     ) -> Arranged<'scope, TraceAgent<Tr>>
     where
-        P: ParallelizationContract<T, Self::Input>,
-        Ba: Batcher<Time = T> + 'static,
-        Chu: ContainerBuilder<Container = Ba::Output>
-            + for<'a> PushInto<&'a mut Self::Input>
-            + 'static,
-        Bu: Builder<Time = T, Input = Ba::Output, Output = Tr::Batch>,
-        Tr: Trace + TraceReader<Time = T> + 'static,
-        Tr::Batch: Batch,
+        P: ParallelizationContract<T, Vec<((K, ()), T, R)>>,
+        Ba: Batcher<Vec<((K, ()), T, R)>, Time = T> + 'static,
+        <Ba as Batcher<Vec<((K, ()), T, R)>>>::Output: Into<Tr::Batch>,
+        Tr: Trace<Time = T> + 'static,
         Arranged<'scope, TraceAgent<Tr>>: ArrangementSize,
     {
         self.0
             .map(|d| (d, ()))
-            .mz_arrange_core::<_, Chu, Ba, Bu, _>(pact, name)
+            .mz_arrange_core::<_, Ba, _>(pact, name, batcher)
     }
 }
 
@@ -290,7 +282,7 @@ fn log_arrangement_size_inner<'scope, B, L>(
     mut logic: L,
 ) -> Arranged<'scope, TraceAgent<Spine<ArcBatch<B>>>>
 where
-    B: Batch + 'static,
+    B: SpineBatch + 'static,
     L: FnMut(&B) -> (usize, usize, usize) + 'static,
 {
     let scope = arranged.stream.scope();
@@ -325,10 +317,13 @@ where
 
             move |input, output| {
                 input.for_each(|time, data| {
-                    for batch in data.iter() {
-                        batches
-                            .entry(Arc::as_ptr(&batch.0))
-                            .or_insert_with(|| (Arc::downgrade(&batch.0), logic(&batch.0)));
+                    for span in data.iter() {
+                        // A span with no updates carries no batch, and so no allocation to weigh.
+                        if let Some(batch) = &span.inner {
+                            batches
+                                .entry(Arc::as_ptr(&batch.0))
+                                .or_insert_with(|| (Arc::downgrade(&batch.0), logic(&batch.0)));
+                        }
                     }
                     output.session(&time).give_container(data);
                 });
@@ -343,10 +338,12 @@ where
                     return;
                 };
 
-                trace.borrow().trace().map_batches(|batch| {
-                    batches
-                        .entry(Arc::as_ptr(&batch.0))
-                        .or_insert_with(|| (Arc::downgrade(&batch.0), logic(&batch.0)));
+                trace.borrow().trace().map_spans(|span| {
+                    if let Some(batch) = &span.inner {
+                        batches
+                            .entry(Arc::as_ptr(&batch.0))
+                            .or_insert_with(|| (Arc::downgrade(&batch.0), logic(&batch.0)));
+                    }
                 });
 
                 let (mut size, mut capacity, mut allocations) = (0, 0, 0);
diff --git a/src/compute/src/extensions/temporal_bucket.rs b/src/compute/src/extensions/temporal_bucket.rs
index 13a0f45009987..60bcea849f85a 100644
--- a/src/compute/src/extensions/temporal_bucket.rs
+++ b/src/compute/src/extensions/temporal_bucket.rs
@@ -13,7 +13,6 @@ use columnar::{Columnar, Index, Len};
 use differential_dataflow::Hashable;
 use differential_dataflow::difference::Semigroup;
 use differential_dataflow::lattice::Lattice;
-use differential_dataflow::trace::Batcher;
 use mz_timely_util::columnar::Column;
 use mz_timely_util::columnar::batcher::ColumnChunker;
 use mz_timely_util::columnar::merge_batcher::ColumnMergeBatcher;
@@ -90,7 +89,7 @@ where
                     }
                 }
 
-                input.for_each_time(|time, data| {
+                input.for_each_stamp(|time, data| {
                     let mut session = output.session_with_builder(&time);
                     for data in data {
                         // Skip data that is about to be revealed.
@@ -194,7 +193,7 @@ where
     logger: Option<differential_dataflow::logging::Logger>,
     operator_id: usize,
     chunker: ColumnChunker<(D, T, R)>,
-    inner: ColumnMergeBatcher<D, T, R>,
+    inner: ColumnMergeBatcher<ColumnChunker<(D, T, R)>, D, T, R, ()>,
 }
 
 impl<D, T, R> MergeBatcherWrapper<D, T, R>
@@ -233,7 +232,7 @@ where
         }
         self.chunker.push_into(&mut raw);
         while let Some(chunk) = self.chunker.extract() {
-            self.inner.push_into(std::mem::take(chunk));
+            self.inner.push_chunk(std::mem::take(chunk));
         }
     }
 
@@ -241,14 +240,14 @@ where
     fn flush(&mut self) {
         use timely::container::ContainerBuilder as _;
         while let Some(chunk) = self.chunker.finish() {
-            self.inner.push_into(std::mem::take(chunk));
+            self.inner.push_chunk(std::mem::take(chunk));
         }
     }
 
     /// Reveal the contents of the merge batcher, returning a vector of `Column` chunks.
     fn done(mut self) -> Vec<Column<(D, T, R)>> {
         self.flush();
-        let (chain, _description) = self.inner.seal(Antichain::new());
+        let (chain, _frontier) = self.inner.extract_chain(Antichain::new().borrow());
         chain
     }
 }
@@ -274,7 +273,7 @@ where
         let upper = Antichain::from_elem(timestamp.clone());
         let mut lower = Self::new(self.logger.clone(), self.operator_id);
         let mut buffer = Vec::new();
-        let (chain, _description) = self.inner.seal(upper);
+        let (chain, _frontier) = self.inner.extract_chain(upper.borrow());
         for chunk in chain {
             *fuel = fuel.saturating_sub(chunk.record_count());
             // TODO: Avoid this cloning.
diff --git a/src/compute/src/logging.rs b/src/compute/src/logging.rs
index c27228d84f0d8..ed70b624c41fa 100644
--- a/src/compute/src/logging.rs
+++ b/src/compute/src/logging.rs
@@ -29,6 +29,7 @@ use ::timely::dataflow::channels::pact::Pipeline;
 use ::timely::dataflow::operators::capture::{Event, EventLink, EventPusher};
 use ::timely::dataflow::operators::generic::Session;
 use ::timely::dataflow::operators::{Capability, CapabilityTrait, InputCapability, Operator};
+use ::timely::progress::Stamp;
 use ::timely::progress::Timestamp as TimelyTimestamp;
 use ::timely::scheduling::Activator;
 use ::timely::{Container, ContainerBuilder};
@@ -38,7 +39,7 @@ use mz_expr::{MirScalarExpr, permutation_for_arrangement};
 use mz_repr::{Datum, Diff, Row, RowPacker, RowRef, Timestamp};
 use mz_timely_util::activator::RcActivator;
 use mz_timely_util::columnar::builder::ColumnBuilder;
-use mz_timely_util::operator::consolidate_pact;
+use mz_timely_util::operator::{BatcherNew, consolidate_pact};
 
 use crate::logging::compute::Logger as ComputeLogger;
 use crate::typedefs::RowRowAgent;
@@ -95,7 +96,9 @@ where
 {
     /// Publishes a batch of logged events.
     fn publish_batch(&mut self, data: C) {
-        self.event_pusher.push(Event::Messages(self.time_ms, data));
+        // One capability per logged batch: the stamp is a singleton.
+        self.event_pusher
+            .push(Event::Messages(Stamp::from_elem(self.time_ms), data));
     }
 
     /// Indicate progress up to `time`, advances the capability.
@@ -294,29 +297,28 @@ struct LogCollection {
 /// the updates into `(Row, Row)` pairs using the provided logic function. It is crucial that the
 /// data is not exchanged between workers, as the consolidation would not function as desired
 /// otherwise.
-pub(super) fn consolidate_and_pack<'scope, Chu, B, CB, L, F, C>(
+pub(super) fn consolidate_and_pack<'scope, B, CB, L, F, C, Ch>(
     input: Stream<'scope, Timestamp, C>,
     log: L,
     mut logic: F,
 ) -> Stream<'scope, Timestamp, CB::Container>
 where
-    B: Batcher<Time = Timestamp> + 'static,
-    Chu: ContainerBuilder<Container = B::Output> + for<'a> PushInto<&'a mut C> + 'static,
+    B: Batcher<C, Time = Timestamp, Output = Vec<Ch>> + BatcherNew + 'static,
     C: Container + Clone + 'static,
-    B::Output: Clone,
+    Ch: Clone + 'static,
     CB: ContainerBuilder,
     L: Into<LogVariant>,
-    F: FnMut(B::Output, &mut PermutedRowPacker, &mut OutputSession<CB>) + 'static,
+    F: FnMut(Ch, &mut PermutedRowPacker, &mut OutputSession<CB>) + 'static,
 {
     let log = log.into();
     // TODO: Use something other than the debug representation of the log variant as a name.
     let c_name = &format!("Consolidate {log:?}");
     let u_name = &format!("ToRow {log:?}");
     let mut packer = PermutedRowPacker::new(log);
-    let consolidated = consolidate_pact::<Chu, B, _, _>(input, Pipeline, c_name);
+    let consolidated = consolidate_pact::<B, _, _>(input, Pipeline, c_name, B::new_batcher);
     consolidated.unary::<CB, _, _, _>(Pipeline, u_name, |_, _| {
         move |input, output| {
-            input.for_each_time(|time, data| {
+            input.for_each_stamp(|time, data| {
                 let mut session = output.session_with_builder(&time);
                 for item in data.flatten().flat_map(|data| data.drain(..)) {
                     logic(item, &mut packer, &mut session);
diff --git a/src/compute/src/logging/compute.rs b/src/compute/src/logging/compute.rs
index 065d51fceb240..00ce4d23f7542 100644
--- a/src/compute/src/logging/compute.rs
+++ b/src/compute/src/logging/compute.rs
@@ -9,25 +9,26 @@
 
 //! Logging dataflows for events generated by clusterd.
 
-use std::cell::RefCell;
-use std::collections::{BTreeMap, BTreeSet};
-use std::fmt::{Display, Write};
-use std::rc::Rc;
-use std::time::{Duration, Instant};
-
 use chrono::DateTime;
 use columnar::{Columnar, Index, Ref};
 use differential_dataflow::VecCollection;
 use differential_dataflow::collection::AsCollection;
-use differential_dataflow::trace::{BatchReader, Cursor, Navigable};
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
+use differential_dataflow::trace::{Cursor, Navigable, Span};
 use mz_compute_types::plan::LirId;
 use mz_ore::cast::CastFrom;
 use mz_repr::adt::timestamp::CheckedTimestamp;
 use mz_repr::{Datum, Diff, GlobalId, Row, RowRef, Timestamp};
+use mz_row_spine::RowRowBuilder;
 use mz_timely_util::columnar::batcher;
 use mz_timely_util::columnar::builder::ColumnBuilder;
 use mz_timely_util::columnar::{Col2ValBatcher, Column, columnar_exchange};
 use mz_timely_util::replay::MzReplay;
+use std::cell::RefCell;
+use std::collections::{BTreeMap, BTreeSet};
+use std::fmt::{Display, Write};
+use std::rc::Rc;
+use std::time::{Duration, Instant};
 use timely::dataflow::channels::pact::{ExchangeCore, Pipeline};
 use timely::dataflow::operators::Operator;
 use timely::dataflow::operators::generic::OutputBuilder;
@@ -44,7 +45,6 @@ use crate::logging::{
     SharedLoggingState, Update,
 };
 use crate::typedefs::RowRowSpine;
-use mz_row_spine::RowRowBuilder;
 
 /// Type alias for a logger of compute events.
 pub type Logger = timely::logging_core::Logger<ComputeEventBuilder>;
@@ -445,13 +445,7 @@ pub(super) fn construct<'scope>(
                     columnar_exchange::<Row, Row, Timestamp, Diff>,
                 );
                 let trace = stream
-                    .mz_arrange_core::<
-                        _,
-                        batcher::Chunker<_>,
-                        Col2ValBatcher<_, _, _, _>,
-                        RowRowBuilder<_, _>,
-                        RowRowSpine<_, _>,
-                    >(exchange, &format!("Arrange {variant:?}"))
+                    .mz_arrange_core::<_, Col2ValBatcher<_, _, _, _, batcher::Chunker<_>, RowRowBuilder<_, _>>, RowRowSpine<_, _>>(exchange, &format!("Arrange {variant:?}"), MergeBatcher::new)
                     .trace;
                 let collection = LogCollection {
                     trace,
@@ -1600,17 +1594,21 @@ where
     }
 }
 
-impl<'scope, T, B> LogDataflowErrors for StreamVec<'scope, T, B>
+impl<'scope, T, B> LogDataflowErrors for StreamVec<'scope, T, Span<T, B>>
 where
     T: timely::progress::Timestamp,
-    B: BatchReader + Navigable + Clone + 'static,
+    B: Navigable + Clone + 'static,
     for<'a> B::Cursor: Cursor<DiffGat<'a> = &'a Diff>,
 {
     fn log_dataflow_errors(self, logger: Logger, export_id: GlobalId) -> Self {
         self.unary(Pipeline, "LogDataflowErrorsStream", |_cap, _info| {
             move |input, output| {
                 input.for_each(|cap, data| {
-                    let diff = data.iter().map(sum_batch_diffs).sum::<Diff>();
+                    let diff = data
+                        .iter()
+                        .filter_map(|span| span.inner.as_ref())
+                        .map(sum_batch_diffs)
+                        .sum::<Diff>();
                     logger.log(&ComputeEvent::ErrorCount(ErrorCount { export_id, diff }));
 
                     output.session(&cap).give_container(data);
@@ -1628,7 +1626,7 @@ where
 /// batches might become large.
 fn sum_batch_diffs<B>(batch: &B) -> Diff
 where
-    B: BatchReader + Navigable,
+    B: Navigable,
     for<'a> B::Cursor: Cursor<DiffGat<'a> = &'a Diff>,
 {
     let mut sum = Diff::ZERO;
diff --git a/src/compute/src/logging/differential.rs b/src/compute/src/logging/differential.rs
index 8d55f24382528..b38306b1d82e4 100644
--- a/src/compute/src/logging/differential.rs
+++ b/src/compute/src/logging/differential.rs
@@ -9,22 +9,22 @@
 
 //! Logging dataflows for events generated by differential dataflow.
 
-use std::cell::RefCell;
-use std::collections::BTreeMap;
-use std::rc::Rc;
-use std::time::Duration;
-
 use differential_dataflow::consolidation::ConsolidatingContainerBuilder;
 use differential_dataflow::logging::{
     BatchEvent, BatcherEvent, DifferentialEvent, DropEvent, MergeEvent, TraceShare,
 };
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use mz_ore::cast::CastFrom;
 use mz_repr::{Datum, Diff, Timestamp};
+use mz_row_spine::RowRowBuilder;
 use mz_timely_util::columnar::batcher;
 use mz_timely_util::columnar::builder::ColumnBuilder;
 use mz_timely_util::columnar::{Col2ValBatcher, columnar_exchange};
-use mz_timely_util::columnation::ColumnationChunker;
 use mz_timely_util::replay::MzReplay;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::rc::Rc;
+use std::time::Duration;
 use timely::dataflow::channels::pact::{ExchangeCore, Pipeline};
 use timely::dataflow::operators::InputCapability;
 use timely::dataflow::operators::generic::builder_rc::OperatorBuilder;
@@ -38,8 +38,8 @@ use crate::logging::{
     DifferentialLog, EventQueue, LogCollection, LogVariant, SharedLoggingState,
     consolidate_and_pack,
 };
-use crate::typedefs::{KeyBatcher, RowRowSpine};
-use mz_row_spine::RowRowBuilder;
+use crate::typedefs::ConsolidateBatcher;
+use crate::typedefs::RowRowSpine;
 
 /// The return type of [`construct`].
 pub(super) struct Return {
@@ -108,7 +108,7 @@ pub(super) fn construct(
                 let mut batcher_capacity = batcher_capacity_out.activate();
                 let mut batcher_allocations = batcher_allocations_out.activate();
 
-                input.for_each_time(|cap, data| {
+                input.for_each_stamp(|cap, data| {
                     let mut output_buffers = DemuxOutput {
                         batches: batches.session_with_builder(&cap),
                         records: records.session_with_builder(&cap),
@@ -145,12 +145,12 @@ pub(super) fn construct(
             mz_timely_util::columnar::Column<((mz_repr::Row, mz_repr::Row), Timestamp, Diff)>,
         > {
             consolidate_and_pack::<
-                ColumnationChunker<_>,
-                KeyBatcher<_, _, _>,
+                ConsolidateBatcher<_, _, _>,
                 ColumnBuilder<_>,
                 _,
                 _,
                 _,
+            _
             >(input, log, move |data, packer, session| {
                 for ((op, ()), time, diff) in data.iter() {
                     let data = packer.pack_slice(&[
@@ -193,13 +193,7 @@ pub(super) fn construct(
                     columnar_exchange::<mz_repr::Row, mz_repr::Row, Timestamp, mz_repr::Diff>,
                 );
                 let trace = collection
-                    .mz_arrange_core::<
-                        _,
-                        batcher::Chunker<_>,
-                        Col2ValBatcher<_, _, _, _>,
-                        RowRowBuilder<_, _>,
-                        RowRowSpine<_, _>,
-                    >(exchange, &format!("Arrange {variant:?}"))
+                    .mz_arrange_core::<_, Col2ValBatcher<_, _, _, _, batcher::Chunker<_>, RowRowBuilder<_, _>>, RowRowSpine<_, _>>(exchange, &format!("Arrange {variant:?}"), MergeBatcher::new)
                     .trace;
                 let collection = LogCollection {
                     trace,
diff --git a/src/compute/src/logging/initialize.rs b/src/compute/src/logging/initialize.rs
index 245cef517d309..017e768e4b3ef 100644
--- a/src/compute/src/logging/initialize.rs
+++ b/src/compute/src/logging/initialize.rs
@@ -5,14 +5,10 @@
 
 //! Initialization of logging dataflows.
 
-use std::cell::RefCell;
-use std::collections::BTreeMap;
-use std::rc::Rc;
-use std::time::{Duration, Instant};
-
 use differential_dataflow::VecCollection;
 use differential_dataflow::dynamic::pointstamp::PointStamp;
 use differential_dataflow::logging::{DifferentialEvent, DifferentialEventBuilder};
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use mz_compute_client::logging::{LogVariant, LoggingConfig};
 use mz_dyncfg::ConfigSet;
 use mz_ore::metrics::MetricsRegistry;
@@ -23,6 +19,10 @@ use mz_timely_util::columnar::builder::ColumnBuilder;
 use mz_timely_util::columnation::ColumnationChunker;
 use mz_timely_util::operator::CollectionExt;
 use mz_timely_util::scope_label::ScopeExt;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::rc::Rc;
+use std::time::{Duration, Instant};
 use timely::ContainerBuilder;
 use timely::container::{ContainerBuilder as _, PushInto};
 use timely::logging::{TimelyEvent, TimelyEventBuilder};
@@ -35,7 +35,7 @@ use crate::extensions::arrange::{KeyCollection, MzArrange};
 use crate::logging::compute::{ComputeEvent, ComputeEventBuilder};
 use crate::logging::{BatchLogger, EventQueue, SharedLoggingState};
 use crate::render::errors::DataflowErrorSer;
-use crate::typedefs::{ErrBatcher, ErrBuilder};
+use crate::typedefs::ErrBatcher;
 
 /// Initialize logging dataflows.
 ///
@@ -197,8 +197,9 @@ impl LoggingContext<'_> {
                 let collection: KeyCollection<_, DataflowErrorSer, Diff> =
                     VecCollection::empty(scope).into();
                 collection
-                    .mz_arrange::<ColumnationChunker<_>, ErrBatcher<_, _>, ErrBuilder<_, _>, _>(
+                    .mz_arrange::<ErrBatcher<_, _, ColumnationChunker<_>>, _>(
                         "Arrange logging err",
+                        MergeBatcher::new,
                     )
                     .trace
             });
diff --git a/src/compute/src/logging/prometheus.rs b/src/compute/src/logging/prometheus.rs
index 9c71433fdcac4..de53fca8cfad6 100644
--- a/src/compute/src/logging/prometheus.rs
+++ b/src/compute/src/logging/prometheus.rs
@@ -9,10 +9,7 @@
 
 //! Logging dataflow for Prometheus metrics gathered from the metrics registry.
 
-use std::collections::BTreeMap;
-use std::rc::Rc;
-use std::time::{Duration, Instant};
-
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use mz_compute_types::dyncfgs::COMPUTE_PROMETHEUS_INTROSPECTION_SCRAPE_INTERVAL;
 use mz_dyncfg::ConfigSet;
 use mz_ore::cast::{CastFrom, CastLossy};
@@ -20,10 +17,14 @@ use mz_ore::collections::CollectionExt;
 use mz_ore::metrics::MetricsRegistry;
 use mz_ore::soft_panic_or_log;
 use mz_repr::{Datum, Timestamp};
+use mz_row_spine::RowRowBuilder;
 use mz_timely_util::columnar::batcher;
 use mz_timely_util::columnar::builder::ColumnBuilder;
 use mz_timely_util::columnar::{Col2ValBatcher, columnar_exchange};
 use prometheus::proto::MetricType;
+use std::collections::BTreeMap;
+use std::rc::Rc;
+use std::time::{Duration, Instant};
 use timely::dataflow::Scope;
 use timely::dataflow::channels::pact::ExchangeCore;
 use timely::dataflow::operators::generic::OutputBuilder;
@@ -35,7 +36,6 @@ use crate::logging::{
     emit_snapshot_diff,
 };
 use crate::typedefs::RowRowSpine;
-use mz_row_spine::RowRowBuilder;
 
 /// The return type of [`construct`].
 pub(super) struct Return {
@@ -140,13 +140,7 @@ pub(super) fn construct(
         columnar_exchange::<mz_repr::Row, mz_repr::Row, Timestamp, mz_repr::Diff>,
     );
     let trace = stream
-        .mz_arrange_core::<
-            _,
-            batcher::Chunker<_>,
-            Col2ValBatcher<_, _, _, _>,
-            RowRowBuilder<_, _>,
-            RowRowSpine<_, _>,
-        >(exchange, "Arrange PrometheusMetrics")
+        .mz_arrange_core::<_, Col2ValBatcher<_, _, _, _, batcher::Chunker<_>, RowRowBuilder<_, _>>, RowRowSpine<_, _>>(exchange, "Arrange PrometheusMetrics", MergeBatcher::new)
         .trace;
     let token: Rc<dyn std::any::Any> = Rc::new(());
     let collection = LogCollection { trace, token };
diff --git a/src/compute/src/logging/reachability.rs b/src/compute/src/logging/reachability.rs
index 0c62d8c87ad1e..3aaf6702e6696 100644
--- a/src/compute/src/logging/reachability.rs
+++ b/src/compute/src/logging/reachability.rs
@@ -9,19 +9,20 @@
 
 //! Logging dataflows for events generated by timely dataflow.
 
-use std::collections::BTreeMap;
-use std::convert::TryInto;
-use std::rc::Rc;
-use std::time::Duration;
-
 use columnar::Index;
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use mz_compute_client::logging::LoggingConfig;
 use mz_ore::cast::CastFrom;
 use mz_repr::{Datum, Diff, Row, Timestamp};
+use mz_row_spine::RowRowBuilder;
 use mz_timely_util::columnar::batcher;
 use mz_timely_util::columnar::builder::ColumnBuilder;
 use mz_timely_util::columnar::{Col2ValBatcher, Column, columnar_exchange};
 use mz_timely_util::replay::MzReplay;
+use std::collections::BTreeMap;
+use std::convert::TryInto;
+use std::rc::Rc;
+use std::time::Duration;
 use timely::dataflow::Scope;
 use timely::dataflow::channels::pact::{ExchangeCore, Pipeline};
 use timely::dataflow::operators::Operator;
@@ -30,8 +31,8 @@ use timely::dataflow::operators::generic::operator::empty;
 use crate::extensions::arrange::MzArrangeCore;
 use crate::logging::initialize::ReachabilityEvent;
 use crate::logging::{EventQueue, LogCollection, LogVariant, TimelyLog, consolidate_and_pack};
+use crate::typedefs::ConsolidateColumnBatcher;
 use crate::typedefs::RowRowSpine;
-use mz_row_spine::RowRowBuilder;
 
 /// The return type of [`construct`].
 pub(super) struct Return {
@@ -69,7 +70,7 @@ pub(super) fn construct(
         };
         let logs = logs.unary::<CB, _, _, _>(Pipeline, "FlatMapReachability", move |_, _| {
             move |input, output| {
-                input.for_each_time(|time, data| {
+                input.for_each_stamp(|time, data| {
                     output
                         .session_with_builder(&time)
                         .give_iterator(data.flat_map(|d| {
@@ -97,12 +98,12 @@ pub(super) fn construct(
         let worker_id = scope.index();
 
         let updates = consolidate_and_pack::<
-            batcher::Chunker<_>,
-            Col2ValBatcher<UpdatesKey, _, _, _>,
+            ConsolidateColumnBatcher<UpdatesKey, _, _, _>,
             ColumnBuilder<_>,
             _,
             _,
             _,
+        _
         >(
             logs,
             TimelyLog::Reachability,
@@ -131,13 +132,7 @@ pub(super) fn construct(
                 );
                 let trace = updates
                     .clone()
-                    .mz_arrange_core::<
-                        _,
-                        batcher::Chunker<_>,
-                        Col2ValBatcher<_, _, _, _>,
-                        RowRowBuilder<_, _>,
-                        RowRowSpine<_, _>,
-                    >(exchange, &format!("Arrange {variant:?}"))
+                    .mz_arrange_core::<_, Col2ValBatcher<_, _, _, _, batcher::Chunker<_>, RowRowBuilder<_, _>>, RowRowSpine<_, _>>(exchange, &format!("Arrange {variant:?}"), MergeBatcher::new)
                     .trace;
                 let collection = LogCollection {
                     trace,
diff --git a/src/compute/src/logging/resource_usage.rs b/src/compute/src/logging/resource_usage.rs
index 6d1cf773afbdd..65866a059de4d 100644
--- a/src/compute/src/logging/resource_usage.rs
+++ b/src/compute/src/logging/resource_usage.rs
@@ -17,10 +17,7 @@
 //! One row per `(process_id, source, metric)`, so a metric that moves every sample does not drag
 //! the stable ones through a retraction with it.
 
-use std::collections::BTreeMap;
-use std::rc::Rc;
-use std::time::{Duration, Instant};
-
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use mz_metrics::usage::{MetricKey, observations};
 use mz_ore::cast::CastFrom;
 use mz_ore::collections::CollectionExt;
@@ -28,6 +25,9 @@ use mz_repr::{Datum, Timestamp};
 use mz_row_spine::RowRowBuilder;
 use mz_timely_util::columnar::builder::ColumnBuilder;
 use mz_timely_util::columnar::{Col2ValBatcher, batcher, columnar_exchange};
+use std::collections::BTreeMap;
+use std::rc::Rc;
+use std::time::{Duration, Instant};
 use timely::dataflow::Scope;
 use timely::dataflow::channels::pact::ExchangeCore;
 use timely::dataflow::operators::generic::OutputBuilder;
@@ -111,13 +111,7 @@ pub(super) fn construct(
         columnar_exchange::<mz_repr::Row, mz_repr::Row, Timestamp, mz_repr::Diff>,
     );
     let trace = stream
-        .mz_arrange_core::<
-            _,
-            batcher::Chunker<_>,
-            Col2ValBatcher<_, _, _, _>,
-            RowRowBuilder<_, _>,
-            RowRowSpine<_, _>,
-        >(exchange, "Arrange ResourceUsage")
+        .mz_arrange_core::<_, Col2ValBatcher<_, _, _, _, batcher::Chunker<_>, RowRowBuilder<_, _>>, RowRowSpine<_, _>>(exchange, "Arrange ResourceUsage", MergeBatcher::new)
         .trace;
     let token: Rc<dyn std::any::Any> = Rc::new(());
     let collection = LogCollection { trace, token };
diff --git a/src/compute/src/logging/timely.rs b/src/compute/src/logging/timely.rs
index 6d15ff5467a1b..8b2137d53d4a1 100644
--- a/src/compute/src/logging/timely.rs
+++ b/src/compute/src/logging/timely.rs
@@ -9,21 +9,21 @@
 
 //! Logging dataflows for events generated by timely dataflow.
 
-use std::cell::RefCell;
-use std::collections::BTreeMap;
-use std::rc::Rc;
-use std::time::Duration;
-
 use columnar::{Columnar, Index};
 use columnation::{Columnation, CopyRegion};
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use mz_compute_client::logging::LoggingConfig;
 use mz_ore::cast::CastFrom;
 use mz_repr::{Datum, Diff, Timestamp};
+use mz_row_spine::RowRowBuilder;
 use mz_timely_util::columnar::batcher;
 use mz_timely_util::columnar::builder::ColumnBuilder;
 use mz_timely_util::columnar::{Col2ValBatcher, columnar_exchange};
-use mz_timely_util::columnation::ColumnationChunker;
 use mz_timely_util::replay::MzReplay;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::rc::Rc;
+use std::time::Duration;
 use timely::dataflow::Scope;
 use timely::dataflow::channels::pact::{ExchangeCore, Pipeline};
 use timely::dataflow::operators::Operator;
@@ -43,8 +43,8 @@ use crate::logging::{
     Update,
 };
 use crate::logging::{LogCollection, SharedLoggingState, consolidate_and_pack};
-use crate::typedefs::{KeyBatcher, KeyValBatcher, RowRowSpine};
-use mz_row_spine::RowRowBuilder;
+use crate::typedefs::RowRowSpine;
+use crate::typedefs::{ConsolidateBatcher, ConsolidateKeyValBatcher};
 
 /// The return type of [`construct`].
 pub(super) struct Return {
@@ -181,12 +181,12 @@ pub(super) fn construct(
         // updates that reach `Row` encoding.
 
         let operates = consolidate_and_pack::<
-            ColumnationChunker<_>,
-            KeyValBatcher<_, _, _, _>,
+            ConsolidateKeyValBatcher<_, _, _, _>,
             ColumnBuilder<_>,
             _,
             _,
             _,
+            _,
         >(
             operates,
             TimelyLog::Operates,
@@ -210,7 +210,7 @@ pub(super) fn construct(
             |_cap, _info| {
                 let mut packer = PermutedRowPacker::new(TimelyLog::Channels);
                 move |input, output| {
-                    input.for_each_time(|time, data| {
+                    input.for_each_stamp(|time, data| {
                         let mut session = output.session_with_builder(&time);
                         for d in data.flat_map(|c| c.borrow().into_index_iter()) {
                             let ((datum, ()), time, diff) = d;
@@ -235,17 +235,10 @@ pub(super) fn construct(
         );
 
         // Types to make rustfmt happy.
-        type KVB<K, V, T, D> = KeyValBatcher<K, V, T, D>;
-        type KB<K, T, D> = KeyBatcher<K, T, D>;
+        type KVB<K, V, T, D> = ConsolidateKeyValBatcher<K, V, T, D>;
+        type KB<K, T, D> = ConsolidateBatcher<K, T, D>;
 
-        let addresses = consolidate_and_pack::<
-            ColumnationChunker<_>,
-            KVB<_, _, _, _>,
-            ColumnBuilder<_>,
-            _,
-            _,
-            _,
-        >(
+        let addresses = consolidate_and_pack::<KVB<_, _, _, _>, ColumnBuilder<_>, _, _, _, _>(
             addresses,
             TimelyLog::Addresses,
             move |data, packer, session| {
@@ -264,119 +257,112 @@ pub(super) fn construct(
             },
         );
 
-        let parks =
-            consolidate_and_pack::<ColumnationChunker<_>, KB<_, _, _>, ColumnBuilder<_>, _, _, _>(
-                parks,
-                TimelyLog::Parks,
-                move |data, packer, session| {
-                    for ((datum, ()), time, diff) in data.iter() {
-                        let data = packer.pack_slice(&[
-                            Datum::UInt64(u64::cast_from(worker_id)),
-                            Datum::UInt64(datum.duration_pow),
-                            datum
-                                .requested_pow
-                                .map(Datum::UInt64)
-                                .unwrap_or(Datum::Null),
-                        ]);
-                        session.give((data, time, diff));
-                    }
-                },
-            );
-
-        let batches_sent =
-            consolidate_and_pack::<ColumnationChunker<_>, KB<_, _, _>, ColumnBuilder<_>, _, _, _>(
-                batches_sent,
-                TimelyLog::BatchesSent,
-                move |data, packer, session| {
-                    for ((datum, ()), time, diff) in data.iter() {
-                        let data = packer.pack_slice(&[
-                            Datum::UInt64(u64::cast_from(datum.channel)),
-                            Datum::UInt64(u64::cast_from(worker_id)),
-                            Datum::UInt64(u64::cast_from(datum.worker)),
-                        ]);
-                        session.give((data, time, diff));
-                    }
-                },
-            );
-
-        let batches_received =
-            consolidate_and_pack::<ColumnationChunker<_>, KB<_, _, _>, ColumnBuilder<_>, _, _, _>(
-                batches_received,
-                TimelyLog::BatchesReceived,
-                move |data, packer, session| {
-                    for ((datum, ()), time, diff) in data.iter() {
-                        let data = packer.pack_slice(&[
-                            Datum::UInt64(u64::cast_from(datum.channel)),
-                            Datum::UInt64(u64::cast_from(datum.worker)),
-                            Datum::UInt64(u64::cast_from(worker_id)),
-                        ]);
-                        session.give((data, time, diff));
-                    }
-                },
-            );
-
-        let messages_sent =
-            consolidate_and_pack::<ColumnationChunker<_>, KB<_, _, _>, ColumnBuilder<_>, _, _, _>(
-                messages_sent,
-                TimelyLog::MessagesSent,
-                move |data, packer, session| {
-                    for ((datum, ()), time, diff) in data.iter() {
-                        let data = packer.pack_slice(&[
-                            Datum::UInt64(u64::cast_from(datum.channel)),
-                            Datum::UInt64(u64::cast_from(worker_id)),
-                            Datum::UInt64(u64::cast_from(datum.worker)),
-                        ]);
-                        session.give((data, time, diff));
-                    }
-                },
-            );
-
-        let messages_received =
-            consolidate_and_pack::<ColumnationChunker<_>, KB<_, _, _>, ColumnBuilder<_>, _, _, _>(
-                messages_received,
-                TimelyLog::MessagesReceived,
-                move |data, packer, session| {
-                    for ((datum, ()), time, diff) in data.iter() {
-                        let data = packer.pack_slice(&[
-                            Datum::UInt64(u64::cast_from(datum.channel)),
-                            Datum::UInt64(u64::cast_from(datum.worker)),
-                            Datum::UInt64(u64::cast_from(worker_id)),
-                        ]);
-                        session.give((data, time, diff));
-                    }
-                },
-            );
-
-        let elapsed =
-            consolidate_and_pack::<ColumnationChunker<_>, KB<_, _, _>, ColumnBuilder<_>, _, _, _>(
-                schedules_duration,
-                TimelyLog::Elapsed,
-                move |data, packer, session| {
-                    for ((operator, ()), time, diff) in data.iter() {
-                        let data = packer.pack_slice(&[
-                            Datum::UInt64(u64::cast_from(*operator)),
-                            Datum::UInt64(u64::cast_from(worker_id)),
-                        ]);
-                        session.give((data, time, diff));
-                    }
-                },
-            );
-
-        let histogram =
-            consolidate_and_pack::<ColumnationChunker<_>, KB<_, _, _>, ColumnBuilder<_>, _, _, _>(
-                schedules_histogram,
-                TimelyLog::Histogram,
-                move |data, packer, session| {
-                    for ((datum, ()), time, diff) in data.iter() {
-                        let data = packer.pack_slice(&[
-                            Datum::UInt64(u64::cast_from(datum.operator)),
-                            Datum::UInt64(u64::cast_from(worker_id)),
-                            Datum::UInt64(datum.duration_pow),
-                        ]);
-                        session.give((data, time, diff));
-                    }
-                },
-            );
+        let parks = consolidate_and_pack::<KB<_, _, _>, ColumnBuilder<_>, _, _, _, _>(
+            parks,
+            TimelyLog::Parks,
+            move |data, packer, session| {
+                for ((datum, ()), time, diff) in data.iter() {
+                    let data = packer.pack_slice(&[
+                        Datum::UInt64(u64::cast_from(worker_id)),
+                        Datum::UInt64(datum.duration_pow),
+                        datum
+                            .requested_pow
+                            .map(Datum::UInt64)
+                            .unwrap_or(Datum::Null),
+                    ]);
+                    session.give((data, time, diff));
+                }
+            },
+        );
+
+        let batches_sent = consolidate_and_pack::<KB<_, _, _>, ColumnBuilder<_>, _, _, _, _>(
+            batches_sent,
+            TimelyLog::BatchesSent,
+            move |data, packer, session| {
+                for ((datum, ()), time, diff) in data.iter() {
+                    let data = packer.pack_slice(&[
+                        Datum::UInt64(u64::cast_from(datum.channel)),
+                        Datum::UInt64(u64::cast_from(worker_id)),
+                        Datum::UInt64(u64::cast_from(datum.worker)),
+                    ]);
+                    session.give((data, time, diff));
+                }
+            },
+        );
+
+        let batches_received = consolidate_and_pack::<KB<_, _, _>, ColumnBuilder<_>, _, _, _, _>(
+            batches_received,
+            TimelyLog::BatchesReceived,
+            move |data, packer, session| {
+                for ((datum, ()), time, diff) in data.iter() {
+                    let data = packer.pack_slice(&[
+                        Datum::UInt64(u64::cast_from(datum.channel)),
+                        Datum::UInt64(u64::cast_from(datum.worker)),
+                        Datum::UInt64(u64::cast_from(worker_id)),
+                    ]);
+                    session.give((data, time, diff));
+                }
+            },
+        );
+
+        let messages_sent = consolidate_and_pack::<KB<_, _, _>, ColumnBuilder<_>, _, _, _, _>(
+            messages_sent,
+            TimelyLog::MessagesSent,
+            move |data, packer, session| {
+                for ((datum, ()), time, diff) in data.iter() {
+                    let data = packer.pack_slice(&[
+                        Datum::UInt64(u64::cast_from(datum.channel)),
+                        Datum::UInt64(u64::cast_from(worker_id)),
+                        Datum::UInt64(u64::cast_from(datum.worker)),
+                    ]);
+                    session.give((data, time, diff));
+                }
+            },
+        );
+
+        let messages_received = consolidate_and_pack::<KB<_, _, _>, ColumnBuilder<_>, _, _, _, _>(
+            messages_received,
+            TimelyLog::MessagesReceived,
+            move |data, packer, session| {
+                for ((datum, ()), time, diff) in data.iter() {
+                    let data = packer.pack_slice(&[
+                        Datum::UInt64(u64::cast_from(datum.channel)),
+                        Datum::UInt64(u64::cast_from(datum.worker)),
+                        Datum::UInt64(u64::cast_from(worker_id)),
+                    ]);
+                    session.give((data, time, diff));
+                }
+            },
+        );
+
+        let elapsed = consolidate_and_pack::<KB<_, _, _>, ColumnBuilder<_>, _, _, _, _>(
+            schedules_duration,
+            TimelyLog::Elapsed,
+            move |data, packer, session| {
+                for ((operator, ()), time, diff) in data.iter() {
+                    let data = packer.pack_slice(&[
+                        Datum::UInt64(u64::cast_from(*operator)),
+                        Datum::UInt64(u64::cast_from(worker_id)),
+                    ]);
+                    session.give((data, time, diff));
+                }
+            },
+        );
+
+        let histogram = consolidate_and_pack::<KB<_, _, _>, ColumnBuilder<_>, _, _, _, _>(
+            schedules_histogram,
+            TimelyLog::Histogram,
+            move |data, packer, session| {
+                for ((datum, ()), time, diff) in data.iter() {
+                    let data = packer.pack_slice(&[
+                        Datum::UInt64(u64::cast_from(datum.operator)),
+                        Datum::UInt64(u64::cast_from(worker_id)),
+                        Datum::UInt64(datum.duration_pow),
+                    ]);
+                    session.give((data, time, diff));
+                }
+            },
+        );
 
         let logs = {
             use TimelyLog::*;
@@ -400,20 +386,18 @@ pub(super) fn construct(
             let variant = LogVariant::Timely(variant);
             if config.index_logs.contains_key(&variant) {
                 // Extract types to make rustfmt happy.
-                type Batcher<K, V, T, R> = Col2ValBatcher<K, V, T, R>;
+                type Batcher<K, V, T, R, Chu, Se> = Col2ValBatcher<K, V, T, R, Chu, Se>;
                 type Builder<T, R> = RowRowBuilder<T, R>;
+                type Chu<K, V, T, R> =
+                    batcher::Chunker<mz_timely_util::columnation::ColumnationStack<((K, V), T, R)>>;
+                type Arranger<K, V, T, R> = Batcher<K, V, T, R, Chu<K, V, T, R>, Builder<T, R>>;
                 let trace = collection
-                    .mz_arrange_core::<
-                        _,
-                        batcher::Chunker<_>,
-                        Batcher<_, _, _, _>,
-                        Builder<_, _>,
-                        RowRowSpine<_, _>,
-                    >(
+                    .mz_arrange_core::<_, Arranger<_, _, _, _>, RowRowSpine<_, _>>(
                         ExchangeCore::<ColumnBuilder<_>, _>::new_core(
                             columnar_exchange::<mz_repr::Row, mz_repr::Row, Timestamp, Diff>,
                         ),
                         &format!("Arrange {variant:?}"),
+                        MergeBatcher::new,
                     )
                     .trace;
                 let combined_token: Rc<dyn std::any::Any> =
diff --git a/src/compute/src/render.rs b/src/compute/src/render.rs
index c8607c22246cc..2d089e8f5eaf3 100644
--- a/src/compute/src/render.rs
+++ b/src/compute/src/render.rs
@@ -100,23 +100,14 @@
 //! stream. This reduces the amount of recomputation that must be performed
 //! if/when the errors are retracted.
 
-use std::any::Any;
-use std::cell::RefCell;
-use std::collections::{BTreeMap, BTreeSet};
-use std::convert::Infallible;
-use std::future::Future;
-use std::pin::Pin;
-use std::rc::{Rc, Weak};
-use std::sync::Arc;
-use std::task::Poll;
-
 use differential_dataflow::dynamic::pointstamp::PointStamp;
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::operators::arrange::Arranged;
 use differential_dataflow::operators::arrange::ShutdownButton;
 use differential_dataflow::operators::iterate::Variable;
 use differential_dataflow::trace::cursor::{BatchCursor, BatchDiff, BatchKey, BatchVal};
-use differential_dataflow::trace::{BatchReader, Cursor, Navigable, TraceReader};
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
+use differential_dataflow::trace::{Cursor, Navigable, TraceReader};
 use differential_dataflow::{AsCollection, Data, VecCollection};
 use futures::FutureExt;
 use futures::channel::oneshot;
@@ -138,18 +129,28 @@ use mz_persist_client::operators::shard_source::{ErrorHandler, SnapshotMode};
 use mz_repr::explain::DummyHumanizer;
 use mz_repr::fixed_length::ExtendDatums;
 use mz_repr::{Datum, DatumVec, Diff, GlobalId, ReprRelationType, Row, RowArena, SharedRow};
+use mz_row_spine::{DatumSeq, RowRowBatcher};
 use mz_storage_operators::persist_source;
 use mz_storage_types::controller::CollectionMetadata;
 use mz_timely_util::columnation::ColumnationChunker;
 use mz_timely_util::operator::{CollectionExt, StreamExt};
 use mz_timely_util::probe::{Handle as MzProbeHandle, ProbeNotify};
 use mz_timely_util::scope_label::ScopeExt;
+use std::any::Any;
+use std::cell::RefCell;
+use std::collections::{BTreeMap, BTreeSet};
+use std::convert::Infallible;
+use std::future::Future;
+use std::pin::Pin;
+use std::rc::{Rc, Weak};
+use std::sync::Arc;
+use std::task::Poll;
 use timely::PartialOrder;
 use timely::container::CapacityContainerBuilder;
 use timely::dataflow::channels::pact::Pipeline;
+use timely::dataflow::operators::vec::Filter;
 use timely::dataflow::operators::vec::ToStream;
-use timely::dataflow::operators::vec::{BranchWhen, Filter};
-use timely::dataflow::operators::{Capability, Operator, Probe, probe};
+use timely::dataflow::operators::{CapabilitySet, Operator, Probe, probe};
 use timely::dataflow::{Scope, Stream, StreamVec};
 use timely::order::{Product, TotalOrder};
 use timely::progress::timestamp::Refines;
@@ -168,8 +169,8 @@ use crate::logging::compute::{
 use crate::render::columnar::CollectionEdge;
 use crate::render::context::{ArrangementFlavor, Context};
 use crate::render::errors::DataflowErrorSer;
-use crate::typedefs::{ErrBatcher, ErrBuilder, ErrSpine, KeyBatcher, MzTimestamp};
-use mz_row_spine::{DatumSeq, RowRowBatcher, RowRowBuilder};
+use crate::typedefs::ConsolidateBatcher;
+use crate::typedefs::{ErrBatcher, ErrBuilder, ErrSpine, MzTimestamp};
 
 pub(crate) mod columnar;
 pub mod context;
@@ -182,7 +183,6 @@ mod threshold;
 mod top_k;
 
 pub use context::CollectionBundle;
-pub use join::LinearJoinSpec;
 
 /// Guard that presses a differential [`ShutdownButton`] when dropped.
 ///
@@ -809,20 +809,17 @@ where
                 let mut oks = oks
                     .as_collection(|k, v| (k.to_row(), v.to_row()))
                     .leave(outer)
-                    .mz_arrange::<
-                        ColumnationChunker<_>,
-                        RowRowBatcher<_, _>,
-                        RowRowBuilder<_, _>,
-                        _,
-                    >(
+                    .mz_arrange::<RowRowBatcher<_, _, ColumnationChunker<_>>, _>(
                         "Arrange export iterative",
+                        MergeBatcher::new,
                     );
 
                 let mut errs = errs
                     .as_collection(|k, v| (k.clone(), v.clone()))
                     .leave(outer)
-                    .mz_arrange::<ColumnationChunker<_>, ErrBatcher<_, _>, ErrBuilder<_, _>, _>(
+                    .mz_arrange::<ErrBatcher<_, _, ColumnationChunker<_>>, _>(
                         "Arrange export iterative err",
+                        MergeBatcher::new,
                     );
 
                 // Ensure that the frontier does not advance past the expiration time, if set.
@@ -961,7 +958,7 @@ impl<'scope> Context<'scope, Product<mz_repr::Timestamp, PointStamp<u64>>> {
                 let (oks_v, err_v) = variables.remove(&Id::Local(id)).unwrap();
 
                 // Set oks variable to `oks` but consolidated to ensure iteration ceases at fixed point.
-                let mut oks = CollectionExt::consolidate_named::<KeyBatcher<_, _, _>>(
+                let mut oks = CollectionExt::consolidate_named::<ConsolidateBatcher<_, _, _>>(
                     oks,
                     "LetRecConsolidation",
                 );
@@ -970,15 +967,15 @@ impl<'scope> Context<'scope, Product<mz_repr::Timestamp, PointStamp<u64>>> {
                     // We swallow the results of the `max_iter`th iteration, because
                     // these results would go into the `max_iter + 1`th iteration.
                     let (in_limit, over_limit) =
-                        oks.inner.branch_when(move |Product { inner: ps, .. }| {
+                        oks.branch_when(move |Product { inner: ps, .. }| {
                             // The iteration number, or if missing a zero (as trailing zeros are truncated).
                             let iteration_index = *ps.get(level).unwrap_or(&0);
                             // The pointstamp starts counting from 0, so we need to add 1.
                             iteration_index + 1 >= limit.max_iters.into()
                         });
-                    oks = VecCollection::new(in_limit);
+                    oks = in_limit;
                     if !limit.return_at_limit {
-                        err = err.concat(VecCollection::new(over_limit).map(move |_data| {
+                        err = err.concat(over_limit.map(move |_data| {
                             DataflowErrorSer::from(EvalError::LetRecLimitExceeded(
                                 format!("{}", limit.max_iters.get()).into(),
                             ))
@@ -993,12 +990,10 @@ impl<'scope> Context<'scope, Product<mz_repr::Timestamp, PointStamp<u64>>> {
                 // multiplicities of errors, but .. this seems to be the better call.
                 let err: KeyCollection<_, _, _> = err.into();
                 let errs = err
-                    .mz_arrange::<
-                        ColumnationChunker<_>,
-                        ErrBatcher<_, _>,
-                        ErrBuilder<_, _>,
-                        ErrSpine<_, _>,
-                    >("Arrange recursive err")
+                    .mz_arrange::<ErrBatcher<_, _, ColumnationChunker<_>>, ErrSpine<_, _>>(
+                        "Arrange recursive err",
+                        MergeBatcher::new,
+                    )
                     .mz_reduce_abelian::<_, ErrBuilder<_, _>, ErrSpine<_, _>, _>(
                         "Distinct recursive err",
                         move |_k, _s, t| t.push(((), Diff::ONE)),
@@ -1839,8 +1834,11 @@ where
         let mut early_cap = Some(default_cap);
 
         move |(input, frontier), output| {
-            input.for_each_time(|data_cap, data| {
-                if as_of.less_than(data_cap.time()) {
+            input.for_each_stamp(|data_cap, data| {
+                // A message whose stamp lies entirely beyond the `as_of` carries no snapshot
+                // updates and keeps its own capability. Any other message travels under the
+                // minimum capability, which is what suppresses the early progress.
+                if data_cap.stamp().iter().all(|time| as_of.less_than(time)) {
                     let mut session = output.session(&data_cap);
                     for data in data {
                         session.give_container(data);
@@ -1921,8 +1919,10 @@ where
             self.unary_frontier(Pipeline, &format!("LimitProgress({name})"), |_cap, info| {
                 // Times that we've observed on our input.
                 let mut pending_times: BTreeSet<mz_repr::Timestamp> = BTreeSet::new();
-                // Capability for the lower bound of `pending_times`, if any.
-                let mut retained_cap: Option<Capability<mz_repr::Timestamp>> = None;
+                // Capabilities for the lower bound of `pending_times`, if any. A set rather
+                // than one capability: a message is stamped by a multiset of them, and
+                // inserting keeps the antichain, which is the earliest we need to hold.
+                let mut retained_cap: Option<CapabilitySet<mz_repr::Timestamp>> = None;
 
                 let activator = scope.activator_for(info.address);
                 handle.activate(activator.clone());
@@ -1946,10 +1946,12 @@ where
                             }
                         }
                         output.session(&cap).give_container(data);
-                        if retained_cap.as_ref().is_none_or(|c| {
-                            !c.time().less_than(cap.time()) && !upper.less_than(cap.time())
-                        }) {
-                            retained_cap = Some(cap.retain(0));
+                        for capability in cap.retain_stamp(0).iter() {
+                            if !upper.less_than(capability.time()) {
+                                retained_cap
+                                    .get_or_insert_with(CapabilitySet::new)
+                                    .insert(capability.clone());
+                            }
                         }
                     });
 
@@ -1967,7 +1969,7 @@ where
                     }
 
                     match (retained_cap.as_mut(), pending_times.first()) {
-                        (Some(cap), Some(first)) => cap.downgrade(first),
+                        (Some(cap), Some(first)) => cap.downgrade([first]),
                         (_, None) => retained_cap = None,
                         _ => {}
                     }
diff --git a/src/compute/src/render/columnar.rs b/src/compute/src/render/columnar.rs
index f673930c15a54..a43cef7ab404b 100644
--- a/src/compute/src/render/columnar.rs
+++ b/src/compute/src/render/columnar.rs
@@ -46,7 +46,7 @@ use timely::dataflow::{Scope, Stream, StreamVec};
 use crate::render::RenderTimestamp;
 use crate::render::context::{ECB, Session};
 use crate::render::errors::DataflowErrorSer;
-use crate::typedefs::KeyBatcher;
+use crate::typedefs::ConsolidateBatcher;
 
 /// A columnar collection of `(D, T, R)` updates traveling on a compute
 /// dataflow edge.
@@ -191,8 +191,8 @@ impl<'scope, T: RenderTimestamp> CollectionEdge<'scope, T> {
                         input.for_each(|time, data| {
                             // Retain the input capability to derive a `Capability` for each output;
                             // the `Session` type alias is fixed to `Capability<T>`.
-                            let ok_cap = time.retain(0);
-                            let err_cap = time.retain(1);
+                            let ok_cap = time.retain_stamp(0);
+                            let err_cap = time.retain_stamp(1);
                             let mut ok_session = ok_output.session_with_builder(&ok_cap);
                             let mut err_session = err_output.session_with_builder(&err_cap);
                             for (v, t, d) in data.drain(..) {
@@ -225,8 +225,8 @@ impl<'scope, T: RenderTimestamp> CollectionEdge<'scope, T> {
                         input.for_each(|time, data| {
                             // Retain the input capability to derive a `Capability` for each output;
                             // the `Session` type alias is fixed to `Capability<T>`.
-                            let ok_cap = time.retain(0);
-                            let err_cap = time.retain(1);
+                            let ok_cap = time.retain_stamp(0);
+                            let err_cap = time.retain_stamp(1);
                             let mut ok_session = ok_output.session_with_builder(&ok_cap);
                             let mut err_session = err_output.session_with_builder(&err_cap);
                             // Rows are read from the borrowed column, never
@@ -252,14 +252,14 @@ impl<'scope, T: RenderTimestamp> CollectionEdge<'scope, T> {
     pub fn consolidate_named(self, name: &str) -> Self {
         match self {
             CollectionEdge::Vec(c) => CollectionEdge::Vec(CollectionExt::consolidate_named::<
-                KeyBatcher<_, _, _>,
+                ConsolidateBatcher<_, _, _>,
             >(c, name)),
             CollectionEdge::Columnar(c) => {
                 // TODO: Consolidate natively over columns. The pieces exist
                 // (`columnar_exchange`, the columnar merge batchers), which
                 // would avoid the row round-trip below.
                 let c = columnar_to_vec(c);
-                let c = CollectionExt::consolidate_named::<KeyBatcher<_, _, _>>(c, name);
+                let c = CollectionExt::consolidate_named::<ConsolidateBatcher<_, _, _>>(c, name);
                 CollectionEdge::Columnar(vec_to_columnar(c))
             }
         }
diff --git a/src/compute/src/render/context.rs b/src/compute/src/render/context.rs
index e3a6351ec857e..b5c59da8ab3c9 100644
--- a/src/compute/src/render/context.rs
+++ b/src/compute/src/render/context.rs
@@ -10,13 +10,11 @@
 //! Management of dataflow-local state, like arrangements, while building a
 //! dataflow.
 
-use std::collections::BTreeMap;
-use std::rc::Rc;
-
 use differential_dataflow::consolidation::ConsolidatingContainerBuilder;
 use differential_dataflow::operators::arrange::Arranged;
 use differential_dataflow::trace::cursor::{BatchCursor, BatchKey, BatchVal};
 use differential_dataflow::trace::implementations::BatchContainer;
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use differential_dataflow::trace::{Cursor, Navigable, TraceReader};
 use differential_dataflow::{AsCollection, Data, VecCollection};
 use mz_compute_types::dataflows::DataflowDescription;
@@ -31,17 +29,21 @@ use mz_expr::{Eval, Id, MfpPlan};
 use mz_ore::soft_assert_or_log;
 use mz_repr::fixed_length::ExtendDatums;
 use mz_repr::{DatumVec, DatumVecBorrow, Diff, GlobalId, Row, RowArena, SharedRow, StableRow};
+use mz_row_spine::{DatumSeq, RowRowBuilder, RowRowColPagedBuilder};
 use mz_storage_types::controller::CollectionMetadata;
 use mz_timely_util::columnar::batcher;
 use mz_timely_util::columnar::builder::ColumnBuilder;
+use mz_timely_util::columnar::merge_batcher::ColumnMergeBatcher;
 use mz_timely_util::columnar::{
     Col2ValBatcher, Col2ValColBatcher, Col2ValPagedBatcher, columnar_exchange,
 };
 use mz_timely_util::columnation::ColumnationChunker;
+use std::collections::BTreeMap;
+use std::rc::Rc;
 use timely::ContainerBuilder;
 use timely::container::{CapacityContainerBuilder, PushInto};
 use timely::dataflow::channels::pact::{ExchangeCore, Pipeline};
-use timely::dataflow::operators::Capability;
+use timely::dataflow::operators::CapabilitySet;
 use timely::dataflow::operators::generic::builder_rc::OperatorBuilder;
 use timely::dataflow::operators::generic::{OutputBuilder, OutputBuilderSession};
 use timely::dataflow::{Scope, Stream};
@@ -53,11 +55,10 @@ use crate::extensions::arrange::{ArrangementBatcher, KeyCollection, MzArrange, M
 use crate::extensions::reduce::MzReduce;
 use crate::render::columnar::CollectionEdge;
 use crate::render::errors::{DataflowErrorSer, ErrorLogger};
-use crate::render::{LinearJoinSpec, MaybeBucketByTime, RenderTimestamp};
+use crate::render::{MaybeBucketByTime, RenderTimestamp};
 use crate::typedefs::{
     ErrAgent, ErrBatcher, ErrBuilder, ErrEnter, ErrSpine, RowRowAgent, RowRowEnter, RowRowSpine,
 };
-use mz_row_spine::{DatumSeq, RowRowBuilder, RowRowColPagedBuilder};
 
 /// Dataflow-local collections and arrangements.
 ///
@@ -90,7 +91,6 @@ pub struct Context<'scope, T: RenderTimestamp> {
     /// The logger, from Timely's logging framework, if logs are enabled.
     pub(super) compute_logger: Option<crate::logging::compute::Logger>,
     /// Specification for rendering linear joins.
-    pub(super) linear_join_spec: LinearJoinSpec,
     /// The expiration time for dataflows in this context. The output's frontier should never advance
     /// past this frontier, except the empty frontier.
     pub dataflow_expiration: Antichain<mz_repr::Timestamp>,
@@ -134,7 +134,6 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
             until,
             bindings: BTreeMap::new(),
             compute_logger,
-            linear_join_spec: compute_state.linear_join_spec,
             dataflow_expiration,
             config_set: Rc::clone(&compute_state.worker_config),
         }
@@ -208,7 +207,6 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
             as_of_frontier: self.as_of_frontier.clone(),
             until: self.until.clone(),
             compute_logger: self.compute_logger.clone(),
-            linear_join_spec: self.linear_join_spec.clone(),
             bindings,
             dataflow_expiration: self.dataflow_expiration.clone(),
             config_set: Rc::clone(&self.config_set),
@@ -467,10 +465,10 @@ pub(crate) fn distinct_errs_collection<'a, T: RenderTimestamp>(
     errs: VecCollection<'a, T, DataflowErrorSer, Diff>,
 ) -> VecCollection<'a, T, DataflowErrorSer, Diff> {
     let errs: KeyCollection<_, _, _> = errs.into();
-    let errs = errs
-        .mz_arrange::<ColumnationChunker<_>, ErrBatcher<_, _>, ErrBuilder<_, _>, ErrSpine<_, _>>(
-            "Arrange errors",
-        );
+    let errs = errs.mz_arrange::<ErrBatcher<_, _, ColumnationChunker<_>>, ErrSpine<_, _>>(
+        "Arrange errors",
+        MergeBatcher::new,
+    );
     distinct_arranged_errs(errs, "Distinct errors").as_collection(|err, _| err.clone())
 }
 
@@ -810,9 +808,12 @@ impl<'scope, T: RenderTimestamp> CollectionBundle<'scope, T> {
                 input.for_each(|time, data| {
                     // Retain a capability for each output, as the work may complete across
                     // multiple activations.
-                    let ok_cap = time.retain(0);
-                    let err_cap = time.retain(1);
-                    for batch in data.iter() {
+                    let ok_cap = time.retain_stamp(0);
+                    let err_cap = time.retain_stamp(1);
+                    for span in data.iter() {
+                        let Some(batch) = &span.inner else {
+                            continue;
+                        };
                         todo.push_back(PendingWork::new(
                             ok_cap.clone(),
                             err_cap.clone(),
@@ -919,8 +920,11 @@ impl<'scope, T: RenderTimestamp> CollectionBundle<'scope, T> {
                 let mut ok_output = ok_output.activate();
 
                 input.for_each(|time, data| {
-                    let cap = time.retain(0);
-                    for batch in data.iter() {
+                    let cap = time.retain_stamp(0);
+                    for span in data.iter() {
+                        let Some(batch) = &span.inner else {
+                            continue;
+                        };
                         todo.push_back(PendingWorkOk::new(
                             cap.clone(),
                             batch.cursor(),
@@ -1180,14 +1184,10 @@ impl<'scope, T: RenderTimestamp> CollectionBundle<'scope, T> {
                     Self::arrange_collection(&name, oks, key.clone(), thinning.clone(), batcher);
                 let errs_concat: KeyCollection<_, _, _> = errs.clone().concat(errs_keyed).into();
                 self.collection = Some((CollectionEdge::Vec(passthrough), errs));
-                let errs =
-                    errs_concat.mz_arrange::<
-                        ColumnationChunker<_>,
-                        ErrBatcher<_, _>,
-                        ErrBuilder<_, _>,
-                        ErrSpine<_, _>,
-                    >(
+                let errs = errs_concat
+                    .mz_arrange::<ErrBatcher<_, _, ColumnationChunker<_>>, ErrSpine<_, _>>(
                         &format!("{}-errors", name),
+                        MergeBatcher::new,
                     );
                 self.arranged
                     .insert(key, ArrangementFlavor::Local(oks, errs));
@@ -1268,27 +1268,35 @@ impl<'scope, T: RenderTimestamp> CollectionBundle<'scope, T> {
         let exchange =
             ExchangeCore::<ColumnBuilder<_>, _>::new_core(columnar_exchange::<Row, Row, T, Diff>);
         let oks = match batcher {
-            ArrangementBatcher::ColumnarPaged => ok_stream.mz_arrange_core::<
+            ArrangementBatcher::ColumnarPaged => ok_stream
+                .mz_arrange_core::<_, Col2ValPagedBatcher<
+                    _,
+                    _,
+                    _,
+                    _,
+                    batcher::ColumnChunker<_>,
+                    RowRowColPagedBuilder<_, _>,
+                >, RowRowSpine<_, _>>(exchange, name, ColumnMergeBatcher::new),
+            ArrangementBatcher::Columnar => {
+                ok_stream.mz_arrange_core::<_, Col2ValColBatcher<
+                    _,
+                    _,
+                    _,
+                    _,
+                    batcher::ColumnChunker<_>,
+                    RowRowColPagedBuilder<_, _>,
+                >, RowRowSpine<_, _>>(exchange, name, MergeBatcher::new)
+            }
+            ArrangementBatcher::Columnation => ok_stream.mz_arrange_core::<_, Col2ValBatcher<
+                _,
                 _,
-                batcher::ColumnChunker<_>,
-                Col2ValPagedBatcher<_, _, _, _>,
-                RowRowColPagedBuilder<_, _>,
-                RowRowSpine<_, _>,
-            >(exchange, name),
-            ArrangementBatcher::Columnar => ok_stream.mz_arrange_core::<
                 _,
-                batcher::ColumnChunker<_>,
-                Col2ValColBatcher<_, _, _, _>,
-                RowRowColPagedBuilder<_, _>,
-                RowRowSpine<_, _>,
-            >(exchange, name),
-            ArrangementBatcher::Columnation => ok_stream.mz_arrange_core::<
                 _,
                 batcher::Chunker<_>,
-                Col2ValBatcher<_, _, _, _>,
                 RowRowBuilder<_, _>,
-                RowRowSpine<_, _>,
-            >(exchange, name),
+            >, RowRowSpine<_, _>>(
+                exchange, name, MergeBatcher::new
+            ),
         };
         (
             oks,
@@ -1301,8 +1309,12 @@ impl<'scope, T: RenderTimestamp> CollectionBundle<'scope, T> {
 /// Type alias for a timely output `Session` whose capability is a `Capability<T>`. The container
 /// builder `CB` is left to the caller; sessions can therefore drive consolidating, capacity, or
 /// (in the future) columnar output builders without changing call sites.
+/// A session over one output of an arrangement-reading operator.
+///
+/// The capability is a whole [`CapabilitySet`]: a batch message's stamp carries every capability
+/// the arrange operator retired with it, and need not be a singleton.
 pub(crate) type Session<'a, 'b, T, CB> =
-    timely::dataflow::operators::generic::Session<'a, 'b, T, CB, Capability<T>>;
+    timely::dataflow::operators::generic::Session<'a, 'b, T, CB, CapabilitySet<T>>;
 
 /// Container builder used for the err output of every flat_map variant. Pre-refactor the
 /// merged Ok/Err stream flowed through a [`ConsolidatingContainerBuilder`] before the
@@ -1319,10 +1331,10 @@ struct PendingWork<C>
 where
     C: Cursor,
 {
-    /// Capability for the `ok` output (output port 0).
-    ok_capability: Capability<C::Time>,
-    /// Capability for the `err` output (output port 1).
-    err_capability: Capability<C::Time>,
+    /// Capabilities for the `ok` output (output port 0), one per element of the batch's stamp.
+    ok_capability: CapabilitySet<C::Time>,
+    /// Capabilities for the `err` output (output port 1), one per element of the batch's stamp.
+    err_capability: CapabilitySet<C::Time>,
     cursor: C,
     batch: C::Storage,
 }
@@ -1334,8 +1346,8 @@ where
     /// Create a new bundle of pending work, from a pair of capabilities (one per output),
     /// a cursor, and backing storage.
     fn new(
-        ok_capability: Capability<C::Time>,
-        err_capability: Capability<C::Time>,
+        ok_capability: CapabilitySet<C::Time>,
+        err_capability: CapabilitySet<C::Time>,
         cursor: C,
         batch: C::Storage,
     ) -> Self {
@@ -1381,7 +1393,7 @@ struct PendingWorkOk<C>
 where
     C: Cursor,
 {
-    capability: Capability<C::Time>,
+    capability: CapabilitySet<C::Time>,
     cursor: C,
     batch: C::Storage,
 }
@@ -1390,7 +1402,7 @@ impl<C> PendingWorkOk<C>
 where
     C: Cursor<KeyContainer: BatchContainer<Owned: PartialEq + Sized>>,
 {
-    fn new(capability: Capability<C::Time>, cursor: C, batch: C::Storage) -> Self {
+    fn new(capability: CapabilitySet<C::Time>, cursor: C, batch: C::Storage) -> Self {
         Self {
             capability,
             cursor,
diff --git a/src/compute/src/render/flat_map.rs b/src/compute/src/render/flat_map.rs
index 4b452272b20be..2d3583b7b9668 100644
--- a/src/compute/src/render/flat_map.rs
+++ b/src/compute/src/render/flat_map.rs
@@ -18,7 +18,7 @@ use mz_repr::{DatumVec, RowArena, SharedRow};
 use mz_repr::{Diff, Row, Timestamp};
 use mz_timely_util::operator::StreamExt;
 use timely::dataflow::channels::pact::Pipeline;
-use timely::dataflow::operators::Capability;
+use timely::dataflow::operators::CapabilitySet;
 use timely::dataflow::operators::generic::Session;
 use timely::progress::Antichain;
 
@@ -60,7 +60,12 @@ impl<'scope, T: crate::render::RenderTimestamp> Context<'scope, T> {
                 let mut budget = budget;
 
                 input.for_each(|cap, data| {
-                    queue.push_back((cap.retain(0), cap.retain(1), std::mem::take(data)))
+                    // A message's stamp need not be a singleton, so hold the whole set.
+                    queue.push_back((
+                        cap.retain_stamp(0),
+                        cap.retain_stamp(1),
+                        std::mem::take(data),
+                    ))
                 });
 
                 while let Some((ok_cap, err_cap, data)) = queue.pop_front() {
@@ -143,14 +148,14 @@ fn drain_through_mfp<T>(
         '_,
         T,
         ConsolidatingContainerBuilder<Vec<(Row, T, Diff)>>,
-        Capability<T>,
+        CapabilitySet<T>,
     >,
     err_output: &mut Session<
         '_,
         '_,
         T,
         ConsolidatingContainerBuilder<Vec<(DataflowErrorSer, T, Diff)>>,
-        Capability<T>,
+        CapabilitySet<T>,
     >,
     budget: &mut usize,
 ) where
diff --git a/src/compute/src/render/join.rs b/src/compute/src/render/join.rs
index e9e4070899ad2..2095d0c9a385b 100644
--- a/src/compute/src/render/join.rs
+++ b/src/compute/src/render/join.rs
@@ -13,6 +13,3 @@
 
 mod delta_join;
 mod linear_join;
-mod mz_join_core;
-
-pub use linear_join::LinearJoinSpec;
diff --git a/src/compute/src/render/join/delta_join.rs b/src/compute/src/render/join/delta_join.rs
index cfac33a55887a..0c7d23ae70259 100644
--- a/src/compute/src/render/join/delta_join.rs
+++ b/src/compute/src/render/join/delta_join.rs
@@ -13,28 +13,23 @@
 
 #![allow(clippy::op_ref)]
 
-use std::collections::BTreeSet;
-use std::rc::Rc;
-
 use differential_dataflow::consolidation::ConsolidatingContainerBuilder;
 use differential_dataflow::operators::arrange::Arranged;
 use differential_dataflow::trace::cursor::BatchCursor;
 use differential_dataflow::trace::implementations::BatchContainer;
 use differential_dataflow::trace::{Cursor, Navigable, TraceReader};
 use differential_dataflow::{AsCollection, VecCollection};
-use mz_compute_types::dyncfgs::ENABLE_HALF_JOIN2;
 use mz_compute_types::plan::join::JoinClosure;
 use mz_compute_types::plan::join::delta_join::{DeltaJoinPlan, DeltaPathPlan, DeltaStagePlan};
 use mz_compute_types::plan::scalar::LirScalarExpr;
-use mz_dyncfg::ConfigSet;
 use mz_expr::Eval;
 use mz_repr::fixed_length::ExtendDatums;
 use mz_repr::{DatumVec, Diff, Row, RowArena, SharedRow};
 use mz_timely_util::operator::{CollectionExt, StreamExt};
+use std::collections::BTreeSet;
 use timely::container::CapacityContainerBuilder;
 use timely::dataflow::channels::pact::Pipeline;
 use timely::dataflow::operators::OkErr;
-use timely::dataflow::operators::generic::Session;
 use timely::dataflow::operators::vec::Map;
 use timely::progress::Antichain;
 
@@ -185,7 +180,6 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
                             lookup_key,
                             source_relation < lookup_relation,
                             closure,
-                            Rc::clone(&self.config_set),
                         );
                         update_stream = oks;
                         region_errs.push(errs);
@@ -343,7 +337,6 @@ fn build_halfjoin<'scope, T>(
     lookup_key: Vec<LirScalarExpr>,
     source_precedes_lookup: bool,
     closure: JoinClosure,
-    config_set: Rc<ConfigSet>,
 ) -> (
     VecCollection<'scope, T, (Row, T), Diff>,
     VecCollection<'scope, T, DataflowErrorSer, Diff>,
@@ -353,51 +346,25 @@ where
 {
     match bundle.arrangement(&lookup_key) {
         Some(ArrangementFlavor::Local(oks, _errs)) => {
-            let (oks, errs2) = if source_precedes_lookup {
-                build_halfjoin_trace::<_, RowRowAgent<_, _>, _>(
-                    updates,
-                    oks,
-                    prev_key,
-                    prev_thinning,
-                    |t1, t2| t1.le(t2),
-                    closure,
-                    config_set,
-                )
-            } else {
-                build_halfjoin_trace::<_, RowRowAgent<_, _>, _>(
-                    updates,
-                    oks,
-                    prev_key,
-                    prev_thinning,
-                    |t1, t2| t1.lt(t2),
-                    closure,
-                    config_set,
-                )
-            };
+            let (oks, errs2) = build_halfjoin_trace::<_, RowRowAgent<_, _>>(
+                updates,
+                oks,
+                prev_key,
+                prev_thinning,
+                !source_precedes_lookup,
+                closure,
+            );
             (oks, errs2)
         }
         Some(ArrangementFlavor::Trace(_, oks, _errs)) => {
-            let (oks, errs2) = if source_precedes_lookup {
-                build_halfjoin_trace::<_, RowRowEnter<_, _, _>, _>(
-                    updates,
-                    oks,
-                    prev_key,
-                    prev_thinning,
-                    |t1, t2| t1.le(t2),
-                    closure,
-                    config_set,
-                )
-            } else {
-                build_halfjoin_trace::<_, RowRowEnter<_, _, _>, _>(
-                    updates,
-                    oks,
-                    prev_key,
-                    prev_thinning,
-                    |t1, t2| t1.lt(t2),
-                    closure,
-                    config_set,
-                )
-            };
+            let (oks, errs2) = build_halfjoin_trace::<_, RowRowEnter<_, _, _>>(
+                updates,
+                oks,
+                prev_key,
+                prev_thinning,
+                !source_precedes_lookup,
+                closure,
+            );
             (oks, errs2)
         }
         None => panic!("Arrangement promised by the planner is absent!"),
@@ -406,22 +373,22 @@ where
 
 /// Constructs a `half_join` from supplied arguments.
 ///
-/// This method exists to factor common logic from four code paths that are generic over the type of trace.
-/// The `comparison` function should either be `le` or `lt` depending on which relation comes first in the
-/// total order on relations (in order to break ties consistently).
+/// This method exists to factor common logic from the code paths that are generic over the type of
+/// trace. `strict` breaks ties consistently: it is false when the source relation precedes the
+/// lookup relation in the total order on relations, and true otherwise. A delta query pairs a
+/// strict operator with a non-strict one, so each pair of matching updates interacts exactly once.
 ///
 /// The input and output streams are of pairs `(data, time)` where the `time` component can be greater than
 /// the time of the update. This operator may manipulate `time` as part of this pair, but will not manipulate
 /// the time of the update. This is crucial for correctness, as the total order on times of updates is used
 /// to ensure that any two updates are matched at most once.
-fn build_halfjoin_trace<'scope, T, Tr, CF>(
+fn build_halfjoin_trace<'scope, T, Tr>(
     updates: VecCollection<'scope, T, (Row, T), Diff>,
     trace: Arranged<'scope, Tr>,
     prev_key: Vec<LirScalarExpr>,
     prev_thinning: Vec<usize>,
-    comparison: CF,
+    strict: bool,
     closure: JoinClosure,
-    config_set: Rc<ConfigSet>,
 ) -> (
     VecCollection<'scope, T, (Row, T), Diff>,
     VecCollection<'scope, T, DataflowErrorSer, Diff>,
@@ -435,10 +402,7 @@ where
             Time = T,
             Diff = Diff,
         >,
-    CF: Fn(<BatchCursor<Tr> as Cursor>::TimeGat<'_>, &T) -> bool + 'static,
 {
-    let use_half_join2 = ENABLE_HALF_JOIN2.get(&config_set);
-
     let name = "DeltaJoinKeyPreparation";
     type CB<C> = CapacityContainerBuilder<C>;
     let (updates, errs) = updates.map_fallible::<CB<_>, CB<_>, _, _, _>(name, {
@@ -464,18 +428,14 @@ where
     });
     let datums = DatumVec::new();
 
-    if use_half_join2 {
-        build_halfjoin2(updates, trace, comparison, closure, datums, errs)
-    } else {
-        build_halfjoin1(updates, trace, comparison, closure, datums, errs)
-    }
+    build_halfjoin_op(updates, trace, strict, closure, datums, errs)
 }
 
 /// `half_join2` implementation (less-quadratic, new default).
-fn build_halfjoin2<'scope, T, Tr, CF>(
+fn build_halfjoin_op<'scope, T, Tr>(
     updates: VecCollection<'scope, T, (Row, Row, T), Diff>,
     trace: Arranged<'scope, Tr>,
-    comparison: CF,
+    strict: bool,
     closure: JoinClosure,
     mut datums: DatumVec,
     errs: VecCollection<'scope, T, DataflowErrorSer, Diff>,
@@ -492,62 +452,68 @@ where
             Time = T,
             Diff = Diff,
         >,
-    CF: Fn(<BatchCursor<Tr> as Cursor>::TimeGat<'_>, &T) -> bool + 'static,
 {
     type CB<C> = CapacityContainerBuilder<C>;
 
     if closure.could_error() {
-        let (oks, errs2) = differential_dogs3::operators::half_join2::half_join_internal_unsafe(
-            updates,
-            trace,
-            |time, antichain| {
-                antichain.insert(time.step_back());
-            },
-            comparison,
-            // TODO(mcsherry): investigate/establish trade-offs here; time based had problems,
-            // in that we seem to yield too much and do too little work when we do.
-            |_timer, count| count > 1_000_000,
-            // TODO(mcsherry): consider `RefOrMut` in `half_join` interface to allow re-use.
-            move |session: &mut CB<Vec<_>>, key, stream_row, lookup_row, initial, diff1, output| {
-                let mut row_builder = SharedRow::get();
-                let temp_storage = RowArena::new();
-
-                let mut datums_local = datums.borrow();
-                datums_local.extend(key.iter());
-                datums_local.extend(stream_row.iter());
-                lookup_row.extend_datums(&temp_storage, &mut datums_local, None);
-
-                let row = closure.apply(&mut datums_local, &temp_storage, &mut row_builder);
+        let (oks, errs2) =
+            differential_dogs3::operators::half_join::cursors::half_join_internal_unsafe(
+                updates,
+                trace,
+                |time, antichain| {
+                    antichain.insert(time.step_back());
+                },
+                strict,
+                // TODO(mcsherry): investigate/establish trade-offs here; time based had problems,
+                // in that we seem to yield too much and do too little work when we do.
+                |_timer, count| count > 1_000_000,
+                // TODO(mcsherry): consider `RefOrMut` in `half_join` interface to allow re-use.
+                move |session: &mut CB<Vec<_>>,
+                      key,
+                      stream_row,
+                      lookup_row,
+                      initial,
+                      diff1,
+                      output| {
+                    let mut row_builder = SharedRow::get();
+                    let temp_storage = RowArena::new();
+
+                    let mut datums_local = datums.borrow();
+                    datums_local.extend(key.iter());
+                    datums_local.extend(stream_row.iter());
+                    lookup_row.extend_datums(&temp_storage, &mut datums_local, None);
+
+                    let row = closure.apply(&mut datums_local, &temp_storage, &mut row_builder);
 
-                for (time, diff2) in output.drain(..) {
-                    let row = row.as_ref().map(|row| row.cloned()).map_err(Clone::clone);
-                    let diff = diff1.clone() * diff2.clone();
-                    let data = ((row, time.clone()), initial.clone(), diff);
-                    use timely::container::PushInto;
-                    session.push_into(data);
+                    for (time, diff2) in output.drain(..) {
+                        let row = row.as_ref().map(|row| row.cloned()).map_err(Clone::clone);
+                        let diff = diff1.clone() * diff2.clone();
+                        let data = ((row, time.clone()), initial.clone(), diff);
+                        use timely::container::PushInto;
+                        session.push_into(data);
+                    }
+                },
+            )
+            .ok_err(|(data_time, init_time, diff)| {
+                // TODO(mcsherry): consider `ok_err()` for `Collection`.
+                match data_time {
+                    (Ok(data), time) => Ok((data.map(|data| (data, time)), init_time, diff)),
+                    (Err(err), _time) => Err((DataflowErrorSer::from(err), init_time, diff)),
                 }
-            },
-        )
-        .ok_err(|(data_time, init_time, diff)| {
-            // TODO(mcsherry): consider `ok_err()` for `Collection`.
-            match data_time {
-                (Ok(data), time) => Ok((data.map(|data| (data, time)), init_time, diff)),
-                (Err(err), _time) => Err((DataflowErrorSer::from(err), init_time, diff)),
-            }
-        });
+            });
 
         (
             oks.as_collection().flat_map(|x| x),
             errs.concat(errs2.as_collection()),
         )
     } else {
-        let oks = differential_dogs3::operators::half_join2::half_join_internal_unsafe(
+        let oks = differential_dogs3::operators::half_join::cursors::half_join_internal_unsafe(
             updates,
             trace,
             |time, antichain| {
                 antichain.insert(time.step_back());
             },
-            comparison,
+            strict,
             // TODO(mcsherry): investigate/establish trade-offs here; time based had problems,
             // in that we seem to yield too much and do too little work when we do.
             |_timer, count| count > 1_000_000,
@@ -582,118 +548,6 @@ where
     }
 }
 
-/// Original `half_join` implementation (fallback).
-fn build_halfjoin1<'scope, T, Tr, CF>(
-    updates: VecCollection<'scope, T, (Row, Row, T), Diff>,
-    trace: Arranged<'scope, Tr>,
-    comparison: CF,
-    closure: JoinClosure,
-    mut datums: DatumVec,
-    errs: VecCollection<'scope, T, DataflowErrorSer, Diff>,
-) -> (
-    VecCollection<'scope, T, (Row, T), Diff>,
-    VecCollection<'scope, T, DataflowErrorSer, Diff>,
-)
-where
-    T: RenderTimestamp,
-    Tr: TraceReader<Batch: Navigable, Time = T> + Clone + 'static,
-    for<'a> BatchCursor<Tr>: Cursor<
-            Val<'a>: ExtendDatums,
-            KeyContainer: BatchContainer<Owned = Row>,
-            Time = T,
-            Diff = Diff,
-        >,
-    CF: Fn(<BatchCursor<Tr> as Cursor>::TimeGat<'_>, &T) -> bool + 'static,
-{
-    type CB<C> = CapacityContainerBuilder<C>;
-
-    if closure.could_error() {
-        let (oks, errs2) = differential_dogs3::operators::half_join::half_join_internal_unsafe(
-            updates,
-            trace,
-            |time, antichain| {
-                antichain.insert(time.step_back());
-            },
-            comparison,
-            |_timer, count| count > 1_000_000,
-            move |session: &mut Session<'_, '_, T, CB<Vec<_>>, _>,
-                  key,
-                  stream_row: &Row,
-                  lookup_row,
-                  initial,
-                  diff1,
-                  output| {
-                let mut row_builder = SharedRow::get();
-                let temp_storage = RowArena::new();
-
-                let mut datums_local = datums.borrow();
-                datums_local.extend(key.iter());
-                datums_local.extend(stream_row.iter());
-                lookup_row.extend_datums(&temp_storage, &mut datums_local, None);
-
-                let row = closure.apply(&mut datums_local, &temp_storage, &mut row_builder);
-
-                for (time, diff2) in output.drain(..) {
-                    let row = row.as_ref().map(|row| row.cloned()).map_err(Clone::clone);
-                    let diff = diff1.clone() * diff2.clone();
-                    let data = ((row, time.clone()), initial.clone(), diff);
-                    session.give(data);
-                }
-            },
-        )
-        .ok_err(|(data_time, init_time, diff)| match data_time {
-            (Ok(data), time) => Ok((data.map(|data| (data, time)), init_time, diff)),
-            (Err(err), _time) => Err((DataflowErrorSer::from(err), init_time, diff)),
-        });
-
-        (
-            oks.as_collection().flat_map(|x| x),
-            errs.concat(errs2.as_collection()),
-        )
-    } else {
-        let oks = differential_dogs3::operators::half_join::half_join_internal_unsafe(
-            updates,
-            trace,
-            |time, antichain| {
-                antichain.insert(time.step_back());
-            },
-            comparison,
-            |_timer, count| count > 1_000_000,
-            move |session: &mut Session<'_, '_, T, CB<Vec<_>>, _>,
-                  key,
-                  stream_row: &Row,
-                  lookup_row,
-                  initial,
-                  diff1,
-                  output| {
-                if output.is_empty() {
-                    return;
-                }
-
-                let mut row_builder = SharedRow::get();
-                let temp_storage = RowArena::new();
-
-                let mut datums_local = datums.borrow();
-                datums_local.extend(key.iter());
-                datums_local.extend(stream_row.iter());
-                lookup_row.extend_datums(&temp_storage, &mut datums_local, None);
-
-                if let Some(row) = closure
-                    .apply(&mut datums_local, &temp_storage, &mut row_builder)
-                    .expect("Closure claimed to never error")
-                {
-                    for (time, diff2) in output.drain(..) {
-                        let diff = diff1.clone() * diff2.clone();
-                        session.give(((row.clone(), time.clone()), initial.clone(), diff));
-                    }
-                }
-            },
-        );
-
-        (oks.as_collection(), errs)
-    }
-}
-
 /// Builds the initial update stream of a delta path from a collection bundle.
 ///
 /// With a `source_key`, demuxes over the two flavors of arrangement the bundle might hold for that
@@ -786,8 +640,11 @@ where
                         let mut ok_session = ok_output.session(&time);
                         let mut err_session = err_output.session(&time);
 
-                        for wrapper in data.iter() {
-                            let batch = &wrapper;
+                        for span in data.iter() {
+                            // A span with no updates carries no batch to walk.
+                            let Some(batch) = &span.inner else {
+                                continue;
+                            };
                             let mut cursor = batch.cursor();
                             while let Some(key) = cursor.get_key(batch) {
                                 while let Some(val) = cursor.get_val(batch) {
diff --git a/src/compute/src/render/join/linear_join.rs b/src/compute/src/render/join/linear_join.rs
index 84de916c96c47..453546e73c7eb 100644
--- a/src/compute/src/render/join/linear_join.rs
+++ b/src/compute/src/render/join/linear_join.rs
@@ -11,23 +11,22 @@
 //!
 //! Consult [LinearJoinPlan] documentation for details.
 
-use std::time::{Duration, Instant};
-
 use differential_dataflow::consolidation::ConsolidatingContainerBuilder;
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::operators::arrange::arrangement::Arranged;
 use differential_dataflow::trace::cursor::{BatchCursor, BatchKey, BatchVal};
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use differential_dataflow::trace::{Cursor, Navigable, TraceReader};
 use differential_dataflow::{AsCollection, Data, VecCollection};
-use mz_compute_types::dyncfgs::{ENABLE_MZ_JOIN_CORE, LINEAR_JOIN_YIELDING};
 use mz_compute_types::plan::join::JoinClosure;
 use mz_compute_types::plan::join::linear_join::{LinearJoinPlan, LinearStagePlan};
-use mz_dyncfg::ConfigSet;
 use mz_expr::Eval;
 use mz_repr::fixed_length::ExtendDatums;
 use mz_repr::{DatumVec, Diff, Row, RowArena, SharedRow};
+use mz_row_spine::{RowRowBuilder, RowRowColPagedBuilder, RowRowSpine};
 use mz_timely_util::columnar::batcher;
 use mz_timely_util::columnar::builder::ColumnBuilder;
+use mz_timely_util::columnar::merge_batcher::ColumnMergeBatcher;
 use mz_timely_util::columnar::{
     Col2ValBatcher, Col2ValColBatcher, Col2ValPagedBatcher, columnar_exchange,
 };
@@ -40,151 +39,26 @@ use crate::extensions::arrange::{ArrangementBatcher, MzArrangeCore};
 use crate::render::RenderTimestamp;
 use crate::render::context::{ArrangementFlavor, CollectionBundle, Context};
 use crate::render::errors::DataflowErrorSer;
-use crate::render::join::mz_join_core::mz_join_core;
 use crate::typedefs::{RowRowAgent, RowRowEnter};
-use mz_row_spine::{RowRowBuilder, RowRowColPagedBuilder, RowRowSpine};
 
-/// Available linear join implementations.
+/// Joins two arranged collections, applying `result` to each matching pair.
 ///
-/// See the `mz_join_core` module docs for our rationale for providing two join implementations.
-#[derive(Clone, Copy)]
-enum LinearJoinImpl {
-    Materialize,
-    DifferentialDataflow,
-}
-
-/// Specification of how linear joins are to be executed.
-///
-/// Note that currently `yielding` only affects the `Materialize` join implementation, as the DD
-/// join doesn't allow configuring its yielding behavior. Merging [#390] would fix this.
-///
-/// [#390]: https://github.com/TimelyDataflow/differential-dataflow/pull/390
-#[derive(Clone, Copy)]
-pub struct LinearJoinSpec {
-    implementation: LinearJoinImpl,
-    yielding: YieldSpec,
-}
-
-impl Default for LinearJoinSpec {
-    fn default() -> Self {
-        Self {
-            implementation: LinearJoinImpl::Materialize,
-            yielding: Default::default(),
-        }
-    }
-}
-
-impl LinearJoinSpec {
-    /// Create a `LinearJoinSpec` based on the given config.
-    pub fn from_config(config: &ConfigSet) -> Self {
-        let implementation = if ENABLE_MZ_JOIN_CORE.get(config) {
-            LinearJoinImpl::Materialize
-        } else {
-            LinearJoinImpl::DifferentialDataflow
-        };
-
-        let yielding_raw = LINEAR_JOIN_YIELDING.get(config);
-        let yielding = YieldSpec::try_from_str(&yielding_raw).unwrap_or_else(|| {
-            tracing::error!("invalid LINEAR_JOIN_YIELDING config: {yielding_raw}");
-            YieldSpec::default()
-        });
-
-        Self {
-            implementation,
-            yielding,
-        }
-    }
-
-    /// Render a join operator according to this specification.
-    fn render<'s, T, Tr1, Tr2, L, I>(
-        &self,
-        arranged1: Arranged<'s, Tr1>,
-        arranged2: Arranged<'s, Tr2>,
-        result: L,
-    ) -> VecCollection<'s, T, I::Item, Diff>
-    where
-        T: Lattice + timely::progress::Timestamp,
-        Tr1: TraceReader<Batch: Navigable, Time = T> + Clone + 'static,
-        Tr2: TraceReader<Batch: Navigable, Time = T> + Clone + 'static,
-        BatchCursor<Tr1>: Cursor<Time = T, Diff = Diff>,
-        for<'a> BatchCursor<Tr2>: Cursor<Key<'a> = BatchKey<'a, Tr1>, Time = T, Diff = Diff>,
-        L: FnMut(BatchKey<'_, Tr1>, BatchVal<'_, Tr1>, BatchVal<'_, Tr2>) -> I + 'static,
-        I: IntoIterator<Item: Data> + 'static,
-    {
-        use LinearJoinImpl::*;
-
-        match (
-            self.implementation,
-            self.yielding.after_work,
-            self.yielding.after_time,
-        ) {
-            (DifferentialDataflow, _, _) => arranged1.join_core(arranged2, result),
-            (Materialize, Some(work_limit), Some(time_limit)) => {
-                let yield_fn =
-                    move |start: Instant, work| work >= work_limit || start.elapsed() >= time_limit;
-                mz_join_core(arranged1, arranged2, result, yield_fn).as_collection()
-            }
-            (Materialize, Some(work_limit), None) => {
-                let yield_fn = move |_start, work| work >= work_limit;
-                mz_join_core(arranged1, arranged2, result, yield_fn).as_collection()
-            }
-            (Materialize, None, Some(time_limit)) => {
-                let yield_fn = move |start: Instant, _work| start.elapsed() >= time_limit;
-                mz_join_core(arranged1, arranged2, result, yield_fn).as_collection()
-            }
-            (Materialize, None, None) => {
-                let yield_fn = |_start, _work| false;
-                mz_join_core(arranged1, arranged2, result, yield_fn).as_collection()
-            }
-        }
-    }
-}
-
-/// Specification of a dataflow operator's yielding behavior.
-#[derive(Clone, Copy)]
-struct YieldSpec {
-    /// Yield after the given amount of work was performed.
-    after_work: Option<usize>,
-    /// Yield after the given amount of time has elapsed.
-    after_time: Option<Duration>,
-}
-
-impl Default for YieldSpec {
-    fn default() -> Self {
-        Self {
-            after_work: Some(1_000_000),
-            after_time: Some(Duration::from_millis(100)),
-        }
-    }
-}
-
-impl YieldSpec {
-    fn try_from_str(s: &str) -> Option<Self> {
-        let mut after_work = None;
-        let mut after_time = None;
-
-        let options = s.split(',').map(|o| o.trim());
-        for option in options {
-            let mut iter = option.split(':').map(|p| p.trim());
-            match std::array::from_fn(|_| iter.next()) {
-                [Some("work"), Some(amount), None] => {
-                    let amount = amount.parse().ok()?;
-                    after_work = Some(amount);
-                }
-                [Some("time"), Some(millis), None] => {
-                    let millis = millis.parse().ok()?;
-                    let duration = Duration::from_millis(millis);
-                    after_time = Some(duration);
-                }
-                _ => return None,
-            }
-        }
-
-        Some(Self {
-            after_work,
-            after_time,
-        })
-    }
+/// A thin name for differential's `join_core`, which owns the fuel budget it yields on.
+fn join_arranged<'s, T, Tr1, Tr2, L, I>(
+    arranged1: Arranged<'s, Tr1>,
+    arranged2: Arranged<'s, Tr2>,
+    result: L,
+) -> VecCollection<'s, T, I::Item, Diff>
+where
+    T: Lattice + timely::progress::Timestamp,
+    Tr1: TraceReader<Batch: Navigable, Time = T> + Clone + 'static,
+    Tr2: TraceReader<Batch: Navigable, Time = T> + Clone + 'static,
+    BatchCursor<Tr1>: Cursor<Time = T, Diff = Diff>,
+    for<'a> BatchCursor<Tr2>: Cursor<Key<'a> = BatchKey<'a, Tr1>, Time = T, Diff = Diff>,
+    L: FnMut(BatchKey<'_, Tr1>, BatchVal<'_, Tr1>, BatchVal<'_, Tr2>) -> I + 'static,
+    I: IntoIterator<Item: Data> + 'static,
+{
+    arranged1.join_core(arranged2, result)
 }
 
 /// Different forms the streamed data might take.
@@ -391,27 +265,37 @@ where
                 columnar_exchange::<Row, Row, T, Diff>,
             );
             let arranged = match ArrangementBatcher::from_config(&self.config_set) {
-                ArrangementBatcher::ColumnarPaged => keyed.mz_arrange_core::<
+                ArrangementBatcher::ColumnarPaged => keyed
+                    .mz_arrange_core::<_, Col2ValPagedBatcher<
+                        _,
+                        _,
+                        _,
+                        _,
+                        batcher::ColumnChunker<_>,
+                        RowRowColPagedBuilder<_, _>,
+                    >, RowRowSpine<_, _>>(
+                        exchange, "JoinStage", ColumnMergeBatcher::new
+                    ),
+                ArrangementBatcher::Columnar => keyed.mz_arrange_core::<_, Col2ValColBatcher<
+                    _,
+                    _,
                     _,
-                    batcher::ColumnChunker<_>,
-                    Col2ValPagedBatcher<_, _, _, _>,
-                    RowRowColPagedBuilder<_, _>,
-                    RowRowSpine<_, _>,
-                >(exchange, "JoinStage"),
-                ArrangementBatcher::Columnar => keyed.mz_arrange_core::<
                     _,
                     batcher::ColumnChunker<_>,
-                    Col2ValColBatcher<_, _, _, _>,
                     RowRowColPagedBuilder<_, _>,
-                    RowRowSpine<_, _>,
-                >(exchange, "JoinStage"),
-                ArrangementBatcher::Columnation => keyed.mz_arrange_core::<
+                >, RowRowSpine<_, _>>(
+                    exchange, "JoinStage", MergeBatcher::new
+                ),
+                ArrangementBatcher::Columnation => keyed.mz_arrange_core::<_, Col2ValBatcher<
+                    _,
+                    _,
+                    _,
                     _,
                     batcher::Chunker<_>,
-                    Col2ValBatcher<_, _, _, _>,
                     RowRowBuilder<_, _>,
-                    RowRowSpine<_, _>,
-                >(exchange, "JoinStage"),
+                >, RowRowSpine<_, _>>(
+                    exchange, "JoinStage", MergeBatcher::new
+                ),
             };
             joined = JoinedFlavor::Local(arranged);
         }
@@ -499,50 +383,46 @@ where
         let mut datums = DatumVec::new();
 
         if closure.could_error() {
-            let (oks, err) = self
-                .linear_join_spec
-                .render(prev_keyed, next_input, move |key, old, new| {
-                    let mut row_builder = SharedRow::get();
-                    let temp_storage = RowArena::new();
-
-                    let mut datums_local = datums.borrow();
-                    key.extend_datums(&temp_storage, &mut datums_local, None);
-                    old.extend_datums(&temp_storage, &mut datums_local, None);
-                    new.extend_datums(&temp_storage, &mut datums_local, None);
-
-                    closure
-                        .apply(&mut datums_local, &temp_storage, &mut row_builder)
-                        .map(|row| row.cloned())
-                        .map_err(DataflowErrorSer::from)
-                        .transpose()
-                })
-                .inner
-                .ok_err(|(x, t, d)| {
-                    // TODO(mcsherry): consider `ok_err()` for `Collection`.
-                    match x {
-                        Ok(x) => Ok((x, t, d)),
-                        Err(x) => Err((x, t, d)),
-                    }
-                });
+            let (oks, err) = join_arranged(prev_keyed, next_input, move |key, old, new| {
+                let mut row_builder = SharedRow::get();
+                let temp_storage = RowArena::new();
+
+                let mut datums_local = datums.borrow();
+                key.extend_datums(&temp_storage, &mut datums_local, None);
+                old.extend_datums(&temp_storage, &mut datums_local, None);
+                new.extend_datums(&temp_storage, &mut datums_local, None);
+
+                closure
+                    .apply(&mut datums_local, &temp_storage, &mut row_builder)
+                    .map(|row| row.cloned())
+                    .map_err(DataflowErrorSer::from)
+                    .transpose()
+            })
+            .inner
+            .ok_err(|(x, t, d)| {
+                // TODO(mcsherry): consider `ok_err()` for `Collection`.
+                match x {
+                    Ok(x) => Ok((x, t, d)),
+                    Err(x) => Err((x, t, d)),
+                }
+            });
 
             (oks.as_collection(), Some(err.as_collection()))
         } else {
-            let oks = self
-                .linear_join_spec
-                .render(prev_keyed, next_input, move |key, old, new| {
-                    let mut row_builder = SharedRow::get();
-                    let temp_storage = RowArena::new();
-
-                    let mut datums_local = datums.borrow();
-                    key.extend_datums(&temp_storage, &mut datums_local, None);
-                    old.extend_datums(&temp_storage, &mut datums_local, None);
-                    new.extend_datums(&temp_storage, &mut datums_local, None);
-
-                    closure
-                        .apply(&mut datums_local, &temp_storage, &mut row_builder)
-                        .expect("Closure claimed to never error")
-                        .cloned()
-                });
+            let oks = join_arranged(prev_keyed, next_input, move |key, old, new| {
+                let mut row_builder = SharedRow::get();
+                let temp_storage = RowArena::new();
+
+                let mut datums_local = datums.borrow();
+                key.extend_datums(&temp_storage, &mut datums_local, None);
+                old.extend_datums(&temp_storage, &mut datums_local, None);
+                new.extend_datums(&temp_storage, &mut datums_local, None);
+
+                closure
+                    .apply(&mut datums_local, &temp_storage, &mut row_builder)
+                    .expect("Closure claimed to never error")
+                    .cloned()
+            });
 
             (oks, None)
         }
diff --git a/src/compute/src/render/join/mz_join_core.rs b/src/compute/src/render/join/mz_join_core.rs
deleted file mode 100644
index 3ef61aa63ef22..0000000000000
--- a/src/compute/src/render/join/mz_join_core.rs
+++ /dev/null
@@ -1,975 +0,0 @@
-// Copyright Materialize, Inc. and contributors. All rights reserved.
-//
-// Use of this software is governed by the Business Source License
-// included in the LICENSE file.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0.
-
-//! A fork of DD's `JoinCore::join_core`.
-//!
-//! Currently, compute rendering knows two implementations for linear joins:
-//!
-//!  * Differential's `JoinCore::join_core`
-//!  * A Materialize fork thereof, called `mz_join_core`
-//!
-//! `mz_join_core` exists to solve a responsiveness problem with the DD implementation.
-//! DD's join is only able to yield between keys. When computing a large cross-join or a highly
-//! skewed join, this can result in loss of interactivity when the join operator refuses to yield
-//! control for multiple seconds or longer, which in turn causes degraded user experience.
-//! `mz_join_core` resolves the loss-of-interactivity issue by also yielding within keys.
-//!
-//! For the moment, we keep both implementations around, selectable through feature flags.
-//! Eventually, we hope that `mz_join_core` proves itself sufficiently to become the only join
-//! implementation.
-
-use std::cell::Cell;
-use std::cell::RefCell;
-use std::cmp::Ordering;
-use std::collections::VecDeque;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::time::Instant;
-
-use differential_dataflow::Data;
-use differential_dataflow::consolidation::{consolidate_from, consolidate_updates};
-use differential_dataflow::lattice::Lattice;
-use differential_dataflow::operators::arrange::arrangement::Arranged;
-use differential_dataflow::trace::cursor::{BatchCursor, BatchKey, BatchVal, CursorList};
-use differential_dataflow::trace::{BatchReader, Cursor, Navigable, TraceReader};
-use mz_ore::future::yield_now;
-use mz_repr::Diff;
-use timely::container::{CapacityContainerBuilder, PushInto, SizableContainer};
-use timely::dataflow::Stream;
-use timely::dataflow::channels::pact::Pipeline;
-use timely::dataflow::operators::generic::OutputBuilderSession;
-use timely::dataflow::operators::{Capability, Operator};
-use timely::{Container, PartialOrder};
-use tracing::trace;
-
-/// Joins two arranged collections with the same key type.
-///
-/// Each matching pair of records `(key, val1)` and `(key, val2)` are subjected to the `result` function,
-/// which produces something implementing `IntoIterator`, where the output collection will have an entry for
-/// every value returned by the iterator.
-pub(super) fn mz_join_core<'scope, T, Tr1, Tr2, L, I, YFn, C>(
-    arranged1: Arranged<'scope, Tr1>,
-    arranged2: Arranged<'scope, Tr2>,
-    result: L,
-    yield_fn: YFn,
-) -> Stream<'scope, T, C>
-where
-    T: timely::progress::Timestamp + Lattice,
-    Tr1: TraceReader<Batch: Navigable, Time = T> + Clone + 'static,
-    Tr2: TraceReader<Batch: Navigable, Time = T> + Clone + 'static,
-    BatchCursor<Tr1>: Cursor<Time = T, Diff = Diff>,
-    for<'a> BatchCursor<Tr2>: Cursor<Key<'a> = BatchKey<'a, Tr1>, Time = T, Diff = Diff>,
-    L: FnMut(BatchKey<'_, Tr1>, BatchVal<'_, Tr1>, BatchVal<'_, Tr2>) -> I + 'static,
-    I: IntoIterator<Item: Data> + 'static,
-    YFn: Fn(Instant, usize) -> bool + 'static,
-    C: Container + SizableContainer + PushInto<(I::Item, T, Diff)> + Data,
-{
-    let scope = arranged1.stream.scope();
-    let mut trace1 = arranged1.trace.clone();
-    let mut trace2 = arranged2.trace.clone();
-
-    arranged1.stream.binary_frontier(
-        arranged2.stream,
-        Pipeline,
-        Pipeline,
-        "Join",
-        move |capability, info| {
-            let operator_id = info.global_id;
-
-            // Acquire an activator to reschedule the operator when it has unfinished work.
-            let activator = scope.activator_for(info.address);
-
-            // Our initial invariants are that for each trace, physical compaction is less or equal the trace's upper bound.
-            // These invariants ensure that we can reference observed batch frontiers from `_start_upper` onward, as long as
-            // we maintain our physical compaction capabilities appropriately. These assertions are tested as we load up the
-            // initial work for the two traces, and before the operator is constructed.
-
-            // Acknowledged frontier for each input.
-            // These two are used exclusively to track batch boundaries on which we may want/need to call `cursor_through`.
-            // They will drive our physical compaction of each trace, and we want to maintain at all times that each is beyond
-            // the physical compaction frontier of their corresponding trace.
-            // Should we ever *drop* a trace, these are 1. much harder to maintain correctly, but 2. no longer used.
-            use timely::progress::frontier::Antichain;
-            let mut acknowledged1 = Antichain::from_elem(<T>::minimum());
-            let mut acknowledged2 = Antichain::from_elem(<T>::minimum());
-
-            // deferred work of batches from each input.
-            let result_fn = Rc::new(RefCell::new(result));
-            // A trace hands out a `CursorList` over its batches' cursors, while an individual
-            // batch hands out a single `BatchCursor`. Input 1's per-batch work joins one batch1
-            // cursor against trace2's merged cursor, and vice versa for input 2.
-            let mut todo1 = Work::<BatchCursor<Tr1>, CursorList<BatchCursor<Tr2>>, _, _>::new(
-                Rc::clone(&result_fn),
-            );
-            let mut todo2 =
-                Work::<CursorList<BatchCursor<Tr1>>, BatchCursor<Tr2>, _, _>::new(result_fn);
-
-            // We'll unload the initial batches here, to put ourselves in a less non-deterministic state to start.
-            trace1.map_batches(|batch1| {
-                trace!(
-                    operator_id,
-                    input = 1,
-                    lower = ?batch1.lower().elements(),
-                    upper = ?batch1.upper().elements(),
-                    size = batch1.len(),
-                    "pre-loading batch",
-                );
-
-                acknowledged1.clone_from(batch1.upper());
-                // No `todo1` work here, because we haven't accepted anything into `batches2` yet.
-                // It is effectively "empty", because we choose to drain `trace1` before `trace2`.
-                // Once we start streaming batches in, we will need to respond to new batches from
-                // `input1` with logic that would have otherwise been here. Check out the next loop
-                // for the structure.
-            });
-            // At this point, `ack1` should exactly equal `trace1.read_upper()`, as they are both determined by
-            // iterating through batches and capturing the upper bound. This is a great moment to assert that
-            // `trace1`'s physical compaction frontier is before the frontier of completed times in `trace1`.
-            // TODO: in the case that this does not hold, instead "upgrade" the physical compaction frontier.
-            assert!(PartialOrder::less_equal(
-                &trace1.get_physical_compaction(),
-                &acknowledged1.borrow()
-            ));
-
-            trace!(
-                operator_id,
-                input = 1,
-                acknowledged1 = ?acknowledged1.elements(),
-                "pre-loading finished",
-            );
-
-            // We capture batch2 cursors first and establish work second to avoid taking a `RefCell` lock
-            // on both traces at the same time, as they could be the same trace and this would panic.
-            let mut batch2_cursors = Vec::new();
-            trace2.map_batches(|batch2| {
-                trace!(
-                    operator_id,
-                    input = 2,
-                    lower = ?batch2.lower().elements(),
-                    upper = ?batch2.upper().elements(),
-                    size = batch2.len(),
-                    "pre-loading batch",
-                );
-
-                acknowledged2.clone_from(batch2.upper());
-                batch2_cursors.push((batch2.cursor(), batch2.clone()));
-            });
-            // At this point, `ack2` should exactly equal `trace2.read_upper()`, as they are both determined by
-            // iterating through batches and capturing the upper bound. This is a great moment to assert that
-            // `trace2`'s physical compaction frontier is before the frontier of completed times in `trace2`.
-            // TODO: in the case that this does not hold, instead "upgrade" the physical compaction frontier.
-            assert!(PartialOrder::less_equal(
-                &trace2.get_physical_compaction(),
-                &acknowledged2.borrow()
-            ));
-
-            // Batches wholly at or before these frontiers were joined by the start-up loading
-            // above, and arriving input batches are ignored up to them. Beyond them, every
-            // non-empty arriving batch must be joined, even once `acknowledged` has advanced past
-            // it. `advance_upper` consults the shared trace, whose merges may have consolidated an
-            // in-flight batch's updates away once logical compaction equates an add/remove pair's
-            // times. The trace's emptiness there is valid only for readers at or beyond the
-            // compaction frontier, while our consumers may read finer times, so the raw batch still
-            // owes them its updates. Testing against these fixed boundaries rather than the mutable
-            // `acknowledged` frontiers keeps such batches from being dropped. See
-            // TimelyDataflow/differential-dataflow#801.
-            let preload_upper1 = acknowledged1.clone();
-            let preload_upper2 = acknowledged2.clone();
-
-            // Load up deferred work using trace2 cursors and batches captured just above.
-            for (batch2_cursor, batch2) in batch2_cursors.into_iter() {
-                trace!(
-                    operator_id,
-                    input = 2,
-                    acknowledged1 = ?acknowledged1.elements(),
-                    "deferring work for batch",
-                );
-
-                // It is safe to ask for `ack1` because we have confirmed it to be in advance of `distinguish_since`.
-                let (trace1_cursor, trace1_storage) =
-                    trace1.cursor_through(acknowledged1.borrow()).unwrap();
-                // We could downgrade the capability here, but doing so is a bit complicated mathematically.
-                // TODO: downgrade the capability by searching out the one time in `batch2.lower()` and not
-                // in `batch2.upper()`. Only necessary for non-empty batches, as empty batches may not have
-                // that property.
-                todo2.push(
-                    trace1_cursor,
-                    trace1_storage,
-                    batch2_cursor,
-                    batch2.clone(),
-                    capability.clone(),
-                );
-            }
-
-            trace!(
-                operator_id,
-                input = 2,
-                acknowledged2 = ?acknowledged2.elements(),
-                "pre-loading finished",
-            );
-
-            // Droppable handles to shared trace data structures.
-            let mut trace1_option = Some(trace1);
-            let mut trace2_option = Some(trace2);
-
-            move |(input1, frontier1), (input2, frontier2), output| {
-                // 1. Consuming input.
-                //
-                // The join computation repeatedly accepts batches of updates from each of its inputs.
-                //
-                // For each accepted batch, it prepares a work-item to join the batch against previously "accepted"
-                // updates from its other input. It is important to track which updates have been accepted, because
-                // we use a shared trace and there may be updates present that are in advance of this accepted bound.
-                //
-                // Batches are accepted: 1. in bulk at start-up (above), 2. as we observe them in the input stream,
-                // and 3. if the trace can confirm a region of empty space directly following our accepted bound.
-                // This last case is a consequence of our inability to transmit empty batches, as they may be formed
-                // in the absence of timely dataflow capabilities.
-
-                // Drain input 1, prepare work.
-                input1.for_each(|capability, data| {
-                    let trace2 = trace2_option
-                        .as_mut()
-                        .expect("we only drop a trace in response to the other input emptying");
-                    let capability = capability.retain(0);
-                    for batch1 in data.drain(..) {
-                        // Ignore any pre-loaded data, which was joined at start-up. This tests the
-                        // fixed preload boundary, not `acknowledged1`, which `advance_upper` can
-                        // move past an in-flight batch whose updates trace merges consolidated away.
-                        // Such a batch must still be joined.
-                        if !PartialOrder::less_equal(batch1.upper(), &preload_upper1) {
-                            trace!(
-                                operator_id,
-                                input = 1,
-                                lower = ?batch1.lower().elements(),
-                                upper = ?batch1.upper().elements(),
-                                size = batch1.len(),
-                                "loading batch",
-                            );
-
-                            if !batch1.is_empty() {
-                                trace!(
-                                    operator_id,
-                                    input = 1,
-                                    acknowledged2 = ?acknowledged2.elements(),
-                                    "deferring work for batch",
-                                );
-
-                                // It is safe to ask for `ack2` as we validated that it was at least `get_physical_compaction()`
-                                // at start-up, and have held back physical compaction ever since.
-                                let (trace2_cursor, trace2_storage) =
-                                    trace2.cursor_through(acknowledged2.borrow()).unwrap();
-                                let batch1_cursor = batch1.cursor();
-                                todo1.push(
-                                    batch1_cursor,
-                                    batch1.clone(),
-                                    trace2_cursor,
-                                    trace2_storage,
-                                    capability.clone(),
-                                );
-                            }
-
-                            // To update `acknowledged1` we might presume that `batch1.lower` should equal it, but we
-                            // may have skipped over empty batches. Still, the batches are in-order, and we should be
-                            // able to just assume the most recent `batch1.upper`, unless `advance_upper` already moved
-                            // `acknowledged1` past this batch, in which case we keep the further frontier.
-                            if PartialOrder::less_equal(&acknowledged1, batch1.lower()) {
-                                mz_ore::soft_assert_or_log!(
-                                    PartialOrder::less_equal(&acknowledged1, batch1.upper()),
-                                    "acknowledged1 {:?} regressed past batch1 upper {:?}",
-                                    acknowledged1.elements(),
-                                    batch1.upper().elements(),
-                                );
-                                acknowledged1.clone_from(batch1.upper());
-                            }
-
-                            trace!(
-                                operator_id,
-                                input = 1,
-                                acknowledged1 = ?acknowledged1.elements(),
-                                "batch acknowledged",
-                            );
-                        }
-                    }
-                });
-
-                // Drain input 2, prepare work.
-                input2.for_each(|capability, data| {
-                    let trace1 = trace1_option
-                        .as_mut()
-                        .expect("we only drop a trace in response to the other input emptying");
-                    let capability = capability.retain(0);
-                    for batch2 in data.drain(..) {
-                        // Ignore any pre-loaded data, which was joined at start-up. This tests the
-                        // fixed preload boundary, not `acknowledged2`, which `advance_upper` can
-                        // move past an in-flight batch whose updates trace merges consolidated away.
-                        // Such a batch must still be joined.
-                        if !PartialOrder::less_equal(batch2.upper(), &preload_upper2) {
-                            trace!(
-                                operator_id,
-                                input = 2,
-                                lower = ?batch2.lower().elements(),
-                                upper = ?batch2.upper().elements(),
-                                size = batch2.len(),
-                                "loading batch",
-                            );
-
-                            if !batch2.is_empty() {
-                                trace!(
-                                    operator_id,
-                                    input = 2,
-                                    acknowledged1 = ?acknowledged1.elements(),
-                                    "deferring work for batch",
-                                );
-
-                                // It is safe to ask for `ack1` as we validated that it was at least `get_physical_compaction()`
-                                // at start-up, and have held back physical compaction ever since.
-                                let (trace1_cursor, trace1_storage) =
-                                    trace1.cursor_through(acknowledged1.borrow()).unwrap();
-                                let batch2_cursor = batch2.cursor();
-                                todo2.push(
-                                    trace1_cursor,
-                                    trace1_storage,
-                                    batch2_cursor,
-                                    batch2.clone(),
-                                    capability.clone(),
-                                );
-                            }
-
-                            // To update `acknowledged2` we might presume that `batch2.lower` should equal it, but we
-                            // may have skipped over empty batches. Still, the batches are in-order, and we should be
-                            // able to just assume the most recent `batch2.upper`, unless `advance_upper` already moved
-                            // `acknowledged2` past this batch, in which case we keep the further frontier.
-                            if PartialOrder::less_equal(&acknowledged2, batch2.lower()) {
-                                mz_ore::soft_assert_or_log!(
-                                    PartialOrder::less_equal(&acknowledged2, batch2.upper()),
-                                    "acknowledged2 {:?} regressed past batch2 upper {:?}",
-                                    acknowledged2.elements(),
-                                    batch2.upper().elements(),
-                                );
-                                acknowledged2.clone_from(batch2.upper());
-                            }
-
-                            trace!(
-                                operator_id,
-                                input = 2,
-                                acknowledged2 = ?acknowledged2.elements(),
-                                "batch acknowledged",
-                            );
-                        }
-                    }
-                });
-
-                // Advance acknowledged frontiers through any empty regions that we may not receive as batches.
-                if let Some(trace1) = trace1_option.as_mut() {
-                    trace!(
-                        operator_id,
-                        input = 1,
-                        acknowledged1 = ?acknowledged1.elements(),
-                        "advancing trace upper",
-                    );
-                    trace1.advance_upper(&mut acknowledged1);
-                }
-                if let Some(trace2) = trace2_option.as_mut() {
-                    trace!(
-                        operator_id,
-                        input = 2,
-                        acknowledged2 = ?acknowledged2.elements(),
-                        "advancing trace upper",
-                    );
-                    trace2.advance_upper(&mut acknowledged2);
-                }
-
-                // 2. Join computation.
-                //
-                // For each of the inputs, we do some amount of work (measured in terms of number
-                // of output records produced). This is meant to yield control to allow downstream
-                // operators to consume and reduce the output, but it it also means to provide some
-                // degree of responsiveness. There is a potential risk here that if we fall behind
-                // then the increasing queues hold back physical compaction of the underlying traces
-                // which results in unintentionally quadratic processing time (each batch of either
-                // input must scan all batches from the other input).
-
-                // Perform some amount of outstanding work for input 1.
-                trace!(
-                    operator_id,
-                    input = 1,
-                    work_left = todo1.remaining(),
-                    "starting work"
-                );
-                todo1.process(output, &yield_fn);
-                trace!(
-                    operator_id,
-                    input = 1,
-                    work_left = todo1.remaining(),
-                    "ceasing work",
-                );
-
-                // Perform some amount of outstanding work for input 2.
-                trace!(
-                    operator_id,
-                    input = 2,
-                    work_left = todo2.remaining(),
-                    "starting work"
-                );
-                todo2.process(output, &yield_fn);
-                trace!(
-                    operator_id,
-                    input = 2,
-                    work_left = todo2.remaining(),
-                    "ceasing work",
-                );
-
-                // Re-activate operator if work remains.
-                if !todo1.is_empty() || !todo2.is_empty() {
-                    activator.activate();
-                }
-
-                // 3. Trace maintenance.
-                //
-                // Importantly, we use `input.frontier()` here rather than `acknowledged` to track
-                // the progress of an input, because should we ever drop one of the traces we will
-                // lose the ability to extract information from anything other than the input.
-                // For example, if we dropped `trace2` we would not be able to use `advance_upper`
-                // to keep `acknowledged2` up to date wrt empty batches, and would hold back logical
-                // compaction of `trace1`.
-
-                // Maintain `trace1`. Drop if `input2` is empty, or advance based on future needs.
-                if let Some(trace1) = trace1_option.as_mut() {
-                    if frontier2.is_empty() {
-                        trace!(operator_id, input = 1, "dropping trace handle");
-                        trace1_option = None;
-                    } else {
-                        trace!(
-                            operator_id,
-                            input = 1,
-                            logical = ?*frontier2.frontier(),
-                            physical = ?acknowledged1.elements(),
-                            "advancing trace compaction",
-                        );
-
-                        // Allow `trace1` to compact logically up to the frontier we may yet receive,
-                        // in the opposing input (`input2`). All `input2` times will be beyond this
-                        // frontier, and joined times only need to be accurate when advanced to it.
-                        trace1.set_logical_compaction(frontier2.frontier());
-                        // Allow `trace1` to compact physically up to the upper bound of batches we
-                        // have received in its input (`input1`). We will not require a cursor that
-                        // is not beyond this bound.
-                        trace1.set_physical_compaction(acknowledged1.borrow());
-                    }
-                }
-
-                // Maintain `trace2`. Drop if `input1` is empty, or advance based on future needs.
-                if let Some(trace2) = trace2_option.as_mut() {
-                    if frontier1.is_empty() {
-                        trace!(operator_id, input = 2, "dropping trace handle");
-                        trace2_option = None;
-                    } else {
-                        trace!(
-                            operator_id,
-                            input = 2,
-                            logical = ?*frontier1.frontier(),
-                            physical = ?acknowledged2.elements(),
-                            "advancing trace compaction",
-                        );
-
-                        // Allow `trace2` to compact logically up to the frontier we may yet receive,
-                        // in the opposing input (`input1`). All `input1` times will be beyond this
-                        // frontier, and joined times only need to be accurate when advanced to it.
-                        trace2.set_logical_compaction(frontier1.frontier());
-                        // Allow `trace2` to compact physically up to the upper bound of batches we
-                        // have received in its input (`input2`). We will not require a cursor that
-                        // is not beyond this bound.
-                        trace2.set_physical_compaction(acknowledged2.borrow());
-                    }
-                }
-            }
-        },
-    )
-}
-
-/// Work collected by the join operator.
-///
-/// The join operator enqueues new work here first, and then processes it at a controlled rate,
-/// potentially yielding control to the Timely runtime in between. This allows it to avoid OOMs,
-/// caused by buffering massive amounts of data at the output, and loss of interactivity.
-///
-/// Collected work can be reduced by calling the `process` method.
-struct Work<C1, C2, D, L>
-where
-    C1: Cursor,
-    C2: Cursor,
-{
-    /// Pending work.
-    todo: VecDeque<(Pin<Box<dyn Future<Output = ()>>>, Capability<C1::Time>)>,
-    /// A function that transforms raw join matches into join results.
-    result_fn: Rc<RefCell<L>>,
-    /// A buffer holding the join results.
-    ///
-    /// Written by the work futures, drained by `Work::process`.
-    output: Rc<RefCell<Vec<(D, C1::Time, Diff)>>>,
-    /// The number of join results produced by work futures.
-    ///
-    /// Used with `yield_fn` to inform when `Work::process` should yield.
-    produced: Rc<Cell<usize>>,
-
-    _cursors: PhantomData<(C1, C2)>,
-}
-
-impl<C1, C2, D, L, I> Work<C1, C2, D, L>
-where
-    C1: Cursor<Diff = Diff> + 'static,
-    C2: for<'a> Cursor<Key<'a> = C1::Key<'a>, Time = C1::Time, Diff = Diff> + 'static,
-    D: Data,
-    L: FnMut(C1::Key<'_>, C1::Val<'_>, C2::Val<'_>) -> I + 'static,
-    I: IntoIterator<Item = D> + 'static,
-{
-    fn new(result_fn: Rc<RefCell<L>>) -> Self {
-        Self {
-            todo: Default::default(),
-            result_fn,
-            output: Default::default(),
-            produced: Default::default(),
-            _cursors: PhantomData,
-        }
-    }
-
-    /// Return the amount of remaining work chunks.
-    fn remaining(&self) -> usize {
-        self.todo.len()
-    }
-
-    /// Return whether there is any work pending.
-    fn is_empty(&self) -> bool {
-        self.remaining() == 0
-    }
-
-    /// Append some pending work.
-    fn push(
-        &mut self,
-        cursor1: C1,
-        storage1: C1::Storage,
-        cursor2: C2,
-        storage2: C2::Storage,
-        capability: Capability<C1::Time>,
-    ) {
-        let fut = self.start_work(
-            cursor1,
-            storage1,
-            cursor2,
-            storage2,
-            capability.time().clone(),
-        );
-
-        self.todo.push_back((Box::pin(fut), capability));
-    }
-
-    /// Process pending work until none is remaining or `yield_fn` requests a yield.
-    fn process<C, YFn>(
-        &mut self,
-        output: &mut OutputBuilderSession<'_, C1::Time, CapacityContainerBuilder<C>>,
-        yield_fn: YFn,
-    ) where
-        C: Container + SizableContainer + PushInto<(D, C1::Time, Diff)> + Data,
-        YFn: Fn(Instant, usize) -> bool,
-    {
-        let start_time = Instant::now();
-        self.produced.set(0);
-
-        let waker = futures::task::noop_waker();
-        let mut ctx = std::task::Context::from_waker(&waker);
-
-        while let Some((mut fut, cap)) = self.todo.pop_front() {
-            // Drive the work future until it's done or it's time to yield.
-            let mut done = false;
-            let mut should_yield = false;
-            while !done && !should_yield {
-                done = fut.as_mut().poll(&mut ctx).is_ready();
-                should_yield = yield_fn(start_time, self.produced.get());
-            }
-
-            // Drain the produced join results.
-            let mut output_buf = self.output.borrow_mut();
-
-            // Consolidating here is important when the join closure produces data that
-            // consolidates well, for example when projecting columns.
-            let old_len = output_buf.len();
-            consolidate_updates(&mut output_buf);
-            let recovered = old_len - output_buf.len();
-            self.produced.update(|x| x - recovered);
-
-            output.session(&cap).give_iterator(output_buf.drain(..));
-
-            if done {
-                // We have finished processing a chunk of work. Use this opportunity to truncate
-                // the output buffer, so we don't keep excess memory allocated forever.
-                *output_buf = Default::default();
-            } else if !done {
-                // Still work to do in this chunk.
-                self.todo.push_front((fut, cap));
-            }
-
-            if should_yield {
-                break;
-            }
-        }
-    }
-
-    /// Start the work of joining the updates produced by the given cursors.
-    ///
-    /// This method returns a `Future` that can be polled to make progress on the join work.
-    /// Returning a future allows us to implement the logic using async/await syntax where we can
-    /// conveniently pause the work at any point by calling `yield_now().await`. We are allowed to
-    /// hold references across yield points, which is something we wouldn't get with a hand-rolled
-    /// state machine implementation.
-    fn start_work(
-        &self,
-        mut cursor1: C1,
-        storage1: C1::Storage,
-        mut cursor2: C2,
-        storage2: C2::Storage,
-        meet: C1::Time,
-    ) -> impl Future<Output = ()> + use<C1, C2, D, L, I> {
-        let result_fn = Rc::clone(&self.result_fn);
-        let output = Rc::clone(&self.output);
-        let produced = Rc::clone(&self.produced);
-
-        async move {
-            let mut joiner = Joiner::new(result_fn, output, produced, meet);
-
-            while let Some(key1) = cursor1.get_key(&storage1)
-                && let Some(key2) = cursor2.get_key(&storage2)
-            {
-                match key1.cmp(&key2) {
-                    Ordering::Less => cursor1.seek_key(&storage1, key2),
-                    Ordering::Greater => cursor2.seek_key(&storage2, key1),
-                    Ordering::Equal => {
-                        joiner
-                            .join_key(key1, &mut cursor1, &storage1, &mut cursor2, &storage2)
-                            .await;
-
-                        cursor1.step_key(&storage1);
-                        cursor2.step_key(&storage2);
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// Type that knows how to perform the core join logic.
-///
-/// The joiner implements two join strategies:
-///
-///  * The "simple" strategy produces a match for each combination of (val1, time1, val2, time2)
-///    found in the inputs. If there are multiple times in the input, it may produce matches for
-///    times in which one of the values wasn't present. These matches cancel each other out, so the
-///    result ends up correct.
-///  * The "linear scan over times" strategy sorts the input data by time and then steps through
-///    the input histories, producing matches for a pair of values only if both values where
-///    present at the same time.
-///
-/// The linear scan strategy avoids redundant work and is much more efficient than the simple
-/// strategy when many distinct times are present in the inputs. However, sorting the input data
-/// incurs some overhead, so we still prefer the simple variant when the input data is small.
-struct Joiner<'a, C1, C2, D, L>
-where
-    C1: Cursor,
-    C2: Cursor,
-{
-    /// A function that transforms raw join matches into join results.
-    result_fn: Rc<RefCell<L>>,
-    /// A buffer holding the join results.
-    output: Rc<RefCell<Vec<(D, C1::Time, Diff)>>>,
-    /// The number of join results produced.
-    produced: Rc<Cell<usize>>,
-    /// A time to which all join results should be advanced.
-    meet: C1::Time,
-
-    /// Buffer for edit histories from the first input.
-    history1: ValueHistory<'a, C1>,
-    /// Buffer for edit histories from the second input.
-    history2: ValueHistory<'a, C2>,
-}
-
-impl<'a, C1, C2, D, L, I> Joiner<'a, C1, C2, D, L>
-where
-    C1: Cursor<Diff = Diff>,
-    C2: Cursor<Key<'a> = C1::Key<'a>, Time = C1::Time, Diff = Diff>,
-    D: Data,
-    L: FnMut(C1::Key<'_>, C1::Val<'_>, C2::Val<'_>) -> I + 'static,
-    I: IntoIterator<Item = D> + 'static,
-{
-    fn new(
-        result_fn: Rc<RefCell<L>>,
-        output: Rc<RefCell<Vec<(D, C1::Time, Diff)>>>,
-        produced: Rc<Cell<usize>>,
-        meet: C1::Time,
-    ) -> Self {
-        Self {
-            result_fn,
-            output,
-            produced,
-            meet,
-            history1: ValueHistory::new(),
-            history2: ValueHistory::new(),
-        }
-    }
-
-    /// Produce matches for the values of a single key.
-    async fn join_key(
-        &mut self,
-        key: C1::Key<'_>,
-        cursor1: &mut C1,
-        storage1: &'a C1::Storage,
-        cursor2: &mut C2,
-        storage2: &'a C2::Storage,
-    ) {
-        self.history1.edits.load(cursor1, storage1, &self.meet);
-        self.history2.edits.load(cursor2, storage2, &self.meet);
-
-        // If the input data is small, use the simple strategy.
-        //
-        // TODO: This conditional is taken directly from DD. We should check if it might make sense
-        //       to do something different, like using the simple strategy always when the number
-        //       of distinct times is small.
-        if self.history1.edits.len() < 10 || self.history2.edits.len() < 10 {
-            self.join_key_simple(key);
-            yield_now().await;
-        } else {
-            self.join_key_linear_time_scan(key).await;
-        }
-    }
-
-    /// Produce matches for the values of a single key, using the simple strategy.
-    ///
-    /// This strategy is only meant to be used for small inputs, so we don't bother including yield
-    /// points or optimizations.
-    fn join_key_simple(&self, key: C1::Key<'_>) {
-        let mut result_fn = self.result_fn.borrow_mut();
-        let mut output = self.output.borrow_mut();
-
-        for (v1, t1, r1) in self.history1.edits.iter() {
-            for (v2, t2, r2) in self.history2.edits.iter() {
-                for data in result_fn(key, v1, v2) {
-                    output.push((data, t1.join(t2), r1 * r2));
-                    self.produced.update(|x| x + 1);
-                }
-            }
-        }
-    }
-
-    /// Produce matches for the values of a single key, using a linear scan through times.
-    async fn join_key_linear_time_scan(&mut self, key: C1::Key<'_>) {
-        let history1 = &mut self.history1;
-        let history2 = &mut self.history2;
-
-        history1.replay();
-        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.
-
-        // Join the next entry in `history1`.
-        let work_history1 = |history1: &mut ValueHistory<C1>, history2: &mut ValueHistory<C2>| {
-            let mut result_fn = self.result_fn.borrow_mut();
-            let mut output = self.output.borrow_mut();
-
-            let (t1, meet, v1, r1) = history1.get().unwrap();
-            history2.advance_past_by(meet);
-            for &(v2, ref t2, r2) in &history2.past {
-                for data in result_fn(key, v1, v2) {
-                    output.push((data, t1.join(t2), r1 * r2));
-                    self.produced.update(|x| x + 1);
-                }
-            }
-            history1.step();
-        };
-
-        // Join the next entry in `history2`.
-        let work_history2 = |history1: &mut ValueHistory<C1>, history2: &mut ValueHistory<C2>| {
-            let mut result_fn = self.result_fn.borrow_mut();
-            let mut output = self.output.borrow_mut();
-
-            let (t2, meet, v2, r2) = history2.get().unwrap();
-            history1.advance_past_by(meet);
-            for &(v1, ref t1, r1) in &history1.past {
-                for data in result_fn(key, v1, v2) {
-                    output.push((data, t1.join(t2), r1 * r2));
-                    self.produced.update(|x| x + 1);
-                }
-            }
-            history2.step();
-        };
-
-        while let Some(time1) = history1.get_time()
-            && let Some(time2) = history2.get_time()
-        {
-            if time1 < time2 {
-                work_history1(history1, history2)
-            } else {
-                work_history2(history1, history2)
-            };
-            yield_now().await;
-        }
-
-        while !history1.is_empty() {
-            work_history1(history1, history2);
-            yield_now().await;
-        }
-        while !history2.is_empty() {
-            work_history2(history1, history2);
-            yield_now().await;
-        }
-    }
-}
-
-/// An accumulation of (value, time, diff) updates.
-///
-/// Deduplicated values are stored in `values`. Each entry includes the end index of the
-/// corresponding range in `edits`. The edits stored for a value are consolidated.
-struct EditList<'a, C: Cursor> {
-    values: Vec<(C::Val<'a>, usize)>,
-    edits: Vec<(C::Time, Diff)>,
-}
-
-impl<'a, C> EditList<'a, C>
-where
-    C: Cursor<Diff = Diff>,
-{
-    fn len(&self) -> usize {
-        self.edits.len()
-    }
-
-    /// Load the updates in the given cursor.
-    ///
-    /// Steps over values, but not over keys.
-    fn load(&mut self, cursor: &mut C, storage: &'a C::Storage, meet: &C::Time) {
-        self.values.clear();
-        self.edits.clear();
-
-        let mut edit_idx = 0;
-        while let Some(value) = cursor.get_val(storage) {
-            cursor.map_times(storage, |time, diff| {
-                let mut time = C::owned_time(time);
-                time.join_assign(meet);
-                self.edits.push((time, C::owned_diff(diff)));
-            });
-
-            consolidate_from(&mut self.edits, edit_idx);
-
-            if self.edits.len() > edit_idx {
-                edit_idx = self.edits.len();
-                self.values.push((value, edit_idx));
-            }
-
-            cursor.step_val(storage);
-        }
-    }
-
-    /// Iterate over the contained updates.
-    fn iter(&self) -> impl Iterator<Item = (C::Val<'a>, &C::Time, Diff)> {
-        self.values
-            .iter()
-            .enumerate()
-            .flat_map(|(idx, (value, end))| {
-                let start = if idx == 0 { 0 } else { self.values[idx - 1].1 };
-                let edits = &self.edits[start..*end];
-                edits.iter().map(|(time, diff)| (*value, time, *diff))
-            })
-    }
-}
-
-/// A history for replaying updates in time order.
-struct ValueHistory<'a, C: Cursor> {
-    /// Unsorted updates to replay.
-    edits: EditList<'a, C>,
-    /// Time-sorted updates that have not been stepped over yet.
-    ///
-    /// Entries are (time, meet, value_idx, diff).
-    future: Vec<(C::Time, C::Time, usize, Diff)>,
-    /// Rolled-up updates that have been stepped over.
-    past: Vec<(C::Val<'a>, C::Time, Diff)>,
-}
-
-impl<'a, C> ValueHistory<'a, C>
-where
-    C: Cursor,
-{
-    /// Create a new empty `ValueHistory`.
-    fn new() -> Self {
-        Self {
-            edits: EditList {
-                values: Default::default(),
-                edits: Default::default(),
-            },
-            future: Default::default(),
-            past: Default::default(),
-        }
-    }
-
-    /// Return whether there are updates left to step over.
-    fn is_empty(&self) -> bool {
-        self.future.is_empty()
-    }
-
-    /// Return the next update.
-    fn get(&self) -> Option<(&C::Time, &C::Time, C::Val<'a>, Diff)> {
-        self.future.last().map(|(t, m, v, r)| {
-            let (value, _) = self.edits.values[*v];
-            (t, m, value, *r)
-        })
-    }
-
-    /// Return the time of the next update.
-    fn get_time(&self) -> Option<&C::Time> {
-        self.future.last().map(|(t, _, _, _)| t)
-    }
-
-    /// Populate `future` with the updates stored in `edits`.
-    fn replay(&mut self) {
-        self.future.clear();
-        self.past.clear();
-
-        let values = &self.edits.values;
-        let edits = &self.edits.edits;
-        for (idx, (_, end)) in values.iter().enumerate() {
-            let start = if idx == 0 { 0 } else { values[idx - 1].1 };
-            for edit_idx in start..*end {
-                let (time, diff) = &edits[edit_idx];
-                self.future.push((time.clone(), time.clone(), idx, *diff));
-            }
-        }
-
-        self.future.sort_by(|x, y| y.cmp(x));
-
-        for idx in 1..self.future.len() {
-            self.future[idx].1 = self.future[idx].1.meet(&self.future[idx - 1].1);
-        }
-    }
-
-    /// Advance the history by moving the next entry from `future` into `past`.
-    fn step(&mut self) {
-        let (time, _, value_idx, diff) = self.future.pop().unwrap();
-        let (value, _) = self.edits.values[value_idx];
-        self.past.push((value, time, diff));
-    }
-
-    /// Advance all times in `past` by `meet`.
-    fn advance_past_by(&mut self, meet: &C::Time) {
-        for (_, time, _) in &mut self.past {
-            time.join_assign(meet);
-        }
-        consolidate_updates(&mut self.past);
-    }
-}
diff --git a/src/compute/src/render/reduce.rs b/src/compute/src/render/reduce.rs
index a5e8afcbb36fa..04f34970d84c6 100644
--- a/src/compute/src/render/reduce.rs
+++ b/src/compute/src/render/reduce.rs
@@ -11,8 +11,6 @@
 //!
 //! Consult [ReducePlan] documentation for details.
 
-use std::collections::BTreeMap;
-
 use columnation::{Columnation, CopyRegion};
 use dec::OrderedDecimal;
 use differential_dataflow::Diff as _;
@@ -23,6 +21,7 @@ use differential_dataflow::hashable::Hashable;
 use differential_dataflow::operators::arrange::{Arranged, TraceAgent};
 use differential_dataflow::trace::cursor::{BatchCursor, BatchDiff, BatchValOwn};
 use differential_dataflow::trace::implementations::BatchContainer;
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use differential_dataflow::trace::{Builder, Cursor, Navigable, Trace};
 use differential_dataflow::{Data, VecCollection};
 use itertools::Itertools;
@@ -38,10 +37,15 @@ use mz_ore::cast::CastLossy;
 use mz_repr::adt::numeric::{self, Numeric, NumericAgg};
 use mz_repr::fixed_length::ExtendDatums;
 use mz_repr::{Datum, DatumVec, Diff, Row, RowArena, SharedRow};
+use mz_row_spine::{
+    DatumContainer, DatumSeq, RowBatcher, RowBuilder, RowRowBatcher, RowRowBuilder, RowValBatcher,
+    RowValBuilder,
+};
 use mz_timely_util::columnation::ColumnationChunker;
 use mz_timely_util::operator::CollectionExt;
 use num_traits::Float;
 use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
 use timely::Container;
 use timely::container::{CapacityContainerBuilder, PushInto};
 use tracing::warn;
@@ -53,13 +57,10 @@ use crate::render::errors::DataflowErrorSer;
 use crate::render::errors::MaybeValidatingRow;
 use crate::render::reduce::monoids::{ReductionMonoid, get_monoid};
 use crate::render::{ArrangementFlavor, Pairer, RenderTimestamp};
+use crate::typedefs::ConsolidateBatcher;
 use crate::typedefs::{
-    ErrBatcher, ErrBuilder, KeyBatcher, RowErrBuilder, RowErrSpine, RowRowAgent, RowRowArrangement,
-    RowRowSpine, RowSpine, RowValSpine,
-};
-use mz_row_spine::{
-    DatumContainer, DatumSeq, RowBatcher, RowBuilder, RowRowBatcher, RowRowBuilder, RowValBatcher,
-    RowValBuilder,
+    ErrBatcher, RowErrBuilder, RowErrSpine, RowRowAgent, RowRowArrangement, RowRowSpine, RowSpine,
+    RowValSpine,
 };
 
 /// Key container of trace `Tr`'s batch cursor.
@@ -209,8 +210,9 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
             0..key_arity,
             ArrangementFlavor::Local(
                 arrangement,
-                errs.mz_arrange::<ColumnationChunker<_>, ErrBatcher<_, _>, ErrBuilder<_, _>, _>(
+                errs.mz_arrange::<ErrBatcher<_, _, ColumnationChunker<_>>, _>(
                     "Arrange bundle err",
+                    MergeBatcher::new,
                 ),
             ),
         )
@@ -300,13 +302,9 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
         let mfp_after2 = mfp_after.filter(|mfp| mfp.could_error());
 
         let arranged = collection
-            .mz_arrange::<
-                ColumnationChunker<_>,
-                RowRowBatcher<_, _>,
-                RowRowBuilder<_, _>,
-                RowRowSpine<_, _>,
-            >(
+            .mz_arrange::<RowRowBatcher<_, _, ColumnationChunker<_>>, RowRowSpine<_, _>>(
                 "Arranged DistinctBy",
+                MergeBatcher::new,
             );
         let output = arranged
             .clone()
@@ -410,13 +408,9 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
         let mfp_after2 = mfp_after.filter(|mfp| mfp.could_error());
 
         let arranged = differential_dataflow::collection::concatenate(input.scope(), to_collect)
-            .mz_arrange::<
-                ColumnationChunker<_>,
-                RowValBatcher<_, _, _>,
-                RowValBuilder<_, _, _>,
-                RowValSpine<_, _, _>,
-            >(
+            .mz_arrange::<RowValBatcher<_, _, _, ColumnationChunker<_>>, RowValSpine<_, _, _>>(
             "Arranged ReduceFuseBasic input",
+            MergeBatcher::new,
         );
 
         let output = arranged
@@ -576,14 +570,10 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
             "FusedReduceUnnestList"
         };
         let arranged = partial
-            .mz_arrange::<
-                ColumnationChunker<_>,
-                RowRowBatcher<_, _>,
-                RowRowBuilder<_, _>,
-                RowRowSpine<_, _>,
-            >(&format!(
-                "Arranged {name}"
-            ));
+            .mz_arrange::<RowRowBatcher<_, _, ColumnationChunker<_>>, RowRowSpine<_, _>>(
+                &format!("Arranged {name}"),
+                MergeBatcher::new,
+            );
         let oks = if !fused_unnest_list {
             arranged
                 .clone()
@@ -805,13 +795,9 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
         );
 
         let input: KeyCollection<_, _, _> = input.into();
-        let arranged = input.mz_arrange::<
-            ColumnationChunker<_>,
-            RowBatcher<_, _>,
-            RowBuilder<_, _>,
-            RowSpine<_, _>,
-        >(
+        let arranged = input.mz_arrange::<RowBatcher<_, _, ColumnationChunker<_>>, RowSpine<_, _>>(
             "Arranged ReduceInaccumulable Distinct [val: empty]",
+            MergeBatcher::new,
         );
         arranged.mz_reduce_abelian::<_, Bu, Tr, _>(&output_name, move |_, source, t| {
             if let Some(err) = BatchValOwn::<Tr>::into_error() {
@@ -940,13 +926,9 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
                 // NOTE(vmarcos): The input operator name below is used in the tuning advice built-in
                 // view mz_introspection.mz_expected_group_size_advice.
                 let arranged = partial
-                    .mz_arrange::<
-                        ColumnationChunker<_>,
-                        RowRowBatcher<_, _>,
-                        RowRowBuilder<_, _>,
-                        RowRowSpine<_, _>,
-                    >(
+                    .mz_arrange::<RowRowBatcher<_, _, ColumnationChunker<_>>, RowRowSpine<_, _>>(
                         "Arrange ReduceMinsMaxes",
+                        MergeBatcher::new,
                     );
                 // Note that we would prefer to use `mz_timely_util::reduce::ReduceExt::reduce_pair` here,
                 // but we then wouldn't be able to do this error check conditionally.  See its documentation
@@ -1151,13 +1133,9 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
         // NOTE(vmarcos): The input operator name below is used in the tuning advice built-in
         // view mz_introspection.mz_expected_group_size_advice.
         let arranged_input = input
-            .mz_arrange::<
-                ColumnationChunker<_>,
-                RowRowBatcher<_, _>,
-                RowRowBuilder<_, _>,
-                RowRowSpine<_, _>,
-            >(
+            .mz_arrange::<RowRowBatcher<_, _, ColumnationChunker<_>>, RowRowSpine<_, _>>(
                 "Arranged MinsMaxesHierarchical input",
+                MergeBatcher::new,
             );
 
         // Scratch buffer for decoding the input values (one column per aggregate) into the
@@ -1248,7 +1226,7 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
 
                 (key, values)
             })
-            .consolidate_named_if::<KeyBatcher<_, _, _>>(
+            .consolidate_named_if::<ConsolidateBatcher<_, _, _>>(
                 must_consolidate,
                 "Consolidated ReduceMonotonic input",
             );
@@ -1283,14 +1261,11 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
         let mfp_after2 = mfp_after.filter(|mfp| mfp.could_error());
 
         let partial: KeyCollection<_, _, _> = partial.into();
+        type MonoidSpine<T> = RowSpine<T, Vec<ReductionMonoid>>;
         let arranged = partial
-            .mz_arrange::<
-                ColumnationChunker<_>,
-                RowBatcher<_, _>,
-                RowBuilder<_, _>,
-                RowSpine<_, Vec<ReductionMonoid>>,
-            >(
+            .mz_arrange::<RowBatcher<_, _, ColumnationChunker<_>>, MonoidSpine<_>>(
                 "ArrangeMonotonic [val: empty]",
+                MergeBatcher::new,
             );
         let output = arranged
             .clone()
@@ -1440,13 +1415,9 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
                     let value = row.iter().nth(datum_index).unwrap();
                     (pairer.merge(&key, std::iter::once(value)), ())
                 })
-                .mz_arrange::<
-                    ColumnationChunker<_>,
-                    RowBatcher<_, _>,
-                    RowBuilder<_, _>,
-                    RowSpine<_, _>,
-                >(
+                .mz_arrange::<RowBatcher<_, _, ColumnationChunker<_>>, RowSpine<_, _>>(
                     "Arranged Accumulable Distinct [val: empty]",
+                    MergeBatcher::new,
                 )
                 .mz_reduce_abelian::<_, RowBuilder<_, _>, RowSpine<_, _>, _>(
                     "Reduced Accumulable Distinct [val: empty]",
@@ -1483,13 +1454,9 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
         let error_logger = self.error_logger();
         let err_full_aggrs = full_aggrs.clone();
         let arranged = collection
-            .mz_arrange::<
-                ColumnationChunker<_>,
-                RowBatcher<_, _>,
-                RowBuilder<_, _>,
-                RowSpine<_, (Vec<Accum>, Diff)>,
-            >(
+            .mz_arrange::<RowBatcher<_, _, ColumnationChunker<_>>, RowSpine<_, (Vec<Accum>, Diff)>>(
                 "ArrangeAccumulable [val: empty]",
+                MergeBatcher::new,
             );
         let arranged_output = arranged
             .clone()
diff --git a/src/compute/src/render/threshold.rs b/src/compute/src/render/threshold.rs
index df4b5b1bf05d6..ac60d40359605 100644
--- a/src/compute/src/render/threshold.rs
+++ b/src/compute/src/render/threshold.rs
@@ -14,6 +14,7 @@
 use differential_dataflow::operators::arrange::Arranged;
 use differential_dataflow::trace::Cursor;
 use differential_dataflow::trace::cursor::BatchCursor;
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use mz_compute_types::plan::scalar::LirScalarExpr;
 use mz_compute_types::plan::threshold::{BasicThresholdPlan, ThresholdPlan};
 use mz_repr::{Diff, Row, Timestamp};
@@ -24,7 +25,7 @@ use crate::extensions::arrange::{KeyCollection, MzArrange};
 use crate::extensions::reduce::MzReduce;
 use crate::render::RenderTimestamp;
 use crate::render::context::{ArrangementFlavor, CollectionBundle, Context};
-use crate::typedefs::{ErrBatcher, ErrBuilder, RowRowAgent, RowRowEnter, RowRowSpine};
+use crate::typedefs::{ErrBatcher, RowRowAgent, RowRowEnter, RowRowSpine};
 
 /// Thresholds a dataflow-local ok arrangement, keeping rows with a positive count.
 ///
@@ -87,10 +88,10 @@ pub fn build_threshold_basic<'scope, T: RenderTimestamp>(
         ArrangementFlavor::Trace(_, oks, errs) => {
             let oks = threshold_trace(oks, "Threshold trace");
             let errs: KeyCollection<_, _, _> = errs.as_collection(|k, _| k.clone()).into();
-            let errs = errs
-                .mz_arrange::<ColumnationChunker<_>, ErrBatcher<_, _>, ErrBuilder<_, _>, _>(
-                    "Arrange threshold basic err",
-                );
+            let errs = errs.mz_arrange::<ErrBatcher<_, _, ColumnationChunker<_>>, _>(
+                "Arrange threshold basic err",
+                MergeBatcher::new,
+            );
             CollectionBundle::from_expressions(key, ArrangementFlavor::Local(oks, errs))
         }
     }
diff --git a/src/compute/src/render/top_k.rs b/src/compute/src/render/top_k.rs
index 9810115be1bad..e0fbd5a0352bd 100644
--- a/src/compute/src/render/top_k.rs
+++ b/src/compute/src/render/top_k.rs
@@ -11,16 +11,13 @@
 //!
 //! Consult [TopKPlan] documentation for details.
 
-use std::cell::RefCell;
-use std::collections::BTreeMap;
-use std::rc::Rc;
-
 use differential_dataflow::AsCollection;
 use differential_dataflow::hashable::Hashable;
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::operators::arrange::{Arranged, TraceAgent};
 use differential_dataflow::operators::iterate::Variable as SemigroupVariable;
 use differential_dataflow::trace::cursor::{BatchCursor, BatchValOwn};
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use differential_dataflow::trace::{Builder, Cursor, Navigable, Trace};
 use differential_dataflow::{Data, VecCollection};
 use mz_compute_types::dyncfgs::{ENABLE_COMPUTE_TEMPORAL_BUCKETING, TEMPORAL_BUCKETING_SUMMARY};
@@ -35,12 +32,18 @@ use mz_ore::cast::CastFrom;
 use mz_ore::soft_assert_or_log;
 use mz_repr::fixed_length::ExtendDatums;
 use mz_repr::{Datum, DatumVec, Diff, ReprScalarType, Row, SharedRow};
+use mz_row_spine::{
+    DatumContainer, DatumSeq, RowBatcher, RowRowBatcher, RowRowBuilder, RowValBuilder, RowValSpine,
+};
 use mz_timely_util::columnation::ColumnationChunker;
 use mz_timely_util::operator::CollectionExt;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::rc::Rc;
 use timely::Container;
 use timely::container::{CapacityContainerBuilder, PushInto};
 use timely::dataflow::channels::pact::Pipeline;
-use timely::dataflow::operators::Operator;
+use timely::dataflow::operators::{Capability, Operator};
 
 use crate::extensions::arrange::{ArrangementSize, KeyCollection, MzArrange};
 use crate::extensions::reduce::{ClearContainer, MzReduce};
@@ -48,11 +51,8 @@ use crate::render::Pairer;
 use crate::render::context::{ArrangementFlavor, CollectionBundle, Context};
 use crate::render::errors::DataflowErrorSer;
 use crate::render::errors::MaybeValidatingRow;
-use crate::typedefs::{ErrBatcher, ErrBuilder, KeyBatcher, MzTimestamp, RowRowSpine, RowSpine};
-use mz_row_spine::{
-    DatumContainer, DatumSeq, RowBatcher, RowBuilder, RowRowBatcher, RowRowBuilder, RowValBuilder,
-    RowValSpine,
-};
+use crate::typedefs::ConsolidateBatcher;
+use crate::typedefs::{ErrBatcher, MzTimestamp, RowRowSpine, RowSpine};
 
 // The implementation requires integer timestamps to be able to delay feedback for monotonic inputs.
 impl<'scope, T: crate::render::RenderTimestamp + crate::render::MaybeBucketByTime>
@@ -176,8 +176,9 @@ impl<'scope, T: crate::render::RenderTimestamp + crate::render::MaybeBucketByTim
                     // the advertised permutation, exactly as for an index arrangement.
                     let errs: KeyCollection<_, _, _> = err_collection.clone().into();
                     let err_arrangement = errs
-                        .mz_arrange::<ColumnationChunker<_>, ErrBatcher<_, _>, ErrBuilder<_, _>, _>(
+                        .mz_arrange::<ErrBatcher<_, _, ColumnationChunker<_>>, _>(
                             "Arrange bundle err",
+                            MergeBatcher::new,
                         );
                     CollectionBundle::from_columns(
                         group_key.iter().copied(),
@@ -211,7 +212,7 @@ impl<'scope, T: crate::render::RenderTimestamp + crate::render::MaybeBucketByTim
                             };
                             (group_row, row)
                         })
-                        .consolidate_named_if::<KeyBatcher<_, _, _>>(
+                        .consolidate_named_if::<ConsolidateBatcher<_, _, _>>(
                             must_consolidate,
                             "Consolidated MonotonicTopK input",
                         );
@@ -271,7 +272,7 @@ impl<'scope, T: crate::render::RenderTimestamp + crate::render::MaybeBucketByTim
                     let (result, errs) =
                         self.build_topk_stage(thinned, order_key, 1u64, 0, limit, arity, false);
                     // Consolidate the output of `build_topk_stage` because it's not guaranteed to be.
-                    let result = CollectionExt::consolidate_named::<KeyBatcher<_, _, _>>(
+                    let result = CollectionExt::consolidate_named::<ConsolidateBatcher<_, _, _>>(
                         result,
                         "Monotonic TopK final consolidate",
                     );
@@ -405,8 +406,10 @@ impl<'scope, T: crate::render::RenderTimestamp + crate::render::MaybeBucketByTim
             collection, order_key, 1u64, offset, limit, arity, validating,
         );
         // Consolidate the output of `build_topk_stage` because it's not guaranteed to be.
-        let oks =
-            CollectionExt::consolidate_named::<KeyBatcher<_, _, _>>(oks, "TopK final consolidate");
+        let oks = CollectionExt::consolidate_named::<ConsolidateBatcher<_, _, _>>(
+            oks,
+            "TopK final consolidate",
+        );
         collection = oks;
         if validating {
             err_collection = errs;
@@ -553,7 +556,7 @@ impl<'scope, T: crate::render::RenderTimestamp + crate::render::MaybeBucketByTim
                     (group_key, row)
                 }
             })
-            .consolidate_named_if::<KeyBatcher<_, _, _>>(
+            .consolidate_named_if::<ConsolidateBatcher<_, _, _>>(
                 must_consolidate,
                 "Consolidated MonotonicTop1 input",
             );
@@ -580,26 +583,19 @@ impl<'scope, T: crate::render::RenderTimestamp + crate::render::MaybeBucketByTim
             })
             .into();
         let result = partial
-            .mz_arrange::<
-                ColumnationChunker<_>,
-                RowBatcher<_, _>,
-                RowBuilder<_, _>,
-                RowSpine<_, _>,
-            >(
+            .mz_arrange::<RowBatcher<_, _, ColumnationChunker<_>>, RowSpine<_, _>>(
                 "Arranged MonotonicTop1 partial [val: empty]",
+                MergeBatcher::new,
             )
-            .mz_reduce_abelian::<_, RowRowBuilder<_, _>, RowRowSpine<_, _>, _>(
-                "MonotonicTop1",
-                {
-                    let mut datum_vec = mz_repr::DatumVec::new();
-                    move |_key, input, output| {
-                        let accum: &monoids::Top1Monoid = &input[0].1;
-                        let datums = datum_vec.borrow_with(&accum.row);
-                        let value = SharedRow::pack(thinning.iter().map(|i| datums[*i]));
-                        output.push((value, Diff::ONE));
-                    }
-                },
-            );
+            .mz_reduce_abelian::<_, RowRowBuilder<_, _>, RowRowSpine<_, _>, _>("MonotonicTop1", {
+                let mut datum_vec = mz_repr::DatumVec::new();
+                move |_key, input, output| {
+                    let accum: &monoids::Top1Monoid = &input[0].1;
+                    let datums = datum_vec.borrow_with(&accum.row);
+                    let value = SharedRow::pack(thinning.iter().map(|i| datums[*i]));
+                    output.push((value, Diff::ONE));
+                }
+            });
         (result, errs)
     }
 }
@@ -646,13 +642,9 @@ where
     // built-in view mz_introspection.mz_expected_group_size_advice.
     let arranged = input
         .clone()
-        .mz_arrange::<
-            ColumnationChunker<_>,
-            RowRowBatcher<_, _>,
-            RowRowBuilder<_, _>,
-            RowRowSpine<_, _>,
-        >(
+        .mz_arrange::<RowRowBatcher<_, _, ColumnationChunker<_>>, RowRowSpine<_, _>>(
             "Arranged TopK input",
+            MergeBatcher::new,
         );
 
     // Eagerly evaluate literal limits.
@@ -785,19 +777,23 @@ where
         left: DatumVec::new(),
         right: DatumVec::new(),
     }));
+    // The capability to emit each buffered time under, held until the input frontier passes
+    // that time.
+    let mut capabilities: BTreeMap<T, Capability<T>> = BTreeMap::new();
+
     collection
         .inner
-        .unary_notify(
-            Pipeline,
-            "TopKIntraTimeThinning",
-            [],
-            move |input, output, notificator| {
-                input.for_each_time(|time, data| {
-                    let agg_time = aggregates
-                        .entry(time.time().clone())
-                        .or_insert_with(BTreeMap::new);
+        .unary_frontier(Pipeline, "TopKIntraTimeThinning", move |_cap, _info| {
+            move |(input, chain), output| {
+                input.for_each_stamp(|cap, data| {
+                    // Bucket by the record's own time rather than the message's: a message is
+                    // stamped by a multiset of capabilities, so it has no one time, and the
+                    // records already carry the time their output is emitted at.
                     for ((grp_row, row), record_time, diff) in data.flat_map(|data| data.drain(..))
                     {
+                        let agg_time = aggregates
+                            .entry(record_time.clone())
+                            .or_insert_with(BTreeMap::new);
                         let monoid = monoids::Top1MonoidLocal {
                             row,
                             shared: Rc::clone(&shared),
@@ -822,29 +818,43 @@ where
                         };
 
                         let topk = agg_time
-                            .entry((grp_row, record_time))
+                            .entry(grp_row)
                             .or_insert_with(move || topk_agg::TopKBatch::new(limit));
                         topk.update(monoid, diff.into_inner());
+                        // Each record's time is greater or equal to an element of the message's
+                        // stamp, so the capability can be delayed to it.
+                        capabilities
+                            .entry(record_time.clone())
+                            .or_insert_with(|| cap.delayed(&record_time, 0));
                     }
-                    notificator.notify_at(time.retain(0));
                 });
 
-                notificator.for_each(|time, _, _| {
-                    if let Some(aggs) = aggregates.remove(time.time()) {
-                        let mut session = output.session(&time);
-                        for ((grp_row, record_time), topk) in aggs {
-                            session.give_iterator(topk.into_iter().map(|(monoid, diff)| {
-                                (
-                                    (grp_row.clone(), monoid.into_row()),
-                                    record_time.clone(),
-                                    diff.into(),
-                                )
-                            }))
-                        }
+                // A time no longer in advance of the input frontier can receive no further
+                // updates, so its aggregate is final.
+                let frontier = chain.frontier();
+                let complete: Vec<_> = aggregates
+                    .keys()
+                    .filter(|time| !frontier.less_equal(time))
+                    .cloned()
+                    .collect();
+                for record_time in complete {
+                    let aggs = aggregates.remove(&record_time).expect("known to exist");
+                    let cap = capabilities
+                        .remove(&record_time)
+                        .expect("held for the time");
+                    let mut session = output.session(&cap);
+                    for (grp_row, topk) in aggs {
+                        session.give_iterator(topk.into_iter().map(|(monoid, diff)| {
+                            (
+                                (grp_row.clone(), monoid.into_row()),
+                                record_time.clone(),
+                                diff.into(),
+                            )
+                        }))
                     }
-                });
-            },
-        )
+                }
+            }
+        })
         .as_collection()
 }
 
diff --git a/src/compute/src/sink/copy_to_s3_oneshot.rs b/src/compute/src/sink/copy_to_s3_oneshot.rs
index 0b6a94d90e758..e5d1cd37867fa 100644
--- a/src/compute/src/sink/copy_to_s3_oneshot.rs
+++ b/src/compute/src/sink/copy_to_s3_oneshot.rs
@@ -7,10 +7,6 @@
 // the Business Source License, use of this software will be governed
 // by the Apache License, Version 2.0.
 
-use std::any::Any;
-use std::cell::RefCell;
-use std::rc::Rc;
-
 use differential_dataflow::{Hashable, VecCollection};
 use mz_compute_client::protocol::response::CopyToResponse;
 use mz_compute_types::dyncfgs::{
@@ -20,9 +16,11 @@ use mz_compute_types::dyncfgs::{
 use mz_compute_types::sinks::{ComputeSinkDesc, CopyToS3OneshotSinkConnection};
 use mz_repr::{Diff, GlobalId, Row, Timestamp};
 use mz_storage_types::controller::CollectionMetadata;
-use mz_timely_util::columnation::ColumnationChunker;
-use mz_timely_util::operator::consolidate_pact;
+use mz_timely_util::operator::{ConsolidatingBatcher, consolidate_pact};
 use mz_timely_util::probe::{Handle, ProbeNotify};
+use std::any::Any;
+use std::cell::RefCell;
+use std::rc::Rc;
 use timely::dataflow::channels::pact::{Exchange, Pipeline};
 use timely::dataflow::operators::Operator;
 use timely::progress::Antichain;
@@ -30,7 +28,7 @@ use timely::progress::Antichain;
 use crate::render::StartSignal;
 use crate::render::errors::DataflowErrorSer;
 use crate::render::sinks::SinkRender;
-use crate::typedefs::KeyBatcher;
+use crate::typedefs::ConsolidateBatcher;
 
 impl<'scope> SinkRender<'scope> for CopyToS3OneshotSinkConnection {
     fn render_sink(
@@ -62,20 +60,22 @@ impl<'scope> SinkRender<'scope> for CopyToS3OneshotSinkConnection {
 
         // We exchange the data according to batch, but we don't want to send the batch ID to the
         // sink. The sink can re-compute the batch ID from the data.
-        let input = consolidate_pact::<ColumnationChunker<_>, KeyBatcher<_, _, _>, _, _>(
+        let input = consolidate_pact::<ConsolidateBatcher<_, _, _>, _, _>(
             sinked_collection.map(move |row| (row, ())).inner,
             Exchange::new(move |((row, ()), _, _): &((Row, _), _, _)| row.hashed() % batch_count),
             "Consolidated COPY TO S3 input",
+            ConsolidatingBatcher::new,
         )
         .probe_notify_with(vec![output_probe.clone()]);
 
         // We need to consolidate the error collection to ensure we don't act on retracted errors.
-        let error = consolidate_pact::<ColumnationChunker<_>, KeyBatcher<_, _, _>, _, _>(
+        let error = consolidate_pact::<ConsolidateBatcher<_, _, _>, _, _>(
             err_collection.map(move |err| (err, ())).inner,
             Exchange::new(move |((err, _), _, _): &((DataflowErrorSer, _), _, _)| {
                 err.hashed() % batch_count
             }),
             "Consolidated COPY TO S3 errors",
+            ConsolidatingBatcher::new,
         );
 
         // We can only propagate the one error back to the client, so filter the error
@@ -87,8 +87,11 @@ impl<'scope> SinkRender<'scope> for CopyToS3OneshotSinkConnection {
                 let up_to = sink.up_to.clone();
                 let mut received_one = false;
                 move |(input, _), output| {
-                    input.for_each_time(|time, data| {
-                        if !up_to.less_equal(time.time()) && !received_one {
+                    input.for_each_stamp(|time, data| {
+                        // A message may carry an error before `up_to` if any time it is stamped
+                        // with is before `up_to`.
+                        let before_up_to = time.stamp().iter().any(|t| !up_to.less_equal(t));
+                        if before_up_to && !received_one {
                             received_one = true;
                             output.session(&time).give_iterator(
                                 data.flatten()
diff --git a/src/compute/src/sink/materialized_view_v2.rs b/src/compute/src/sink/materialized_view_v2.rs
index 5408d63142025..e5102f1353735 100644
--- a/src/compute/src/sink/materialized_view_v2.rs
+++ b/src/compute/src/sink/materialized_view_v2.rs
@@ -769,7 +769,10 @@ mod write {
 
                 // Accept batch descriptions.
                 descs_input.for_each(|cap, data| {
-                    let cap = cap.retain(0);
+                    // The `mint` operator above emits one `cap_set.delayed(..)` per message.
+                    let cap = cap
+                        .retain_least(0)
+                        .expect("message stamped with no capabilities");
                     for desc in data.drain(..) {
                         state.absorb_batch_description(desc, cap.clone());
                     }
diff --git a/src/compute/src/sink/refresh.rs b/src/compute/src/sink/refresh.rs
index dd383f33a5ae8..e4ed79ccd557a 100644
--- a/src/compute/src/sink/refresh.rs
+++ b/src/compute/src/sink/refresh.rs
@@ -55,7 +55,7 @@ where
                 let Some(capability) = capability.as_mut() else {
                     soft_panic_or_log!(
                         "should have a capability if we received data. input_cap: {:?}, frontier: {:?}",
-                        input_cap.time(),
+                        input_cap.stamp(),
                         frontiers[0].frontier()
                     );
                     return;
diff --git a/src/compute/src/typedefs.rs b/src/compute/src/typedefs.rs
index 0c71a624f5fbb..fac14f673aa09 100644
--- a/src/compute/src/typedefs.rs
+++ b/src/compute/src/typedefs.rs
@@ -18,9 +18,10 @@ use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use differential_dataflow::trace::wrappers::enter::TraceEnter;
 use differential_dataflow::trace::wrappers::frontier::TraceFrontier;
 use mz_repr::Diff;
-use mz_timely_util::columnation::ColInternalMerger;
-
 use mz_row_spine::RowValBuilder;
+use mz_timely_util::columnar::batcher::Chunker;
+use mz_timely_util::columnation::{ColInternalMerger, ColumnationChunker, ColumnationStack};
+use mz_timely_util::operator::ConsolidatingBatcher;
 
 use crate::render::errors::DataflowErrorSer;
 use crate::typedefs::spines::{ColKeyBatcher, ColKeyBuilder, ColValBatcher, ColValBuilder};
@@ -43,13 +44,14 @@ pub(crate) mod spines {
 
     /// A spine for generic keys and values.
     pub type ColValSpine<K, V, T, R> = Spine<ArcBatch<OrdValBatch<MzStack<((K, V), T, R)>>>>;
-    pub type ColValBatcher<K, V, T, R> = KeyValBatcher<K, V, T, R>;
+    pub type ColValBatcher<K, V, T, R, Chu> =
+        KeyValBatcher<K, V, T, R, Chu, ColValBuilder<K, V, T, R>>;
     pub type ColValBuilder<K, V, T, R> =
         ArcBuilder<OrdValBuilder<MzStack<((K, V), T, R)>, ColumnationStack<((K, V), T, R)>>>;
 
     /// A spine for generic keys
     pub type ColKeySpine<K, T, R> = Spine<ArcBatch<OrdKeyBatch<MzStack<((K, ()), T, R)>>>>;
-    pub type ColKeyBatcher<K, T, R> = KeyBatcher<K, T, R>;
+    pub type ColKeyBatcher<K, T, R, Chu> = KeyBatcher<K, T, R, Chu, ColKeyBuilder<K, T, R>>;
     pub type ColKeyBuilder<K, T, R> =
         ArcBuilder<OrdKeyBuilder<MzStack<((K, ()), T, R)>, ColumnationStack<((K, ()), T, R)>>>;
 
@@ -102,23 +104,36 @@ pub type RowEnter<T, R, TEnter> = TraceEnter<TraceFrontier<RowAgent<T, R>>, TEnt
 
 // Error specialized spines and agents.
 pub type ErrSpine<T, R> = ColKeySpine<DataflowErrorSer, T, R>;
-pub type ErrBatcher<T, R> = ColKeyBatcher<DataflowErrorSer, T, R>;
+pub type ErrBatcher<T, R, Chu> = ColKeyBatcher<DataflowErrorSer, T, R, Chu>;
 pub type ErrBuilder<T, R> = ColKeyBuilder<DataflowErrorSer, T, R>;
 
 pub type ErrAgent<T, R> = TraceAgent<ErrSpine<T, R>>;
 pub type ErrEnter<T, TEnter> = TraceEnter<TraceFrontier<ErrAgent<T, Diff>>, TEnter>;
 
 pub type KeyErrSpine<K, T, R> = ColValSpine<K, DataflowErrorSer, T, R>;
-pub type KeyErrBatcher<K, T, R> = ColValBatcher<K, DataflowErrorSer, T, R>;
+pub type KeyErrBatcher<K, T, R, Chu> = ColValBatcher<K, DataflowErrorSer, T, R, Chu>;
 pub type KeyErrBuilder<K, T, R> = ColValBuilder<K, DataflowErrorSer, T, R>;
 
 pub type RowErrSpine<T, R> = RowValSpine<DataflowErrorSer, T, R>;
-pub type RowErrBatcher<T, R> = RowValBatcher<DataflowErrorSer, T, R>;
+pub type RowErrBatcher<T, R, Chu> = RowValBatcher<DataflowErrorSer, T, R, Chu>;
 pub type RowErrBuilder<T, R> = RowValBuilder<DataflowErrorSer, T, R>;
 
-// Batchers for consolidation
-pub type KeyBatcher<K, T, D> = KeyValBatcher<K, (), T, D>;
-pub type KeyValBatcher<K, V, T, D> = MergeBatcher<ColInternalMerger<(K, V), T, D>>;
+// Batchers over columnation chains. `Chu` melds raw input into chunks, `Se` seals an
+// extracted chain: a spine builder to arrange it, `ChainSealer` to merely consolidate it.
+pub type KeyBatcher<K, T, D, Chu, Se> = KeyValBatcher<K, (), T, D, Chu, Se>;
+pub type KeyValBatcher<K, V, T, D, Chu, Se> =
+    MergeBatcher<Chu, ColInternalMerger<(K, V), T, D>, Se>;
+
+/// The batcher a consolidation wants: chunks `Vec` input, hands the chain back unsealed.
+pub type ConsolidateKeyValBatcher<K, V, T, D> =
+    ConsolidatingBatcher<ColumnationChunker<((K, V), T, D)>, ColInternalMerger<(K, V), T, D>>;
+/// [`ConsolidateKeyValBatcher`] with unit values.
+pub type ConsolidateBatcher<K, T, D> = ConsolidateKeyValBatcher<K, (), T, D>;
+/// [`ConsolidateKeyValBatcher`] over `Column` input rather than `Vec` input.
+pub type ConsolidateColumnBatcher<K, V, T, D> = ConsolidatingBatcher<
+    Chunker<ColumnationStack<((K, V), T, D)>>,
+    ColInternalMerger<(K, V), T, D>,
+>;
 
 /// Timestamp trait for rendering, constraint to support [`MzData`] and [timely::progress::Timestamp].
 pub trait MzTimestamp:
diff --git a/src/interchange/src/envelopes.rs b/src/interchange/src/envelopes.rs
index 80c002ace965d..eb5d53266cfbf 100644
--- a/src/interchange/src/envelopes.rs
+++ b/src/interchange/src/envelopes.rs
@@ -7,18 +7,17 @@
 // the Business Source License, use of this software will be governed
 // by the Apache License, Version 2.0.
 
-use std::collections::BTreeMap;
-use std::iter;
-use std::sync::LazyLock;
-
 use differential_dataflow::trace::implementations::BatchContainer;
-use differential_dataflow::trace::{BatchReader, Cursor, Navigable};
+use differential_dataflow::trace::{Cursor, Navigable};
 use itertools::EitherOrBoth;
 use maplit::btreemap;
 use mz_ore::cast::CastFrom;
 use mz_repr::{
     CatalogItemId, ColumnName, Datum, Diff, Row, RowPacker, SqlColumnType, SqlScalarType,
 };
+use std::collections::BTreeMap;
+use std::iter;
+use std::sync::LazyLock;
 use timely::progress::Antichain;
 
 use crate::avro::DiffPair;
@@ -29,7 +28,7 @@ use crate::avro::DiffPair;
 /// Thin wrapper around `iter_diff_pairs`.
 pub fn for_each_diff_pair<B, C, F>(batch: &B, mut on_diff_pair: F)
 where
-    B: BatchReader<Time = C::Time> + Navigable<Cursor = C>,
+    B: Navigable<Cursor = C>,
     C: Cursor<Storage = B, Diff = Diff>,
     C::Time: Copy,
     C::ValOwn: 'static,
@@ -52,7 +51,7 @@ pub async fn for_each_diff_pair_async<B, C, F, E>(
     mut on_diff_pair: F,
 ) -> Result<(), E>
 where
-    B: BatchReader<Time = C::Time> + Navigable<Cursor = C>,
+    B: Navigable<Cursor = C>,
     C: Cursor<Storage = B, Diff = Diff>,
     C::Time: Copy,
     C::ValOwn: 'static,
@@ -98,7 +97,7 @@ pub fn iter_diff_pairs<B, C>(
     ),
 >
 where
-    B: BatchReader<Time = C::Time> + Navigable<Cursor = C>,
+    B: Navigable<Cursor = C>,
     C: Cursor<Storage = B, Diff = Diff>,
     C::Time: Copy,
     C::ValOwn: 'static,
@@ -221,10 +220,10 @@ pub fn dbz_format(rp: &mut RowPacker, dp: DiffPair<Row>) {
 mod tests {
     use std::cell::Cell;
 
-    use differential_dataflow::trace::implementations::chunker::ContainerChunker;
+    use differential_dataflow::batcher::Batcher;
+    use differential_dataflow::trace::Builder;
     use differential_dataflow::trace::implementations::{ValBatcher, ValBuilder};
-    use differential_dataflow::trace::{Batcher, Builder};
-    use timely::container::{ContainerBuilder, PushInto};
+
     use timely::progress::Antichain;
 
     use super::*;
@@ -235,19 +234,14 @@ mod tests {
         mut tuples: Vec<((String, V), u64, Diff)>,
         upper: u64,
     ) -> <ValBuilder<String, V, u64, Diff> as Builder>::Output {
-        // The batcher consumes already-chunked input via `PushInto`; chunking
-        // is the caller's responsibility.
         let mut batcher = ValBatcher::<String, V, u64, Diff>::new(None, 0);
-        let mut chunker = ContainerChunker::<Vec<((String, V), u64, Diff)>>::default();
-        chunker.push_into(&mut tuples);
-        while let Some(chunk) = chunker.extract() {
-            batcher.push_into(std::mem::take(chunk));
-        }
-        while let Some(chunk) = chunker.finish() {
-            batcher.push_into(std::mem::take(chunk));
-        }
-        let (mut chain, description) = batcher.seal(Antichain::from_elem(upper));
-        ValBuilder::<String, V, u64, Diff>::seal(&mut chain, description)
+        // `Batcher` is generic in its input container, so name it.
+        Batcher::<Vec<((String, V), u64, Diff)>>::insert(&mut batcher, &mut tuples);
+        let (batch, _frontier) = Batcher::<Vec<((String, V), u64, Diff)>>::extract(
+            &mut batcher,
+            Antichain::from_elem(upper).borrow(),
+        );
+        batch.expect("updates were pushed, so the batch is non-empty")
     }
 
     /// `batch_from_tuples_with` pinned to `String` values, so call sites can
@@ -263,7 +257,7 @@ mod tests {
     /// sorted list for easy assertion.
     fn collect_diff_pairs<B, C>(batch: &B) -> Vec<(String, u64, Option<String>, Option<String>)>
     where
-        B: BatchReader<Time = C::Time> + Navigable<Cursor = C>,
+        B: Navigable<Cursor = C>,
         C: Cursor<Storage = B, Diff = Diff>,
         C::Time: Copy + Into<u64>,
         C::ValOwn: 'static + Into<String>,
@@ -290,7 +284,7 @@ mod tests {
         upper: Option<u64>,
     ) -> Vec<(String, Vec<(u64, Option<String>, Option<String>)>)>
     where
-        B: BatchReader<Time = u64> + Navigable<Cursor = C>,
+        B: Navigable<Cursor = C>,
         C: Cursor<Storage = B, Diff = Diff, Time = u64>,
         C::ValOwn: 'static + Into<String>,
         <C::KeyContainer as BatchContainer>::Owned: Into<String>,
diff --git a/src/persist-client/src/operators/shard_source.rs b/src/persist-client/src/operators/shard_source.rs
index fa5efad69df75..3c0f445ac861a 100644
--- a/src/persist-client/src/operators/shard_source.rs
+++ b/src/persist-client/src/operators/shard_source.rs
@@ -9,19 +9,6 @@
 
 //! A source that reads from a persist shard.
 
-use std::cell::RefCell;
-use std::collections::BTreeMap;
-use std::collections::VecDeque;
-use std::collections::hash_map::DefaultHasher;
-use std::convert::Infallible;
-use std::fmt::{Debug, Formatter};
-use std::future::Future;
-use std::hash::{Hash, Hasher};
-use std::pin::pin;
-use std::rc::Rc;
-use std::sync::Arc;
-use std::time::Instant;
-
 use anyhow::anyhow;
 use arrow::array::ArrayRef;
 use differential_dataflow::Hashable;
@@ -36,10 +23,22 @@ use mz_persist_types::{Codec, Codec64};
 use mz_timely_util::builder_async::{
     Event, OperatorBuilder as AsyncOperatorBuilder, PressOnDropButton,
 };
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::collections::VecDeque;
+use std::collections::hash_map::DefaultHasher;
+use std::convert::Infallible;
+use std::fmt::{Debug, Formatter};
+use std::future::Future;
+use std::hash::{Hash, Hasher};
+use std::pin::pin;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::time::Instant;
 use timely::PartialOrder;
 use timely::container::CapacityContainerBuilder;
 use timely::dataflow::channels::pact::{Exchange, Pipeline};
-use timely::dataflow::operators::{Capability, CapabilitySet, ConnectLoop, Enter, Feedback, Leave};
+use timely::dataflow::operators::{CapabilitySet, ConnectLoop, Enter, Feedback, Leave};
 use timely::dataflow::{Scope, StreamVec};
 use timely::order::TotalOrder;
 use timely::progress::frontier::AntichainRef;
@@ -658,7 +657,7 @@ where
     let (fetched_output, fetched_stream) = builder.new_output::<CapacityContainerBuilder<_>>();
     let (completed_fetches_output, completed_fetches_stream) =
         builder.new_output::<CapacityContainerBuilder<Vec<Infallible>>>();
-    let mut descs_input = builder.new_input_for_many(
+    let mut descs_input = builder.new_input_for_many_stamp(
         descs,
         Exchange::new(|&(i, _): &(usize, _)| u64::cast_from(i)),
         [&fetched_output, &completed_fetches_output],
@@ -704,7 +703,7 @@ where
         // come back with the result. The missing-blob diagnostics round-trip
         // happens inside the future, so the error surfaces only after the fetch
         // has truly failed.
-        let fetch_one = |caps: [Capability<TInner>; 2], part: ExchangeableBatchPart<T>| {
+        let fetch_one = |caps: [CapabilitySet<TInner>; 2], part: ExchangeableBatchPart<T>| {
             let mut fetcher = fetcher.clone();
             async move {
                 let reader_id = part.reader_id().clone();
@@ -748,7 +747,7 @@ where
         // worker via the completed-fetches feedback. Carrying capabilities
         // rather than a separate time-keyed map makes correctness independent of
         // the order results come back in.
-        let mut pending: VecDeque<([Capability<TInner>; 2], ExchangeableBatchPart<T>)> =
+        let mut pending: VecDeque<([CapabilitySet<TInner>; 2], ExchangeableBatchPart<T>)> =
             VecDeque::new();
         let mut in_flight = FuturesUnordered::new();
         let mut input_done = false;
@@ -1086,8 +1085,8 @@ mod tests {
                 // frontier downgrades are held back.
                 let mut max_msg_time: Option<u64> = None;
                 while let Ok(event) = receiver.try_recv() {
-                    if let CaptureEvent::Messages(time, _) = event {
-                        max_msg_time = max_msg_time.max(Some(time));
+                    if let CaptureEvent::Messages(stamp, _) = event {
+                        max_msg_time = max_msg_time.max(stamp.iter().copied().max());
                     }
                 }
                 max_msg_time
@@ -1590,9 +1589,9 @@ mod tests {
             let mut blob_count = 0;
             let mut max_time: Option<u64> = None;
             while let Ok(event) = capture.try_recv() {
-                if let CaptureEvent::Messages(time, msgs) = event {
+                if let CaptureEvent::Messages(stamp, msgs) = event {
                     blob_count += msgs.len();
-                    max_time = max_time.max(Some(time));
+                    max_time = max_time.max(stamp.iter().copied().max());
                 }
             }
             (blob_count, max_time)
diff --git a/src/row-spine/src/arc_batch.rs b/src/row-spine/src/arc_batch.rs
index 5d37b8dd836aa..e2b35588bc267 100644
--- a/src/row-spine/src/arc_batch.rs
+++ b/src/row-spine/src/arc_batch.rs
@@ -15,7 +15,7 @@
 //! thread.
 //!
 //! The blanket `impl Trait for Arc<B>` that would express this lives outside this crate: both `Arc`
-//! and differential's `Batch`/`Builder`/`Merger`/`Cursor` traits are foreign, so the orphan rule
+//! and differential's `SpineBatch`/`Builder`/`Merger`/`Cursor` traits are foreign, so the orphan rule
 //! forbids it here. [`ArcBatch`] is a local newtype around `Arc<B>` that carries those impls
 //! instead. The impls delegate straight through to the inner batch, so `ArcBatch<B>` behaves
 //! exactly like `B` except that its handle is atomically reference counted.
@@ -24,12 +24,11 @@
 //! here as a newtype lets cross-thread arrangement sharing build against a released
 //! differential-dataflow, with no differential-side `Arc` batch impls required.
 
+use differential_dataflow::trace::implementations::merge_batcher::Sealer;
+use differential_dataflow::trace::implementations::spine_fueled::{Merger, SpineBatch};
+use differential_dataflow::trace::{Builder, Cursor, Navigable};
 use std::sync::Arc;
-
-use differential_dataflow::trace::{
-    Batch, BatchReader, Builder, Cursor, Description, Merger, Navigable,
-};
-use timely::progress::{Antichain, frontier::AntichainRef};
+use timely::progress::frontier::AntichainRef;
 
 /// An `Arc`-backed batch, shareable across threads when `B`'s contents are `Send + Sync`.
 ///
@@ -61,7 +60,7 @@ impl<B> std::ops::Deref for ArcBatch<B> {
     }
 }
 
-impl<B: BatchReader + Navigable> Navigable for ArcBatch<B> {
+impl<B: Navigable> Navigable for ArcBatch<B> {
     type Cursor = ArcBatchCursor<B::Cursor>;
     fn cursor(&self) -> Self::Cursor {
         // Disambiguate to the inner batch's cursor, reached through the `Deref`, so the wrapper's
@@ -70,14 +69,12 @@ impl<B: BatchReader + Navigable> Navigable for ArcBatch<B> {
     }
 }
 
-impl<B: BatchReader> BatchReader for ArcBatch<B> {
+impl<B: SpineBatch> SpineBatch for ArcBatch<B> {
     type Time = B::Time;
+    type Merger = ArcMerger<B>;
     fn len(&self) -> usize {
         self.0.len()
     }
-    fn description(&self) -> &Description<Self::Time> {
-        self.0.description()
-    }
 }
 
 /// Cursor over an [`ArcBatch`], delegating to the inner batch's cursor.
@@ -170,70 +167,69 @@ impl<C: Cursor> Cursor for ArcBatchCursor<C> {
     }
 }
 
-impl<B: Batch> Batch for ArcBatch<B> {
-    type Merger = ArcMerger<B>;
-    fn empty(lower: Antichain<Self::Time>, upper: Antichain<Self::Time>) -> Self {
-        ArcBatch::new(B::empty(lower, upper))
-    }
-}
-
 /// Builds [`ArcBatch`]es, delegating to the inner batch's builder.
-pub struct ArcBuilder<B: Builder> {
+pub struct ArcBuilder<B> {
     builder: B,
 }
 
-impl<B: Builder> Builder for ArcBuilder<B> {
-    type Input = B::Input;
-    type Time = B::Time;
-    type Output = ArcBatch<B::Output>;
-    fn with_capacity(keys: usize, vals: usize, upds: usize) -> Self {
+impl<B: Default> Default for ArcBuilder<B> {
+    fn default() -> Self {
         ArcBuilder {
-            builder: B::with_capacity(keys, vals, upds),
+            builder: B::default(),
         }
     }
+}
+
+impl<B: Builder + Default> Builder for ArcBuilder<B> {
+    type Input = B::Input;
+    type Time = B::Time;
+    type Output = ArcBatch<B::Output>;
     fn push(&mut self, input: &mut Self::Input) {
         self.builder.push(input)
     }
-    fn done(self, description: Description<Self::Time>) -> ArcBatch<B::Output> {
-        ArcBatch::new(self.builder.done(description))
+    fn done(self) -> Option<ArcBatch<B::Output>> {
+        self.builder.done().map(ArcBatch::new)
     }
-    fn seal(chain: &mut Vec<Self::Input>, description: Description<Self::Time>) -> Self::Output {
-        ArcBatch::new(B::seal(chain, description))
+}
+
+impl<C, B: Sealer<C>> Sealer<C> for ArcBuilder<B> {
+    type Output = ArcBatch<B::Output>;
+    fn seal(chain: &mut Vec<C>) -> Option<Self::Output> {
+        B::seal(chain).map(ArcBatch::new)
     }
 }
 
 /// Merges [`ArcBatch`]es, delegating to the inner batch's merger.
-pub struct ArcMerger<B: Batch> {
+pub struct ArcMerger<B: SpineBatch> {
     merger: B::Merger,
 }
 
-impl<B: Batch> Merger<ArcBatch<B>> for ArcMerger<B> {
+impl<B: SpineBatch> Merger<ArcBatch<B>> for ArcMerger<B> {
     fn new(
         source1: &ArcBatch<B>,
         source2: &ArcBatch<B>,
         compaction_frontier: AntichainRef<B::Time>,
     ) -> Self {
         ArcMerger {
-            merger: B::begin_merge(&source1.0, &source2.0, compaction_frontier),
+            merger: B::Merger::new(&source1.0, &source2.0, compaction_frontier),
         }
     }
     fn work(&mut self, source1: &ArcBatch<B>, source2: &ArcBatch<B>, fuel: &mut isize) {
         self.merger.work(&source1.0, &source2.0, fuel)
     }
-    fn done(self) -> ArcBatch<B> {
-        ArcBatch::new(self.merger.done())
+    fn done(self) -> Option<ArcBatch<B>> {
+        self.merger.done().map(ArcBatch::new)
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use differential_dataflow::batcher::Batcher;
+    use differential_dataflow::trace::Navigable;
     use differential_dataflow::trace::cursor::Cursor;
-    use differential_dataflow::trace::implementations::ord_neu::OrdValBatcher;
-    use differential_dataflow::trace::{Batcher, Builder, Navigable};
-    use timely::container::PushInto;
     use timely::progress::Antichain;
 
-    use crate::ArcOrdValBuilder;
+    use crate::ArcOrdValBatcher;
 
     /// An `ArcBatch`'s cursor can be constructed and read from a thread other than the one that
     /// built it, proving the newtype's batches are usable across a thread boundary. This is the
@@ -247,10 +243,14 @@ mod tests {
     fn arc_batch_reads_from_other_thread() {
         fn assert_send_sync<T: Send + Sync>(_: &T) {}
 
-        let mut batcher = OrdValBatcher::<u64, u64, usize, i64>::new(None, 0);
-        batcher.push_into(vec![((1, 2), 0, 1), ((2, 3), 1, 1)]);
-        let (mut chain, description) = batcher.seal(Antichain::from_elem(2));
-        let batch = ArcOrdValBuilder::<u64, u64, usize, i64>::seal(&mut chain, description);
+        let mut batcher = ArcOrdValBatcher::<u64, u64, usize, i64>::new(None, 0);
+        let mut updates: Vec<((u64, u64), usize, i64)> = vec![((1, 2), 0, 1), ((2, 3), 1, 1)];
+        Batcher::<Vec<((u64, u64), usize, i64)>>::insert(&mut batcher, &mut updates);
+        let (batch, _frontier) = Batcher::<Vec<((u64, u64), usize, i64)>>::extract(
+            &mut batcher,
+            Antichain::from_elem(2).borrow(),
+        );
+        let batch = batch.expect("updates were pushed, so the batch is non-empty");
 
         assert_send_sync(&batch);
 
diff --git a/src/row-spine/src/lib.rs b/src/row-spine/src/lib.rs
index a64795a1c3008..0a70a9f202100 100644
--- a/src/row-spine/src/lib.rs
+++ b/src/row-spine/src/lib.rs
@@ -18,9 +18,10 @@ pub use self::dictionary::DatumContainer;
 pub use self::dictionary::DatumSeq;
 pub use self::offset_opt::OffsetOptimized;
 pub use self::spines::{
-    ArcOrdKeyBuilder, ArcOrdKeySpine, ArcOrdValBuilder, ArcOrdValSpine, RowBatcher, RowBuilder,
-    RowRowBatcher, RowRowBuilder, RowRowColPagedBuilder, RowRowSpine, RowSpine, RowValBatcher,
-    RowValBuilder, RowValSpine, ValRowBatcher, ValRowBuilder, ValRowColPagedBuilder, ValRowSpine,
+    ArcOrdKeyBatcher, ArcOrdKeyBuilder, ArcOrdKeySpine, ArcOrdValBatcher, ArcOrdValBuilder,
+    ArcOrdValSpine, RowBatcher, RowBuilder, RowRowBatcher, RowRowBuilder, RowRowColPagedBuilder,
+    RowRowSpine, RowSpine, RowValBatcher, RowValBuilder, RowValSpine, ValRowBatcher, ValRowBuilder,
+    ValRowColPagedBuilder, ValRowSpine,
 };
 
 mod arc_batch;
@@ -37,7 +38,9 @@ mod spines {
     use differential_dataflow::trace::implementations::Layout;
     use differential_dataflow::trace::implementations::Update;
     use differential_dataflow::trace::implementations::Vector;
-    use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
+    use differential_dataflow::trace::implementations::merge_batcher::{
+        MergeBatcher, chunker::ContainerChunker, vec::VecMerger,
+    };
     use differential_dataflow::trace::implementations::ord_neu::{
         OrdKeyBatch, OrdKeyBuilder, OrdValBatch, OrdValBuilder,
     };
@@ -50,11 +53,12 @@ mod spines {
 
     /// Batcher matching `mz_compute::typedefs::KeyValBatcher`, redeclared
     /// locally so this crate does not need to depend on `mz_compute`.
-    type KeyValBatcher<K, V, T, D> = MergeBatcher<ColInternalMerger<(K, V), T, D>>;
-    type KeyBatcher<K, T, D> = KeyValBatcher<K, (), T, D>;
+    type KeyValBatcher<K, V, T, D, Chu, Se> =
+        MergeBatcher<Chu, ColInternalMerger<(K, V), T, D>, Se>;
+    type KeyBatcher<K, T, D, Chu, Se> = KeyValBatcher<K, (), T, D, Chu, Se>;
 
     pub type RowRowSpine<T, R> = Spine<ArcBatch<OrdValBatch<RowRowLayout<((Row, Row), T, R)>>>>;
-    pub type RowRowBatcher<T, R> = KeyValBatcher<Row, Row, T, R>;
+    pub type RowRowBatcher<T, R, Chu> = KeyValBatcher<Row, Row, T, R, Chu, RowRowBuilder<T, R>>;
     pub type RowRowBuilder<T, R> = ArcBuilder<crate::dictionary::builders::RowRowBuilder<T, R>>;
 
     /// `RowRowBuilder` variant that consumes [`Column`] chunks. Pairs with any
@@ -72,16 +76,16 @@ mod spines {
         ArcBuilder<crate::dictionary::builders::RowRowColPagedBuilder<T, R>>;
 
     pub type RowValSpine<V, T, R> = Spine<ArcBatch<OrdValBatch<RowValLayout<((Row, V), T, R)>>>>;
-    pub type RowValBatcher<V, T, R> = KeyValBatcher<Row, V, T, R>;
+    pub type RowValBatcher<V, T, R, Chu> = KeyValBatcher<Row, V, T, R, Chu, RowValBuilder<V, T, R>>;
     pub type RowValBuilder<V, T, R> =
         ArcBuilder<crate::dictionary::builders::RowValBuilder<V, T, R>>;
 
     pub type RowSpine<T, R> = Spine<ArcBatch<OrdKeyBatch<RowLayout<((Row, ()), T, R)>>>>;
-    pub type RowBatcher<T, R> = KeyBatcher<Row, T, R>;
+    pub type RowBatcher<T, R, Chu> = KeyBatcher<Row, T, R, Chu, RowBuilder<T, R>>;
     pub type RowBuilder<T, R> = ArcBuilder<crate::dictionary::builders::RowBuilder<T, R>>;
 
     pub type ValRowSpine<K, T, R> = Spine<ArcBatch<OrdValBatch<ValRowLayout<((K, Row), T, R)>>>>;
-    pub type ValRowBatcher<K, T, R> = KeyValBatcher<K, Row, T, R>;
+    pub type ValRowBatcher<K, T, R, Chu> = KeyValBatcher<K, Row, T, R, Chu, ValRowBuilder<K, T, R>>;
     pub type ValRowBuilder<K, T, R> =
         ArcBuilder<crate::dictionary::builders::ValRowBuilder<K, T, R>>;
 
@@ -108,6 +112,18 @@ mod spines {
     /// Builder pairing with [`ArcOrdKeySpine`].
     pub type ArcOrdKeyBuilder<K, T, R> =
         ArcBuilder<OrdKeyBuilder<Vector<((K, ()), T, R)>, Vec<((K, ()), T, R)>>>;
+    /// Batcher pairing with [`ArcOrdValSpine`], over `Vec` input.
+    pub type ArcOrdValBatcher<K, V, T, R> = MergeBatcher<
+        ContainerChunker<Vec<((K, V), T, R)>>,
+        VecMerger<(K, V), T, R>,
+        ArcOrdValBuilder<K, V, T, R>,
+    >;
+    /// Batcher pairing with [`ArcOrdKeySpine`], over `Vec` input.
+    pub type ArcOrdKeyBatcher<K, T, R> = MergeBatcher<
+        ContainerChunker<Vec<((K, ()), T, R)>>,
+        VecMerger<(K, ()), T, R>,
+        ArcOrdKeyBuilder<K, T, R>,
+    >;
 
     /// A layout based on timely stacks
     pub struct RowRowLayout<U: Update<Key = Row, Val = Row>> {
@@ -902,7 +918,7 @@ mod dictionary {
         use differential_dataflow::difference::Semigroup;
         use differential_dataflow::lattice::Lattice;
         use differential_dataflow::trace::Builder;
-        use differential_dataflow::trace::Description;
+        use differential_dataflow::trace::implementations::merge_batcher::Sealer;
         use differential_dataflow::trace::implementations::ord_neu::{OrdKeyBatch, OrdKeyBuilder};
         use differential_dataflow::trace::implementations::ord_neu::{OrdValBatch, OrdValBuilder};
         use mz_timely_util::columnar::Column;
@@ -957,15 +973,10 @@ mod dictionary {
             type Time = T;
             type Output = OrdValBatch<RowRowLayout<((Row, Row), T, R)>>;
 
-            fn with_capacity(keys: usize, vals: usize, upds: usize) -> Self {
-                Self {
-                    inner: Builder::with_capacity(keys, vals, upds),
-                }
-            }
             fn push(&mut self, chunk: &mut Self::Input) {
                 self.inner.push(chunk)
             }
-            fn done(self, description: Description<Self::Time>) -> Self::Output {
+            fn done(self) -> Option<Self::Output> {
                 // The push/done build path (e.g. the `reduce` operator, which builds
                 // batches with `Builder::new()` + `push` + `done` rather than `seal`)
                 // never runs `seal`'s codec install. Install a codec here from the
@@ -976,12 +987,39 @@ mod dictionary {
                 let mut inner = self.inner;
                 inner.result.keys.promote_stats_to_codec();
                 inner.result.vals.vals.promote_stats_to_codec();
-                inner.done(description)
+                inner.done()
+            }
+        }
+
+        impl<T: Lattice + Timestamp + Columnation, R: Ord + Semigroup + Columnation + 'static>
+            RowRowBuilder<T, R>
+        {
+            /// Allocates a builder sized for the counts a chain reports.
+            ///
+            /// TODO(differential): the counts are dropped on the floor. The inner builder's
+            /// `with_capacity` is private to differential, so a wrapping builder cannot pre-size
+            /// it and every seal re-pays the grow cycle.
+            fn with_capacity(_keys: usize, _vals: usize, _upds: usize) -> Self {
+                Self {
+                    inner: Default::default(),
+                }
             }
-            fn seal(
-                chain: &mut Vec<Self::Input>,
-                description: Description<Self::Time>,
-            ) -> Self::Output {
+        }
+
+        impl<T: Lattice + Timestamp + Columnation, R: Ord + Semigroup + Columnation + 'static>
+            Default for RowRowBuilder<T, R>
+        {
+            fn default() -> Self {
+                Self::with_capacity(0, 0, 0)
+            }
+        }
+
+        impl<T: Lattice + Timestamp + Columnation, R: Ord + Semigroup + Columnation + 'static>
+            Sealer<TimelyStack<((Row, Row), T, R)>> for RowRowBuilder<T, R>
+        {
+            type Output = OrdValBatch<RowRowLayout<((Row, Row), T, R)>>;
+
+            fn seal(chain: &mut Vec<TimelyStack<((Row, Row), T, R)>>) -> Option<Self::Output> {
                 let key_codec = build_codec(
                     chain
                         .iter()
@@ -993,9 +1031,9 @@ mod dictionary {
                         .flat_map(|link| link.iter().map(|((_, v), _, _)| v)),
                 );
 
-                use differential_dataflow::trace::implementations::BuilderInput;
+                use differential_dataflow::trace::implementations::ord_neu::BuilderInput;
 
-                let (keys, vals, upds) = <Self::Input as BuilderInput<
+                let (keys, vals, upds) = <TimelyStack<((Row, Row), T, R)> as BuilderInput<
                     DatumContainer,
                     DatumContainer,
                 >>::key_val_upd_counts(&chain[..]);
@@ -1012,7 +1050,7 @@ mod dictionary {
                     builder.push(&mut chunk);
                 }
 
-                builder.done(description)
+                builder.done()
             }
         }
 
@@ -1034,34 +1072,65 @@ mod dictionary {
             type Time = T;
             type Output = OrdValBatch<RowValLayout<((Row, V), T, R)>>;
 
-            fn with_capacity(keys: usize, vals: usize, upds: usize) -> Self {
-                Self {
-                    inner: Builder::with_capacity(keys, vals, upds),
-                }
-            }
             fn push(&mut self, chunk: &mut Self::Input) {
                 self.inner.push(chunk)
             }
-            fn done(self, description: Description<Self::Time>) -> Self::Output {
+            fn done(self) -> Option<Self::Output> {
                 // See `RowRowBuilder::done`: install a codec on the `Row`-shaped key
                 // container for the push/done (e.g. `reduce`) path that skips `seal`.
                 let mut inner = self.inner;
                 inner.result.keys.promote_stats_to_codec();
-                inner.done(description)
+                inner.done()
+            }
+        }
+
+        impl<
+            V: Ord + Clone + Columnation,
+            T: Lattice + Timestamp + Columnation,
+            R: Ord + Semigroup + Columnation + 'static,
+        > RowValBuilder<V, T, R>
+        {
+            /// Allocates a builder sized for the counts a chain reports.
+            ///
+            /// TODO(differential): the counts are dropped on the floor. The inner builder's
+            /// `with_capacity` is private to differential, so a wrapping builder cannot pre-size
+            /// it and every seal re-pays the grow cycle.
+            fn with_capacity(_keys: usize, _vals: usize, _upds: usize) -> Self {
+                Self {
+                    inner: Default::default(),
+                }
+            }
+        }
+
+        impl<
+            V: Ord + Clone + Columnation,
+            T: Lattice + Timestamp + Columnation,
+            R: Ord + Semigroup + Columnation + 'static,
+        > Default for RowValBuilder<V, T, R>
+        {
+            fn default() -> Self {
+                Self::with_capacity(0, 0, 0)
             }
-            fn seal(
-                chain: &mut Vec<Self::Input>,
-                description: Description<Self::Time>,
-            ) -> Self::Output {
+        }
+
+        impl<
+            V: Ord + Clone + Columnation,
+            T: Lattice + Timestamp + Columnation,
+            R: Ord + Semigroup + Columnation + 'static,
+        > Sealer<TimelyStack<((Row, V), T, R)>> for RowValBuilder<V, T, R>
+        {
+            type Output = OrdValBatch<RowValLayout<((Row, V), T, R)>>;
+
+            fn seal(chain: &mut Vec<TimelyStack<((Row, V), T, R)>>) -> Option<Self::Output> {
                 let key_codec = build_codec(
                     chain
                         .iter()
                         .flat_map(|link| link.iter().map(|((k, _), _, _)| k)),
                 );
 
-                use differential_dataflow::trace::implementations::BuilderInput;
+                use differential_dataflow::trace::implementations::ord_neu::BuilderInput;
 
-                let (keys, vals, upds) = <Self::Input as BuilderInput<
+                let (keys, vals, upds) = <TimelyStack<((Row, V), T, R)> as BuilderInput<
                     DatumContainer,
                     TimelyStack<V>,
                 >>::key_val_upd_counts(&chain[..]);
@@ -1074,7 +1143,7 @@ mod dictionary {
                     builder.push(&mut chunk);
                 }
 
-                builder.done(description)
+                builder.done()
             }
         }
 
@@ -1092,34 +1161,56 @@ mod dictionary {
             type Time = T;
             type Output = OrdKeyBatch<RowLayout<((Row, ()), T, R)>>;
 
-            fn with_capacity(keys: usize, vals: usize, upds: usize) -> Self {
-                Self {
-                    inner: Builder::with_capacity(keys, vals, upds),
-                }
-            }
             fn push(&mut self, chunk: &mut Self::Input) {
                 self.inner.push(chunk)
             }
-            fn done(self, description: Description<Self::Time>) -> Self::Output {
+            fn done(self) -> Option<Self::Output> {
                 // See `RowRowBuilder::done`: install a codec on the `Row`-shaped key
                 // container for the push/done (e.g. `reduce`) path that skips `seal`.
                 let mut inner = self.inner;
                 inner.result.keys.promote_stats_to_codec();
-                inner.done(description)
+                inner.done()
+            }
+        }
+
+        impl<T: Lattice + Timestamp + Columnation, R: Ord + Semigroup + Columnation + 'static>
+            RowBuilder<T, R>
+        {
+            /// Allocates a builder sized for the counts a chain reports.
+            ///
+            /// TODO(differential): the counts are dropped on the floor. The inner builder's
+            /// `with_capacity` is private to differential, so a wrapping builder cannot pre-size
+            /// it and every seal re-pays the grow cycle.
+            fn with_capacity(_keys: usize, _vals: usize, _upds: usize) -> Self {
+                Self {
+                    inner: Default::default(),
+                }
+            }
+        }
+
+        impl<T: Lattice + Timestamp + Columnation, R: Ord + Semigroup + Columnation + 'static>
+            Default for RowBuilder<T, R>
+        {
+            fn default() -> Self {
+                Self::with_capacity(0, 0, 0)
             }
-            fn seal(
-                chain: &mut Vec<Self::Input>,
-                description: Description<Self::Time>,
-            ) -> Self::Output {
+        }
+
+        impl<T: Lattice + Timestamp + Columnation, R: Ord + Semigroup + Columnation + 'static>
+            Sealer<TimelyStack<((Row, ()), T, R)>> for RowBuilder<T, R>
+        {
+            type Output = OrdKeyBatch<RowLayout<((Row, ()), T, R)>>;
+
+            fn seal(chain: &mut Vec<TimelyStack<((Row, ()), T, R)>>) -> Option<Self::Output> {
                 let key_codec = build_codec(
                     chain
                         .iter()
                         .flat_map(|link| link.iter().map(|((k, _), _, _)| k)),
                 );
 
-                use differential_dataflow::trace::implementations::BuilderInput;
+                use differential_dataflow::trace::implementations::ord_neu::BuilderInput;
 
-                let (keys, vals, upds) = <Self::Input as BuilderInput<
+                let (keys, vals, upds) = <TimelyStack<((Row, ()), T, R)> as BuilderInput<
                     DatumContainer,
                     TimelyStack<()>,
                 >>::key_val_upd_counts(&chain[..]);
@@ -1132,7 +1223,7 @@ mod dictionary {
                     builder.push(&mut chunk);
                 }
 
-                builder.done(description)
+                builder.done()
             }
         }
 
@@ -1157,34 +1248,65 @@ mod dictionary {
             type Time = T;
             type Output = OrdValBatch<ValRowLayout<((K, Row), T, R)>>;
 
-            fn with_capacity(keys: usize, vals: usize, upds: usize) -> Self {
-                Self {
-                    inner: Builder::with_capacity(keys, vals, upds),
-                }
-            }
             fn push(&mut self, chunk: &mut Self::Input) {
                 self.inner.push(chunk)
             }
-            fn done(self, description: Description<Self::Time>) -> Self::Output {
+            fn done(self) -> Option<Self::Output> {
                 // See `RowRowBuilder::done`: install a codec on the `Row`-shaped value
                 // container for the push/done (e.g. `reduce`) path that skips `seal`.
                 let mut inner = self.inner;
                 inner.result.vals.vals.promote_stats_to_codec();
-                inner.done(description)
+                inner.done()
+            }
+        }
+
+        impl<
+            K: Ord + Clone + Columnation,
+            T: Lattice + Timestamp + Columnation,
+            R: Ord + Semigroup + Columnation + 'static,
+        > ValRowBuilder<K, T, R>
+        {
+            /// Allocates a builder sized for the counts a chain reports.
+            ///
+            /// TODO(differential): the counts are dropped on the floor. The inner builder's
+            /// `with_capacity` is private to differential, so a wrapping builder cannot pre-size
+            /// it and every seal re-pays the grow cycle.
+            fn with_capacity(_keys: usize, _vals: usize, _upds: usize) -> Self {
+                Self {
+                    inner: Default::default(),
+                }
+            }
+        }
+
+        impl<
+            K: Ord + Clone + Columnation,
+            T: Lattice + Timestamp + Columnation,
+            R: Ord + Semigroup + Columnation + 'static,
+        > Default for ValRowBuilder<K, T, R>
+        {
+            fn default() -> Self {
+                Self::with_capacity(0, 0, 0)
             }
-            fn seal(
-                chain: &mut Vec<Self::Input>,
-                description: Description<Self::Time>,
-            ) -> Self::Output {
+        }
+
+        impl<
+            K: Ord + Clone + Columnation,
+            T: Lattice + Timestamp + Columnation,
+            R: Ord + Semigroup + Columnation + 'static,
+        > Sealer<TimelyStack<((K, Row), T, R)>> for ValRowBuilder<K, T, R>
+        {
+            type Output = OrdValBatch<ValRowLayout<((K, Row), T, R)>>;
+
+            fn seal(chain: &mut Vec<TimelyStack<((K, Row), T, R)>>) -> Option<Self::Output> {
                 let val_codec = build_codec(
                     chain
                         .iter()
                         .flat_map(|link| link.iter().map(|((_, v), _, _)| v)),
                 );
 
-                use differential_dataflow::trace::implementations::BuilderInput;
+                use differential_dataflow::trace::implementations::ord_neu::BuilderInput;
 
-                let (keys, vals, upds) = <Self::Input as BuilderInput<
+                let (keys, vals, upds) = <TimelyStack<((K, Row), T, R)> as BuilderInput<
                     TimelyStack<K>,
                     DatumContainer,
                 >>::key_val_upd_counts(&chain[..]);
@@ -1197,7 +1319,7 @@ mod dictionary {
                     builder.push(&mut chunk);
                 }
 
-                builder.done(description)
+                builder.done()
             }
         }
 
@@ -1222,21 +1344,49 @@ mod dictionary {
             type Time = T;
             type Output = OrdValBatch<RowRowLayout<((Row, Row), T, R)>>;
 
-            fn with_capacity(keys: usize, vals: usize, upds: usize) -> Self {
-                Self {
-                    inner: Builder::with_capacity(keys, vals, upds),
-                }
-            }
             fn push(&mut self, chunk: &mut Self::Input) {
                 self.inner.push(chunk)
             }
-            fn done(self, description: Description<Self::Time>) -> Self::Output {
-                self.inner.done(description)
+            fn done(self) -> Option<Self::Output> {
+                self.inner.done()
+            }
+        }
+
+        impl<
+            T: Lattice + Timestamp + Columnation + Columnar,
+            R: Ord + Semigroup + Columnation + Columnar + Clone + 'static,
+        > RowRowColPagedBuilder<T, R>
+        {
+            /// Allocates a builder sized for the counts a chain reports.
+            ///
+            /// TODO(differential): the counts are dropped on the floor. The inner builder's
+            /// `with_capacity` is private to differential, so a wrapping builder cannot pre-size
+            /// it and every seal re-pays the grow cycle.
+            fn with_capacity(_keys: usize, _vals: usize, _upds: usize) -> Self {
+                Self {
+                    inner: Default::default(),
+                }
             }
-            fn seal(
-                chain: &mut Vec<Self::Input>,
-                description: Description<Self::Time>,
-            ) -> Self::Output {
+        }
+
+        impl<
+            T: Lattice + Timestamp + Columnation + Columnar,
+            R: Ord + Semigroup + Columnation + Columnar + Clone + 'static,
+        > Default for RowRowColPagedBuilder<T, R>
+        {
+            fn default() -> Self {
+                Self::with_capacity(0, 0, 0)
+            }
+        }
+
+        impl<
+            T: Lattice + Timestamp + Columnation + Columnar,
+            R: Ord + Semigroup + Columnation + Columnar + Clone + 'static,
+        > Sealer<Column<((Row, Row), T, R)>> for RowRowColPagedBuilder<T, R>
+        {
+            type Output = OrdValBatch<RowRowLayout<((Row, Row), T, R)>>;
+
+            fn seal(chain: &mut Vec<Column<((Row, Row), T, R)>>) -> Option<Self::Output> {
                 // `into_index_iter` yields the value column's `Row`s as `&RowRef`,
                 // which `build_codec` consumes directly.
                 let key_codec = build_codec(
@@ -1250,9 +1400,9 @@ mod dictionary {
                         .flat_map(|c| c.borrow().into_index_iter().map(|((_, v), _, _)| v)),
                 );
 
-                use differential_dataflow::trace::implementations::BuilderInput;
+                use differential_dataflow::trace::implementations::ord_neu::BuilderInput;
 
-                let (keys, vals, upds) = <Self::Input as BuilderInput<
+                let (keys, vals, upds) = <Column<((Row, Row), T, R)> as BuilderInput<
                     DatumContainer,
                     DatumContainer,
                 >>::key_val_upd_counts(&chain[..]);
@@ -1268,7 +1418,7 @@ mod dictionary {
                     builder.push(&mut chunk);
                 }
 
-                builder.done(description)
+                builder.done()
             }
         }
 
@@ -1297,30 +1447,73 @@ mod dictionary {
             type Time = T;
             type Output = OrdValBatch<ValRowLayout<((K, Row), T, R)>>;
 
-            fn with_capacity(keys: usize, vals: usize, upds: usize) -> Self {
-                Self {
-                    inner: Builder::with_capacity(keys, vals, upds),
-                }
-            }
             fn push(&mut self, chunk: &mut Self::Input) {
                 self.inner.push(chunk)
             }
-            fn done(self, description: Description<Self::Time>) -> Self::Output {
-                self.inner.done(description)
+            fn done(self) -> Option<Self::Output> {
+                self.inner.done()
+            }
+        }
+
+        impl<
+            K: Ord + Clone + Columnation + Columnar + 'static,
+            T: Lattice + Timestamp + Columnation + Columnar,
+            R: Ord + Semigroup + Columnation + Columnar + Clone + 'static,
+        > ValRowColPagedBuilder<K, T, R>
+        where
+            for<'a> columnar::Ref<'a, K>: Copy + Ord,
+            for<'a, 'b> &'a K: PartialEq<columnar::Ref<'b, K>>,
+            for<'a> TimelyStack<K>: timely::container::PushInto<columnar::Ref<'a, K>>,
+        {
+            /// Allocates a builder sized for the counts a chain reports.
+            ///
+            /// TODO(differential): the counts are dropped on the floor. The inner builder's
+            /// `with_capacity` is private to differential, so a wrapping builder cannot pre-size
+            /// it and every seal re-pays the grow cycle.
+            fn with_capacity(_keys: usize, _vals: usize, _upds: usize) -> Self {
+                Self {
+                    inner: Default::default(),
+                }
+            }
+        }
+
+        impl<
+            K: Ord + Clone + Columnation + Columnar + 'static,
+            T: Lattice + Timestamp + Columnation + Columnar,
+            R: Ord + Semigroup + Columnation + Columnar + Clone + 'static,
+        > Default for ValRowColPagedBuilder<K, T, R>
+        where
+            for<'a> columnar::Ref<'a, K>: Copy + Ord,
+            for<'a, 'b> &'a K: PartialEq<columnar::Ref<'b, K>>,
+            for<'a> TimelyStack<K>: timely::container::PushInto<columnar::Ref<'a, K>>,
+        {
+            fn default() -> Self {
+                Self::with_capacity(0, 0, 0)
             }
-            fn seal(
-                chain: &mut Vec<Self::Input>,
-                description: Description<Self::Time>,
-            ) -> Self::Output {
+        }
+
+        impl<
+            K: Ord + Clone + Columnation + Columnar + 'static,
+            T: Lattice + Timestamp + Columnation + Columnar,
+            R: Ord + Semigroup + Columnation + Columnar + Clone + 'static,
+        > Sealer<Column<((K, Row), T, R)>> for ValRowColPagedBuilder<K, T, R>
+        where
+            for<'a> columnar::Ref<'a, K>: Copy + Ord,
+            for<'a, 'b> &'a K: PartialEq<columnar::Ref<'b, K>>,
+            for<'a> TimelyStack<K>: timely::container::PushInto<columnar::Ref<'a, K>>,
+        {
+            type Output = OrdValBatch<ValRowLayout<((K, Row), T, R)>>;
+
+            fn seal(chain: &mut Vec<Column<((K, Row), T, R)>>) -> Option<Self::Output> {
                 let val_codec = build_codec(
                     chain
                         .iter()
                         .flat_map(|c| c.borrow().into_index_iter().map(|((_, v), _, _)| v)),
                 );
 
-                use differential_dataflow::trace::implementations::BuilderInput;
+                use differential_dataflow::trace::implementations::ord_neu::BuilderInput;
 
-                let (keys, vals, upds) = <Self::Input as BuilderInput<
+                let (keys, vals, upds) = <Column<((K, Row), T, R)> as BuilderInput<
                     TimelyStack<K>,
                     DatumContainer,
                 >>::key_val_upd_counts(&chain[..]);
@@ -1333,7 +1526,7 @@ mod dictionary {
                     builder.push(&mut chunk);
                 }
 
-                builder.done(description)
+                builder.done()
             }
         }
     }
diff --git a/src/storage-operators/src/oneshot_source.rs b/src/storage-operators/src/oneshot_source.rs
index 87e91eadf5aa8..3a7b083f24c51 100644
--- a/src/storage-operators/src/oneshot_source.rs
+++ b/src/storage-operators/src/oneshot_source.rs
@@ -335,7 +335,7 @@ pub fn render_split_work<'scope, T, S, F>(
     PressOnDropButton,
 )
 where
-    T: timely::progress::Timestamp,
+    T: timely::progress::Timestamp + timely::order::TotalOrder,
     S: OneshotSource + Send + Sync + 'static,
     F: OneshotFormat + Send + Sync + 'static,
 {
@@ -407,7 +407,7 @@ pub fn render_fetch_work<'scope, T, S, F>(
     PressOnDropButton,
 )
 where
-    T: timely::progress::Timestamp,
+    T: timely::progress::Timestamp + timely::order::TotalOrder,
     S: OneshotSource + Sync + 'static,
     F: OneshotFormat + Sync + 'static,
 {
@@ -474,7 +474,7 @@ pub fn render_decode_chunk<'scope, T, F>(
     PressOnDropButton,
 )
 where
-    T: timely::progress::Timestamp,
+    T: timely::progress::Timestamp + timely::order::TotalOrder,
     F: OneshotFormat + 'static,
 {
     let mut builder = AsyncOperatorBuilder::new("CopyFrom-decode_chunk".to_string(), scope.clone());
@@ -556,7 +556,7 @@ pub fn render_stage_batches_operator<'scope, T>(
     PressOnDropButton,
 )
 where
-    T: timely::progress::Timestamp,
+    T: timely::progress::Timestamp + timely::order::TotalOrder,
 {
     let persist_location = collection_meta.persist_location.clone();
     let shard_id = collection_meta.data_shard;
diff --git a/src/storage-operators/src/persist_source.rs b/src/storage-operators/src/persist_source.rs
index ab10d44ce5e2b..990e199cf21db 100644
--- a/src/storage-operators/src/persist_source.rs
+++ b/src/storage-operators/src/persist_source.rs
@@ -503,7 +503,11 @@ where
 
         move |_frontier| {
             fetched_input.for_each(|time, data| {
-                let capability = time.retain(0);
+                // The scope is totally ordered, so the least of the message's capabilities
+                // dominates the rest and alone suffices to hold the fetched parts.
+                let capability = time
+                    .retain_least(0)
+                    .expect("message stamped with no capabilities");
                 for fetched_blob in data.drain(..) {
                     pending_work.push_back(PendingWork {
                         panic_on_audit_failure: panic_on_audit_failure.get(),
@@ -865,7 +869,10 @@ where
                     }
                     break;
                 }
-                Some(Event::Data(time, data)) => {
+                Some(Event::Data(stamp, data)) => {
+                    // Backpressure accounts a part against the time at which it can first cause
+                    // downstream work, which is the least time the message is stamped with.
+                    let time = stamp.least().expect("message stamped with no capabilities");
                     for d in data {
                         parts.push((time.clone(), d));
                     }
@@ -1496,7 +1503,7 @@ mod tests {
     /// being processed. Also connects the `feedback` handle to its output.
     fn consumer_operator<
         'scope,
-        T: timely::progress::Timestamp,
+        T: timely::progress::Timestamp + timely::order::TotalOrder,
         O: Backpressureable + std::fmt::Debug,
     >(
         scope: Scope<'scope, T>,
diff --git a/src/storage/src/decode.rs b/src/storage/src/decode.rs
index d013b3608221a..c547eeb3cc952 100644
--- a/src/storage/src/decode.rs
+++ b/src/storage/src/decode.rs
@@ -515,7 +515,7 @@ pub fn render_decode_delimited<'scope, T: Timestamp, FromTime: Timestamp>(
     let mut builder = AsyncOperatorBuilder::new(op_name, input.scope());
 
     let (output_handle, output) = builder.new_output::<CapacityContainerBuilder<_>>();
-    let mut input = builder.new_input_for(input.inner, Exchange::new(dist), &output_handle);
+    let mut input = builder.new_input_for_stamp(input.inner, Exchange::new(dist), &output_handle);
 
     let (_, transient_errors) = builder.build_fallible(move |caps| {
         Box::pin(async move {
diff --git a/src/storage/src/render/persist_sink.rs b/src/storage/src/render/persist_sink.rs
index b915a9fa74b8e..652c9f8797e8c 100644
--- a/src/storage/src/render/persist_sink.rs
+++ b/src/storage/src/render/persist_sink.rs
@@ -121,7 +121,7 @@ use timely::PartialOrder;
 use timely::container::CapacityContainerBuilder;
 use timely::dataflow::channels::pact::{Exchange, Pipeline};
 use timely::dataflow::operators::vec::Broadcast;
-use timely::dataflow::operators::{Capability, CapabilitySet, InspectCore};
+use timely::dataflow::operators::{Capability, CapabilitySet, Inspect};
 use timely::dataflow::{Scope, Stream, StreamVec};
 use timely::progress::{Antichain, Timestamp};
 use tokio::sync::Semaphore;
@@ -847,15 +847,15 @@ fn write_batches<'scope>(
         }
     });
 
-    // Use `InspectCore::inspect_container` instead of `Inspect::inspect`.
-    // `Inspect` carries a `where for<'a> &'a C: IntoIterator` bound, and on
-    // macOS the solver can satisfy that bound by chasing objc2's
-    // `&Retained<T>: IntoIterator` blanket impl into an endless
-    // `Retained<Retained<…>>` chain, overflowing the recursion limit.
-    // `InspectCore` has no such bound, so the cascade never starts. We
-    // iterate the container by hand to recover the per-item callback.
+    // Use `inspect_core` instead of `inspect`. `inspect` carries a
+    // `where for<'a> &'a C: IntoIterator` bound, and on macOS the solver can
+    // satisfy that bound by chasing objc2's `&Retained<T>: IntoIterator`
+    // blanket impl into an endless `Retained<Retained<…>>` chain, overflowing
+    // the recursion limit. `inspect_core` has no such bound, so the cascade
+    // never starts. We iterate the container by hand to recover the per-item
+    // callback.
     let output_stream = if collection_id.is_user() {
-        InspectCore::inspect_container(output_stream, |event| {
+        Inspect::inspect_core(output_stream, |event| {
             if let Ok((_, data)) = event {
                 for d in data {
                     trace!("batch: {:?}", d);
diff --git a/src/storage/src/render/sinks.rs b/src/storage/src/render/sinks.rs
index c0d44acf083ec..19c8fd7514d63 100644
--- a/src/storage/src/render/sinks.rs
+++ b/src/storage/src/render/sinks.rs
@@ -9,21 +9,20 @@
 
 //! Logic related to the creation of dataflow sinks.
 
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-
-use differential_dataflow::operators::arrange::{Arrange, Arranged, TraceAgent};
-use differential_dataflow::trace::TraceReader;
-use differential_dataflow::trace::implementations::ord_neu::OrdValBatcher;
+use differential_dataflow::operators::arrange::{Arranged, TraceAgent};
+use differential_dataflow::trace::SpanOf;
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use differential_dataflow::{AsCollection, Hashable, VecCollection};
 use mz_persist_client::operators::shard_source::SnapshotMode;
 use mz_repr::{Datum, Diff, GlobalId, Row, Timestamp};
-use mz_row_spine::{ArcOrdValBuilder, ArcOrdValSpine};
+use mz_row_spine::{ArcOrdValBatcher, ArcOrdValSpine};
 use mz_storage_operators::persist_source;
 use mz_storage_types::controller::CollectionMetadata;
 use mz_storage_types::errors::DataflowError;
 use mz_storage_types::sinks::{StorageSinkConnection, StorageSinkDesc};
 use mz_timely_util::builder_async::PressOnDropButton;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
 use timely::dataflow::operators::Leave;
 use timely::dataflow::{Scope, StreamVec};
 use tracing::warn;
@@ -43,8 +42,7 @@ pub(crate) type SinkTrace = TraceAgent<ArcOrdValSpine<Option<Row>, Row, Timestam
 /// a `TraceAgent` alive. Dropping the reader lets the spine's compaction
 /// frontiers advance to the empty antichain, so the arrange operator can
 /// aggressively compact / release batch state as updates flow through.
-pub(crate) type SinkBatchStream<'scope> =
-    StreamVec<'scope, Timestamp, <SinkTrace as TraceReader>::Batch>;
+pub(crate) type SinkBatchStream<'scope> = StreamVec<'scope, Timestamp, SpanOf<SinkTrace>>;
 
 /// _Renders_ complete _differential_ collections
 /// that represent the sink and its errors as requested
@@ -147,7 +145,11 @@ fn arrange_sink_input<'scope>(
     // Allow access to `arrange_named` because we cannot access Mz's wrapper
     // from here. TODO(database-issues#5046): Revisit with cluster unification.
     #[allow(clippy::disallowed_methods)]
-    let Arranged {stream, trace: _} = keyed.arrange_named::<OrdValBatcher<_, _, _, _>, ArcOrdValBuilder<_, _, _, _>, ArcOrdValSpine<_, _, _, _>>("Arrange Sink");
+    let Arranged { stream, trace: _ } = keyed
+        .arrange_named::<ArcOrdValBatcher<_, _, _, _>, ArcOrdValSpine<_, _, _, _>>(
+            "Arrange Sink",
+            MergeBatcher::new,
+        );
     stream
 }
 
diff --git a/src/storage/src/server.rs b/src/storage/src/server.rs
index 86c3d99718f6a..c46298589b523 100644
--- a/src/storage/src/server.rs
+++ b/src/storage/src/server.rs
@@ -9,9 +9,6 @@
 
 //! An interactive dataflow server.
 
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-
 use mz_cluster::client::{ClusterClient, ClusterSpec};
 use mz_cluster_client::client::TimelyConfig;
 use mz_ore::metrics::MetricsRegistry;
@@ -23,9 +20,12 @@ use mz_storage_client::client::{StorageClient, StorageCommand, StorageResponse};
 use mz_storage_types::connections::ConnectionContext;
 use mz_timely_util::capture::EventLink;
 use mz_txn_wal::operator::TxnsContext;
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
 use timely::logging::{
     ChannelsEvent, MessagesEvent, OperatesEvent, ScheduleEvent, ShutdownEvent, TimelyEvent,
 };
+use timely::progress::Stamp;
 use timely::worker::Worker as TimelyWorker;
 use tokio::sync::mpsc;
 use uuid::Uuid;
@@ -166,7 +166,8 @@ impl ClusterSpec for Config {
                             remap_timely_event_ids(event);
                             true
                         });
-                        event_pusher.push(Event::Messages(time_ms, data));
+                        // One capability per logged batch: the stamp is a singleton.
+                        event_pusher.push(Event::Messages(Stamp::from_elem(time_ms), data));
                     } else {
                         // Advance progress.
                         let new_time_ms: u64 = (((time.as_millis() / interval_ms) + 1)
diff --git a/src/storage/src/sink/iceberg.rs b/src/storage/src/sink/iceberg.rs
index eb6526aea0ddf..5cc1728376477 100644
--- a/src/storage/src/sink/iceberg.rs
+++ b/src/storage/src/sink/iceberg.rs
@@ -82,18 +82,12 @@
 //! table's metadata to reflect the new snapshots, including updating the
 //! `mz-frontier` property to track progress.
 
-use std::cmp::Ordering;
-use std::collections::VecDeque;
-use std::convert::Infallible;
-use std::future::Future;
-use std::time::Instant;
-use std::{cell::RefCell, rc::Rc, sync::Arc};
-
 use anyhow::{Context, anyhow};
 use arrow::array::{ArrayRef, Int32Array, Int64Array, RecordBatch};
 use arrow::datatypes::{DataType, Field, Schema as ArrowSchema};
-use differential_dataflow::trace::BatchReader;
+use differential_dataflow::trace::Span;
 use differential_dataflow::trace::implementations::ord_neu::OrdValBatch;
+use differential_dataflow::trace::implementations::spine_fueled::SpineBatch;
 use differential_dataflow::trace::implementations::{BatchContainer, Layout};
 use differential_dataflow::{Hashable, VecCollection};
 use futures::StreamExt;
@@ -148,6 +142,12 @@ use mz_timely_util::builder_async::{Event, OperatorBuilder, PressOnDropButton};
 use parquet::arrow::PARQUET_FIELD_ID_META_KEY;
 use parquet::file::properties::WriterProperties;
 use serde::{Deserialize, Serialize};
+use std::cmp::Ordering;
+use std::collections::VecDeque;
+use std::convert::Infallible;
+use std::future::Future;
+use std::time::Instant;
+use std::{cell::RefCell, rc::Rc, sync::Arc};
 use timely::PartialOrder;
 use timely::container::CapacityContainerBuilder;
 use timely::dataflow::StreamVec;
@@ -1647,7 +1647,8 @@ fn write_data_files<'scope, H: EnvelopeHandler + 'static>(
                 // Rows can arrive before their batch description due to dataflow parallelism.
                 // Stash them until we know which batch they belong to.
                 // Keyed by the lower bound (per arrangement batch) of the rows.
-                let mut stashed_rows: VecDeque<ArcBatch<OrdValBatch<_>>> = VecDeque::new();
+                let mut stashed_rows: VecDeque<Span<Timestamp, ArcBatch<OrdValBatch<_>>>> =
+                    VecDeque::new();
 
                 // Track batches currently being written. When a row arrives, we check if it belongs
                 // to an in-flight batch. When frontiers advance to a batch's upper, we close the
@@ -1751,7 +1752,10 @@ fn write_data_files<'scope, H: EnvelopeHandler + 'static>(
                     }
 
                     metrics.stashed_rows.set(u64::cast_from(
-                        stashed_rows.iter().map(|rows| rows.len()).sum::<usize>(),
+                        stashed_rows
+                            .iter()
+                            .map(|rows| rows.inner.as_ref().map_or(0, |b| b.len()))
+                            .sum::<usize>(),
                     ));
 
                     // Operator Recipe Steps 2-4: Consult frontiers. Plan work. Do all the work.
@@ -1761,10 +1765,14 @@ fn write_data_files<'scope, H: EnvelopeHandler + 'static>(
                     let mut staged_messages_since_flush: u64 = 0;
 
                     // How to write rows from a(n arrangement) batch into a(n Iceberg) batch.
-                    let write_rows = async |rows: &OrdValBatch<_>,
+                    let write_rows = async |rows: &Span<Timestamp, ArcBatch<OrdValBatch<_>>>,
                                             (lower, upper): BatchDescription,
                                             batch_writer: &mut Box<dyn IcebergWriter>|
                            -> Result<(), anyhow::Error> {
+                        // A span with no updates has no rows to write.
+                        let Some(rows) = &rows.inner else {
+                            return Ok(());
+                        };
                         for_each_diff_pair_async(
                             rows,
                             Some(lower),
@@ -1857,7 +1865,10 @@ fn write_data_files<'scope, H: EnvelopeHandler + 'static>(
                         statistics.inc_messages_staged_by(staged_messages_since_flush);
                     }
                     metrics.stashed_rows.set(u64::cast_from(
-                        stashed_rows.iter().map(|rows| rows.len()).sum::<usize>(),
+                        stashed_rows
+                            .iter()
+                            .map(|rows| rows.inner.as_ref().map_or(0, |b| b.len()))
+                            .sum::<usize>(),
                     ));
                 }
                 Ok(())
@@ -1888,7 +1899,7 @@ type BatchDescription = (Antichain<Timestamp>, Antichain<Timestamp>);
 /// are in order and non-overlapping.
 async fn with_ready_batches<L: Layout, W, Write, Close>(
     input_frontier: Antichain<Timestamp>,
-    input_batches: &mut VecDeque<ArcBatch<OrdValBatch<L>>>,
+    input_batches: &mut VecDeque<Span<Timestamp, ArcBatch<OrdValBatch<L>>>>,
     output_frontier: Antichain<Timestamp>,
     output_batches: &mut VecDeque<(BatchDescription, W)>,
     mut write_rows: Write,
@@ -1896,7 +1907,11 @@ async fn with_ready_batches<L: Layout, W, Write, Close>(
 ) -> Result<(), anyhow::Error>
 where
     L::TimeContainer: BatchContainer<Owned = Timestamp>,
-    Write: AsyncFnMut(&OrdValBatch<L>, BatchDescription, &mut W) -> Result<(), anyhow::Error>,
+    Write: AsyncFnMut(
+        &Span<Timestamp, ArcBatch<OrdValBatch<L>>>,
+        BatchDescription,
+        &mut W,
+    ) -> Result<(), anyhow::Error>,
     Close: AsyncFnMut(BatchDescription, &mut W) -> Result<(), anyhow::Error>,
 {
     loop {
@@ -2262,8 +2277,10 @@ mod tests {
     }
 
     mod with_ready_batches {
-        use differential_dataflow::trace::Batch;
+        use differential_dataflow::batcher::Batcher;
+        use differential_dataflow::trace::Description;
         use differential_dataflow::trace::implementations::Vector;
+        use mz_row_spine::ArcOrdValBatcher;
 
         use super::*;
 
@@ -2279,11 +2296,25 @@ mod tests {
             (frontier(Some(lower)), frontier(upper))
         }
 
-        /// An input batch with the given bounds. The pairing logic under test
-        /// only looks at bounds, so the batch holds no data.
-        fn input(lower: u64, upper: Option<u64>) -> ArcBatch<TestBatch> {
+        /// An input span with the given bounds.
+        ///
+        /// The pairing logic only looks at bounds, but a span with no updates carries no batch
+        /// and so is never written, so this seals one update at the span's lower bound.
+        fn input(lower: u64, upper: Option<u64>) -> Span<Timestamp, ArcBatch<TestBatch>> {
             let (lower, upper) = span(lower, upper);
-            ArcBatch(Arc::new(TestBatch::empty(lower, upper)))
+            let mut updates = vec![(
+                (0u64, 0u64),
+                Timestamp::new(lower.elements()[0].into()),
+                Diff::ONE,
+            )];
+            let mut batcher = ArcOrdValBatcher::<u64, u64, Timestamp, Diff>::new(None, 0);
+            Batcher::<Vec<((u64, u64), Timestamp, Diff)>>::insert(&mut batcher, &mut updates);
+            let (batch, _frontier) = Batcher::<Vec<((u64, u64), Timestamp, Diff)>>::extract(
+                &mut batcher,
+                upper.borrow(),
+            );
+            let since = Antichain::from_elem(Timestamp::MIN);
+            Span::new(Description::new(lower, upper, since), batch)
         }
 
         #[derive(Debug, PartialEq)]
@@ -2297,7 +2328,7 @@ mod tests {
         /// sequence of calls it made.
         async fn run(
             input_frontier: Antichain<Timestamp>,
-            input_batches: &mut VecDeque<ArcBatch<TestBatch>>,
+            input_batches: &mut VecDeque<Span<Timestamp, ArcBatch<TestBatch>>>,
             output_frontier: Antichain<Timestamp>,
             output_batches: &mut VecDeque<(BatchDescription, ())>,
         ) -> Vec<Call> {
@@ -2307,7 +2338,7 @@ mod tests {
                 input_batches,
                 output_frontier,
                 output_batches,
-                async |rows: &TestBatch, desc, _writer: &mut ()| {
+                async |rows: &Span<Timestamp, ArcBatch<TestBatch>>, desc, _writer: &mut ()| {
                     let bounds = (rows.lower().clone(), rows.upper().clone());
                     calls.borrow_mut().push(Call::Write(bounds, desc));
                     Ok(())
diff --git a/src/storage/src/sink/kafka.rs b/src/storage/src/sink/kafka.rs
index 4e989affb7b50..66163440bca45 100644
--- a/src/storage/src/sink/kafka.rs
+++ b/src/storage/src/sink/kafka.rs
@@ -71,20 +71,6 @@
 //!
 //! [1]: https://github.com/confluentinc/librdkafka/blob/master/INTRODUCTION.md#message-reliability
 
-use std::cell::RefCell;
-use std::cmp::Ordering;
-use std::collections::BTreeMap;
-use std::future::Future;
-use std::rc::Rc;
-use std::sync::atomic::AtomicU64;
-use std::sync::{Arc, Weak};
-use std::time::Duration;
-
-use crate::healthcheck::{HealthStatusMessage, HealthStatusUpdate, StatusNamespace};
-use crate::metrics::sink::kafka::KafkaSinkMetrics;
-use crate::render::sinks::{PkViolationWarner, SinkBatchStream, SinkRender};
-use crate::statistics::SinkStatistics;
-use crate::storage_state::StorageState;
 use anyhow::{Context, anyhow, bail};
 use differential_dataflow::{AsCollection, Hashable, VecCollection};
 use futures::StreamExt;
@@ -136,6 +122,14 @@ use rdkafka::producer::{BaseRecord, Producer, ThreadedProducer};
 use rdkafka::types::RDKafkaErrorCode;
 use rdkafka::{Message, Offset, Statistics, TopicPartitionList};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::cell::RefCell;
+use std::cmp::Ordering;
+use std::collections::BTreeMap;
+use std::future::Future;
+use std::rc::Rc;
+use std::sync::atomic::AtomicU64;
+use std::sync::{Arc, Weak};
+use std::time::Duration;
 use timely::PartialOrder;
 use timely::container::CapacityContainerBuilder;
 use timely::dataflow::StreamVec;
@@ -147,6 +141,12 @@ use tokio::sync::watch;
 use tokio::time::{self, MissedTickBehavior};
 use tracing::{debug, error, info, warn};
 
+use crate::healthcheck::{HealthStatusMessage, HealthStatusUpdate, StatusNamespace};
+use crate::metrics::sink::kafka::KafkaSinkMetrics;
+use crate::render::sinks::{PkViolationWarner, SinkBatchStream, SinkRender};
+use crate::statistics::SinkStatistics;
+use crate::storage_state::StorageState;
+
 impl<'scope> SinkRender<'scope> for KafkaSinkConnection {
     fn get_key_indices(&self) -> Option<&[usize]> {
         self.key_desc_and_indices
@@ -1601,8 +1601,12 @@ fn encode_collection<'scope>(
 
             while let Some(event) = input.next().await {
                 if let Event::Data(cap, mut batches) = event {
-                    for batch in batches.drain(..) {
-                        for_each_diff_pair(&batch, |key, time, value| {
+                    for span in batches.drain(..) {
+                        // A span with no updates carries no batch to encode.
+                        let Some(batch) = &span.inner else {
+                            continue;
+                        };
+                        for_each_diff_pair(batch, |key, time, value| {
                             if let Some(warner) = pk_warner.as_mut() {
                                 warner.observe(key, time);
                             }
diff --git a/src/storage/src/source/generator.rs b/src/storage/src/source/generator.rs
index 6adc9a2c18ba5..66921538ace6f 100644
--- a/src/storage/src/source/generator.rs
+++ b/src/storage/src/source/generator.rs
@@ -493,7 +493,7 @@ fn synthesize_probes<'scope, T: timely::progress::Timestamp>(
 
     let mut op = AsyncOperatorBuilder::new("synthesize_probes".into(), scope);
     let (output, output_stream) = op.new_output::<CapacityContainerBuilder<_>>();
-    let mut input = op.new_input_for(progress, Pipeline, &output);
+    let mut input = op.new_input_for_stamp(progress, Pipeline, &output);
 
     op.build(|caps| async move {
         if !is_active_worker {
diff --git a/src/storage/src/source/mysql/replication.rs b/src/storage/src/source/mysql/replication.rs
index 2d7bfdbc5e047..b0832181450e8 100644
--- a/src/storage/src/source/mysql/replication.rs
+++ b/src/storage/src/source/mysql/replication.rs
@@ -119,7 +119,9 @@ pub(crate) fn render<'scope>(
     // Captures DefiniteErrors that affect the entire source, including all outputs
     let (definite_error_handle, definite_errors) =
         builder.new_output::<CapacityContainerBuilder<Vec<_>>>();
-    let mut rewind_input = builder.new_input_for(
+    // GTID partitions are only partially ordered, so a message has no single time and the whole
+    // stamp is retained to ship rewound updates under.
+    let mut rewind_input = builder.new_input_for_stamp(
         rewind_stream,
         Exchange::new(move |_| repl_reader_id),
         &data_output,
diff --git a/src/storage/src/source/mysql/replication/context.rs b/src/storage/src/source/mysql/replication/context.rs
index 4a1f8d7138f34..067098784c3a1 100644
--- a/src/storage/src/source/mysql/replication/context.rs
+++ b/src/storage/src/source/mysql/replication/context.rs
@@ -12,7 +12,7 @@ use std::pin::Pin;
 
 use mysql_async::BinlogStream;
 use mz_storage_types::errors::DataflowError;
-use timely::dataflow::operators::{Capability, CapabilitySet};
+use timely::dataflow::operators::CapabilitySet;
 use timely::progress::Antichain;
 use tracing::trace;
 
@@ -40,7 +40,7 @@ pub(super) struct ReplContext<'a> {
     >,
     pub(super) data_cap_set: &'a mut CapabilitySet<GtidPartition>,
     // Owned values:
-    pub(super) rewinds: BTreeMap<usize, (Capability<GtidPartition>, RewindRequest)>,
+    pub(super) rewinds: BTreeMap<usize, (CapabilitySet<GtidPartition>, RewindRequest)>,
     pub(super) errored_outputs: BTreeSet<usize>,
 }
 
@@ -56,7 +56,7 @@ impl<'a> ReplContext<'a> {
             (usize, Result<SourceMessage, DataflowError>),
         >,
         data_cap_set: &'a mut CapabilitySet<GtidPartition>,
-        rewinds: BTreeMap<usize, (Capability<GtidPartition>, RewindRequest)>,
+        rewinds: BTreeMap<usize, (CapabilitySet<GtidPartition>, RewindRequest)>,
     ) -> Self {
         Self {
             config,
diff --git a/src/storage/src/source/postgres/replication.rs b/src/storage/src/source/postgres/replication.rs
index 17534244fa1ce..b1199e80e2520 100644
--- a/src/storage/src/source/postgres/replication.rs
+++ b/src/storage/src/source/postgres/replication.rs
@@ -615,7 +615,7 @@ pub(crate) fn render<'scope>(
     let replication_updates = data_stream
         .unary(round_robin, "PgCastReplicationRows", |_, _| {
             move |input, output| {
-                input.for_each_time(|time, data| {
+                input.for_each_stamp(|time, data| {
                     let mut session = output.session(&time);
                     for ((oid, output_index, event), time, diff) in
                         data.flat_map(|data| data.drain(..))
diff --git a/src/storage/src/source/postgres/snapshot.rs b/src/storage/src/source/postgres/snapshot.rs
index 9e88708b514c9..6b7a42ecb4d23 100644
--- a/src/storage/src/source/postgres/snapshot.rs
+++ b/src/storage/src/source/postgres/snapshot.rs
@@ -756,7 +756,7 @@ pub(crate) fn render<'scope>(
     let snapshot_updates = raw_data
         .unary(Pipeline, "PgCastSnapshotRows", |_, _| {
             move |input, output| {
-                input.for_each_time(|time, data| {
+                input.for_each_stamp(|time, data| {
                     let mut session = output.session(&time);
                     for ((oid, output_index, event), time, diff) in
                         data.flat_map(|data| data.drain(..))
diff --git a/src/storage/src/source/source_reader_pipeline.rs b/src/storage/src/source/source_reader_pipeline.rs
index 003d4b3a28b0d..5212c3449059f 100644
--- a/src/storage/src/source/source_reader_pipeline.rs
+++ b/src/storage/src/source/source_reader_pipeline.rs
@@ -55,7 +55,7 @@ use timely::dataflow::operators::core::Map as _;
 use timely::dataflow::operators::generic::OutputBuilder;
 use timely::dataflow::operators::generic::builder_rc::OperatorBuilder as OperatorBuilderRc;
 use timely::dataflow::operators::vec::Broadcast;
-use timely::dataflow::operators::{CapabilitySet, InspectCore, Leave};
+use timely::dataflow::operators::{CapabilitySet, Inspect, Leave};
 use timely::dataflow::{Scope, StreamVec};
 use timely::order::TotalOrder;
 use timely::progress::frontier::MutableAntichain;
@@ -384,14 +384,14 @@ where
     // Broadcasting does more work than necessary, which would be to exchange the probes to the
     // worker that will be the one minting the bindings but we'd have to thread this information
     // through and couple the two functions enough that it's not worth the optimization (I think).
-    // Use `InspectCore::inspect_container` instead of `Inspect::inspect`.
-    // `Inspect` carries a `where for<'a> &'a C: IntoIterator` bound, and on
-    // macOS the solver can satisfy that bound by chasing objc2's
-    // `&Retained<T>: IntoIterator` blanket impl into an endless
-    // `Retained<Retained<…>>` chain, overflowing the recursion limit.
-    // `InspectCore` has no such bound, so the cascade never starts. We
-    // iterate the container by hand to recover the per-item callback.
-    probe_stream.broadcast().inspect_container(move |event| {
+    // Use `inspect_core` instead of `inspect`. `inspect` carries a
+    // `where for<'a> &'a C: IntoIterator` bound, and on macOS the solver can
+    // satisfy that bound by chasing objc2's `&Retained<T>: IntoIterator`
+    // blanket impl into an endless `Retained<Retained<…>>` chain, overflowing
+    // the recursion limit. `inspect_core` has no such bound, so the cascade
+    // never starts. We iterate the container by hand to recover the per-item
+    // callback.
+    probe_stream.broadcast().inspect_core(move |event| {
         if let Ok((_, data)) = event {
             for probe in data {
                 // We don't care if the receiver is gone
diff --git a/src/storage/src/upsert.rs b/src/storage/src/upsert.rs
index 6bdb4bcd6acd4..78ee8491bd1a2 100644
--- a/src/storage/src/upsert.rs
+++ b/src/storage/src/upsert.rs
@@ -40,7 +40,7 @@ use mz_timely_util::builder_async::{
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
 use timely::dataflow::channels::pact::Exchange;
-use timely::dataflow::operators::{Capability, InputCapability, Operator};
+use timely::dataflow::operators::{Capability, Operator};
 use timely::dataflow::{Scope, StreamVec};
 use timely::order::{PartialOrder, TotalOrder};
 use timely::progress::timestamp::Refines;
@@ -769,7 +769,7 @@ where
         .inner
         .unary(Pipeline, "UpsertThinning", |_, _| {
             // A capability suitable to emit all updates in `updates`, if any.
-            let mut capability: Option<InputCapability<T>> = None;
+            let mut capability: Option<Capability<T>> = None;
             // A batch of received updates
             let mut updates = Vec::new();
             move |input, output| {
@@ -779,6 +779,11 @@ where
                         "invalid upsert input"
                     );
                     updates.append(data);
+                    // `T: TotalOrder`, so the message's stamp has a least element, and holding
+                    // that one capability suffices to emit every update in the message.
+                    let cap = cap
+                        .retain_least(0)
+                        .expect("message stamped with no capabilities");
                     match capability.as_mut() {
                         Some(capability) => {
                             if cap.time() <= capability.time() {
diff --git a/src/storage/src/upsert_continual_feedback_v2.rs b/src/storage/src/upsert_continual_feedback_v2.rs
index 5b4b699ac2048..c5f2cf60e0b41 100644
--- a/src/storage/src/upsert_continual_feedback_v2.rs
+++ b/src/storage/src/upsert_continual_feedback_v2.rs
@@ -88,20 +88,22 @@
 //! with `p < ts` is ineligible (persist hasn't caught up), and one with
 //! `ts < p` is already persisted and dropped.
 
-use std::fmt::Debug;
-
 use differential_dataflow::difference::{IsZero, Semigroup};
 use differential_dataflow::hashable::Hashable;
 use differential_dataflow::lattice::Lattice;
-use differential_dataflow::logging::Logger;
 use differential_dataflow::operators::arrange::agent::TraceAgent;
 use differential_dataflow::operators::arrange::arrangement::{Arranged, arrange_core};
-use differential_dataflow::trace::chunk::{ChunkBatcher, ChunkBuilder, ChunkSpine};
-use differential_dataflow::trace::{Batcher, Cursor, Description, TraceReader};
+use differential_dataflow::trace::chunk::{ChunkBatcher, ChunkSpine};
+use differential_dataflow::trace::{Batcher, Cursor, TraceReader};
 use differential_dataflow::{AsCollection, VecCollection};
 use mz_dyncfg::ConfigSet;
 use mz_repr::{Datum, Diff, GlobalId, Row};
+use std::fmt::Debug;
+
 // Only the fuzzing-gated `datum_seq_to_upsert_value` takes a `DatumSeq`.
+use differential_dataflow::trace::chunk::ChunkMerger;
+use differential_dataflow::trace::cursor::cursor_list;
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 #[cfg(feature = "fuzzing")]
 use mz_row_spine::DatumSeq;
 use mz_row_spine::{ValRowColPagedBuilder, ValRowSpine};
@@ -118,8 +120,9 @@ use mz_timely_util::columnar::merge_batcher::ColumnMergeBatcher;
 use mz_timely_util::columnar::unload::UnloadBatch;
 use mz_timely_util::columnar::{Col2ValPagedBatcher, Column};
 use mz_timely_util::containers::stack::FueledBuilder;
+use mz_timely_util::operator::ConsolidatingBatcher;
 use std::convert::Infallible;
-use timely::container::{CapacityContainerBuilder, PushInto};
+use timely::container::CapacityContainerBuilder;
 use timely::dataflow::channels::pact::{Exchange, Pipeline};
 use timely::dataflow::operators::generic::Operator;
 use timely::dataflow::operators::{Capability, CapabilitySet, Exchange as _};
@@ -164,53 +167,6 @@ impl UpsertStashFlavor {
     }
 }
 
-/// The paged flavor's persist-feedback batcher, wrapping
-/// [`Col2ValPagedBatcher`] only to capture the storage upsert-stash pager at
-/// construction.
-///
-/// `arrange_core` builds its batcher via [`Batcher::new`], which has no pager
-/// hook, so a plain `Col2ValPagedBatcher` falls back to the process-global
-/// (compute) pager, meaning the feedback arrangement's spill would be gated
-/// by compute's `enable_column_paged_batcher_spill` rather than storage's
-/// `enable_upsert_paged_spill`. Injecting `upsert_stash_pager::pager()` in
-/// `new` puts the feedback arrangement under the same flag as the source
-/// stash. Every other method delegates to the inner batcher unchanged.
-struct UpsertFeedbackBatcher<T: columnar::Columnar>(Col2ValPagedBatcher<UpsertKey, Row, T, Diff>);
-
-impl<T> Batcher for UpsertFeedbackBatcher<T>
-where
-    T: Timestamp + columnar::Columnar + Default + PartialOrder,
-    for<'a> columnar::Ref<'a, T>: Copy + Ord,
-{
-    type Output = Column<((UpsertKey, Row), T, Diff)>;
-    type Time = T;
-
-    fn new(logger: Option<Logger>, operator_id: usize) -> Self {
-        let mut batcher =
-            <Col2ValPagedBatcher<UpsertKey, Row, T, Diff> as Batcher>::new(logger, operator_id);
-        batcher.set_pager(crate::upsert::upsert_stash_pager::pager());
-        Self(batcher)
-    }
-
-    fn seal(&mut self, upper: Antichain<T>) -> (Vec<Self::Output>, Description<T>) {
-        self.0.seal(upper)
-    }
-
-    fn frontier(&mut self) -> AntichainRef<'_, T> {
-        self.0.frontier()
-    }
-}
-
-impl<T> PushInto<Column<((UpsertKey, Row), T, Diff)>> for UpsertFeedbackBatcher<T>
-where
-    T: Timestamp + columnar::Columnar + Default + PartialOrder,
-    for<'a> columnar::Ref<'a, T>: Copy + Ord,
-{
-    fn push_into(&mut self, chunk: Column<((UpsertKey, Row), T, Diff)>) {
-        self.0.push_into(chunk)
-    }
-}
-
 /// One persist-feedback update: a key, its current value row, the time, and
 /// an additive count.
 type FeedbackUpdate<T> = ((UpsertKey, Row), T, Diff);
@@ -299,13 +255,15 @@ type UpsertChunk<T, O> = ColumnChunk<UpsertKey, T, UpsertDiff<O>>;
 /// process buffer pool (see `mz_timely_util::columnar::chunk`), so the
 /// not-yet-eligible backlog (the snapshot / persist-lag window) pages out of
 /// RSS instead of growing it.
-type UpsertChunkBatcher<T, O> = ChunkBatcher<UpsertChunk<T, O>>;
+type UpsertChunkBatcher<T, O> =
+    ConsolidatingBatcher<ChunkChunker<UpsertKey, T, UpsertDiff<O>>, ChunkMerger<UpsertChunk<T, O>>>;
 
 /// The paged flavor's stash: the paged columnar merge batcher, consolidating
 /// like [`UpsertChunkBatcher`] but storing each chain entry as a `Column`
 /// routed through the storage-owned pager, which pages cold chains out of
 /// RSS.
-type UpsertPagedBatcher<T, O> = ColumnMergeBatcher<UpsertKey, T, UpsertDiff<O>>;
+type UpsertPagedBatcher<T, O> =
+    ColumnMergeBatcher<UpsertChunker<T, O>, UpsertKey, T, UpsertDiff<O>, ()>;
 
 /// The chunker that sorts and consolidates raw input into the `Column` chunks
 /// both stash batchers consume.
@@ -446,14 +404,13 @@ where
             // Chains and sealed batches alike are `FeedbackChunk`s whose
             // bodies spill to the buffer pool, behind the same process spill
             // gate as the source stash.
-            let persist_arranged = arrange_core::<
-                _,
-                _,
-                ChunkChunker<(UpsertKey, Row), T, Diff>,
-                ChunkBatcher<FeedbackChunk<T>>,
-                ChunkBuilder<FeedbackChunk<T>>,
-                FeedbackSpine<T>,
-            >(encoded, Pipeline, "Persist feedback");
+            let persist_arranged =
+                arrange_core::<
+                    _,
+                    _,
+                    ChunkBatcher<ChunkChunker<(UpsertKey, Row), T, Diff>, FeedbackChunk<T>>,
+                    FeedbackSpine<T>,
+                >(encoded, Pipeline, "Persist feedback", MergeBatcher::new);
             build_upsert_operator::<ChunkedArm, _, _>(
                 input,
                 resume_upper,
@@ -472,11 +429,28 @@ where
             let persist_arranged = arrange_core::<
                 _,
                 _,
-                ColumnChunker<((UpsertKey, Row), T, Diff)>,
-                UpsertFeedbackBatcher<T>,
-                ValRowColPagedBuilder<UpsertKey, T, Diff>,
+                Col2ValPagedBatcher<
+                    UpsertKey,
+                    Row,
+                    T,
+                    Diff,
+                    ColumnChunker<((UpsertKey, Row), T, Diff)>,
+                    ValRowColPagedBuilder<UpsertKey, T, Diff>,
+                >,
                 ValRowSpine<UpsertKey, T, Diff>,
-            >(encoded, Pipeline, "Persist feedback");
+            >(
+                encoded,
+                Pipeline,
+                "Persist feedback",
+                |logger, operator_id| {
+                    // The feedback arrangement must spill under storage's gate, not compute's, so
+                    // capture the storage-owned pager here rather than falling back to the
+                    // process-global one.
+                    let mut batcher = Col2ValPagedBatcher::new(logger, operator_id);
+                    batcher.set_pager(crate::upsert::upsert_stash_pager::pager());
+                    batcher
+                },
+            );
             build_upsert_operator::<PagedArm, _, _>(
                 input,
                 resume_upper,
@@ -789,9 +763,7 @@ where
                 // Step 1 already consolidated `push_buffer` through the chunker
                 // (which readies a complete chunk per `push_into`), so the
                 // chunker holds nothing pending here and we can seal directly.
-                let (sealed, _description) = batcher.seal(input_upper.clone());
-                // Frontier of data remaining in the batcher (ts >= input_upper).
-                let remaining_frontier = batcher.frontier().to_owned();
+                let (sealed, remaining_frontier) = A::extract(&mut batcher, input_upper.borrow());
 
                 let mut ineligible = Vec::new();
                 // The drain emits eligible output directly through
@@ -883,11 +855,23 @@ where
     type Spine: TraceReader<Time = T> + 'static;
     /// The source-stash batcher. `'static` because the operator future owns
     /// it.
-    type Batcher: Batcher<Time = T> + 'static;
+    type Batcher: 'static;
+    /// The chunk representation the stash batcher accumulates into.
+    type Chunk;
 
     /// A new stash batcher for one source dataflow.
     fn new_batcher() -> Self::Batcher;
 
+    /// Carve the chain of updates `upper` unblocks out of the stash.
+    ///
+    /// Returns the chunks and a lower bound on the times of what stays behind. The stash keeps
+    /// the chunks as they are: a caller that wanted a trace batch would have to take it apart
+    /// again.
+    fn extract(
+        batcher: &mut Self::Batcher,
+        upper: AntichainRef<T>,
+    ) -> (Vec<Self::Chunk>, Antichain<T>);
+
     /// Push one sorted, consolidated `Column` chunk into the batcher, in the
     /// batcher's chunk representation.
     fn push_chunk(batcher: &mut Self::Batcher, chunk: Column<UpsertUpdate<T, O>>);
@@ -918,7 +902,7 @@ where
     /// Classify one sealed stash against `persist_upper` and emit eligible
     /// output; see [`DrainStats`].
     async fn drain(
-        sealed: Vec<<Self::Batcher as Batcher>::Output>,
+        sealed: Vec<Self::Chunk>,
         ineligible: &mut Vec<UpsertUpdate<T, O>>,
         output_handle: &UpsertOutputHandle<T>,
         output_cap: &Capability<T>,
@@ -952,13 +936,22 @@ where
 {
     type Spine = FeedbackSpine<T>;
     type Batcher = UpsertChunkBatcher<T, O>;
+    type Chunk = UpsertChunk<T, O>;
 
     fn new_batcher() -> Self::Batcher {
-        Batcher::new(None, 0)
+        ConsolidatingBatcher::new(None, 0)
     }
 
-    fn push_chunk(batcher: &mut Self::Batcher, chunk: Column<UpsertUpdate<T, O>>) {
-        batcher.push_into(ColumnChunk::from_column(chunk));
+    fn extract(
+        batcher: &mut Self::Batcher,
+        upper: AntichainRef<T>,
+    ) -> (Vec<Self::Chunk>, Antichain<T>) {
+        let (chain, frontier) = Batcher::extract(batcher, upper);
+        (chain.unwrap_or_default(), frontier.to_owned())
+    }
+
+    fn push_chunk(batcher: &mut Self::Batcher, mut chunk: Column<UpsertUpdate<T, O>>) {
+        Batcher::insert(batcher, &mut chunk);
     }
 
     async fn drain(
@@ -1000,15 +993,24 @@ where
 {
     type Spine = ValRowSpine<UpsertKey, T, Diff>;
     type Batcher = UpsertPagedBatcher<T, O>;
+    type Chunk = Column<UpsertUpdate<T, O>>;
 
     fn new_batcher() -> Self::Batcher {
-        let mut batcher: UpsertPagedBatcher<T, O> = Batcher::new(None, 0);
+        let mut batcher = UpsertPagedBatcher::<T, O>::new(None, 0);
         batcher.set_pager(crate::upsert::upsert_stash_pager::pager());
         batcher
     }
 
+    fn extract(
+        batcher: &mut Self::Batcher,
+        upper: AntichainRef<T>,
+    ) -> (Vec<Self::Chunk>, Antichain<T>) {
+        let (chain, frontier) = batcher.extract_chain(upper);
+        (chain, frontier.to_owned())
+    }
+
     fn push_chunk(batcher: &mut Self::Batcher, chunk: Column<UpsertUpdate<T, O>>) {
-        batcher.push_into(chunk);
+        batcher.push_chunk(chunk);
     }
 
     async fn drain(
@@ -1351,7 +1353,10 @@ where
     let mut updates: u64 = 0;
     let mut deletes: u64 = 0;
 
-    let (mut cursor, storage) = trace.cursor();
+    let batches = trace
+        .batches_through(Antichain::new().borrow())
+        .expect("complete batch set for the feedback trace; is it closed?");
+    let (mut cursor, storage) = cursor_list(batches);
 
     for chunk in &sealed {
         for (key, ts, diff) in chunk.borrow().into_index_iter() {
diff --git a/src/timely-util/examples/column_paged_spill.rs b/src/timely-util/examples/column_paged_spill.rs
index 7aa0dc7fcc7e8..30adb3591b58a 100644
--- a/src/timely-util/examples/column_paged_spill.rs
+++ b/src/timely-util/examples/column_paged_spill.rs
@@ -29,16 +29,10 @@
 //!     --sample-secs 30
 //! ```
 
-use std::rc::Rc;
-use std::sync::Arc;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::time::{Duration, Instant};
-
 use differential_dataflow::operators::arrange::arrangement::arrange_core;
 use differential_dataflow::trace::implementations::Vector;
 use differential_dataflow::trace::implementations::ord_neu::{OrdValBatch, OrdValBuilder};
 use differential_dataflow::trace::implementations::spine_fueled::Spine;
-use differential_dataflow::trace::rc_blanket_impls::RcBuilder;
 use mz_ore::cast::{CastFrom, CastLossy, ReinterpretCast};
 use mz_ore::pager::{self, Backend};
 use mz_timely_util::column_pager::policy::TieredPolicy;
@@ -47,6 +41,11 @@ use mz_timely_util::columnar::Col2ValPagedBatcher;
 use mz_timely_util::columnar::Column;
 use mz_timely_util::columnar::batcher::ColumnChunker;
 use mz_timely_util::columnar::builder::ColumnBuilder;
+use mz_timely_util::columnar::merge_batcher::ColumnMergeBatcher;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::{Duration, Instant};
 use timely::dataflow::InputHandle;
 use timely::dataflow::channels::pact::Pipeline;
 use timely::dataflow::operators::Input;
@@ -55,8 +54,8 @@ use timely::dataflow::operators::probe::{Handle as ProbeHandle, Probe};
 type Update = ((u64, u64), u64, i64);
 
 type MyChunker = ColumnChunker<Update>;
-type MyBatcher = Col2ValPagedBatcher<u64, u64, u64, i64>;
-type MyBuilder = RcBuilder<OrdValBuilder<Vector<Update>, Column<Update>>>;
+type MyBatcher = Col2ValPagedBatcher<u64, u64, u64, i64, MyChunker, MyBuilder>;
+type MyBuilder = OrdValBuilder<Vector<Update>, Column<Update>>;
 type MySpine = Spine<Rc<OrdValBatch<Vector<Update>>>>;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -131,10 +130,11 @@ fn run_dataflow(cfg: &Config, label: &str) -> Duration {
             // Demo wires the raw DD operator; production paths go through
             // `MzArrange::mz_arrange_core` in `mz-compute`.
             #[allow(clippy::disallowed_methods)]
-            let arranged = arrange_core::<_, _, MyChunker, MyBatcher, MyBuilder, MySpine>(
+            let arranged = arrange_core::<_, _, MyBatcher, MySpine>(
                 stream,
                 Pipeline,
                 "ColumnPagedSpillArrange",
+                ColumnMergeBatcher::new,
             );
             arranged.stream.probe_with(&probe);
         });
diff --git a/src/timely-util/src/builder_async.rs b/src/timely-util/src/builder_async.rs
index 51eb84b39d8b1..9c83798c0d401 100644
--- a/src/timely-util/src/builder_async.rs
+++ b/src/timely-util/src/builder_async.rs
@@ -33,9 +33,10 @@ use timely::dataflow::channels::pact::ParallelizationContract;
 use timely::dataflow::channels::pushers::Output;
 use timely::dataflow::operators::generic::builder_rc::OperatorBuilder as OperatorBuilderRc;
 use timely::dataflow::operators::generic::{InputHandleCore, OperatorInfo};
-use timely::dataflow::operators::{Capability, CapabilitySet, InputCapability};
+use timely::dataflow::operators::{Capability, CapabilitySet, CapabilityTrait, InputCapability};
 use timely::dataflow::{Scope, Stream as TimelyStream, StreamVec};
-use timely::progress::{Antichain, Timestamp};
+use timely::order::TotalOrder;
+use timely::progress::{Antichain, Stamp, Timestamp};
 use timely::scheduling::{Activator, SyncActivator};
 use timely::{Bincode, Container, ContainerBuilder, PartialOrder};
 
@@ -215,7 +216,7 @@ struct AsyncOutputHandleInner<T: Timestamp, CB: ContainerBuilder> {
     /// Handle to write to the output stream.
     output: Output<T, CB::Container>,
     /// Current capability held by this output handle.
-    capability: Option<Capability<T>>,
+    capability: Option<CapabilitySet<T>>,
     /// Container builder to accumulate data before sending at `capability`.
     builder: CB,
 }
@@ -236,20 +237,21 @@ impl<T: Timestamp, CB: ContainerBuilder> AsyncOutputHandleInner<T, CB> {
         self.capability = None;
     }
 
-    /// Provides data at the time specified by the capability. Flushes automatically when the
-    /// capability time changes.
-    fn give<D>(&mut self, cap: &Capability<T>, data: D)
+    /// Provides data under the given capability. Flushes automatically when the capability
+    /// changes, so each output message carries the capability its data was given under.
+    fn give<D, C>(&mut self, cap: &C, data: D)
     where
         CB: PushInto<D>,
+        C: ShipUnder<T>,
     {
         if let Some(capability) = &self.capability
-            && cap.time() != capability.time()
+            && cap.stamp() != capability.stamp()
         {
             self.flush();
             self.capability = None;
         }
         if self.capability.is_none() {
-            self.capability = Some(cap.clone());
+            self.capability = Some(cap.to_set());
         }
 
         self.builder.push_into(data);
@@ -271,7 +273,7 @@ where
     C: Container + Clone + 'static,
 {
     #[inline]
-    pub fn give_container(&self, cap: &Capability<T>, container: &mut C) {
+    pub fn give_container<Cap: ShipUnder<T>>(&self, cap: &Cap, container: &mut C) {
         let mut inner = self.inner.borrow_mut();
         inner.flush();
         inner.output.give(cap, container);
@@ -305,7 +307,7 @@ where
     T: Timestamp,
     CB: ContainerBuilder,
 {
-    pub fn give<D>(&self, cap: &Capability<T>, data: D)
+    pub fn give<D, Cap: ShipUnder<T>>(&self, cap: &Cap, data: D)
     where
         CB: PushInto<D>,
     {
@@ -324,7 +326,7 @@ where
     /// charges `size_bytes` against the builder's fuel counter. Once at least
     /// [`Self::MAX_OUTSTANDING_BYTES`] have been emitted since the last yield
     /// this method yields back to timely and resets the counter.
-    pub async fn give_fueled<D2>(&self, cap: &Capability<T>, data: D2, size_bytes: usize)
+    pub async fn give_fueled<D2, Cap: ShipUnder<T>>(&self, cap: &Cap, data: D2, size_bytes: usize)
     where
         FueledBuilder<CapacityContainerBuilder<Vec<D>>>: PushInto<D2>,
     {
@@ -354,8 +356,20 @@ impl<T: Timestamp, CB: ContainerBuilder> Clone for AsyncOutputHandle<T, CB> {
     }
 }
 
+/// A message with an empty stamp makes no progress claims, so there is no capability to hand an
+/// operator body for it. An operator that must tolerate such a message takes a stamp connection,
+/// whose capability set is simply empty.
+const EMPTY_STAMP: &str = "message stamped with no capabilities";
+
 /// A trait describing the connection behavior between an input of an operator and zero or more of
 /// its outputs.
+///
+/// The single-capability connections ([`ConnectedToOne`], [`ConnectedToMany`]) hand the operator
+/// body one capability per message, which exists only for a totally ordered timestamp, where a
+/// message's stamp is an antichain of at most one element. The stamp connections
+/// ([`ConnectedToOneStamp`], [`ConnectedToManyStamp`]) hand over the whole stamp, and work in any
+/// scope; an operator that wants a single point from one calls `CapabilitySet::delayed`.
+/// [`Disconnected`] holds no capability at all and so reports the message's stamp as plain times.
 pub trait InputConnection<T: Timestamp> {
     /// The capability type associated with this connection behavior.
     type Capability;
@@ -371,21 +385,21 @@ pub trait InputConnection<T: Timestamp> {
 pub struct Disconnected;
 
 impl<T: Timestamp> InputConnection<T> for Disconnected {
-    type Capability = T;
+    type Capability = Stamp<T>;
 
     fn describe(&self, outputs: usize) -> Vec<Antichain<T::Summary>> {
         vec![Antichain::new(); outputs]
     }
 
     fn accept(&self, input_cap: InputCapability<T>) -> Self::Capability {
-        input_cap.time().clone()
+        input_cap.stamp().clone()
     }
 }
 
 /// A marker type representing an input connected to exactly one output.
 pub struct ConnectedToOne(usize);
 
-impl<T: Timestamp> InputConnection<T> for ConnectedToOne {
+impl<T: Timestamp + TotalOrder> InputConnection<T> for ConnectedToOne {
     type Capability = Capability<T>;
 
     fn describe(&self, outputs: usize) -> Vec<Antichain<T::Summary>> {
@@ -395,14 +409,14 @@ impl<T: Timestamp> InputConnection<T> for ConnectedToOne {
     }
 
     fn accept(&self, input_cap: InputCapability<T>) -> Self::Capability {
-        input_cap.retain(self.0)
+        input_cap.retain_least(self.0).expect(EMPTY_STAMP)
     }
 }
 
 /// A marker type representing an input connected to many outputs.
 pub struct ConnectedToMany<const N: usize>([usize; N]);
 
-impl<const N: usize, T: Timestamp> InputConnection<T> for ConnectedToMany<N> {
+impl<const N: usize, T: Timestamp + TotalOrder> InputConnection<T> for ConnectedToMany<N> {
     type Capability = [Capability<T>; N];
 
     fn describe(&self, outputs: usize) -> Vec<Antichain<T::Summary>> {
@@ -414,7 +428,65 @@ impl<const N: usize, T: Timestamp> InputConnection<T> for ConnectedToMany<N> {
     }
 
     fn accept(&self, input_cap: InputCapability<T>) -> Self::Capability {
-        self.0.map(|output| input_cap.retain(output))
+        self.0
+            .map(|output| input_cap.retain_least(output).expect(EMPTY_STAMP))
+    }
+}
+
+/// A marker type representing an input connected to exactly one output, carrying the whole stamp.
+pub struct ConnectedToOneStamp(usize);
+
+impl<T: Timestamp> InputConnection<T> for ConnectedToOneStamp {
+    type Capability = CapabilitySet<T>;
+
+    fn describe(&self, outputs: usize) -> Vec<Antichain<T::Summary>> {
+        let mut summary = vec![Antichain::new(); outputs];
+        summary[self.0] = Antichain::from_elem(T::Summary::default());
+        summary
+    }
+
+    fn accept(&self, input_cap: InputCapability<T>) -> Self::Capability {
+        input_cap.retain_stamp(self.0)
+    }
+}
+
+/// A marker type representing an input connected to many outputs, carrying the whole stamp.
+pub struct ConnectedToManyStamp<const N: usize>([usize; N]);
+
+impl<const N: usize, T: Timestamp> InputConnection<T> for ConnectedToManyStamp<N> {
+    type Capability = [CapabilitySet<T>; N];
+
+    fn describe(&self, outputs: usize) -> Vec<Antichain<T::Summary>> {
+        let mut summary = vec![Antichain::new(); outputs];
+        for output in self.0 {
+            summary[output] = Antichain::from_elem(T::Summary::default());
+        }
+        summary
+    }
+
+    fn accept(&self, input_cap: InputCapability<T>) -> Self::Capability {
+        self.0.map(|output| input_cap.retain_stamp(output))
+    }
+}
+
+/// A capability an output handle can ship data under: one capability, or a whole set.
+///
+/// The set is the general form. A lone [`Capability`] is the one-element case, which is what an
+/// operator in a totally ordered scope holds.
+pub trait ShipUnder<T: Timestamp>: CapabilityTrait<T> {
+    /// The capabilities to hold while the data is buffered.
+    fn to_set(&self) -> CapabilitySet<T>;
+}
+
+impl<T: Timestamp> ShipUnder<T> for Capability<T> {
+    fn to_set(&self) -> CapabilitySet<T> {
+        std::iter::once(self.clone()).collect()
+    }
+}
+
+impl<T: Timestamp> ShipUnder<T> for CapabilitySet<T> {
+    fn to_set(&self) -> CapabilitySet<T> {
+        self.clone()
     }
 }
 
@@ -458,6 +530,43 @@ impl<'scope, T: Timestamp> OperatorBuilder<'scope, T> {
         }
     }
 
+    /// Adds a new input connected to the specified output, whose handle carries the whole stamp
+    /// of each message.
+    ///
+    /// Use this where the scope's timestamp is partially ordered, so a message's stamp is an
+    /// antichain that may hold several incomparable capabilities.
+    pub fn new_input_for_stamp<D, P>(
+        &mut self,
+        stream: TimelyStream<'scope, T, D>,
+        pact: P,
+        output: &dyn OutputIndex,
+    ) -> AsyncInputHandle<T, D, ConnectedToOneStamp>
+    where
+        D: Container + Clone + 'static,
+        P: ParallelizationContract<T, D>,
+    {
+        let index = output.index();
+        self.new_input_connection(stream, pact, ConnectedToOneStamp(index))
+    }
+
+    /// Adds a new input connected to the specified outputs, whose handle carries the whole stamp
+    /// of each message.
+    ///
+    /// See [`Self::new_input_for_stamp`].
+    pub fn new_input_for_many_stamp<const N: usize, D, P>(
+        &mut self,
+        stream: TimelyStream<'scope, T, D>,
+        pact: P,
+        outputs: [&dyn OutputIndex; N],
+    ) -> AsyncInputHandle<T, D, ConnectedToManyStamp<N>>
+    where
+        D: Container + Clone + 'static,
+        P: ParallelizationContract<T, D>,
+    {
+        let indices = outputs.map(|output| output.index());
+        self.new_input_connection(stream, pact, ConnectedToManyStamp(indices))
+    }
+
     /// Adds a new input that is connected to the specified output, returning the async input handle to use.
     pub fn new_input_for<D, P>(
         &mut self,
@@ -466,6 +575,7 @@ impl<'scope, T: Timestamp> OperatorBuilder<'scope, T> {
         output: &dyn OutputIndex,
     ) -> AsyncInputHandle<T, D, ConnectedToOne>
     where
+        T: TotalOrder,
         D: Container + Clone + 'static,
         P: ParallelizationContract<T, D>,
     {
@@ -482,6 +592,7 @@ impl<'scope, T: Timestamp> OperatorBuilder<'scope, T> {
         outputs: [&dyn OutputIndex; N],
     ) -> AsyncInputHandle<T, D, ConnectedToMany<N>>
     where
+        T: TotalOrder,
         D: Container + Clone + 'static,
         P: ParallelizationContract<T, D>,
     {
diff --git a/src/timely-util/src/columnar.rs b/src/timely-util/src/columnar.rs
index d10fd370c899f..5f7819810a345 100644
--- a/src/timely-util/src/columnar.rs
+++ b/src/timely-util/src/columnar.rs
@@ -43,26 +43,27 @@ use crate::columnation::ColInternalMerger;
 
 /// A batcher for columnar storage.
 ///
-/// The chunker is supplied to the arrange operator separately. Callers pass
-/// it explicitly: [`ColumnationChunker`](crate::columnation::ColumnationChunker)
-/// for `Vec<_>` input, or [`batcher::Chunker`] (over a `ColumnationStack<_>`) for
-/// [`Column`] input.
-pub type Col2ValBatcher<K, V, T, R> = MergeBatcher<ColInternalMerger<(K, V), T, R>>;
+/// `Chu` melds raw input containers into the chunks the batcher merges:
+/// [`ColumnationChunker`](crate::columnation::ColumnationChunker) for `Vec<_>`
+/// input, or [`batcher::Chunker`] (over a `ColumnationStack<_>`) for [`Column`]
+/// input. `Se` seals each extracted chain; a spine builder seals into a batch,
+/// [`ChainSealer`](crate::operator::ChainSealer) hands the chain back as-is.
+pub type Col2ValBatcher<K, V, T, R, Chu, Se> =
+    MergeBatcher<Chu, ColInternalMerger<(K, V), T, R>, Se>;
 /// A batcher for columnar storage with unit values.
-pub type Col2KeyBatcher<K, T, R> = Col2ValBatcher<K, (), T, R>;
+pub type Col2KeyBatcher<K, T, R, Chu, Se> = Col2ValBatcher<K, (), T, R, Chu, Se>;
 
 /// Pageable counterpart to [`Col2ValBatcher`]. Routes every chunk produced
 /// by chunking, merging, or extract through a [`crate::column_pager::ColumnPager`],
 /// so memory pressure can spill chains to a backing store without touching
 /// the merge / extract bodies.
 ///
-/// Drop-in shape at the type level: both aliases take `(K, V, T, R)` and
-/// produce a `Batcher<Input = Column<((K, V), T, R)>, Output = Column<((K,
-/// V), T, R)>>`. Call sites can swap with `cargo fix`–style renaming once
-/// downstream `Trace`/`Builder` impls have been wired up. The pager itself
-/// defaults to [`crate::column_pager::ColumnPager::disabled`]; inject a
-/// real one via [`merge_batcher::ColumnMergeBatcher::set_pager`].
-pub type Col2ValPagedBatcher<K, V, T, R> = merge_batcher::ColumnMergeBatcher<(K, V), T, R>;
+/// Drop-in shape at the type level: both aliases take the same parameters and
+/// produce a `Batcher<C>` over the same chunk type. The pager itself defaults
+/// to [`crate::column_pager::ColumnPager::disabled`]; inject a real one via
+/// [`merge_batcher::ColumnMergeBatcher::set_pager`].
+pub type Col2ValPagedBatcher<K, V, T, R, Chu, Se> =
+    merge_batcher::ColumnMergeBatcher<Chu, (K, V), T, R, Se>;
 
 /// Columnar-native counterpart to [`Col2ValBatcher`], holding [`Column`]
 /// chunks rather than columnation stacks and merging them through
@@ -71,7 +72,8 @@ pub type Col2ValPagedBatcher<K, V, T, R> = merge_batcher::ColumnMergeBatcher<(K,
 /// Pairs with [`batcher::ColumnChunker`] and any builder whose `Input` is
 /// `Column<((K, V), T, R)>`. Unlike [`Col2ValPagedBatcher`] the chains stay
 /// resident, so this arm carries no pager and no spill budget.
-pub type Col2ValColBatcher<K, V, T, R> = MergeBatcher<batcher::ColumnMerger<(K, V), T, R>>;
+pub type Col2ValColBatcher<K, V, T, R, Chu, Se> =
+    MergeBatcher<Chu, batcher::ColumnMerger<(K, V), T, R>, Se>;
 
 /// A container based on a columnar store, encoded in aligned bytes.
 ///
diff --git a/src/timely-util/src/columnar/builder_input.rs b/src/timely-util/src/columnar/builder_input.rs
index 8dbd0e8347339..7db40a246fa02 100644
--- a/src/timely-util/src/columnar/builder_input.rs
+++ b/src/timely-util/src/columnar/builder_input.rs
@@ -34,7 +34,8 @@
 use columnar::{Columnar, Index, Len};
 use differential_dataflow::difference::Semigroup;
 use differential_dataflow::lattice::Lattice;
-use differential_dataflow::trace::implementations::{BatchContainer, BuilderInput};
+use differential_dataflow::trace::implementations::BatchContainer;
+use differential_dataflow::trace::implementations::ord_neu::BuilderInput;
 use timely::progress::Timestamp;
 
 use crate::columnar::Column;
diff --git a/src/timely-util/src/columnar/chunk.rs b/src/timely-util/src/columnar/chunk.rs
index 28cbd51a11a5f..dc9ede3782775 100644
--- a/src/timely-util/src/columnar/chunk.rs
+++ b/src/timely-util/src/columnar/chunk.rs
@@ -1090,9 +1090,18 @@ pub struct UnchunkBuilder<Bu, D: Columnar, T: Columnar, R: Columnar> {
     _marker: std::marker::PhantomData<(D, T, R)>,
 }
 
+impl<Bu: Default, D: Columnar, T: Columnar, R: Columnar> Default for UnchunkBuilder<Bu, D, T, R> {
+    fn default() -> Self {
+        Self {
+            inner: Bu::default(),
+            _marker: std::marker::PhantomData,
+        }
+    }
+}
+
 impl<Bu, D, T, R> differential_dataflow::trace::Builder for UnchunkBuilder<Bu, D, T, R>
 where
-    Bu: differential_dataflow::trace::Builder<Input = Column<(D, T, R)>>,
+    Bu: differential_dataflow::trace::Builder<Input = Column<(D, T, R)>> + Default,
     D: Columnar + 'static,
     T: Columnar + 'static,
     R: Columnar + 'static,
@@ -1101,37 +1110,38 @@ where
     type Time = Bu::Time;
     type Output = Bu::Output;
 
-    fn with_capacity(keys: usize, vals: usize, upds: usize) -> Self {
-        Self {
-            inner: Bu::with_capacity(keys, vals, upds),
-            _marker: std::marker::PhantomData,
-        }
-    }
-
     fn push(&mut self, chunk: &mut Self::Input) {
         let mut column = std::mem::take(chunk).into_column();
         self.inner.push(&mut column);
     }
 
-    fn done(
-        self,
-        description: differential_dataflow::trace::Description<Self::Time>,
-    ) -> Self::Output {
-        self.inner.done(description)
+    fn done(self) -> Option<Self::Output> {
+        self.inner.done()
     }
+}
+
+impl<Bu, D, T, R>
+    differential_dataflow::trace::implementations::merge_batcher::Sealer<ColumnChunk<D, T, R>>
+    for UnchunkBuilder<Bu, D, T, R>
+where
+    Bu: differential_dataflow::trace::Builder<Input = Column<(D, T, R)>> + Default,
+    D: Columnar + 'static,
+    T: Columnar + 'static,
+    R: Columnar + 'static,
+{
+    type Output = Bu::Output;
+
+    fn seal(chain: &mut Vec<ColumnChunk<D, T, R>>) -> Option<Self::Output> {
+        use differential_dataflow::trace::Builder;
 
-    fn seal(
-        chain: &mut Vec<Self::Input>,
-        description: differential_dataflow::trace::Description<Self::Time>,
-    ) -> Self::Output {
         // One chunk at a time through `push`, so peak transient memory is a
         // single loaded body rather than the whole chain at once.
-        let mut builder = Self::new();
+        let mut builder = Self::default();
         for chunk in chain.iter_mut() {
             builder.push(chunk);
         }
         chain.clear();
-        builder.done(description)
+        builder.done()
     }
 }
 
@@ -1202,8 +1212,8 @@ mod tests {
     //! `D = (u64, u64)`, `T = u64`, `R = i64` from small ranges so equal-key
     //! collisions are common and consolidation actually runs.
 
-    use differential_dataflow::trace::chunk::{ChunkBatch, ChunkBatcher};
-    use differential_dataflow::trace::{Batcher, Description};
+    use differential_dataflow::trace::Batcher;
+    use differential_dataflow::trace::chunk::ChunkBatch;
     use mz_ore::pool::Pool;
     use proptest::prelude::*;
     use timely::container::PushInto;
@@ -1215,6 +1225,11 @@ mod tests {
 
     type Tuple = ((u64, u64), u64, i64);
     type TestChunk = ColumnChunk<(u64, u64), u64, i64>;
+    /// A batcher over [`TestChunk`]s that hands its chain back rather than sealing it.
+    type TestChunkBatcher = crate::operator::ConsolidatingBatcher<
+        ChunkChunker<(u64, u64), u64, i64>,
+        differential_dataflow::trace::chunk::ChunkMerger<TestChunk>,
+    >;
 
     /// The delegated codec's stored form is byte-identical to the extent
     /// store's previous hard-coded framing: a little-endian `u32`
@@ -1366,16 +1381,17 @@ mod tests {
             inputs in prop::collection::vec(arb_consolidated(), 1..6),
             cuts in prop::collection::vec(0usize..7, 0..8),
         ) {
-            let mut batcher: ChunkBatcher<TestChunk> = Batcher::new(None, 0);
+            let mut batcher = TestChunkBatcher::new(None, 0);
             let mut union = Vec::new();
             for input in &inputs {
                 Extend::extend(&mut union, input.iter().copied());
                 for chunk in chunked(input, &cuts) {
-                    batcher.push_into(chunk);
+                    batcher.push_chunk(chunk);
                 }
             }
             // An empty upper ships everything.
-            let (sealed, _description) = batcher.seal(Antichain::new());
+            let (sealed, _frontier) = batcher.extract(Antichain::new().borrow());
+            let sealed = sealed.unwrap_or_default();
             prop_assert_eq!(collect_chunks(sealed), consolidate(union));
         }
 
@@ -1388,15 +1404,16 @@ mod tests {
             cuts in prop::collection::vec(0usize..7, 0..6),
         ) {
             let pool = test_pool();
-            let mut batcher: ChunkBatcher<TestChunk> = Batcher::new(None, 0);
+            let mut batcher = TestChunkBatcher::new(None, 0);
             let mut union = Vec::new();
             for input in &inputs {
                 Extend::extend(&mut union, input.iter().copied());
                 for chunk in chunked_spilled(input, &cuts, &pool) {
-                    batcher.push_into(chunk);
+                    batcher.push_chunk(chunk);
                 }
             }
-            let (sealed, _description) = batcher.seal(Antichain::new());
+            let (sealed, _frontier) = batcher.extract(Antichain::new().borrow());
+            let sealed = sealed.unwrap_or_default();
             prop_assert_eq!(collect_chunks(sealed), consolidate(union));
         }
 
@@ -1409,20 +1426,22 @@ mod tests {
             cuts in prop::collection::vec(0usize..7, 0..8),
             upper in 0u64..5,
         ) {
-            let mut batcher: ChunkBatcher<TestChunk> = Batcher::new(None, 0);
+            let mut batcher = TestChunkBatcher::new(None, 0);
             for chunk in chunked(&input, &cuts) {
-                batcher.push_into(chunk);
+                batcher.push_chunk(chunk);
             }
-            let (shipped, _) = batcher.seal(Antichain::from_elem(upper));
+            let (shipped, frontier) = batcher.extract(Antichain::from_elem(upper).borrow());
+            let shipped = shipped.unwrap_or_default();
+            let frontier = frontier.to_owned();
             let expected_shipped: Vec<Tuple> =
                 input.iter().copied().filter(|(_, t, _)| *t < upper).collect();
             prop_assert_eq!(collect_chunks(shipped), consolidate(expected_shipped));
 
             let kept_min = input.iter().filter(|(_, t, _)| *t >= upper).map(|(_, t, _)| *t).min();
-            let frontier = batcher.frontier().to_owned();
             prop_assert_eq!(frontier.elements().first().copied(), kept_min);
 
-            let (rest, _) = batcher.seal(Antichain::new());
+            let (rest, _frontier) = batcher.extract(Antichain::new().borrow());
+            let rest = rest.unwrap_or_default();
             let expected_rest: Vec<Tuple> =
                 input.iter().copied().filter(|(_, t, _)| *t >= upper).collect();
             prop_assert_eq!(collect_chunks(rest), consolidate(expected_rest));
@@ -1439,20 +1458,22 @@ mod tests {
             upper in 0u64..5,
         ) {
             let pool = test_pool();
-            let mut batcher: ChunkBatcher<TestChunk> = Batcher::new(None, 0);
+            let mut batcher = TestChunkBatcher::new(None, 0);
             for chunk in chunked_spilled(&input, &cuts, &pool) {
-                batcher.push_into(chunk);
+                batcher.push_chunk(chunk);
             }
-            let (shipped, _) = batcher.seal(Antichain::from_elem(upper));
+            let (shipped, frontier) = batcher.extract(Antichain::from_elem(upper).borrow());
+            let shipped = shipped.unwrap_or_default();
+            let frontier = frontier.to_owned();
             let expected_shipped: Vec<Tuple> =
                 input.iter().copied().filter(|(_, t, _)| *t < upper).collect();
             prop_assert_eq!(collect_chunks(shipped), consolidate(expected_shipped));
 
             let kept_min = input.iter().filter(|(_, t, _)| *t >= upper).map(|(_, t, _)| *t).min();
-            let frontier = batcher.frontier().to_owned();
             prop_assert_eq!(frontier.elements().first().copied(), kept_min);
 
-            let (rest, _) = batcher.seal(Antichain::new());
+            let (rest, _frontier) = batcher.extract(Antichain::new().borrow());
+            let rest = rest.unwrap_or_default();
             let expected_rest: Vec<Tuple> =
                 input.iter().copied().filter(|(_, t, _)| *t >= upper).collect();
             prop_assert_eq!(collect_chunks(rest), consolidate(expected_rest));
@@ -1522,12 +1543,7 @@ mod tests {
             } else {
                 chunked(&input, &cuts).into()
             };
-            let description = Description::new(
-                Antichain::from_elem(0u64),
-                Antichain::new(),
-                Antichain::from_elem(0u64),
-            );
-            let batch = ChunkBatch::new(chunks, description);
+                        let batch = ChunkBatch::new(chunks);
 
             let mut probe_col = <u64 as Columnar>::Container::default();
             for key in &probe_keys {
@@ -1743,11 +1759,12 @@ mod tests {
         assert_eq!(committed.len(), data.len());
         assert_eq!(collect_column(&committed.clone().into_column()), data);
 
-        let mut batcher: ChunkBatcher<TestChunk> = Batcher::new(None, 0);
+        let mut batcher = TestChunkBatcher::new(None, 0);
         for piece in data.chunks(10_000) {
-            batcher.push_into(ColumnChunk::from_column(build_column(piece)));
+            batcher.push_chunk(ColumnChunk::from_column(build_column(piece)));
         }
-        let (sealed, _) = batcher.seal(Antichain::new());
+        let (sealed, _frontier) = batcher.extract(Antichain::new().borrow());
+        let sealed = sealed.unwrap_or_default();
         assert!(
             sealed.iter().any(ColumnChunk::is_spilled),
             "sealed output should contain spilled chunks",
diff --git a/src/timely-util/src/columnar/merge_batcher.rs b/src/timely-util/src/columnar/merge_batcher.rs
index 05a64860a1462..8645aaa82f67d 100644
--- a/src/timely-util/src/columnar/merge_batcher.rs
+++ b/src/timely-util/src/columnar/merge_batcher.rs
@@ -28,15 +28,15 @@
 //!
 //! [`differential_dataflow`]: differential_dataflow::trace::implementations::merge_batcher
 
-use std::collections::VecDeque;
-
 use columnar::{Columnar, Index, Len};
+use differential_dataflow::batcher::Batcher;
 use differential_dataflow::difference::Semigroup;
 use differential_dataflow::logging::{BatcherEvent, Logger};
-use differential_dataflow::trace::{Batcher, Description};
+use differential_dataflow::trace::implementations::merge_batcher::Sealer;
+use std::collections::VecDeque;
 use timely::Accountable;
 use timely::PartialOrder;
-use timely::container::{PushInto, SizableContainer};
+use timely::container::{ContainerBuilder, PushInto, SizableContainer};
 use timely::dataflow::channels::ContainerBytes;
 use timely::progress::Timestamp;
 use timely::progress::frontier::{Antichain, AntichainRef};
@@ -91,14 +91,15 @@ fn recycle_capped<C: Columnar>(chunk: Column<C>, stash: &mut Vec<Column<C>>) {
 /// late-arriving dyncfg updates (e.g. `enable_column_paged_batcher` flipping
 /// on after the batcher was constructed) take effect without rebuilding the
 /// operator. Tests may override that lookup via [`Self::set_pager`].
-pub struct ColumnMergeBatcher<D, T, R>
+pub struct ColumnMergeBatcher<Chu, D, T, R, S>
 where
     D: Columnar,
     T: Columnar,
     R: Columnar,
 {
+    /// Melds raw input containers into sorted, consolidated chunks.
+    chunker: Chu,
     chains: Vec<VecDeque<PagedColumn<(D, T, R)>>>,
-    lower: Antichain<T>,
     frontier: Antichain<T>,
     /// Recycled empty `Column::Typed` chunks. Drained heads and shipped result
     /// buffers feed in here; subsequent merge / extract calls pop from here
@@ -115,9 +116,35 @@ where
     pager_override: Option<ColumnPager>,
     logger: Option<Logger>,
     operator_id: usize,
+    /// Seals each extracted chain into a batch.
+    sealer: std::marker::PhantomData<S>,
 }
 
-impl<D, T, R> ColumnMergeBatcher<D, T, R>
+impl<Chu: Default, D, T, R, S> ColumnMergeBatcher<Chu, D, T, R, S>
+where
+    D: Columnar,
+    T: Columnar + Timestamp,
+    R: Columnar,
+{
+    /// 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 {
+            chunker: Chu::default(),
+            chains: Vec::new(),
+            frontier: Antichain::new(),
+            stash: Vec::new(),
+            pager_override: None,
+            logger,
+            operator_id,
+            sealer: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<Chu, D, T, R, S> ColumnMergeBatcher<Chu, D, T, R, S>
 where
     D: Columnar,
     T: Columnar,
@@ -187,7 +214,7 @@ where
     }
 }
 
-impl<D, T, R> Drop for ColumnMergeBatcher<D, T, R>
+impl<Chu, D, T, R, S> Drop for ColumnMergeBatcher<Chu, D, T, R, S>
 where
     D: Columnar,
     T: Columnar,
@@ -219,7 +246,7 @@ fn account_chunk<C: Columnar>(entry: &PagedColumn<C>) -> (usize, usize, usize, u
     }
 }
 
-impl<D, T, R> Batcher for ColumnMergeBatcher<D, T, R>
+impl<C, Chu, D, T, R, S> Batcher<C> for ColumnMergeBatcher<Chu, D, T, R, S>
 where
     D: Columnar,
     for<'a> columnar::Ref<'a, D>: Copy + Ord,
@@ -227,26 +254,52 @@ where
     for<'a> columnar::Ref<'a, T>: Copy + Ord,
     R: Columnar + Default + Semigroup + for<'a> Semigroup<columnar::Ref<'a, R>>,
     for<'a> columnar::Ref<'a, R>: Ord,
+    Chu: ContainerBuilder<Container = Column<(D, T, R)>> + for<'a> PushInto<&'a mut C>,
+    S: Sealer<Column<(D, T, R)>>,
 {
-    type Output = Column<(D, T, R)>;
+    type Output = S::Output;
     type Time = T;
 
-    fn new(logger: Option<Logger>, operator_id: usize) -> Self {
-        Self {
-            chains: Vec::new(),
-            lower: Antichain::from_elem(T::minimum()),
-            frontier: Antichain::new(),
-            stash: Vec::new(),
-            pager_override: None,
-            logger,
-            operator_id,
+    fn insert(&mut self, container: &mut C) {
+        self.chunker.push_into(container);
+        while let Some(chunk) = self.chunker.extract().map(std::mem::take) {
+            self.push_chunk(chunk);
         }
     }
 
-    fn seal(
-        &mut self,
-        upper: Antichain<Self::Time>,
-    ) -> (Vec<Self::Output>, Description<Self::Time>) {
+    fn extract<'a>(
+        &'a mut self,
+        upper: AntichainRef<'_, Self::Time>,
+    ) -> (Option<Self::Output>, AntichainRef<'a, Self::Time>) {
+        let (mut readied, frontier) = self.extract_chain(upper);
+        (S::seal(&mut readied), frontier)
+    }
+}
+
+impl<Chu, D, T, R, S> ColumnMergeBatcher<Chu, D, T, R, S>
+where
+    D: Columnar,
+    for<'a> columnar::Ref<'a, D>: Copy + Ord,
+    T: Columnar + Default + Timestamp + PartialOrder,
+    for<'a> columnar::Ref<'a, T>: Copy + Ord,
+    R: Columnar + Default + Semigroup + for<'a> Semigroup<columnar::Ref<'a, R>>,
+    for<'a> columnar::Ref<'a, R>: Ord,
+    Chu: ContainerBuilder<Container = Column<(D, T, R)>>,
+{
+    /// Carves out the updates `upper` unblocks, and lower bounds the times of those retained.
+    ///
+    /// The chunks come back as they are. [`Batcher::extract`] is this plus a seal, for callers
+    /// that want a batch rather than the updates.
+    pub fn extract_chain<'a>(
+        &'a mut self,
+        upper: AntichainRef<'_, T>,
+    ) -> (Vec<Column<(D, T, R)>>, AntichainRef<'a, T>) {
+        // 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.push_chunk(chunk);
+        }
+
         let pager = self.pager();
         // Merge all remaining chains into one.
         while self.chains.len() > 1 {
@@ -257,9 +310,8 @@ where
         }
         let merged = self.chain_pop().unwrap_or_default();
 
-        // Extract `merged` into `readied` (ship side, materialized for the
-        // builder) and `kept_chain` (keep side, stays paged for the next
-        // round).
+        // Extract `merged` into `readied` (ship side, materialized for the builder) and
+        // `kept_chain` (keep side, stays paged for the next round).
         let mut readied: Vec<Column<(D, T, R)>> = Vec::new();
         let mut kept_chain: VecDeque<PagedColumn<(D, T, R)>> = VecDeque::new();
         self.frontier.clear();
@@ -269,7 +321,7 @@ where
             let stash = &mut self.stash;
             extract_chain(
                 FetchIter::new(merged, pager),
-                upper.borrow(),
+                upper,
                 frontier,
                 |paged| readied.push(pager.take(paged)),
                 |paged| kept_chain.push_back(paged),
@@ -281,28 +333,16 @@ where
             self.chain_push(kept_chain);
         }
 
-        let description = Description::new(
-            self.lower.clone(),
-            upper.clone(),
-            Antichain::from_elem(T::minimum()),
-        );
-        self.lower = upper;
-
-        // Drop the recycle stash now that this round's hot work is done:
-        // the next merge re-pays one chunk's worth of leaf grow tax, and in
-        // exchange the leaf bytes are not held resident across what may be
-        // a quiet stretch.
+        // Drop the recycle stash now that this round's hot work is done: the next merge
+        // re-pays one chunk's worth of leaf grow tax, and in exchange the leaf bytes are not
+        // held resident across what may be a quiet stretch.
         self.stash.clear();
 
-        (readied, description)
-    }
-
-    fn frontier(&mut self) -> AntichainRef<'_, Self::Time> {
-        self.frontier.borrow()
+        (readied, self.frontier.borrow())
     }
 }
 
-impl<D, T, R> PushInto<Column<(D, T, R)>> for ColumnMergeBatcher<D, T, R>
+impl<Chu, D, T, R, S> PushInto<Column<(D, T, R)>> for ColumnMergeBatcher<Chu, D, T, R, S>
 where
     D: Columnar,
     for<'a> columnar::Ref<'a, D>: Copy + Ord,
@@ -312,14 +352,12 @@ where
 {
     /// Accept an already-consolidated chunk from the upstream chunker, route
     /// it through the pager, and insert it as a singleton chain.
-    fn push_into(&mut self, mut chunk: Column<(D, T, R)>) {
-        let pager = self.pager();
-        let paged = pager.page(&mut chunk);
-        self.insert_chain(VecDeque::from([paged]));
+    fn push_into(&mut self, chunk: Column<(D, T, R)>) {
+        self.push_chunk(chunk);
     }
 }
 
-impl<D, T, R> ColumnMergeBatcher<D, T, R>
+impl<Chu, D, T, R, S> ColumnMergeBatcher<Chu, D, T, R, S>
 where
     D: Columnar,
     for<'a> columnar::Ref<'a, D>: Copy + Ord,
@@ -327,6 +365,14 @@ where
     for<'a> columnar::Ref<'a, T>: Copy + Ord,
     R: Columnar + Default + Semigroup + for<'a> Semigroup<columnar::Ref<'a, R>>,
 {
+    /// Route an already-consolidated chunk through the pager and insert it
+    /// as a singleton chain.
+    pub fn push_chunk(&mut self, mut chunk: Column<(D, T, R)>) {
+        let pager = self.pager();
+        let paged = pager.page(&mut chunk);
+        self.insert_chain(VecDeque::from([paged]));
+    }
+
     /// Insert `chain` and rebalance: while the youngest chain is at least
     /// half the size of its predecessor, merge them.
     fn insert_chain(&mut self, chain: VecDeque<PagedColumn<(D, T, R)>>) {
@@ -664,6 +710,15 @@ pub fn extract_chain<D, T, R, SinkShip, SinkKeep>(
 #[cfg(test)]
 #[allow(clippy::clone_on_ref_ptr)]
 mod tests {
+    /// The paged batcher under test, with no sealer: these tests read the chain directly.
+    type TestPagedBatcher = super::ColumnMergeBatcher<
+        crate::columnar::batcher::ColumnChunker<((u64, u64), u64, i64)>,
+        (u64, u64),
+        u64,
+        i64,
+        (),
+    >;
+
     use std::sync::Arc;
 
     use columnar::Index;
@@ -968,8 +1023,7 @@ mod tests {
 
     #[mz_ore::test]
     fn batcher_seal_round_trip() {
-        let mut b: ColumnMergeBatcher<(u64, u64), u64, i64> =
-            differential_dataflow::trace::Batcher::new(None, 0);
+        let mut b = TestPagedBatcher::new(None, 0);
         // Two pushes; second has an equal-key collision with the first.
         // Inputs arrive pre-consolidated chunk-by-chunk, as from the upstream
         // chunker.
@@ -980,7 +1034,7 @@ mod tests {
 
         // Seal everything (upper = ∞-ish, here just past any time we used).
         let upper = Antichain::from_elem(u64::MAX);
-        let (chain, _description) = differential_dataflow::trace::Batcher::seal(&mut b, upper);
+        let (chain, _frontier) = b.extract_chain(upper.borrow());
         let out: Vec<KvUpdate> = chain.iter().flat_map(collect_column).collect();
 
         // (2, 0)@0 was pushed with +1 then +2; sums to +3 after consolidation.
@@ -1024,8 +1078,7 @@ mod tests {
         let policy = ForcePagePolicy::new();
         let pager = ColumnPager::new(policy.clone());
 
-        let mut b: ColumnMergeBatcher<(u64, u64), u64, i64> =
-            differential_dataflow::trace::Batcher::new(None, 0);
+        let mut b = TestPagedBatcher::new(None, 0);
         b.set_pager(pager);
 
         // Push records straddling an upper of 5 — half should be kept, half
@@ -1036,7 +1089,7 @@ mod tests {
             b.push_into(input);
         }
         let upper = Antichain::from_elem(5u64);
-        let _ = differential_dataflow::trace::Batcher::seal(&mut b, upper);
+        let _ = b.extract_chain(upper.borrow());
 
         // Anything kept (times >= 5) should be sitting in b.chains as paged.
         let kept_records: usize = b
diff --git a/src/timely-util/src/columnar/unload.rs b/src/timely-util/src/columnar/unload.rs
index 58911a62bb5e9..413a2ef366046 100644
--- a/src/timely-util/src/columnar/unload.rs
+++ b/src/timely-util/src/columnar/unload.rs
@@ -19,9 +19,8 @@
 //! this crate); the method names and signatures match, so call sites survive
 //! a future switch to upstream re-exports unchanged.
 
-use std::cmp::Ordering;
-
 use differential_dataflow::trace::chunk::{Chunk, ChunkBatch};
+use std::cmp::Ordering;
 
 /// Look up a sorted set of keys in a chunk, copying the matching updates out
 /// into caller-owned staging.
@@ -173,7 +172,6 @@ mod tests {
 
     use std::collections::VecDeque;
 
-    use differential_dataflow::trace::Description;
     use timely::progress::Antichain;
     use timely::progress::frontier::AntichainRef;
 
@@ -265,12 +263,7 @@ mod tests {
 
     fn batch_of(rows: &[(u64, u64)], cut: usize) -> ChunkBatch<Rows> {
         let chunks: Vec<Rows> = rows.chunks(cut).map(|c| Rows(c.to_vec())).collect();
-        let description = Description::new(
-            Antichain::from_elem(0u64),
-            Antichain::new(),
-            Antichain::from_elem(0u64),
-        );
-        ChunkBatch::new(chunks, description)
+        ChunkBatch::new(chunks)
     }
 
     /// Every (chunk cut, contiguous probe range) placement over rows with a
diff --git a/src/timely-util/src/columnation.rs b/src/timely-util/src/columnation.rs
index 61b5090b6385e..6de0d27ed764d 100644
--- a/src/timely-util/src/columnation.rs
+++ b/src/timely-util/src/columnation.rs
@@ -19,15 +19,15 @@
 //! columnation library, along with [`ColumnationChunker`] for organizing streams into sorted
 //! chunks, and the [`ColInternalMerger`] [`Merger`] implementation needed by the merge batcher.
 
-use std::collections::VecDeque;
-use std::iter::FromIterator;
-
 use columnation::{Columnation, Region};
 use differential_dataflow::consolidation::consolidate_updates;
 use differential_dataflow::difference::Semigroup;
 use differential_dataflow::lattice::Lattice;
+use differential_dataflow::trace::implementations::BatchContainer;
 use differential_dataflow::trace::implementations::merge_batcher::Merger;
-use differential_dataflow::trace::implementations::{BatchContainer, BuilderInput};
+use differential_dataflow::trace::implementations::ord_neu::BuilderInput;
+use std::collections::VecDeque;
+use std::iter::FromIterator;
 use timely::container::{ContainerBuilder, DrainContainer, PushInto, SizableContainer};
 use timely::progress::Timestamp;
 use timely::progress::frontier::{Antichain, AntichainRef};
diff --git a/src/timely-util/src/operator.rs b/src/timely-util/src/operator.rs
index 1da24f7baf4c9..d496278d97c35 100644
--- a/src/timely-util/src/operator.rs
+++ b/src/timely-util/src/operator.rs
@@ -15,15 +15,17 @@
 
 //! Common operator transformations on timely streams and differential collections.
 
-use std::hash::{BuildHasher, Hash, Hasher};
-
 use columnation::Columnation;
+use differential_dataflow::batcher::Batcher;
 use differential_dataflow::consolidation::ConsolidatingContainerBuilder;
 use differential_dataflow::difference::{Multiply, Semigroup};
 use differential_dataflow::lattice::Lattice;
-use differential_dataflow::trace::Batcher;
+use differential_dataflow::logging::BatcherEvent;
+use differential_dataflow::logging::Logger;
+use differential_dataflow::trace::implementations::merge_batcher::Merger;
 use differential_dataflow::{AsCollection, Collection, Hashable, VecCollection};
-use timely::container::{DrainContainer, PushInto};
+use std::hash::{BuildHasher, Hash, Hasher};
+use timely::container::{CapacityContainerBuilder, DrainContainer, PushInto};
 use timely::dataflow::channels::pact::{Exchange, ParallelizationContract, Pipeline};
 use timely::dataflow::operators::Capability;
 use timely::dataflow::operators::generic::builder_rc::{
@@ -34,11 +36,12 @@ use timely::dataflow::operators::generic::{
     InputHandleCore, OperatorInfo, OutputBuilder, OutputBuilderSession,
 };
 use timely::dataflow::{Scope, Stream, StreamVec};
+use timely::progress::frontier::AntichainRef;
 use timely::progress::operate::FrontierInterest;
 use timely::progress::{Antichain, Timestamp};
 use timely::{Container, ContainerBuilder, PartialOrder};
 
-use crate::columnation::{ColumnationChunker, ColumnationStack};
+use crate::columnation::ColumnationStack;
 
 /// Extension methods for timely [`Stream`]s.
 pub trait StreamExt<'scope, T, C1>
@@ -160,6 +163,19 @@ where
     /// Block progress of the frontier at `expiration` time.
     fn expire_collection_at(self, name: &str, expiration: T) -> VecCollection<'scope, T, D1, R>;
 
+    /// Splits the collection in two by the time of each update.
+    ///
+    /// Updates for which `condition` holds land in the second collection, the rest in the first.
+    /// The test is per update, not per message, because a message carries a set of capabilities
+    /// rather than a single time and so cannot be routed as a whole.
+    fn branch_when(
+        self,
+        condition: impl Fn(&T) -> bool + 'static,
+    ) -> (
+        VecCollection<'scope, T, D1, R>,
+        VecCollection<'scope, T, D1, R>,
+    );
+
     /// Replaces each record with another, with a new difference type.
     ///
     /// This method is most commonly used to take records containing aggregatable data (e.g. numbers to be summed)
@@ -198,7 +214,12 @@ where
         D1: differential_dataflow::ExchangeData + Hash + Columnation,
         R: Semigroup + differential_dataflow::ExchangeData + Columnation,
         T: Lattice + Columnation,
-        Ba: Batcher<Time = T, Output = ColumnationStack<((D1, ()), T, R)>> + 'static;
+        Ba: Batcher<
+                Vec<((D1, ()), T, R)>,
+                Time = T,
+                Output = Vec<ColumnationStack<((D1, ()), T, R)>>,
+            > + 'static,
+        Ba: BatcherNew;
 
     /// Consolidates the collection.
     fn consolidate_named<Ba>(self, name: &str) -> Self
@@ -206,7 +227,12 @@ where
         D1: differential_dataflow::ExchangeData + Hash + Columnation,
         R: Semigroup + differential_dataflow::ExchangeData + Columnation,
         T: Lattice + Columnation,
-        Ba: Batcher<Time = T, Output = ColumnationStack<((D1, ()), T, R)>> + 'static;
+        Ba: Batcher<
+                Vec<((D1, ()), T, R)>,
+                Time = T,
+                Output = Vec<ColumnationStack<((D1, ()), T, R)>>,
+            > + 'static,
+        Ba: BatcherNew;
 }
 
 impl<'scope, T, C1> StreamExt<'scope, T, C1> for Stream<'scope, T, C1>
@@ -285,7 +311,7 @@ where
     {
         self.unary_fallible::<DCB, ECB, _, _>(Pipeline, name, move |_, _| {
             Box::new(move |input, ok_output, err_output| {
-                input.for_each_time(|time, data| {
+                input.for_each_stamp(|time, data| {
                     let mut ok_session = ok_output.session_with_builder(&time);
                     let mut err_session = err_output.session_with_builder(&time);
                     for r in data
@@ -381,6 +407,37 @@ where
             .as_collection()
     }
 
+    fn branch_when(
+        self,
+        condition: impl Fn(&T) -> bool + 'static,
+    ) -> (
+        VecCollection<'scope, T, D1, R>,
+        VecCollection<'scope, T, D1, R>,
+    ) {
+        let (falses, trues) = self
+            .inner
+            .unary_fallible::<CapacityContainerBuilder<_>, CapacityContainerBuilder<_>, _, _>(
+                Pipeline,
+                "BranchWhen",
+                move |_, _| {
+                    Box::new(move |input, false_output, true_output| {
+                        input.for_each(|time, data| {
+                            let mut false_session = false_output.session_with_builder(&time);
+                            let mut true_session = true_output.session_with_builder(&time);
+                            for update in data.drain(..) {
+                                if condition(&update.1) {
+                                    true_session.give(update)
+                                } else {
+                                    false_session.give(update)
+                                }
+                            }
+                        })
+                    })
+                },
+            );
+        (falses.as_collection(), trues.as_collection())
+    }
+
     fn explode_one<D2, R2, L>(
         self,
         mut logic: L,
@@ -451,7 +508,12 @@ where
         D1: differential_dataflow::ExchangeData + Hash + Columnation,
         R: Semigroup + differential_dataflow::ExchangeData + Columnation,
         T: Lattice + Ord + Columnation,
-        Ba: Batcher<Time = T, Output = ColumnationStack<((D1, ()), T, R)>> + 'static,
+        Ba: Batcher<
+                Vec<((D1, ()), T, R)>,
+                Time = T,
+                Output = Vec<ColumnationStack<((D1, ()), T, R)>>,
+            > + 'static,
+        Ba: BatcherNew,
     {
         if must_consolidate {
             // We employ AHash below instead of the default hasher in DD to obtain
@@ -473,10 +535,11 @@ where
                 data.hash(&mut h);
                 h.finish()
             });
-            consolidate_pact::<ColumnationChunker<((D1, ()), T, R)>, Ba, _, _>(
+            consolidate_pact::<Ba, _, _>(
                 self.map(|k| (k, ())).inner,
                 exchange,
                 name,
+                Ba::new_batcher,
             )
             .unary(Pipeline, "unpack consolidated", |_, _| {
                 |input, output| {
@@ -500,26 +563,28 @@ where
         D1: differential_dataflow::ExchangeData + Hash + Columnation,
         R: Semigroup + differential_dataflow::ExchangeData + Columnation,
         T: Lattice + Ord + Columnation,
-        Ba: Batcher<Time = T, Output = ColumnationStack<((D1, ()), T, R)>> + 'static,
+        Ba: Batcher<
+                Vec<((D1, ()), T, R)>,
+                Time = T,
+                Output = Vec<ColumnationStack<((D1, ()), T, R)>>,
+            > + 'static,
+        Ba: BatcherNew,
     {
         let exchange = Exchange::new(move |update: &((D1, ()), T, R)| (update.0).0.hashed());
 
-        consolidate_pact::<ColumnationChunker<((D1, ()), T, R)>, Ba, _, _>(
-            self.map(|k| (k, ())).inner,
-            exchange,
-            name,
-        )
-        .unary(Pipeline, &format!("Unpack {name}"), |_, _| {
-            |input, output| {
-                input.for_each(|time, data| {
-                    let mut session = output.session(&time);
-                    for ((k, ()), t, d) in data.iter().flatten().flat_map(|chunk| chunk.iter()) {
-                        session.give((k.clone(), t.clone(), d.clone()))
-                    }
-                })
-            }
-        })
-        .as_collection()
+        consolidate_pact::<Ba, _, _>(self.map(|k| (k, ())).inner, exchange, name, Ba::new_batcher)
+            .unary(Pipeline, &format!("Unpack {name}"), |_, _| {
+                |input, output| {
+                    input.for_each(|time, data| {
+                        let mut session = output.session(&time);
+                        for ((k, ()), t, d) in data.iter().flatten().flat_map(|chunk| chunk.iter())
+                        {
+                            session.give((k.clone(), t.clone(), d.clone()))
+                        }
+                    })
+                }
+            })
+            .as_collection()
     }
 }
 
@@ -529,16 +594,17 @@ where
 /// data is sorted according to `Ba`. For each timestamp, it produces at most one chain.
 ///
 /// The data are accumulated in place, each held back until their timestamp has completed.
-pub fn consolidate_pact<'scope, Chu, Ba, C, P>(
+pub fn consolidate_pact<'scope, Ba, C, P>(
     stream: Stream<'scope, Ba::Time, C>,
     pact: P,
     name: &str,
-) -> StreamVec<'scope, Ba::Time, Vec<Ba::Output>>
+    batcher: impl FnOnce(Option<Logger>, usize) -> Ba + 'static,
+) -> StreamVec<'scope, Ba::Time, Ba::Output>
 where
-    Ba: Batcher + 'static,
-    Chu: ContainerBuilder<Container = Ba::Output> + for<'a> PushInto<&'a mut C> + 'static,
+    Ba: Batcher<C> + 'static,
+    Ba::Time: Timestamp,
     C: Container + Clone + 'static,
-    Ba::Output: Clone,
+    Ba::Output: Default + Clone + 'static,
     P: ParallelizationContract<Ba::Time, C>,
 {
     let logger = stream
@@ -546,33 +612,26 @@ where
         .worker()
         .logger_for("differential/arrange")
         .map(Into::into);
-    stream.unary_frontier(pact, name, |_cap, info| {
-        // Acquire a logger for arrange events.
-
-        let mut batcher = Ba::new(logger, info.global_id);
-        // The chunker consolidates raw input containers into the chunks the
-        // batcher consumes.
-        let mut chunker = Chu::default();
+    stream.unary_frontier(pact, name, move |_cap, info| {
+        let mut batcher = batcher(logger, info.global_id);
         // Capabilities for the lower envelope of updates in `batcher`.
         let mut capabilities = Antichain::<Capability<Ba::Time>>::new();
         let mut prev_frontier = Antichain::from_elem(Ba::Time::minimum());
+        // `extract` reports the batcher's retained lower bound borrowed from the batcher
+        // itself, so it must be copied out before the next call reborrows the batcher.
+        let mut batcher_frontier = Antichain::<Ba::Time>::new();
 
         move |(input, frontier), output| {
             input.for_each(|cap, data| {
-                capabilities.insert(cap.retain(0));
-                chunker.push_into(data);
-                while let Some(chunk) = chunker.extract() {
-                    batcher.push_into(std::mem::take(chunk));
+                // A message's stamp need not be a singleton, so retain the whole set rather
+                // than asking for the one time `retain` would insist on.
+                for capability in cap.retain_stamp(0).iter() {
+                    capabilities.insert(capability.clone());
                 }
+                batcher.insert(data);
             });
 
             if prev_frontier.borrow() != frontier.frontier() {
-                // Flush any data the chunker is still accumulating into the
-                // batcher before we seal.
-                while let Some(chunk) = chunker.finish() {
-                    batcher.push_into(std::mem::take(chunk));
-                }
-
                 if capabilities
                     .elements()
                     .iter()
@@ -594,11 +653,14 @@ where
                                 upper.insert(other_capability.time().clone());
                             }
 
+                            // Extract updates not in advance of `upper`.
+                            let (chain, retained) = batcher.extract(upper.borrow());
+                            batcher_frontier.clear();
+                            batcher_frontier.extend(retained.iter().cloned());
+
                             // send the batch to downstream consumers, empty or not.
                             let mut session = output.session(&capabilities.elements()[index]);
-                            // Extract updates not in advance of `upper`.
-                            let (chain, _description) = batcher.seal(upper.clone());
-                            session.give(chain);
+                            session.give(chain.unwrap_or_default());
                         }
                     }
 
@@ -608,7 +670,7 @@ where
                     // in messages with new capabilities.
 
                     let mut new_capabilities = Antichain::new();
-                    for time in batcher.frontier().iter() {
+                    for time in batcher_frontier.iter() {
                         if let Some(capability) = capabilities
                             .elements()
                             .iter()
@@ -630,6 +692,203 @@ where
     })
 }
 
+/// Accumulates updates into sorted, consolidated chains, and releases what a frontier unblocks.
+///
+/// This is the [`Batcher`] a consolidation wants. Differential's own `MergeBatcher` seals each
+/// extracted chain into a trace batch, which a caller that only needs the updates consolidated
+/// would immediately have to take apart again; this one hands the chain over as it is.
+///
+/// `Chu` melds raw input containers into sorted, consolidated chunks, and `M` merges those
+/// chunks and splits them by time. The batcher's own work is the geometric ladder of chains
+/// and the carve-by-frontier, mirroring `MergeBatcher`'s.
+pub struct ConsolidatingBatcher<Chu, M: Merger> {
+    /// 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. A chain is immutable until merged, so
+    /// the weight is computed once, at push. Go through [`Self::chain_push`] and
+    /// [`Self::chain_pop`] rather than touching this directly, or the accounting drifts.
+    chains: Vec<(usize, Vec<M::Chunk>)>,
+    /// Stash of empty chunks, recycled through the merging process.
+    stash: Vec<M::Chunk>,
+    /// Merges consolidated chunks, and splits a chain at a frontier.
+    merger: M,
+    /// The lower-bound frontier of the data retained after the last extract.
+    frontier: Antichain<M::Time>,
+    /// Logger for size accounting.
+    logger: Option<Logger>,
+    /// Timely operator ID, which the accounting is attributed to.
+    operator_id: usize,
+}
+
+impl<Chu: Default, M: Merger<Time: Timestamp>> ConsolidatingBatcher<Chu, M> {
+    /// Allocates a new empty batcher.
+    pub fn new(logger: Option<Logger>, operator_id: usize) -> Self {
+        Self {
+            chunker: Chu::default(),
+            chains: Vec::new(),
+            stash: Vec::new(),
+            merger: M::default(),
+            frontier: Antichain::new(),
+            logger,
+            operator_id,
+        }
+    }
+}
+
+impl<C, Chu, M> Batcher<C> for ConsolidatingBatcher<Chu, M>
+where
+    M: Merger<Time: Timestamp>,
+    Chu: ContainerBuilder<Container = M::Chunk> + for<'a> PushInto<&'a mut C>,
+{
+    type Time = M::Time;
+    type Output = Vec<M::Chunk>;
+
+    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]);
+        }
+    }
+
+    fn extract<'a>(
+        &'a mut self,
+        upper: AntichainRef<'_, M::Time>,
+    ) -> (Option<Self::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]);
+        }
+
+        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();
+
+        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();
+
+        let readied = (!readied.is_empty()).then_some(readied);
+        (readied, self.frontier.borrow())
+    }
+}
+
+impl<Chu, M: Merger> ConsolidatingBatcher<Chu, M> {
+    /// Insert one already sorted and consolidated chunk, bypassing the chunker.
+    ///
+    /// The ladder assumes each chunk it holds is sorted and consolidated, so a caller that
+    /// prepared the chunk itself uses this; everything else goes through [`Batcher::insert`].
+    pub fn push_chunk(&mut self, chunk: M::Chunk) {
+        self.insert_chain(vec![chunk]);
+    }
+
+    /// Insert a chain and restore the ladder: chains are geometrically sized by summed
+    /// updates and ordered by decreasing 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);
+            }
+        }
+    }
+
+    fn merge_by(&mut self, list1: Vec<M::Chunk>, list2: Vec<M::Chunk>) -> Vec<M::Chunk> {
+        let mut output = Vec::with_capacity(list1.len() + list2.len());
+        self.merger
+            .merge(list1, list2, &mut output, &mut self.stash);
+        output
+    }
+
+    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)
+    }
+
+    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));
+    }
+
+    fn record(chunk: &M::Chunk) -> (usize, usize, usize, usize) {
+        let (size, capacity, allocations) = M::allocation(chunk);
+        (M::len(chunk), size, capacity, allocations)
+    }
+
+    /// Report a signed change in the resident chains, if a logger is attached.
+    fn account<I: IntoIterator<Item = (usize, usize, usize, usize)>>(&self, items: I, diff: isize) {
+        let Some(logger) = &self.logger else {
+            return;
+        };
+        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.saturating_mul(diff),
+            size_diff: size.saturating_mul(diff),
+            capacity_diff: capacity.saturating_mul(diff),
+            allocations_diff: allocations.saturating_mul(diff),
+        });
+    }
+}
+
+impl<Chu, M: Merger> Drop for ConsolidatingBatcher<Chu, M> {
+    fn drop(&mut self) {
+        // Retract the accounting for whatever is still resident, so the per-operator
+        // counters end at zero.
+        while self.chain_pop().is_some() {}
+    }
+}
+
+/// A batcher with differential's constructor shape, for generic code that must build one.
+///
+/// [`Batcher`] itself has no constructor: differential's operators take one as an `FnOnce`
+/// argument, which callers can supply because they name the batcher type. A generic caller
+/// that does not, such as [`CollectionExt::consolidate_named`], needs this instead.
+pub trait BatcherNew {
+    /// Allocates an empty batcher, reporting its footprint against `operator_id`.
+    fn new_batcher(logger: Option<Logger>, operator_id: usize) -> Self;
+}
+
+impl<Chu: Default, M: Merger<Time: Timestamp>> BatcherNew for ConsolidatingBatcher<Chu, M> {
+    fn new_batcher(logger: Option<Logger>, operator_id: usize) -> Self {
+        Self::new(logger, operator_id)
+    }
+}
+
 /// Merge the contents of multiple streams and combine the containers using a container builder.
 pub trait ConcatenateFlatten<'scope, T: Timestamp, C: Container + DrainContainer> {
     /// Merge the contents of multiple streams and use the provided container builder to form
@@ -702,7 +961,7 @@ where
             move |_frontier| {
                 let mut output = output.activate();
                 for handle in handles.iter_mut() {
-                    handle.for_each_time(|time, data| {
+                    handle.for_each_stamp(|time, data| {
                         output
                             .session_with_builder(&time)
                             .give_iterator(data.flat_map(DrainContainer::drain));
diff --git a/src/timely-util/src/probe.rs b/src/timely-util/src/probe.rs
index 93a25c70b9c12..0a1afca0a2da4 100644
--- a/src/timely-util/src/probe.rs
+++ b/src/timely-util/src/probe.rs
@@ -18,7 +18,7 @@ use std::convert::Infallible;
 use std::rc::Rc;
 
 use timely::container::CapacityContainerBuilder;
-use timely::dataflow::operators::{CapabilitySet, InspectCore};
+use timely::dataflow::operators::{CapabilitySet, Inspect};
 use timely::dataflow::{Scope, Stream, StreamVec};
 use timely::progress::Timestamp;
 use timely::progress::frontier::{Antichain, AntichainRef, MutableAntichain};
@@ -51,7 +51,7 @@ where
 
         // TODO: This operator observes but doesn't consume data.
         // Instead, it should only observe progress statements.
-        self.inspect_container(move |update| {
+        self.inspect_core(move |update| {
             if let Err(frontier) = update {
                 for handle in &mut handles {
                     handle.update_frontier(frontier);
diff --git a/src/timely-util/src/reclock.rs b/src/timely-util/src/reclock.rs
index 9f4b2b41afac4..9259ebc6a469a 100644
--- a/src/timely-util/src/reclock.rs
+++ b/src/timely-util/src/reclock.rs
@@ -170,16 +170,15 @@
 //! 11. Q.E.D
 //!     * _Proof: By <1>5 and <1>10_
 
-use std::cmp::{Ordering, Reverse};
-use std::collections::VecDeque;
-use std::collections::binary_heap::{BinaryHeap, PeekMut};
-use std::iter::FromIterator;
-
 use differential_dataflow::difference::Semigroup;
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::{AsCollection, ExchangeData, VecCollection, consolidation};
 use mz_ore::Overflowing;
 use mz_ore::collections::CollectionExt;
+use std::cmp::{Ordering, Reverse};
+use std::collections::VecDeque;
+use std::collections::binary_heap::{BinaryHeap, PeekMut};
+use std::iter::FromIterator;
 use timely::communication::{Pull, Push};
 use timely::dataflow::channels::pact::Pipeline;
 use timely::dataflow::operators::CapabilitySet;
@@ -608,8 +607,8 @@ mod test {
     use timely::dataflow::operators::vec::UnorderedInput;
     use timely::dataflow::operators::vec::unordered_input::UnorderedHandle;
     use timely::dataflow::operators::{ActivateCapability, Capture};
-    use timely::progress::PathSummary;
     use timely::progress::timestamp::Refines;
+    use timely::progress::{PathSummary, Stamp};
     use timely::worker::Worker;
 
     use crate::capture::PusherCapture;
@@ -751,7 +750,7 @@ mod test {
                 assert_eq!(
                     reclocked.try_recv(),
                     Ok(Event::Messages(
-                        0u64,
+                        Stamp::from_elem(0u64),
                         vec![
                             (1, 1000, Diff::ONE),
                             (1, 1000, Diff::ONE),
@@ -776,7 +775,7 @@ mod test {
                 assert_eq!(
                     reclocked.try_recv(),
                     Ok(Event::Messages(
-                        1000u64,
+                        Stamp::from_elem(1000u64),
                         vec![(3, 1000, Diff::ONE), (3, 1000, Diff::ONE)]
                     ))
                 );
@@ -899,7 +898,7 @@ mod test {
                 assert_eq!(
                     reclocked.try_recv(),
                     Ok(Event::Messages(
-                        0,
+                        Stamp::from_elem(0),
                         vec![(1, 1000, Diff::ONE), (2, 1000, Diff::ONE)]
                     ))
                 );
@@ -930,7 +929,7 @@ mod test {
                 assert_eq!(
                     reclocked.try_recv(),
                     Ok(Event::Messages(
-                        1001,
+                        Stamp::from_elem(1001),
                         vec![
                             (3, 2000, Diff::ONE),
                             (3, 2000, Diff::ONE),
@@ -992,7 +991,10 @@ mod test {
                 step(worker);
                 assert_eq!(
                     reclocked.try_recv(),
-                    Ok(Event::Messages(0, vec![(50, 3000, Diff::ONE),]))
+                    Ok(Event::Messages(
+                        Stamp::from_elem(0),
+                        vec![(50, 3000, Diff::ONE),]
+                    ))
                 );
                 assert_eq!(
                     reclocked.try_recv(),
diff --git a/src/txn-wal/src/operator.rs b/src/txn-wal/src/operator.rs
index 06166c0d502a5..94ff1cddca11a 100644
--- a/src/txn-wal/src/operator.rs
+++ b/src/txn-wal/src/operator.rs
@@ -9,14 +9,6 @@
 
 //! Timely operators for the crate
 
-use std::any::Any;
-use std::fmt::Debug;
-use std::future::Future;
-use std::rc::Rc;
-use std::sync::mpsc::TryRecvError;
-use std::sync::{Arc, mpsc};
-use std::time::Duration;
-
 use differential_dataflow::Hashable;
 use differential_dataflow::difference::Monoid;
 use differential_dataflow::lattice::Lattice;
@@ -32,7 +24,15 @@ use mz_persist_types::txn::TxnsCodec;
 use mz_persist_types::{Codec, Codec64, StepForward};
 use mz_timely_util::activator::ArcActivator;
 use mz_timely_util::builder_async::{PressOnDropButton, button};
+use std::any::Any;
+use std::fmt::Debug;
+use std::future::Future;
+use std::rc::Rc;
+use std::sync::mpsc::TryRecvError;
+use std::sync::{Arc, mpsc};
+use std::time::Duration;
 use timely::dataflow::channels::pact::Pipeline;
+
 #[cfg(test)]
 use timely::dataflow::operators::Input;
 use timely::dataflow::operators::capture::Event;
@@ -1066,7 +1066,11 @@ mod tests {
         let frontier = probe.with_frontier(|f| *f.as_option().unwrap_or(&u64::MAX));
         let mut output = Vec::new();
         while let Ok(event) = capture.try_recv() {
-            if let Event::Messages(time, msgs) = event {
+            if let Event::Messages(stamp, msgs) = event {
+                // A message may be stamped by several capabilities; the records it carries are
+                // at times greater or equal to one of them, so the largest is the tightest
+                // single time to attribute them to.
+                let time = stamp.iter().copied().max().expect("non-empty stamp");
                 for payload in msgs {
                     output.push((payload, time, 1));
                 }
@@ -1295,16 +1299,16 @@ mod tests {
         ];
         assert_eq!(actual_records, expected_records);
 
-        // Verify the differential invariant: each batch's stream
-        // timestamp `ts` must be `<= record_time` for every record it
-        // carries. The operator's contract requires this so that
-        // downstream differential operators can integrate the records
-        // at their declared times.
-        for (ts, data) in &actual_events {
+        // Verify the differential invariant: every record a batch carries must be at a time
+        // greater or equal to some element of the batch's stamp. The operator's contract
+        // requires this so that downstream differential operators can integrate the records at
+        // their declared times.
+        for (stamp, data) in &actual_events {
             for (_key, record_ts, _diff) in data {
                 assert!(
-                    ts <= record_ts,
-                    "differential invariant violated: stream ts {ts} > record time {record_ts}",
+                    stamp.less_equal(record_ts),
+                    "differential invariant violated: no element of stamp {stamp:?} is \
+                     less or equal to record time {record_ts}",
                 );
             }
         }