diff --git a/LICENSE b/LICENSE
index 0cc0ff1ff8409..f0e5e32d33ff2 100644
--- a/LICENSE
+++ b/LICENSE
@@ -13,7 +13,7 @@ Business Source License 1.1
 
 Licensor:                  Materialize, Inc.
 
-Licensed Work:             Materialize Version 20260911
+Licensed Work:             Materialize Version 20260912
                            The Licensed Work is © 2026 Materialize, Inc.
 
 Additional Use Grant:      Within a single installation of the Licensed Work,
@@ -39,7 +39,7 @@ Additional Use Grant:      Within a single installation of the Licensed Work,
                            whose definitions are controlled by such third
                            parties.
 
-Change Date:               September 11, 2030
+Change Date:               September 12, 2030
 
 Change License:            Apache License, Version 2.0
 
diff --git a/ci/mkpipeline.py b/ci/mkpipeline.py
index 909a2d7de7ebd..ddaf8d78370f5 100644
--- a/ci/mkpipeline.py
+++ b/ci/mkpipeline.py
@@ -759,33 +759,47 @@ def permit_rerunning_successful_steps(pipeline: Any) -> None:
         )
 
 
+# Failures that are the infrastructure's fault rather than the step's, so every
+# step retries them regardless of what else it asks for.
+SHARED_AUTOMATIC_RETRIES = [
+    {
+        "exit_status": -1,
+        "signal_reason": "none",
+        "limit": 2,
+    },
+    {
+        "signal_reason": "agent_stop",  # Stopped by OS
+        "limit": 2,
+    },
+    {
+        "exit_status": 128,  # Temporary Github/GHCR/DockerHub connection issue
+        "limit": 2,
+    },
+    {
+        "exit_status": 199,  # Rust ICE https://github.com/rust-lang/rust/issues/148581
+        "limit": 2,
+    },
+]
+
+
 def set_retry_on_agent_lost(pipeline: Any) -> None:
     for step in steps(pipeline):
         if "trigger" in step or "wait" in step or "group" in step or "block" in step:
             continue
-        retry = step.setdefault("retry", {})
-        if "automatic" in retry:
+        automatic = step.setdefault("retry", {}).setdefault("automatic", [])
+        # A step retrying on every exit status already covers these.
+        if any(rule.get("exit_status") == "*" for rule in automatic):
             continue
-        retry.setdefault("automatic", []).extend(
-            [
-                {
-                    "exit_status": -1,
-                    "signal_reason": "none",
-                    "limit": 2,
-                },
-                {
-                    "signal_reason": "agent_stop",  # Stopped by OS
-                    "limit": 2,
-                },
-                {
-                    "exit_status": 128,  # Temporary Github/GHCR/DockerHub connection issue
-                    "limit": 2,
-                },
-                {
-                    "exit_status": 199,  # Rust ICE https://github.com/rust-lang/rust/issues/148581
-                    "limit": 2,
-                },
-            ]
+        # Merge rather than skip a step that declares its own rules: skipping
+        # lets a narrow override such as `exit_status: 1` drop every shared rule
+        # and hard-fail the step on the infrastructure classes they exist for.
+        # Nothing surfaces that, and the mzcompose plugin goes out of its way to
+        # propagate 128 and 199 so these rules can match.
+        declared = {(r.get("exit_status"), r.get("signal_reason")) for r in automatic}
+        automatic.extend(
+            dict(rule)
+            for rule in SHARED_AUTOMATIC_RETRIES
+            if (rule.get("exit_status"), rule.get("signal_reason")) not in declared
         )
 
 
diff --git a/doc/user/content/sql/system-catalog/mz_internal.md b/doc/user/content/sql/system-catalog/mz_internal.md
index d36965fa807ed..0778a125b2121 100644
--- a/doc/user/content/sql/system-catalog/mz_internal.md
+++ b/doc/user/content/sql/system-catalog/mz_internal.md
@@ -227,6 +227,7 @@ usage.
 | `disk_bytes`        | [`uint8`]    | Approximate disk usage, in bytes.
 | `heap_bytes`        | [`uint8`]    | Approximate heap (RAM + swap) usage, in bytes.
 | `heap_limit`        | [`uint8`]    | Available heap (RAM + swap) space, in bytes.
+| `swap_bytes`        | [`uint8`]    | Approximate swap usage, in bytes.
 
 ## `mz_cluster_replica_metrics_history`
 
@@ -252,6 +253,7 @@ history is retained across restarts.
 | `occurred_at`    | [`timestamp with time zone`] | Wall-clock timestamp at which the event occurred.
 | `heap_bytes`     | [`uint8`] | Approximate heap (RAM + swap) usage, in bytes.
 | `heap_limit`     | [`uint8`] | Available heap (RAM + swap) space, in bytes.
+| `swap_bytes`     | [`uint8`] | Approximate swap usage, in bytes.
 
 ## `mz_cluster_replica_statuses`
 
@@ -298,6 +300,7 @@ At this time, we do not make any guarantees about the exactness or freshness of
 | `memory_percent` | [`double precision`] | Approximate RAM usage, in percent of the total allocation.
 | `disk_percent`   | [`double precision`] | Approximate disk usage, in percent of the total allocation.
 | `heap_percent`   | [`double precision`] | Approximate heap (RAM + swap) usage, in percent of the total allocation.
+| `swap_percent`   | [`double precision`] | Approximate swap usage, in percent of the total heap allocation.
 
 ## `mz_cluster_replica_utilization_history`
 
@@ -316,6 +319,7 @@ At this time, we do not make any guarantees about the exactness or freshness of
 | `memory_percent` | [`double precision`] | Approximate RAM usage, in percent of the total allocation.
 | `disk_percent`   | [`double precision`] | Approximate disk usage, in percent of the total allocation.
 | `heap_percent`   | [`double precision`] | Approximate heap (RAM + swap) usage, in percent of the total allocation.
+| `swap_percent`   | [`double precision`] | Approximate swap usage, in percent of the total heap allocation.
 | `occurred_at`    | [`timestamp with time zone`] | Wall-clock timestamp at which the event occurred.
 
 ## `mz_cluster_replica_history`
diff --git a/src/adapter/src/catalog/open/builtin_schema_migration.rs b/src/adapter/src/catalog/open/builtin_schema_migration.rs
index 34653cd13aad0..e21d3da4179bb 100644
--- a/src/adapter/src/catalog/open/builtin_schema_migration.rs
+++ b/src/adapter/src/catalog/open/builtin_schema_migration.rs
@@ -462,6 +462,16 @@ static MIGRATIONS: LazyLock<Vec<MigrationStep>> = LazyLock::new(|| {
             MZ_INTERNAL_SCHEMA,
             "mz_object_dependencies",
         ),
+        // Adding the `swap_bytes` column to `mz_cluster_replica_metrics_history`
+        // is a backward-compatible append, so the shard schema can evolve in
+        // place. See the NOTE above: this version must stay at the workspace's
+        // current dev version until the change ships.
+        MigrationStep::evolution(
+            "26.43.0-dev.0",
+            CatalogItemType::Source,
+            MZ_INTERNAL_SCHEMA,
+            "mz_cluster_replica_metrics_history",
+        ),
     ]
 });
 
diff --git a/src/catalog/src/builtin/mz_internal.rs b/src/catalog/src/builtin/mz_internal.rs
index 006492fbdf5d2..ccde5b89bd957 100644
--- a/src/catalog/src/builtin/mz_internal.rs
+++ b/src/catalog/src/builtin/mz_internal.rs
@@ -2734,6 +2734,7 @@ pub static MZ_CLUSTER_REPLICA_METRICS_HISTORY: LazyLock<BuiltinSource> =
                 "Approximate heap (RAM + swap) usage, in bytes.",
             ),
             ("heap_limit", "Available heap (RAM + swap) space, in bytes."),
+            ("swap_bytes", "Approximate swap usage, in bytes."),
         ]),
         is_retained_metrics_object: false,
         access: vec![PUBLIC_SELECT],
@@ -2752,6 +2753,7 @@ pub static MZ_CLUSTER_REPLICA_METRICS: LazyLock<BuiltinView> = LazyLock::new(||
         .with_column("disk_bytes", SqlScalarType::UInt64.nullable(true))
         .with_column("heap_bytes", SqlScalarType::UInt64.nullable(true))
         .with_column("heap_limit", SqlScalarType::UInt64.nullable(true))
+        .with_column("swap_bytes", SqlScalarType::UInt64.nullable(true))
         .with_key(vec![0, 1])
         .finish(),
     column_comments: BTreeMap::from_iter([
@@ -2768,6 +2770,7 @@ pub static MZ_CLUSTER_REPLICA_METRICS: LazyLock<BuiltinView> = LazyLock::new(||
             "Approximate heap (RAM + swap) usage, in bytes.",
         ),
         ("heap_limit", "Available heap (RAM + swap) space, in bytes."),
+        ("swap_bytes", "Approximate swap usage, in bytes."),
     ]),
     sql: "
 SELECT
@@ -2778,7 +2781,8 @@ SELECT
     memory_bytes,
     disk_bytes,
     heap_bytes,
-    heap_limit
+    heap_limit,
+    swap_bytes
 FROM mz_internal.mz_cluster_replica_metrics_history
 JOIN mz_cluster_replicas r ON r.id = replica_id
 ORDER BY replica_id, process_id, occurred_at DESC",
@@ -2805,6 +2809,7 @@ ORDER BY replica_id, process_id, occurred_at DESC",
                 ("disk_bytes", SemanticType::ByteCount),
                 ("heap_bytes", SemanticType::ByteCount),
                 ("heap_limit", SemanticType::ByteCount),
+                ("swap_bytes", SemanticType::ByteCount),
             ]
         },
     }),
@@ -5421,6 +5426,7 @@ pub static MZ_CLUSTER_REPLICA_UTILIZATION: LazyLock<BuiltinView> = LazyLock::new
         .with_column("memory_percent", SqlScalarType::Float64.nullable(true))
         .with_column("disk_percent", SqlScalarType::Float64.nullable(true))
         .with_column("heap_percent", SqlScalarType::Float64.nullable(true))
+        .with_column("swap_percent", SqlScalarType::Float64.nullable(true))
         .finish(),
     column_comments: BTreeMap::from_iter([
         ("replica_id", "The ID of a cluster replica."),
@@ -5441,6 +5447,10 @@ pub static MZ_CLUSTER_REPLICA_UTILIZATION: LazyLock<BuiltinView> = LazyLock::new
             "heap_percent",
             "Approximate heap (RAM + swap) usage, in percent of the total allocation.",
         ),
+        (
+            "swap_percent",
+            "Approximate swap usage, in percent of the total heap allocation.",
+        ),
     ]),
     sql: "
 SELECT
@@ -5449,7 +5459,8 @@ SELECT
     m.cpu_nano_cores::float8 / NULLIF(s.cpu_nano_cores, 0) * 100 AS cpu_percent,
     m.memory_bytes::float8 / NULLIF(s.memory_bytes, 0) * 100 AS memory_percent,
     m.disk_bytes::float8 / NULLIF(s.disk_bytes, 0) * 100 AS disk_percent,
-    m.heap_bytes::float8 / NULLIF(m.heap_limit, 0) * 100 AS heap_percent
+    m.heap_bytes::float8 / NULLIF(m.heap_limit, 0) * 100 AS heap_percent,
+    m.swap_bytes::float8 / NULLIF(m.heap_limit, 0) * 100 AS swap_percent
 FROM
     mz_catalog.mz_cluster_replicas AS r
         JOIN mz_catalog.mz_cluster_replica_sizes AS s ON r.size = s.size
@@ -5486,6 +5497,7 @@ pub static MZ_CLUSTER_REPLICA_UTILIZATION_HISTORY: LazyLock<BuiltinView> =
             .with_column("memory_percent", SqlScalarType::Float64.nullable(true))
             .with_column("disk_percent", SqlScalarType::Float64.nullable(true))
             .with_column("heap_percent", SqlScalarType::Float64.nullable(true))
+            .with_column("swap_percent", SqlScalarType::Float64.nullable(true))
             .with_column(
                 "occurred_at",
                 SqlScalarType::TimestampTz { precision: None }.nullable(false),
@@ -5510,6 +5522,10 @@ pub static MZ_CLUSTER_REPLICA_UTILIZATION_HISTORY: LazyLock<BuiltinView> =
                 "heap_percent",
                 "Approximate heap (RAM + swap) usage, in percent of the total allocation.",
             ),
+            (
+                "swap_percent",
+                "Approximate swap usage, in percent of the total heap allocation.",
+            ),
             (
                 "occurred_at",
                 "Wall-clock timestamp at which the event occurred.",
@@ -5523,6 +5539,7 @@ SELECT
     m.memory_bytes::float8 / NULLIF(s.memory_bytes, 0) * 100 AS memory_percent,
     m.disk_bytes::float8 / NULLIF(s.disk_bytes, 0) * 100 AS disk_percent,
     m.heap_bytes::float8 / NULLIF(m.heap_limit, 0) * 100 AS heap_percent,
+    m.swap_bytes::float8 / NULLIF(m.heap_limit, 0) * 100 AS swap_percent,
     m.occurred_at
 FROM
     mz_catalog.mz_cluster_replicas AS r
diff --git a/src/compute/src/extensions/temporal_bucket.rs b/src/compute/src/extensions/temporal_bucket.rs
index 13a0f45009987..6f24cf081683d 100644
--- a/src/compute/src/extensions/temporal_bucket.rs
+++ b/src/compute/src/extensions/temporal_bucket.rs
@@ -9,73 +9,81 @@
 
 //! Utilities and stream extensions for temporal bucketing.
 
-use columnar::{Columnar, Index, Len};
+use std::hash::Hash;
+
+use columnar::{Columnar, Index, Len, Push};
 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::builder::ColumnBuilder;
+use mz_timely_util::columnar::columnar_exchange_data;
 use mz_timely_util::columnar::merge_batcher::ColumnMergeBatcher;
-use mz_timely_util::temporal::{Bucket, BucketChain, BucketTimestamp};
+use mz_timely_util::temporal::{Bucket, BucketChain, BucketRange, BucketTimestamp};
 use timely::Accountable;
-use timely::container::PushInto;
-use timely::dataflow::channels::pact::Exchange;
+use timely::container::{CapacityContainerBuilder, PushInto};
+use timely::dataflow::channels::pact::{Exchange, ExchangeCore};
 use timely::dataflow::operators::Operator;
 use timely::dataflow::{Stream, StreamVec};
 use timely::order::TotalOrder;
 use timely::progress::{Antichain, PathSummary, Timestamp};
-use timely::{ContainerBuilder, ExchangeData, PartialOrder};
+use timely::{ExchangeData, PartialOrder};
 
 use crate::typedefs::MzData;
 
 /// Sort outstanding updates into a [`BucketChain`], and reveal data not in advance of the input
 /// frontier. Retains a capability at the last input frontier to retain the right to produce data
 /// at times between the last input frontier and the current input frontier.
-pub trait TemporalBucketing<'scope, T: Timestamp, O> {
+pub trait TemporalBucketing<'scope, T: Timestamp>: Sized {
     /// Construct a new stream that stores updates into a [`BucketChain`] and reveals data
     /// not in advance of the frontier. Data that is within `threshold` distance of the input
     /// frontier or the `as_of` is passed through without being stored in the chain.
-    fn bucket<CB>(
-        self,
-        as_of: Antichain<T>,
-        threshold: T::Summary,
-    ) -> Stream<'scope, T, CB::Container>
-    where
-        CB: ContainerBuilder + PushInto<O>;
+    ///
+    /// The output container matches the input's, so a caller keeps whichever
+    /// representation it had.
+    fn bucket(self, as_of: Antichain<T>, threshold: T::Summary) -> Self;
 }
 
 /// Implementation for streams in scopes where timestamps define a total order.
-impl<'scope, T, D> TemporalBucketing<'scope, T, (D, T, mz_repr::Diff)>
-    for StreamVec<'scope, T, (D, T, mz_repr::Diff)>
+impl<'scope, T, D> TemporalBucketing<'scope, T> for Stream<'scope, T, Column<(D, T, mz_repr::Diff)>>
 where
     T: Timestamp + Default + ExchangeData + MzData + BucketTimestamp + TotalOrder + Lattice,
+    for<'a> columnar::Ref<'a, T>: Copy + Ord,
     D: ExchangeData + MzData + Ord + Clone + std::fmt::Debug + Hashable,
+    for<'a> columnar::Ref<'a, D>: Copy + Ord + Hash,
+    for<'a> columnar::Ref<'a, mz_repr::Diff>: Ord,
+    for<'a> <(D, T, mz_repr::Diff) as Columnar>::Container:
+        Push<columnar::Ref<'a, (D, T, mz_repr::Diff)>>,
 {
-    fn bucket<CB>(
-        self,
-        as_of: Antichain<T>,
-        threshold: T::Summary,
-    ) -> Stream<'scope, T, CB::Container>
-    where
-        CB: ContainerBuilder + PushInto<(D, T, mz_repr::Diff)>,
-    {
+    fn bucket(self, as_of: Antichain<T>, threshold: T::Summary) -> Self {
         let scope = self.scope();
         let logger = scope
             .worker()
             .logger_for("differential/arrange")
             .map(Into::into);
 
-        let pact = Exchange::new(|(d, _, _): &(D, T, mz_repr::Diff)| d.hashed().into());
-        self.unary_frontier::<CB, _, _, _>(pact, "Temporal delay", |cap, info| {
+        type CB<D, T> = CapacityContainerBuilder<Column<(D, T, mz_repr::Diff)>>;
+
+        let pact = ExchangeCore::<ColumnBuilder<_>, _>::new_core(
+            columnar_exchange_data::<D, T, mz_repr::Diff>,
+        );
+        self.unary_frontier::<CB<D, T>, _, _, _>(pact, "Temporal delay", |cap, info| {
             let mut chain = BucketChain::new(MergeBatcherWrapper::new(logger, info.global_id));
             let activator = scope.activator_for(info.address);
 
             // Cap tracking the lower bound of potentially outstanding data.
             let mut cap = Some(cap);
 
-            // Buffer for data to be inserted into the chain.
-            let mut buffer = Vec::new();
+            // Holds one bucket's worth of updates on the way into the chain.
+            // Reused across activations for its allocation.
+            let mut buffer: Column<(D, T, mz_repr::Diff)> = Default::default();
+            // Reused input permutation, ordered by time.
+            let mut permutation: Vec<usize> = Vec::new();
+            // Reused so reading a record's time does not allocate: an iterative `T`
+            // owns a `PointStamp`'s allocation.
+            let mut time_buf = T::minimum();
 
             move |(input, frontier), output| {
                 // The upper frontier is the join of the input frontier and the `as_of` frontier,
@@ -93,41 +101,55 @@ where
                 input.for_each_time(|time, data| {
                     let mut session = output.session_with_builder(&time);
                     for data in data {
-                        // Skip data that is about to be revealed.
-                        let pass_through = data.extract_if(.., |(_, t, _)| !upper.less_equal(t));
-                        session.give_iterator(pass_through);
-
-                        // Sort data by time, then drain it into a buffer that contains data for a
-                        // single bucket. We scan the data for ranges of time that fall into the same
-                        // bucket so we can push batches of data at once.
-                        data.sort_unstable_by(|(_, t, _), (_, t2, _)| t.cmp(t2));
-
-                        let mut drain = data.drain(..);
-                        if let Some((datum, time, diff)) = drain.next() {
-                            let mut range = chain.range_of(&time).expect("Must exist");
-                            buffer.push((datum, time, diff));
-                            for (datum, time, diff) in drain {
-                                // If we have a range, check if the time is not within it.
-                                if !range.contains(&time) {
-                                    // If the time is outside the range, push the current buffer
-                                    // to the chain and reset the range.
-                                    if !buffer.is_empty() {
-                                        let bucket =
-                                            chain.find_mut(&range.start).expect("Must exist");
-                                        bucket.push_container(&mut buffer);
-                                        buffer.clear();
-                                    }
-                                    range = chain.range_of(&time).expect("Must exist");
-                                }
-                                buffer.push((datum, time, diff));
+                        let borrowed = data.borrow();
+
+                        // Pass through data about to be revealed, and retain the
+                        // index of everything the chain has to hold. Only the
+                        // retained records need ordering, and in steady state the
+                        // pass-through share is the larger one.
+                        permutation.clear();
+                        for index in 0..borrowed.len() {
+                            let update = borrowed.get(index);
+                            time_buf.copy_from(update.1);
+                            if upper.less_equal(&time_buf) {
+                                permutation.push(index);
+                            } else {
+                                session.give(update);
                             }
+                        }
 
-                            // Handle leftover data in the buffer.
-                            if !buffer.is_empty() {
-                                let bucket = chain.find_mut(&range.start).expect("Must exist");
-                                bucket.push_container(&mut buffer);
-                                buffer.clear();
+                        // Order the retained records by time so each bucket's
+                        // records land contiguously below. Sorting indices keeps
+                        // the records in place.
+                        permutation.sort_unstable_by_key(|index| borrowed.get(*index).1);
+
+                        // The range `buffer`'s contents belong to, `None` while empty.
+                        let mut buffered_range = None;
+                        for index in permutation.drain(..) {
+                            let update = borrowed.get(index);
+                            time_buf.copy_from(update.1);
+
+                            // Ship the buffer whenever the bucket changes, which
+                            // the time order makes a single transition per bucket.
+                            let contained = match &buffered_range {
+                                Some(range) => BucketRange::contains(range, &time_buf),
+                                None => false,
+                            };
+                            if !contained {
+                                if let Some(range) = buffered_range.take() {
+                                    let bucket = chain.find_mut(&range.start).expect("Must exist");
+                                    bucket.push_container(&mut buffer);
+                                }
+                                buffered_range =
+                                    Some(chain.range_of(&time_buf).expect("Must exist"));
                             }
+                            buffer.push_into(update);
+                        }
+
+                        // Handle leftover data in the buffer.
+                        if let Some(range) = buffered_range.take() {
+                            let bucket = chain.find_mut(&range.start).expect("Must exist");
+                            bucket.push_container(&mut buffer);
                         }
                     }
                 });
@@ -136,16 +158,10 @@ where
                 let peeled = chain.peel(upper.borrow());
                 if let Some(cap) = cap.as_ref() {
                     let mut session = output.session_with_builder(cap);
-                    for chunk in peeled.into_iter().flat_map(|x| x.done()) {
-                        // The columnar merge batcher hands back `Column` chunks; the output
-                        // builder consumes owned `(D, T, Diff)` tuples, so reconstitute each
-                        // record from its columnar reference.
-                        session.give_iterator(
-                            chunk
-                                .borrow()
-                                .into_index_iter()
-                                .map(<(D, T, mz_repr::Diff)>::into_owned),
-                        );
+                    // The chain hands back `Column` chunks already in the output's
+                    // shape, so each one moves as a container.
+                    for mut chunk in peeled.into_iter().flat_map(|x| x.done()) {
+                        session.give_container(&mut chunk);
                     }
                 } else {
                     // If we don't have a cap, we should not have any data to reveal.
@@ -178,13 +194,146 @@ where
     }
 }
 
+/// Implementation for `Vec` streams in scopes where timestamps define a total order.
+///
+/// A caller whose consumer wants owned records keeps a `Vec`-native operator, because
+/// staging the whole stream through a column would copy every pass-through record and
+/// allocate it again on the way out. Only records that enter the chain are encoded, which
+/// they were anyway: the chain's batcher is columnar. The reduce key-value path is the one
+/// such caller, and this implementation goes away once its consumer reads columns.
+impl<'scope, T, D> TemporalBucketing<'scope, T> for StreamVec<'scope, T, (D, T, mz_repr::Diff)>
+where
+    T: Timestamp + Default + ExchangeData + MzData + BucketTimestamp + TotalOrder + Lattice,
+    D: ExchangeData + MzData + Ord + Clone + std::fmt::Debug + Hashable,
+    for<'a> <(D, T, mz_repr::Diff) as Columnar>::Container: Push<&'a (D, T, mz_repr::Diff)>,
+{
+    fn bucket(self, as_of: Antichain<T>, threshold: T::Summary) -> Self {
+        let scope = self.scope();
+        let logger = scope
+            .worker()
+            .logger_for("differential/arrange")
+            .map(Into::into);
+
+        let pact = Exchange::new(|(d, _, _): &(D, T, mz_repr::Diff)| d.hashed().into());
+        self.unary_frontier::<CapacityContainerBuilder<Vec<(D, T, mz_repr::Diff)>>, _, _, _>(
+            pact,
+            "Temporal delay",
+            |cap, info| {
+                let mut chain = BucketChain::new(MergeBatcherWrapper::new(logger, info.global_id));
+                let activator = scope.activator_for(info.address);
+
+                // Cap tracking the lower bound of potentially outstanding data.
+                let mut cap = Some(cap);
+
+                // Staging column for the records of one bucket. The chain's batcher is
+                // columnar, so a stored record is encoded either way.
+                let mut buffer: Column<(D, T, mz_repr::Diff)> = Default::default();
+
+                move |(input, frontier), output| {
+                    // The upper frontier is the join of the input frontier and the `as_of`
+                    // frontier, with the `threshold` summary applied to it.
+                    let mut upper = Antichain::new();
+                    for time1 in &frontier.frontier() {
+                        for time2 in as_of.elements() {
+                            // TODO: Use `join_assign` if we ever use a timestamp with allocations.
+                            if let Some(time) = threshold.results_in(&time1.join(time2)) {
+                                upper.insert(time);
+                            }
+                        }
+                    }
+
+                    input.for_each_time(|time, data| {
+                        let mut session = output.session_with_builder(&time);
+                        for data in data {
+                            // Skip data that is about to be revealed.
+                            let pass_through =
+                                data.extract_if(.., |(_, t, _)| !upper.less_equal(t));
+                            session.give_iterator(pass_through);
+
+                            // Sort data by time, then drain it into a buffer that contains data
+                            // for a single bucket. We scan the data for ranges of time that fall
+                            // into the same bucket so we can push batches of data at once.
+                            data.sort_unstable_by(|(_, t, _), (_, t2, _)| t.cmp(t2));
+
+                            let mut drain = data.drain(..);
+                            if let Some(update) = drain.next() {
+                                let mut range = chain.range_of(&update.1).expect("Must exist");
+                                buffer.push_into(&update);
+                                for update in drain {
+                                    // If we have a range, check if the time is not within it.
+                                    if !range.contains(&update.1) {
+                                        // If the time is outside the range, push the current
+                                        // buffer to the chain and reset the range.
+                                        if !buffer.is_empty() {
+                                            let bucket =
+                                                chain.find_mut(&range.start).expect("Must exist");
+                                            bucket.push_container(&mut buffer);
+                                        }
+                                        range = chain.range_of(&update.1).expect("Must exist");
+                                    }
+                                    buffer.push_into(&update);
+                                }
+
+                                // Handle leftover data in the buffer.
+                                if !buffer.is_empty() {
+                                    let bucket = chain.find_mut(&range.start).expect("Must exist");
+                                    bucket.push_container(&mut buffer);
+                                }
+                            }
+                        }
+                    });
+
+                    // Check for data that is ready to be revealed.
+                    let peeled = chain.peel(upper.borrow());
+                    if let Some(cap) = cap.as_ref() {
+                        let mut session = output.session_with_builder(cap);
+                        for chunk in peeled.into_iter().flat_map(|x| x.done()) {
+                            session.give_iterator(
+                                chunk
+                                    .borrow()
+                                    .into_index_iter()
+                                    .map(<(D, T, mz_repr::Diff)>::into_owned),
+                            );
+                        }
+                    } else {
+                        // If we don't have a cap, we should not have any data to reveal.
+                        assert!(
+                            peeled
+                                .into_iter()
+                                .flat_map(|x| x.done())
+                                .all(|chunk| chunk.record_count() == 0),
+                            "Unexpected data revealed without a cap."
+                        );
+                    }
+
+                    // Downgrade the cap to the current input frontier.
+                    if frontier.is_empty() || upper.is_empty() {
+                        cap = None;
+                    } else if let Some(cap) = cap.as_mut() {
+                        // TODO: This assumes that the time is total ordered.
+                        cap.downgrade(&upper[0]);
+                    }
+
+                    // Maintain the bucket chain by restoring it with fuel.
+                    let mut fuel = 1_000_000;
+                    chain.restore(&mut fuel);
+                    if fuel <= 0 {
+                        // If we run out of fuel, we activate the operator to continue processing.
+                        activator.activate();
+                    }
+                }
+            },
+        )
+    }
+}
+
 /// A wrapper around [`ColumnMergeBatcher`] that implements the bucketing API.
 ///
 /// This is the same columnar-native merge batcher (`Col2ValPagedBatcher`) the
 /// default arrangement uses, so the bucket chain and arrangements share a single
 /// merge-batcher implementation. The batcher consumes pre-chunked, consolidated
 /// [`Column`] input, so this wrapper carries a [`ColumnChunker`] that sorts and
-/// consolidates the `Vec` input into the [`Column`] chunks the batcher consumes.
+/// consolidates the input columns into the chunks the batcher consumes.
 struct MergeBatcherWrapper<D, T, R>
 where
     D: MzData + Ord + Clone,
@@ -203,10 +352,10 @@ where
     T: MzData + Ord + PartialOrder + Clone + Default + Timestamp,
     R: MzData + Semigroup + Default + 'static + for<'a> Semigroup<columnar::Ref<'a, R>>,
     for<'a> columnar::Ref<'a, R>: Ord,
-    for<'a> <D as Columnar>::Container: columnar::Push<columnar::Ref<'a, D>>,
-    for<'a> <T as Columnar>::Container: columnar::Push<columnar::Ref<'a, T>>,
-    for<'a> <R as Columnar>::Container: columnar::Push<&'a R>,
-    for<'a> <(D, T, R) as Columnar>::Container: columnar::Push<&'a (D, T, R)>,
+    for<'a> <D as Columnar>::Container: Push<columnar::Ref<'a, D>>,
+    for<'a> <T as Columnar>::Container: Push<columnar::Ref<'a, T>>,
+    for<'a> <R as Columnar>::Container: Push<&'a R>,
+    for<'a> <(D, T, R) as Columnar>::Container: Push<&'a (D, T, R)>,
 {
     /// Construct a new `MergeBatcherWrapper` with the given logger and operator ID.
     fn new(logger: Option<differential_dataflow::logging::Logger>, operator_id: usize) -> Self {
@@ -219,19 +368,14 @@ where
     }
 
     /// Consolidate `buffer` through the chunker and feed any complete chunks to
-    /// the batcher. Empties `buffer`, retaining its capacity.
-    fn push_container(&mut self, buffer: &mut Vec<(D, T, R)>) {
+    /// the batcher. Leaves `buffer` empty, retaining its allocation.
+    fn push_container(&mut self, buffer: &mut Column<(D, T, R)>) {
         use timely::container::{ContainerBuilder as _, PushInto as _};
         if buffer.is_empty() {
             return;
         }
-        // The chunker consumes `Column` input, so stage the `Vec` updates into a
-        // raw `Column` first; the chunker then sorts and consolidates them.
-        let mut raw: Column<(D, T, R)> = Default::default();
-        for update in buffer.drain(..) {
-            raw.push_into(&update);
-        }
-        self.chunker.push_into(&mut raw);
+        self.chunker.push_into(buffer);
+        buffer.clear();
         while let Some(chunk) = self.chunker.extract() {
             self.inner.push_into(std::mem::take(chunk));
         }
@@ -259,33 +403,27 @@ where
     T: MzData + Ord + PartialOrder + Clone + Default + 'static + BucketTimestamp,
     R: MzData + Semigroup + Default + 'static + for<'a> Semigroup<columnar::Ref<'a, R>>,
     for<'a> columnar::Ref<'a, R>: Ord,
-    for<'a> <D as Columnar>::Container: columnar::Push<columnar::Ref<'a, D>>,
-    for<'a> <T as Columnar>::Container: columnar::Push<columnar::Ref<'a, T>>,
-    for<'a> <R as Columnar>::Container: columnar::Push<&'a R>,
-    for<'a> <(D, T, R) as Columnar>::Container: columnar::Push<&'a (D, T, R)>,
+    for<'a> <D as Columnar>::Container: Push<columnar::Ref<'a, D>>,
+    for<'a> <T as Columnar>::Container: Push<columnar::Ref<'a, T>>,
+    for<'a> <R as Columnar>::Container: Push<&'a R>,
+    for<'a> <(D, T, R) as Columnar>::Container: Push<&'a (D, T, R)>,
 {
     type Timestamp = T;
 
     fn split(mut self, timestamp: &Self::Timestamp, fuel: &mut i64) -> (Self, Self) {
-        // The implementation isn't tuned for performance: we round-trip the sealed
-        // chunks back through a `Vec` and re-chunk them into the lower batcher.
+        // Re-chunks the sealed chunks into the lower batcher rather than splitting the
+        // batcher's chains in place, so the chunker sorts and re-pushes every record,
+        // which is what the per-record `fuel` charge below accounts for. No record is
+        // reconstituted as an owned tuple on the way.
+        //
         // TODO: Split the batcher's chains directly without re-chunking.
         self.flush();
         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);
-        for chunk in chain {
+        for mut chunk in chain {
             *fuel = fuel.saturating_sub(chunk.record_count());
-            // TODO: Avoid this cloning.
-            buffer.extend(
-                chunk
-                    .borrow()
-                    .into_index_iter()
-                    .map(<(D, T, R)>::into_owned),
-            );
-            lower.push_container(&mut buffer);
-            buffer.clear();
+            lower.push_container(&mut chunk);
         }
         (lower, self)
     }
diff --git a/src/compute/src/render.rs b/src/compute/src/render.rs
index dd7ffdf40bbb1..ae60942908a5a 100644
--- a/src/compute/src/render.rs
+++ b/src/compute/src/render.rs
@@ -110,6 +110,7 @@ use std::rc::{Rc, Weak};
 use std::sync::Arc;
 use std::task::Poll;
 
+use ::columnar::{Columnar as ColumnarData, Index as ColumnarIndex, Push as ColumnarPush};
 use differential_dataflow::dynamic::pointstamp::PointStamp;
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::operators::arrange::Arranged;
@@ -117,7 +118,7 @@ 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::{AsCollection, Data, VecCollection};
+use differential_dataflow::{AsCollection, Collection, Data, VecCollection};
 use futures::FutureExt;
 use futures::channel::oneshot;
 use itertools::Itertools;
@@ -140,12 +141,12 @@ use mz_repr::fixed_length::ExtendDatums;
 use mz_repr::{Datum, DatumVec, Diff, GlobalId, ReprRelationType, Row, RowArena, SharedRow};
 use mz_storage_operators::persist_source;
 use mz_storage_types::controller::CollectionMetadata;
+use mz_timely_util::columnar::Column;
 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 timely::PartialOrder;
-use timely::container::CapacityContainerBuilder;
 use timely::dataflow::channels::pact::Pipeline;
 use timely::dataflow::operators::core::to_stream::ToStreamBuilder;
 use timely::dataflow::operators::vec::ToStream;
@@ -292,22 +293,24 @@ pub fn build_compute_dataflow(
 
                     // Note: For correctness, we require that sources only emit times advanced by
                     // `dataflow.as_of`. `persist_source` is documented to provide this guarantee.
-                    let (mut ok_stream, err_stream, token) =
-                        persist_source::persist_source::<DataflowErrorSer>(
-                            inner,
-                            *source_id,
-                            Arc::clone(&compute_state.persist_clients),
-                            &compute_state.txns_ctx,
-                            import.desc.storage_metadata.clone(),
-                            read_schema,
-                            dataflow.as_of.clone(),
-                            snapshot_mode,
-                            until.clone(),
-                            mfp.as_mut(),
-                            compute_state.dataflow_max_inflight_bytes(),
-                            start_signal.clone().into_send_future(),
-                            ErrorHandler::Halt("compute_import"),
-                        );
+                    let (mut ok_stream, err_stream, token) = persist_source::persist_source::<
+                        DataflowErrorSer,
+                        ConsolidatingColumnBuilder<Row, mz_repr::Timestamp, Diff>,
+                    >(
+                        inner,
+                        *source_id,
+                        Arc::clone(&compute_state.persist_clients),
+                        &compute_state.txns_ctx,
+                        import.desc.storage_metadata.clone(),
+                        read_schema,
+                        dataflow.as_of.clone(),
+                        snapshot_mode,
+                        until.clone(),
+                        mfp.as_mut(),
+                        compute_state.dataflow_max_inflight_bytes(),
+                        start_signal.clone().into_send_future(),
+                        ErrorHandler::Halt("compute_import"),
+                    );
 
                     // If `mfp` is non-identity, we need to apply what remains.
                     // For the moment, assert that it is either trivial or `None`.
@@ -377,10 +380,8 @@ pub fn build_compute_dataflow(
                 );
 
                 for (id, (oks, errs)) in imported_sources.into_iter() {
-                    // Persist batches are row-shaped and already consolidated, so the
-                    // encode here is non-consolidating.
                     let bundle = crate::render::CollectionBundle::from_edge(
-                        vec_to_columnar(oks.enter(region)),
+                        oks.enter(region),
                         errs.enter(region),
                     );
                     // Associate collection bundle with the source identifier.
@@ -479,10 +480,8 @@ pub fn build_compute_dataflow(
                 );
 
                 for (id, (oks, errs)) in imported_sources.into_iter() {
-                    // Persist batches are row-shaped and already consolidated, so the
-                    // encode here is non-consolidating.
                     let bundle = crate::render::CollectionBundle::from_edge(
-                        vec_to_columnar(oks.enter_region(region)),
+                        oks.enter_region(region),
                         errs.enter_region(region),
                     );
                     // Associate collection bundle with the source identifier.
@@ -1431,14 +1430,11 @@ impl<'scope, T: RenderTimestamp + MaybeBucketByTime> Context<'scope, T> {
                             .get(&self.config_set)
                             .try_into()
                             .expect("must fit");
-                        // Temporal bucketing is `Vec`-internal, so decode in and
-                        // encode out, keeping this Union input a columnar edge.
-                        let os = columnar_to_vec(os);
-                        vec_to_columnar(T::maybe_apply_temporal_bucketing(
+                        T::maybe_apply_temporal_bucketing(
                             os.inner,
                             self.as_of_frontier.clone(),
                             summary,
-                        ))
+                        )
                     } else {
                         os
                     };
@@ -1627,8 +1623,30 @@ pub trait RenderTimestamp: MzTimestamp + Default + Refines<mz_repr::Timestamp> {
 /// general property of a render timestamp, so the dispatch lives in its own trait.
 /// Total-ordered timestamps perform real bucketing; partially-ordered timestamps
 /// (e.g. `Product<…>` in iterative scopes) implement this as a no-op.
-pub trait MaybeBucketByTime: Timestamp {
+pub trait MaybeBucketByTime: Timestamp + ColumnarData {
+    /// Buckets a columnar dataflow edge, keeping it columnar.
     fn maybe_apply_temporal_bucketing<'scope, D>(
+        stream: Stream<'scope, Self, Column<(D, Self, Diff)>>,
+        as_of: Antichain<mz_repr::Timestamp>,
+        summary: mz_repr::Timestamp,
+    ) -> Collection<'scope, Self, Column<(D, Self, Diff)>>
+    where
+        D: differential_dataflow::ExchangeData
+            + crate::typedefs::MzData
+            + differential_dataflow::Hashable
+            + ColumnarData,
+        for<'a> ::columnar::Ref<'a, D>: Copy + Ord + std::hash::Hash,
+        for<'a> ::columnar::Ref<'a, Self>: Copy + Ord,
+        for<'a> ::columnar::Ref<'a, Diff>: Ord,
+        for<'a> <(D, Self, Diff) as ColumnarData>::Container:
+            ColumnarPush<&'a (D, Self, Diff)> + ColumnarPush<::columnar::Ref<'a, (D, Self, Diff)>>;
+
+    /// Buckets a `Vec` stream, keeping it `Vec`.
+    ///
+    /// For a consumer that re-encodes what it reads, where a `Vec` hands it moved
+    /// allocations rather than copied bytes. The reduce key-value path is the one
+    /// such caller, since its bucketed output feeds an arrangement.
+    fn maybe_apply_temporal_bucketing_vec<'scope, D>(
         stream: StreamVec<'scope, Self, (D, Self, Diff)>,
         as_of: Antichain<mz_repr::Timestamp>,
         summary: mz_repr::Timestamp,
@@ -1636,7 +1654,13 @@ pub trait MaybeBucketByTime: Timestamp {
     where
         D: differential_dataflow::ExchangeData
             + crate::typedefs::MzData
-            + differential_dataflow::Hashable;
+            + differential_dataflow::Hashable
+            + ColumnarData,
+        for<'a> ::columnar::Ref<'a, D>: Copy + Ord + std::hash::Hash,
+        for<'a> ::columnar::Ref<'a, Self>: Copy + Ord,
+        for<'a> ::columnar::Ref<'a, Diff>: Ord,
+        for<'a> <(D, Self, Diff) as ColumnarData>::Container:
+            ColumnarPush<&'a (D, Self, Diff)> + ColumnarPush<::columnar::Ref<'a, (D, Self, Diff)>>;
 }
 
 impl RenderTimestamp for mz_repr::Timestamp {
@@ -1662,6 +1686,25 @@ impl RenderTimestamp for mz_repr::Timestamp {
 
 impl MaybeBucketByTime for mz_repr::Timestamp {
     fn maybe_apply_temporal_bucketing<'scope, D>(
+        stream: Stream<'scope, Self, Column<(D, Self, Diff)>>,
+        as_of: Antichain<mz_repr::Timestamp>,
+        summary: mz_repr::Timestamp,
+    ) -> Collection<'scope, Self, Column<(D, Self, Diff)>>
+    where
+        D: differential_dataflow::ExchangeData
+            + crate::typedefs::MzData
+            + differential_dataflow::Hashable
+            + ColumnarData,
+        for<'a> ::columnar::Ref<'a, D>: Copy + Ord + std::hash::Hash,
+        for<'a> ::columnar::Ref<'a, Self>: Copy + Ord,
+        for<'a> ::columnar::Ref<'a, Diff>: Ord,
+        for<'a> <(D, Self, Diff) as ColumnarData>::Container:
+            ColumnarPush<&'a (D, Self, Diff)> + ColumnarPush<::columnar::Ref<'a, (D, Self, Diff)>>,
+    {
+        stream.bucket(as_of, summary).as_collection()
+    }
+
+    fn maybe_apply_temporal_bucketing_vec<'scope, D>(
         stream: StreamVec<'scope, Self, (D, Self, Diff)>,
         as_of: Antichain<mz_repr::Timestamp>,
         summary: mz_repr::Timestamp,
@@ -1669,11 +1712,15 @@ impl MaybeBucketByTime for mz_repr::Timestamp {
     where
         D: differential_dataflow::ExchangeData
             + crate::typedefs::MzData
-            + differential_dataflow::Hashable,
+            + differential_dataflow::Hashable
+            + ColumnarData,
+        for<'a> ::columnar::Ref<'a, D>: Copy + Ord + std::hash::Hash,
+        for<'a> ::columnar::Ref<'a, Self>: Copy + Ord,
+        for<'a> ::columnar::Ref<'a, Diff>: Ord,
+        for<'a> <(D, Self, Diff) as ColumnarData>::Container:
+            ColumnarPush<&'a (D, Self, Diff)> + ColumnarPush<::columnar::Ref<'a, (D, Self, Diff)>>,
     {
-        stream
-            .bucket::<CapacityContainerBuilder<_>>(as_of, summary)
-            .as_collection()
+        stream.bucket(as_of, summary).as_collection()
     }
 }
 
@@ -1708,6 +1755,26 @@ impl RenderTimestamp for Product<mz_repr::Timestamp, PointStamp<u64>> {
 
 impl MaybeBucketByTime for Product<mz_repr::Timestamp, PointStamp<u64>> {
     fn maybe_apply_temporal_bucketing<'scope, D>(
+        stream: Stream<'scope, Self, Column<(D, Self, Diff)>>,
+        _as_of: Antichain<mz_repr::Timestamp>,
+        _summary: mz_repr::Timestamp,
+    ) -> Collection<'scope, Self, Column<(D, Self, Diff)>>
+    where
+        D: differential_dataflow::ExchangeData
+            + crate::typedefs::MzData
+            + differential_dataflow::Hashable
+            + ColumnarData,
+        for<'a> ::columnar::Ref<'a, D>: Copy + Ord + std::hash::Hash,
+        for<'a> ::columnar::Ref<'a, Self>: Copy + Ord,
+        for<'a> ::columnar::Ref<'a, Diff>: Ord,
+        for<'a> <(D, Self, Diff) as ColumnarData>::Container:
+            ColumnarPush<&'a (D, Self, Diff)> + ColumnarPush<::columnar::Ref<'a, (D, Self, Diff)>>,
+    {
+        // TODO: Implement bucketing on outer timestamp for iterative scopes.
+        stream.as_collection()
+    }
+
+    fn maybe_apply_temporal_bucketing_vec<'scope, D>(
         stream: StreamVec<'scope, Self, (D, Self, Diff)>,
         _as_of: Antichain<mz_repr::Timestamp>,
         _summary: mz_repr::Timestamp,
@@ -1715,7 +1782,13 @@ impl MaybeBucketByTime for Product<mz_repr::Timestamp, PointStamp<u64>> {
     where
         D: differential_dataflow::ExchangeData
             + crate::typedefs::MzData
-            + differential_dataflow::Hashable,
+            + differential_dataflow::Hashable
+            + ColumnarData,
+        for<'a> ::columnar::Ref<'a, D>: Copy + Ord + std::hash::Hash,
+        for<'a> ::columnar::Ref<'a, Self>: Copy + Ord,
+        for<'a> ::columnar::Ref<'a, Diff>: Ord,
+        for<'a> <(D, Self, Diff) as ColumnarData>::Container:
+            ColumnarPush<&'a (D, Self, Diff)> + ColumnarPush<::columnar::Ref<'a, (D, Self, Diff)>>,
     {
         // TODO: Implement bucketing on outer timestamp for iterative scopes.
         stream.as_collection()
@@ -1865,7 +1938,7 @@ fn suppress_early_progress<'scope, T: Timestamp, D>(
     as_of: Antichain<T>,
 ) -> Stream<'scope, T, D>
 where
-    D: Data + timely::Container,
+    D: timely::Container + Clone,
 {
     stream.unary_frontier(Pipeline, "SuppressEarlyProgress", |default_cap, _info| {
         let mut early_cap = Some(default_cap);
@@ -1932,13 +2005,44 @@ trait LimitProgress<T: Timestamp> {
     ) -> Self;
 }
 
+/// Reads the times of the records a container holds, for [`LimitProgress`].
+trait RecordTimes {
+    /// Call `f` once per record, with that record's time.
+    fn for_each_time(&self, f: impl FnMut(mz_repr::Timestamp));
+}
+
+impl<D, R> RecordTimes for Vec<(D, mz_repr::Timestamp, R)> {
+    fn for_each_time(&self, mut f: impl FnMut(mz_repr::Timestamp)) {
+        for (_, time, _) in self {
+            f(*time);
+        }
+    }
+}
+
+impl<D, R> RecordTimes for Column<(D, mz_repr::Timestamp, R)>
+where
+    D: ColumnarData,
+    R: ColumnarData,
+    (D, mz_repr::Timestamp, R): ColumnarData<
+        Container = (
+            D::Container,
+            <mz_repr::Timestamp as ColumnarData>::Container,
+            R::Container,
+        ),
+    >,
+{
+    fn for_each_time(&self, mut f: impl FnMut(mz_repr::Timestamp)) {
+        for time in self.borrow().1.into_index_iter() {
+            f(time);
+        }
+    }
+}
+
 // TODO: We could make this generic over a `T` that can be converted to and from a u64 millisecond
 // number.
-impl<'scope, D, R> LimitProgress<mz_repr::Timestamp>
-    for StreamVec<'scope, mz_repr::Timestamp, (D, mz_repr::Timestamp, R)>
+impl<'scope, C> LimitProgress<mz_repr::Timestamp> for Stream<'scope, mz_repr::Timestamp, C>
 where
-    D: Clone + 'static,
-    R: Clone + 'static,
+    C: timely::Container + Clone + RecordTimes,
 {
     fn limit_progress(
         self,
@@ -1961,10 +2065,10 @@ where
 
                 move |(input, frontier), output| {
                     input.for_each(|cap, data| {
-                        for time in data
-                            .iter()
-                            .flat_map(|(_, time, _)| u64::from(time).checked_add(slack_ms))
-                        {
+                        data.for_each_time(|time| {
+                            let Some(time) = u64::from(time).checked_add(slack_ms) else {
+                                return;
+                            };
                             // `slack_ms == 0` means no rounding; otherwise round up to the next
                             // multiple of `slack_ms`. Avoids a divide-by-zero panic when the
                             // operator is configured without slack.
@@ -1976,7 +2080,7 @@ where
                             if !upper.less_than(&rounded_time.into()) {
                                 pending_times.insert(rounded_time.into());
                             }
-                        }
+                        });
                         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())
diff --git a/src/compute/src/render/context.rs b/src/compute/src/render/context.rs
index 4ce4ad6bec604..dcda673932f39 100644
--- a/src/compute/src/render/context.rs
+++ b/src/compute/src/render/context.rs
@@ -51,7 +51,7 @@ use timely::progress::{Antichain, Timestamp};
 use crate::compute_state::ComputeState;
 use crate::extensions::arrange::{ArrangementBatcher, KeyCollection, MzArrange, MzArrangeCore};
 use crate::extensions::reduce::MzReduce;
-use crate::render::columnar::{CollectionEdge, columnar_to_vec, flat_map_datums, vec_to_columnar};
+use crate::render::columnar::{CollectionEdge, flat_map_datums};
 use crate::render::errors::{DataflowErrorSer, ErrorLogger};
 use crate::render::{LinearJoinSpec, MaybeBucketByTime, RenderTimestamp};
 use crate::typedefs::{
@@ -1095,12 +1095,8 @@ impl<'scope, T: RenderTimestamp> CollectionBundle<'scope, T> {
                     .try_into()
                     .expect("must fit");
                 bucketed = true;
-                // Temporal bucketing is `Vec`-internal, so decode in and encode out.
-                vec_to_columnar(T::maybe_apply_temporal_bucketing(
-                    columnar_to_vec(oks).inner,
-                    as_of.clone(),
-                    summary,
-                ))
+                // Temporal bucketing is columnar throughout, so no round trip here.
+                T::maybe_apply_temporal_bucketing(oks.inner, as_of.clone(), summary)
             } else {
                 oks
             };
@@ -1132,13 +1128,8 @@ impl<'scope, T: RenderTimestamp> CollectionBundle<'scope, T> {
                         .try_into()
                         .expect("must fit");
                     bucketed = true;
-                    // Temporal bucketing is `Vec`-internal, so decode in and encode out.
-                    let oks = columnar_to_vec(oks);
-                    vec_to_columnar(T::maybe_apply_temporal_bucketing(
-                        oks.inner,
-                        as_of.clone(),
-                        summary,
-                    ))
+                    // Temporal bucketing is columnar throughout, so no round trip here.
+                    T::maybe_apply_temporal_bucketing(oks.inner, as_of.clone(), summary)
                 } else {
                     oks
                 };
@@ -1472,7 +1463,7 @@ mod tests {
     use timely::dataflow::operators::capture::{Event, Extract};
 
     use super::*;
-    use crate::render::columnar::vec_to_columnar;
+    use crate::render::columnar::{columnar_to_vec, vec_to_columnar};
 
     type OkUpdate = ((Row, Row), Timestamp, Diff);
     type ErrUpdate = (DataflowErrorSer, Timestamp, Diff);
diff --git a/src/compute/src/render/join/linear_join.rs b/src/compute/src/render/join/linear_join.rs
index 0b960c688614f..53cd8fa218dec 100644
--- a/src/compute/src/render/join/linear_join.rs
+++ b/src/compute/src/render/join/linear_join.rs
@@ -36,8 +36,11 @@ use mz_timely_util::columnar::{
     Col2ValBatcher, Col2ValColBatcher, Col2ValPagedBatcher, columnar_exchange,
 };
 use mz_timely_util::operator::{CollectionExt, StreamExt};
+use timely::ContainerBuilder;
+use timely::container::{CapacityContainerBuilder, PushInto};
 use timely::dataflow::channels::pact::{ExchangeCore, Pipeline};
 use timely::dataflow::operators::OkErr;
+use timely::dataflow::operators::generic::Operator;
 use timely::dataflow::{Scope, Stream};
 
 use crate::extensions::arrange::{ArrangementBatcher, MzArrangeCore};
@@ -100,15 +103,21 @@ impl LinearJoinSpec {
         }
     }
 
-    /// Render a join operator according to this specification.
-    fn render<'s, T, Tr1, Tr2, L, I>(
+    /// Render a join operator according to this specification, assembling its
+    /// output through `CB`.
+    ///
+    /// The `DifferentialDataflow` implementation builds its own `Vec` output and
+    /// cannot be handed a container builder, so that arm re-encodes through `CB`.
+    /// The `Materialize` implementation writes `CB` directly.
+    fn render<'s, T, Tr1, Tr2, L, I, CB>(
         &self,
         arranged1: Arranged<'s, Tr1>,
         arranged2: Arranged<'s, Tr2>,
         result: L,
-    ) -> VecCollection<'s, T, I::Item, Diff>
+    ) -> Stream<'s, T, CB::Container>
     where
         T: Lattice + timely::progress::Timestamp,
+        CB: ContainerBuilder + PushInto<(I::Item, T, Diff)> + 'static,
         Tr1: TraceReader<Batch: Navigable, Time = T> + Clone + 'static,
         Tr2: TraceReader<Batch: Navigable, Time = T> + Clone + 'static,
         BatchCursor<Tr1>: Cursor<Time = T, Diff = Diff>,
@@ -123,23 +132,25 @@ impl LinearJoinSpec {
             self.yielding.after_work,
             self.yielding.after_time,
         ) {
-            (DifferentialDataflow, _, _) => arranged1.join_core(arranged2, result),
+            (DifferentialDataflow, _, _) => {
+                encode_updates::<_, _, CB>(arranged1.join_core(arranged2, result), "JoinCoreEncode")
+            }
             (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()
+                mz_join_core::<_, _, _, _, _, _, CB>(arranged1, arranged2, result, yield_fn)
             }
             (Materialize, Some(work_limit), None) => {
                 let yield_fn = move |_start, work| work >= work_limit;
-                mz_join_core(arranged1, arranged2, result, yield_fn).as_collection()
+                mz_join_core::<_, _, _, _, _, _, CB>(arranged1, arranged2, result, yield_fn)
             }
             (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()
+                mz_join_core::<_, _, _, _, _, _, CB>(arranged1, arranged2, result, yield_fn)
             }
             (Materialize, None, None) => {
                 let yield_fn = |_start, _work| false;
-                mz_join_core(arranged1, arranged2, result, yield_fn).as_collection()
+                mz_join_core::<_, _, _, _, _, _, CB>(arranged1, arranged2, result, yield_fn)
             }
         }
     }
@@ -198,9 +209,13 @@ enum JoinedFlavor<'scope, T: RenderTimestamp> {
     /// `differential_join` forms its arrangement key off the edge, so a columnar source
     /// needs no decode.
     Edge(CollectionEdge<'scope, T>),
-    /// The intra-operator multi-stage accumulator. `mz_join_core` is
-    /// `Vec`-internal, so the accumulator is a bare `VecCollection`, not a
-    /// collection edge.
+    /// The intra-operator multi-stage accumulator.
+    ///
+    /// A stage whose output is consumed by another stage's arrangement or by a
+    /// finalization closure writes this. Both of those re-encode what they read,
+    /// and a `Vec` hands them moved `Row` allocations where a `Column` would
+    /// copy row bytes, so the accumulator stays `Vec`. Only a stage whose output
+    /// *is* the node's output writes [`JoinedFlavor::Edge`].
     Collection(VecCollection<'scope, T, Row, Diff>),
     /// A dataflow-local arrangement.
     Local(Arranged<'scope, RowRowAgent<T, Diff>>),
@@ -299,17 +314,23 @@ where
         };
 
         // progress through stages, updating partial results and errors.
-        for stage_plan in linear_plan.stage_plans.into_iter() {
+        //
+        // The last stage writes the node's output edge directly, but only when
+        // no finalization closure follows it. With a closure, the closure's
+        // builder writes the edge and the stage feeds it the `Vec` accumulator.
+        let stage_count = linear_plan.stage_plans.len();
+        let terminal_stage_writes_edge = linear_plan.final_closure.is_none();
+        for (index, stage_plan) in linear_plan.stage_plans.into_iter().enumerate() {
+            let terminal = index + 1 == stage_count && terminal_stage_writes_edge;
             // Different variants of `joined` implement this differently,
             // and the logic is centralized there.
-            let stream = self.differential_join(
+            joined = self.differential_join(
                 joined,
                 inputs[stage_plan.lookup_relation].enter_region(inner),
                 stage_plan,
+                terminal,
                 &mut errors,
             );
-            // Update joined results and capture any errors.
-            joined = JoinedFlavor::Collection(stream);
         }
 
         // We have completed the join building, but may have work remaining.
@@ -346,9 +367,13 @@ where
             errors.push(errs);
             updates
         } else {
-            // With identity finalization the raw output is the result. A single-input
-            // join's source edge is already columnar; the `Vec` accumulator encodes
-            // here, non-consolidating to match.
+            // Identity finalization: the raw output is the result. A single-input join
+            // passes its source edge through, and with stages the last one wrote the
+            // edge itself, because `terminal_stage_writes_edge` holds exactly here.
+            //
+            // The accumulator arm is reachable only through an initial closure on a
+            // stage-less join, which current lowering never emits. It encodes rather
+            // than panics, so a lowering change stays correct.
             match joined {
                 JoinedFlavor::Edge(edge) => edge,
                 JoinedFlavor::Collection(collection) => vec_to_columnar(collection),
@@ -366,6 +391,9 @@ where
 
     /// Looks up the arrangement for the next input and joins it to the arranged
     /// version of the join of previous inputs.
+    ///
+    /// `terminal` marks a stage whose output is the node's output, which makes
+    /// it write the output edge rather than the `Vec` accumulator.
     fn differential_join<'s>(
         &self,
         mut joined: JoinedFlavor<'s, T>,
@@ -377,8 +405,9 @@ where
             closure,
             lookup_relation: _,
         }: LinearStagePlan,
+        terminal: bool,
         errors: &mut Vec<VecCollection<'s, T, DataflowErrorSer, Diff>>,
-    ) -> VecCollection<'s, T, Row, Diff> {
+    ) -> JoinedFlavor<'s, T> {
         // If we have a streamed input, we must first form an arrangement. The
         // source edge keys off the `CollectionEdge` (a columnar source has no
         // `ColumnarToVec` hop); the intra-operator accumulator is a bare
@@ -420,7 +449,7 @@ where
                 ArrangementFlavor::Local(oks, errs1) => {
                     let (oks, errs2) = self
                         .differential_join_inner::<RowRowAgent<_, _>, RowRowAgent<_, _>>(
-                            local, oks, closure,
+                            local, oks, closure, terminal,
                         );
 
                     errors.push(errs1.as_collection(|k, _v| k.clone()));
@@ -430,7 +459,7 @@ where
                 ArrangementFlavor::Trace(_gid, oks, errs1) => {
                     let (oks, errs2) = self
                         .differential_join_inner::<RowRowAgent<_, _>, RowRowEnter<_, _, _>>(
-                            local, oks, closure,
+                            local, oks, closure, terminal,
                         );
 
                     errors.push(errs1.as_collection(|k, _v| k.clone()));
@@ -442,7 +471,7 @@ where
                 ArrangementFlavor::Local(oks, errs1) => {
                     let (oks, errs2) = self
                         .differential_join_inner::<RowRowEnter<_, _, _>, RowRowAgent<_, _>>(
-                            trace, oks, closure,
+                            trace, oks, closure, terminal,
                         );
 
                     errors.push(errs1.as_collection(|k, _v| k.clone()));
@@ -452,7 +481,7 @@ where
                 ArrangementFlavor::Trace(_gid, oks, errs1) => {
                     let (oks, errs2) = self
                         .differential_join_inner::<RowRowEnter<_, _, _>, RowRowEnter<_, _, _>>(
-                            trace, oks, closure,
+                            trace, oks, closure, terminal,
                         );
 
                     errors.push(errs1.as_collection(|k, _v| k.clone()));
@@ -469,13 +498,19 @@ where
     ///
     /// The return type includes an optional error collection, which may be
     /// `None` if we can determine that `closure` cannot error.
+    /// `terminal` marks a stage whose output is the node's output, which makes
+    /// the ok side write a [`ColumnBuilder`] instead of the `Vec` accumulator,
+    /// so the node needs no leaf encode. An error-capable closure writes the
+    /// accumulator either way, because its output has to be demuxed by
+    /// `ok_err` before the ok side can be encoded.
     fn differential_join_inner<'s, Tr1, Tr2>(
         &self,
         prev_keyed: Arranged<'s, Tr1>,
         next_input: Arranged<'s, Tr2>,
         closure: JoinClosure,
+        terminal: bool,
     ) -> (
-        VecCollection<'s, T, Row, Diff>,
+        JoinedFlavor<'s, T>,
         Option<VecCollection<'s, T, DataflowErrorSer, Diff>>,
     )
     where
@@ -489,25 +524,22 @@ where
         // Reuseable allocation for unpacking.
         let mut datums = DatumVec::new();
 
+        // The `Vec` accumulator's builder. Named because the ok side picks
+        // between it and a `ColumnBuilder` on `terminal`.
+        type VecCB<D, T> = CapacityContainerBuilder<Vec<(D, T, Diff)>>;
+
         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
+                .render::<T, _, _, _, _, VecCB<Result<Row, DataflowErrorSer>, T>>(
+                    prev_keyed,
+                    next_input,
+                    move |key, old, new| {
+                        apply_join_closure(&closure, &mut datums, key, old, new)
+                            .map_err(DataflowErrorSer::from)
+                            .transpose()
+                    },
+                )
                 .ok_err(|(x, t, d)| {
                     // TODO(mcsherry): consider `ok_err()` for `Collection`.
                     match x {
@@ -516,30 +548,101 @@ where
                     }
                 });
 
-            (oks.as_collection(), Some(err.as_collection()))
-        } else {
+            let oks = oks.as_collection();
+            let oks = if terminal {
+                // The demux already materialized the ok side as a `Vec`, so the
+                // leaf encode stands here.
+                JoinedFlavor::Edge(vec_to_columnar(oks))
+            } else {
+                JoinedFlavor::Collection(oks)
+            };
+            (oks, Some(err.as_collection()))
+        } else if terminal {
             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);
+                .render::<T, _, _, _, _, ConsolidatingColumnBuilder<Row, T, Diff>>(
+                    prev_keyed,
+                    next_input,
+                    move |key, old, new| {
+                        apply_join_closure(&closure, &mut datums, key, old, new)
+                            .expect("Closure claimed to never error")
+                    },
+                );
 
-                    closure
-                        .apply(&mut datums_local, &temp_storage, &mut row_builder)
-                        .expect("Closure claimed to never error")
-                        .cloned()
-                });
+            (JoinedFlavor::Edge(oks.as_collection()), None)
+        } else {
+            let oks = self
+                .linear_join_spec
+                .render::<T, _, _, _, _, VecCB<Row, T>>(
+                    prev_keyed,
+                    next_input,
+                    move |key, old, new| {
+                        apply_join_closure(&closure, &mut datums, key, old, new)
+                            .expect("Closure claimed to never error")
+                    },
+                );
 
-            (oks, None)
+            (JoinedFlavor::Collection(oks.as_collection()), None)
         }
     }
 }
 
+/// Unpacks one join match into datums and applies `closure` to it.
+///
+/// `None` means the closure filtered the match out. The output row is owned
+/// because the row `closure` writes borrows the shared row builder, which the
+/// caller must not hold past this call.
+fn apply_join_closure<K, V1, V2>(
+    closure: &JoinClosure,
+    datums: &mut DatumVec,
+    key: K,
+    old: V1,
+    new: V2,
+) -> Result<Option<Row>, mz_expr::EvalError>
+where
+    K: ExtendDatums,
+    V1: ExtendDatums,
+    V2: ExtendDatums,
+{
+    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())
+}
+
+/// Re-encodes a `Vec` collection through `CB`.
+///
+/// For a join implementation that builds its own `Vec` output and so cannot be
+/// handed a container builder.
+fn encode_updates<'s, T, D, CB>(
+    collection: VecCollection<'s, T, D, Diff>,
+    name: &str,
+) -> Stream<'s, T, CB::Container>
+where
+    T: timely::progress::Timestamp,
+    D: Data,
+    CB: ContainerBuilder + PushInto<(D, T, Diff)> + 'static,
+{
+    collection
+        .inner
+        .unary::<CB, _, _, _>(Pipeline, name, |_, _| {
+            move |input, output| {
+                input.for_each(|time, data| {
+                    output
+                        .session_with_builder(&time)
+                        .give_iterator(data.drain(..));
+                });
+            }
+        })
+}
+
 /// Keys a row-formatted join input stream into columnar `((key, value), t, d)`
 /// updates, splitting off key-evaluation errors into a separate stream.
 ///
diff --git a/src/compute/src/render/join/mz_join_core.rs b/src/compute/src/render/join/mz_join_core.rs
index 3ef61aa63ef22..12856baccaebb 100644
--- a/src/compute/src/render/join/mz_join_core.rs
+++ b/src/compute/src/render/join/mz_join_core.rs
@@ -41,12 +41,12 @@ use differential_dataflow::trace::cursor::{BatchCursor, BatchKey, BatchVal, Curs
 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::container::PushInto;
 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 timely::{ContainerBuilder, PartialOrder};
 use tracing::trace;
 
 /// Joins two arranged collections with the same key type.
@@ -54,12 +54,12 @@ use tracing::trace;
 /// 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>(
+pub(super) fn mz_join_core<'scope, T, Tr1, Tr2, L, I, YFn, CB>(
     arranged1: Arranged<'scope, Tr1>,
     arranged2: Arranged<'scope, Tr2>,
     result: L,
     yield_fn: YFn,
-) -> Stream<'scope, T, C>
+) -> Stream<'scope, T, CB::Container>
 where
     T: timely::progress::Timestamp + Lattice,
     Tr1: TraceReader<Batch: Navigable, Time = T> + Clone + 'static,
@@ -69,13 +69,13 @@ where
     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,
+    CB: ContainerBuilder + PushInto<(I::Item, T, Diff)> + 'static,
 {
     let scope = arranged1.stream.scope();
     let mut trace1 = arranged1.trace.clone();
     let mut trace2 = arranged2.trace.clone();
 
-    arranged1.stream.binary_frontier(
+    arranged1.stream.binary_frontier::<_, CB, _, _, _, _>(
         arranged2.stream,
         Pipeline,
         Pipeline,
@@ -572,12 +572,12 @@ where
     }
 
     /// Process pending work until none is remaining or `yield_fn` requests a yield.
-    fn process<C, YFn>(
+    fn process<CB, YFn>(
         &mut self,
-        output: &mut OutputBuilderSession<'_, C1::Time, CapacityContainerBuilder<C>>,
+        output: &mut OutputBuilderSession<'_, C1::Time, CB>,
         yield_fn: YFn,
     ) where
-        C: Container + SizableContainer + PushInto<(D, C1::Time, Diff)> + Data,
+        CB: ContainerBuilder + PushInto<(D, C1::Time, Diff)>,
         YFn: Fn(Instant, usize) -> bool,
     {
         let start_time = Instant::now();
@@ -605,7 +605,9 @@ where
             let recovered = old_len - output_buf.len();
             self.produced.update(|x| x - recovered);
 
-            output.session(&cap).give_iterator(output_buf.drain(..));
+            output
+                .session_with_builder(&cap)
+                .give_iterator(output_buf.drain(..));
 
             if done {
                 // We have finished processing a chunk of work. Use this opportunity to truncate
diff --git a/src/compute/src/render/reduce.rs b/src/compute/src/render/reduce.rs
index 57487a1970491..f08edabcecf7e 100644
--- a/src/compute/src/render/reduce.rs
+++ b/src/compute/src/render/reduce.rs
@@ -176,7 +176,7 @@ impl<'scope, T: RenderTimestamp> Context<'scope, T> {
                     .get(&self.config_set)
                     .try_into()
                     .expect("must fit");
-                T::maybe_apply_temporal_bucketing(
+                T::maybe_apply_temporal_bucketing_vec(
                     key_val_collection.inner,
                     self.as_of_frontier.clone(),
                     summary,
diff --git a/src/compute/src/render/top_k.rs b/src/compute/src/render/top_k.rs
index 80ce50c52cf48..1a2cb589c4e5a 100644
--- a/src/compute/src/render/top_k.rs
+++ b/src/compute/src/render/top_k.rs
@@ -49,7 +49,7 @@ use timely::dataflow::operators::generic::builder_rc::OperatorBuilder;
 use crate::extensions::arrange::{ArrangementSize, KeyCollection, MzArrange};
 use crate::extensions::reduce::{ClearContainer, MzReduce};
 use crate::render::Pairer;
-use crate::render::columnar::{CollectionEdge, columnar_to_vec, flat_map_datums, vec_to_columnar};
+use crate::render::columnar::{CollectionEdge, flat_map_datums};
 use crate::render::context::{ArrangementFlavor, CollectionBundle, Context};
 use crate::render::errors::DataflowErrorSer;
 use crate::render::errors::MaybeValidatingRow;
@@ -109,13 +109,8 @@ impl<'scope, T: crate::render::RenderTimestamp + crate::render::MaybeBucketByTim
                  `mz_now()` has been const-folded and no temporal bucketing is set",
             );
         }
-        // Temporal bucketing is `Vec`-internal, so decode in and encode out. It fires
-        // only under `ENABLE_COMPUTE_TEMPORAL_BUCKETING` and the `TemporalBucketing`
-        // strategy.
-        //
-        // TODO: `map_topk_key` decodes this encode again one operator later, so a
-        // bucketed TopK pays a round trip that no consumer here wants. Both halves
-        // go away with the columnar push-down noted on `topk_result_to_columnar`.
+        // Temporal bucketing fires only under `ENABLE_COMPUTE_TEMPORAL_BUCKETING`
+        // and the `TemporalBucketing` strategy.
         let ok_input = if matches!(
             temporal_bucketing_strategy,
             ArrangementStrategy::TemporalBucketing
@@ -125,11 +120,7 @@ impl<'scope, T: crate::render::RenderTimestamp + crate::render::MaybeBucketByTim
                 .get(&self.config_set)
                 .try_into()
                 .expect("must fit");
-            vec_to_columnar(T::maybe_apply_temporal_bucketing(
-                columnar_to_vec(ok_input).inner,
-                self.as_of_frontier.clone(),
-                summary,
-            ))
+            T::maybe_apply_temporal_bucketing(ok_input.inner, self.as_of_frontier.clone(), summary)
         } else {
             ok_input
         };
diff --git a/src/compute/src/sink/materialized_view.rs b/src/compute/src/sink/materialized_view.rs
index e5d1a4064c1ba..3e82b9203e4aa 100644
--- a/src/compute/src/sink/materialized_view.rs
+++ b/src/compute/src/sink/materialized_view.rs
@@ -409,22 +409,24 @@ pub(super) fn persist_source<'s>(
     let until = Antichain::new();
     let map_filter_project = None;
 
-    let (ok_stream, err_stream, token) =
-        mz_storage_operators::persist_source::persist_source::<DataflowErrorSer>(
-            scope,
-            sink_id,
-            Arc::clone(&compute_state.persist_clients),
-            &compute_state.txns_ctx,
-            target,
-            None,
-            as_of,
-            SnapshotMode::Include,
-            until,
-            map_filter_project,
-            compute_state.dataflow_max_inflight_bytes(),
-            start_signal.into_send_future(),
-            ErrorHandler::Halt("compute persist sink"),
-        );
+    let (ok_stream, err_stream, token) = mz_storage_operators::persist_source::persist_source::<
+        DataflowErrorSer,
+        mz_storage_operators::persist_source::RowVecBuilder<Timestamp>,
+    >(
+        scope,
+        sink_id,
+        Arc::clone(&compute_state.persist_clients),
+        &compute_state.txns_ctx,
+        target,
+        None,
+        as_of,
+        SnapshotMode::Include,
+        until,
+        map_filter_project,
+        compute_state.dataflow_max_inflight_bytes(),
+        start_signal.into_send_future(),
+        ErrorHandler::Halt("compute persist sink"),
+    );
 
     let streams = OkErr::new(ok_stream, err_stream);
     (streams, token)
diff --git a/src/controller/src/lib.rs b/src/controller/src/lib.rs
index 6e675eb3001d1..7547d1d403ee5 100644
--- a/src/controller/src/lib.rs
+++ b/src/controller/src/lib.rs
@@ -636,6 +636,7 @@ impl Controller {
                     Datum::TimestampTz(now_tz),
                     m.heap_bytes.into(),
                     m.heap_limit.into(),
+                    m.swap_bytes.into(),
                 ]);
                 (row.clone(), mz_repr::Diff::ONE)
             })
diff --git a/src/orchestrator-kubernetes/src/lib.rs b/src/orchestrator-kubernetes/src/lib.rs
index 3515b7d07b495..98be7d1b6889b 100644
--- a/src/orchestrator-kubernetes/src/lib.rs
+++ b/src/orchestrator-kubernetes/src/lib.rs
@@ -1592,6 +1592,7 @@ impl OrchestratorWorker {
                 };
 
                 process_metrics.heap_limit = usage.heap_limit;
+                process_metrics.swap_bytes = usage.swap_bytes;
             }
 
             process_metrics
diff --git a/src/orchestrator-process/src/lib.rs b/src/orchestrator-process/src/lib.rs
index 2c1c599d5fe2d..3eb515a7eb5c7 100644
--- a/src/orchestrator-process/src/lib.rs
+++ b/src/orchestrator-process/src/lib.rs
@@ -559,6 +559,7 @@ impl OrchestratorWorker {
                 disk_bytes: None,
                 heap_bytes: None,
                 heap_limit: None,
+                swap_bytes: None,
             });
         }
         Ok(metrics)
diff --git a/src/orchestrator/src/lib.rs b/src/orchestrator/src/lib.rs
index 5503065867aa1..e70accf1e1eed 100644
--- a/src/orchestrator/src/lib.rs
+++ b/src/orchestrator/src/lib.rs
@@ -154,6 +154,7 @@ pub struct ServiceProcessMetrics {
     pub disk_bytes: Option<u64>,
     pub heap_bytes: Option<u64>,
     pub heap_limit: Option<u64>,
+    pub swap_bytes: Option<u64>,
 }
 
 /// A simple language for describing assertions about a label's existence and value.
diff --git a/src/storage-client/src/healthcheck.rs b/src/storage-client/src/healthcheck.rs
index 1c164a2f24dd3..f3792b2b0e3b0 100644
--- a/src/storage-client/src/healthcheck.rs
+++ b/src/storage-client/src/healthcheck.rs
@@ -174,6 +174,7 @@ pub static REPLICA_METRICS_HISTORY_DESC: LazyLock<RelationDesc> = LazyLock::new(
         )
         .with_column("heap_bytes", SqlScalarType::UInt64.nullable(true))
         .with_column("heap_limit", SqlScalarType::UInt64.nullable(true))
+        .with_column("swap_bytes", SqlScalarType::UInt64.nullable(true))
         .finish()
 });
 
diff --git a/src/storage-operators/src/persist_source.rs b/src/storage-operators/src/persist_source.rs
index 12c97ec06304c..4eb4ea214f874 100644
--- a/src/storage-operators/src/persist_source.rs
+++ b/src/storage-operators/src/persist_source.rs
@@ -10,13 +10,15 @@
 //! A source that reads from an a persist shard.
 
 use differential_dataflow::consolidation::ConsolidatingContainerBuilder;
+use std::borrow::Cow;
+use std::collections::VecDeque;
 use std::convert::Infallible;
 use std::fmt::Debug;
 use std::future::Future;
 use std::hash::Hash;
 use std::sync::Arc;
-use std::time::Instant;
 
+use differential_dataflow::AsCollection;
 use differential_dataflow::lattice::Lattice;
 use futures::{StreamExt, future::Either};
 use mz_expr::{ColumnSpecs, EvalError, Interpreter, MfpPlan, ResultSpec, UnmaterializableFunc};
@@ -46,14 +48,13 @@ use mz_timely_util::builder_async::{
     Event, OperatorBuilder as AsyncOperatorBuilder, PressOnDropButton,
 };
 use mz_timely_util::probe::ProbeNotify;
-use mz_txn_wal::operator::{TxnsContext, txns_progress};
+use mz_txn_wal::operator::{TxnsContext, TxnsProgress};
 use serde::{Deserialize, Serialize};
-use timely::PartialOrder;
-use timely::container::CapacityContainerBuilder;
+use timely::container::{CapacityContainerBuilder, PushInto};
 use timely::dataflow::channels::pact::Pipeline;
+use timely::dataflow::operators::generic::OutputBuilder;
 use timely::dataflow::operators::generic::builder_rc::OperatorBuilder;
-use timely::dataflow::operators::generic::{OutputBuilder, OutputBuilderSession};
-use timely::dataflow::operators::{Capability, Leave, OkErr};
+use timely::dataflow::operators::{Capability, Leave};
 use timely::dataflow::operators::{CapabilitySet, ConnectLoop, Feedback};
 use timely::dataflow::{Scope, Stream, StreamVec};
 use timely::order::TotalOrder;
@@ -61,6 +62,7 @@ use timely::progress::Antichain;
 use timely::progress::Timestamp as TimelyTimestamp;
 use timely::progress::timestamp::PathSummary;
 use timely::scheduling::Activator;
+use timely::{ContainerBuilder, PartialOrder};
 use tokio::sync::mpsc::UnboundedSender;
 use tracing::{error, trace};
 
@@ -147,6 +149,8 @@ impl Subtime {
 /// Creates a new source that reads from a persist shard, distributing the work
 /// of reading data to all timely workers.
 ///
+/// Returns the shard's rows in `CB`'s containers and its errors in a stream of their own.
+///
 /// All times emitted will have been [advanced by] the given `as_of` frontier.
 /// All updates at times greater or equal to `until` will be suppressed.
 /// The `map_filter_project` argument, if supplied, may be partially applied,
@@ -166,7 +170,7 @@ impl Subtime {
 /// using [`timely::dataflow::operators::generic::operator::empty`].
 ///
 /// [advanced by]: differential_dataflow::lattice::Lattice::advance_by
-pub fn persist_source<'scope, E>(
+pub fn persist_source<'scope, E, CB>(
     scope: Scope<'scope, mz_repr::Timestamp>,
     source_id: GlobalId,
     persist_clients: Arc<PersistClientCache>,
@@ -181,113 +185,133 @@ pub fn persist_source<'scope, E>(
     start_signal: impl Future<Output = ()> + Send + 'static,
     error_handler: ErrorHandler,
 ) -> (
-    StreamVec<'scope, mz_repr::Timestamp, (Row, Timestamp, Diff)>,
+    Stream<'scope, mz_repr::Timestamp, CB::Container>,
     StreamVec<'scope, mz_repr::Timestamp, (E, Timestamp, Diff)>,
     Vec<PressOnDropButton>,
 )
 where
     E: timely::ExchangeData + Ord + Clone + Debug + From<DataflowError> + From<EvalError>,
+    CB: ContainerBuilder + PushInto<(Row, mz_repr::Timestamp, Diff)>,
+    CB::Container: Clone,
 {
     let mut tokens = vec![];
+    let name = source_id.to_string();
 
     let outer = scope.clone();
-    let stream = scope.scoped(&format!("granular_backpressure({})", source_id), |scope| {
-        let (flow_control, flow_control_probe) = match max_inflight_bytes {
-            Some(max_inflight_bytes) => {
-                let series = &persist_clients.metrics().backpressure;
-                let backpressure_metrics = BackpressureOperatorMetrics::new(
-                    series.emitted_bytes.clone(),
-                    series.last_backpressured_bytes.clone(),
-                    series.retired_bytes.clone(),
-                );
+    let (ok_stream, err_stream) =
+        scope.scoped(&format!("granular_backpressure({})", source_id), |scope| {
+            let (flow_control, flow_control_probe) = match max_inflight_bytes {
+                Some(max_inflight_bytes) => {
+                    let series = &persist_clients.metrics().backpressure;
+                    let backpressure_metrics = BackpressureOperatorMetrics::new(
+                        series.emitted_bytes.clone(),
+                        series.last_backpressured_bytes.clone(),
+                        series.retired_bytes.clone(),
+                    );
 
-                let probe = mz_timely_util::probe::Handle::default();
-                let progress_stream = mz_timely_util::probe::source(
-                    scope.clone(),
-                    format!("decode_backpressure_probe({source_id})"),
-                    probe.clone(),
-                );
-                let flow_control = FlowControl {
-                    progress_stream,
-                    max_inflight_bytes,
-                    summary: (Default::default(), Subtime::least_summary()),
-                    metrics: Some(backpressure_metrics),
-                };
-                (Some(flow_control), Some(probe))
-            }
-            None => (None, None),
-        };
+                    let probe = mz_timely_util::probe::Handle::default();
+                    let progress_stream = mz_timely_util::probe::source(
+                        scope.clone(),
+                        format!("decode_backpressure_probe({source_id})"),
+                        probe.clone(),
+                    );
+                    let flow_control = FlowControl {
+                        progress_stream,
+                        max_inflight_bytes,
+                        summary: (Default::default(), Subtime::least_summary()),
+                        metrics: Some(backpressure_metrics),
+                    };
+                    (Some(flow_control), Some(probe))
+                }
+                None => (None, None),
+            };
 
-        // Our default listen sleeps are tuned for the case of a shard that is
-        // written once a second, but txn-wal allows these to be lazy.
-        // Override the tuning to reduce crdb load. The pubsub fallback
-        // responsibility is then replaced by manual "one state" wakeups in the
-        // txns_progress operator.
-        let cfg = Arc::clone(&persist_clients.cfg().configs);
-        let subscribe_sleep = match metadata.txns_shard {
-            Some(_) => Some(move || mz_txn_wal::operator::txns_data_shard_retry_params(&cfg)),
-            None => None,
-        };
+            // Our default listen sleeps are tuned for the case of a shard that is
+            // written once a second, but txn-wal allows these to be lazy.
+            // Override the tuning to reduce crdb load. The pubsub fallback
+            // responsibility is then replaced by manual "one state" wakeups in the
+            // txns_progress operator.
+            let cfg = Arc::clone(&persist_clients.cfg().configs);
+            let subscribe_sleep = match metadata.txns_shard {
+                Some(_) => Some(move || mz_txn_wal::operator::txns_data_shard_retry_params(&cfg)),
+                None => None,
+            };
 
-        let (stream, source_tokens) = persist_source_core(
-            outer,
-            scope,
-            source_id,
-            Arc::clone(&persist_clients),
-            metadata.clone(),
-            read_schema,
-            as_of.clone(),
-            snapshot_mode,
-            until.clone(),
-            map_filter_project,
-            flow_control,
-            subscribe_sleep,
-            start_signal,
-            error_handler,
-        );
-        tokens.extend(source_tokens);
+            let filter_plan = map_filter_project.as_ref().map(|p| (*p).clone());
+            let (cfg, fetched, source_tokens) = fetch_parts(
+                outer,
+                scope,
+                source_id,
+                Arc::clone(&persist_clients),
+                metadata.clone(),
+                read_schema,
+                as_of.clone(),
+                snapshot_mode,
+                until.clone(),
+                filter_plan,
+                flow_control,
+                subscribe_sleep,
+                start_signal,
+                error_handler,
+            );
+            tokens.extend(source_tokens);
+
+            let (ok_stream, err_stream) = decode_and_mfp::<E, mz_repr::Timestamp, CB>(
+                cfg,
+                fetched,
+                &name,
+                until.clone(),
+                map_filter_project,
+                |time| time.0,
+            );
 
-        let stream = match flow_control_probe {
-            Some(probe) => stream.probe_notify_with(vec![probe]),
-            None => stream,
-        };
+            // The handle's frontier is the meet of what its clones report, so both streams
+            // have to feed it for backpressure to retire the right bytes.
+            let (ok_stream, err_stream) = match flow_control_probe {
+                Some(probe) => (
+                    ok_stream.probe_notify_with(vec![probe.clone()]),
+                    err_stream.probe_notify_with(vec![probe]),
+                ),
+                None => (ok_stream, err_stream),
+            };
 
-        stream.leave(outer)
-    });
+            (ok_stream.leave(outer), err_stream.leave(outer))
+        });
 
     // If a txns_shard was provided, then this shard is in the txn-wal
     // system. This means the "logical" upper may be ahead of the "physical"
-    // upper. Render a dataflow operator that passes through the input and
-    // translates the progress frontiers as necessary.
-    let (stream, txns_tokens) = match metadata.txns_shard {
-        Some(txns_shard) => txns_progress::<SourceData, (), Timestamp, i64, _, TxnsCodecRow, _>(
-            stream,
-            &source_id.to_string(),
-            txns_ctx,
-            move || {
-                let (c, l) = (
-                    Arc::clone(&persist_clients),
-                    metadata.persist_location.clone(),
-                );
-                async move { c.open(l).await.expect("location is valid") }
-            },
-            txns_shard,
-            metadata.data_shard,
-            as_of
-                .expect("as_of is provided for table sources")
-                .into_option()
-                .expect("shard is not closed"),
-            until,
-            Arc::new(metadata.relation_desc),
-            Arc::new(UnitSchema),
-        ),
-        None => (stream, vec![]),
+    // upper. Render dataflow operators that pass through the inputs and
+    // translate the progress frontiers as necessary.
+    let (ok_stream, err_stream) = match metadata.txns_shard {
+        Some(txns_shard) => {
+            let (progress, remap_token) = TxnsProgress::new::<SourceData, (), i64, TxnsCodecRow, _>(
+                outer,
+                &name,
+                txns_ctx,
+                move || {
+                    let (c, l) = (
+                        Arc::clone(&persist_clients),
+                        metadata.persist_location.clone(),
+                    );
+                    async move { c.open(l).await.expect("location is valid") }
+                },
+                txns_shard,
+                metadata.data_shard,
+                as_of
+                    .expect("as_of is provided for table sources")
+                    .into_option()
+                    .expect("shard is not closed"),
+                Arc::new(metadata.relation_desc),
+                Arc::new(UnitSchema),
+            );
+            let (ok_stream, ok_token) = progress.translate(ok_stream, until.clone());
+            let (err_stream, err_token) = progress.translate(err_stream, until);
+            tokens.extend([remap_token, ok_token, err_token]);
+            (ok_stream, err_stream)
+        }
+        None => (ok_stream, err_stream),
     };
-    tokens.extend(txns_tokens);
-    let (ok_stream, err_stream) = stream.ok_err(|(d, t, r)| match d {
-        Ok(row) => Ok((row, t.0, r)),
-        Err(err) => Err((err, t.0, r)),
-    });
+
     (ok_stream, err_stream, tokens)
 }
 
@@ -299,7 +323,6 @@ type RefinedScope<'scope, T> = Scope<'scope, (T, Subtime)>;
 /// All times emitted will have been [advanced by] the given `as_of` frontier.
 ///
 /// [advanced by]: differential_dataflow::lattice::Lattice::advance_by
-#[allow(clippy::needless_borrow)]
 pub fn persist_source_core<'g, 'outer, E>(
     outer: Scope<'outer, mz_repr::Timestamp>,
     scope: RefinedScope<'g, mz_repr::Timestamp>,
@@ -311,25 +334,81 @@ pub fn persist_source_core<'g, 'outer, E>(
     snapshot_mode: SnapshotMode,
     until: Antichain<Timestamp>,
     map_filter_project: Option<&mut MfpPlan>,
-    flow_control: Option<FlowControl<'g, (mz_repr::Timestamp, Subtime)>>,
+    flow_control: Option<FlowControl<'g, RefinedTime>>,
     // If Some, an override for the default listen sleep retry parameters.
     listen_sleep: Option<impl Fn() -> RetryParameters + Send + 'static>,
     start_signal: impl Future<Output = ()> + Send + 'static,
     error_handler: ErrorHandler,
 ) -> (
-    Stream<
-        'g,
-        (mz_repr::Timestamp, Subtime),
-        Vec<(Result<Row, E>, (mz_repr::Timestamp, Subtime), Diff)>,
-    >,
+    StreamVec<'g, RefinedTime, (Result<Row, E>, RefinedTime, Diff)>,
     Vec<PressOnDropButton>,
 )
 where
     E: timely::ExchangeData + Ord + Clone + Debug + From<DataflowError> + From<EvalError>,
 {
-    let cfg = persist_clients.cfg().clone();
     let name = source_id.to_string();
     let filter_plan = map_filter_project.as_ref().map(|p| (*p).clone());
+    let (cfg, fetched, token) = fetch_parts(
+        outer,
+        scope,
+        source_id,
+        persist_clients,
+        metadata,
+        read_schema,
+        as_of,
+        snapshot_mode,
+        until.clone(),
+        filter_plan,
+        flow_control,
+        listen_sleep,
+        start_signal,
+        error_handler,
+    );
+    let (oks, errs) = decode_and_mfp::<E, RefinedTime, RowVecBuilder<RefinedTime>>(
+        cfg,
+        fetched,
+        &name,
+        until,
+        map_filter_project,
+        |time| time,
+    );
+    // `upsert` reads one collection of `Result`s. Records keep the refined time, so putting
+    // the sides back together is a move per record with no re-timestamping.
+    let rows = oks
+        .as_collection()
+        .map(Ok)
+        .concat(errs.as_collection().map(Err))
+        .inner;
+    (rows, token)
+}
+
+/// Fetch the parts of a persist shard a dataflow needs, distributing the work of reading them
+/// across all timely workers.
+#[allow(clippy::needless_borrow)]
+fn fetch_parts<'g, 'outer>(
+    outer: Scope<'outer, mz_repr::Timestamp>,
+    scope: RefinedScope<'g, mz_repr::Timestamp>,
+    source_id: GlobalId,
+    persist_clients: Arc<PersistClientCache>,
+    metadata: CollectionMetadata,
+    read_schema: Option<RelationDesc>,
+    as_of: Option<Antichain<Timestamp>>,
+    snapshot_mode: SnapshotMode,
+    until: Antichain<Timestamp>,
+    // The MFP whose filter is pushed down into persist, if any.
+    filter_plan: Option<MfpPlan>,
+    flow_control: Option<FlowControl<'g, RefinedTime>>,
+    // If Some, an override for the default listen sleep retry parameters.
+    listen_sleep: Option<impl Fn() -> RetryParameters + Send + 'static>,
+    start_signal: impl Future<Output = ()> + Send + 'static,
+    error_handler: ErrorHandler,
+) -> (
+    PersistConfig,
+    StreamVec<'g, RefinedTime, FetchedBlob<SourceData, (), Timestamp, StorageDiff>>,
+    Vec<PressOnDropButton>,
+) {
+    let cfg = persist_clients.cfg().clone();
+    let name = source_id.to_string();
 
     // N.B. `read_schema` may be a subset of the total columns for this shard.
     let read_desc = match read_schema {
@@ -403,8 +482,7 @@ where
         start_signal,
         error_handler,
     );
-    let rows = decode_and_mfp(cfg, fetched, &name, until, map_filter_project);
-    (rows, token)
+    (cfg, fetched, token)
 }
 
 fn filter_result(
@@ -453,23 +531,39 @@ fn filter_result(
     }
 }
 
-pub fn decode_and_mfp<'scope, E>(
+/// The time a decode operator's capabilities carry, refined with a [`Subtime`] so flow
+/// control can pace parts within a millisecond.
+type RefinedTime = (mz_repr::Timestamp, Subtime);
+
+/// Ok-side container builder producing row vectors timestamped with `T`.
+pub type RowVecBuilder<T> = ConsolidatingContainerBuilder<Vec<(Row, T, Diff)>>;
+
+/// Err-side container builder.
+type ErrBuilder<E, RT> = ConsolidatingContainerBuilder<Vec<(E, RT, Diff)>>;
+
+/// Decode fetched parts and apply `map_filter_project`, writing ok records into `CB`'s
+/// containers and err records into a separate output.
+///
+/// `record_time` picks what a record stores for its time. A reader that does not distinguish
+/// times within a millisecond passes `|time| time.0`, which drops the [`Subtime`] coordinate
+/// the enclosing scope refines with: that coordinate exists to pace flow control and stays on
+/// the capabilities, and keeping it in the records would force a re-encode to strip it later.
+/// A reader that builds a collection in the refined scope needs it, and passes `|time| time`.
+fn decode_and_mfp<'scope, E, RT, CB>(
     cfg: PersistConfig,
-    fetched: StreamVec<
-        'scope,
-        (mz_repr::Timestamp, Subtime),
-        FetchedBlob<SourceData, (), Timestamp, StorageDiff>,
-    >,
+    fetched: StreamVec<'scope, RefinedTime, FetchedBlob<SourceData, (), Timestamp, StorageDiff>>,
     name: &str,
     until: Antichain<Timestamp>,
     mut map_filter_project: Option<&mut MfpPlan>,
-) -> StreamVec<
-    'scope,
-    (mz_repr::Timestamp, Subtime),
-    (Result<Row, E>, (mz_repr::Timestamp, Subtime), Diff),
->
+    record_time: fn(RefinedTime) -> RT,
+) -> (
+    Stream<'scope, RefinedTime, CB::Container>,
+    StreamVec<'scope, RefinedTime, (E, RT, Diff)>,
+)
 where
     E: timely::ExchangeData + Ord + Clone + Debug + From<DataflowError> + From<EvalError>,
+    RT: Ord + Clone + Debug + 'static,
+    CB: ContainerBuilder + PushInto<(Row, RT, Diff)>,
 {
     let scope = fetched.scope();
     let mut builder = OperatorBuilder::new(
@@ -479,57 +573,68 @@ where
     let operator_info = builder.operator_info();
 
     let mut fetched_input = builder.new_input(fetched, Pipeline);
-    let (updates_output, updates_stream) = builder.new_output();
-    let mut updates_output = OutputBuilder::from(updates_output);
-
-    // Re-used state for processing and building rows.
-    let mut datum_vec = mz_repr::DatumVec::new();
-    let mut row_builder = Row::default();
+    let (ok_output, ok_stream) = builder.new_output::<CB::Container>();
+    let mut ok_output: OutputBuilder<_, CB> = OutputBuilder::from(ok_output);
+    let (err_output, err_stream) = builder.new_output();
+    let mut err_output: OutputBuilder<_, ErrBuilder<E, RT>> = OutputBuilder::from(err_output);
 
+    let name = name.to_owned();
     // Extract the MFP if it exists; leave behind an identity MFP in that case.
     let map_filter_project = map_filter_project.as_mut().map(|mfp| mfp.take());
 
     builder.build(move |_caps| {
-        let name = name.to_owned();
         // Acquire an activator to reschedule the operator when it has unfinished work.
-        let activations = scope.activations();
-        let activator = Activator::new(operator_info.address, activations);
-        // Maintain a list of work to do
-        let mut pending_work = std::collections::VecDeque::new();
+        let activator = Activator::new(operator_info.address, scope.activations());
         let panic_on_audit_failure = STATS_AUDIT_PANIC.handle(&cfg);
+        let mut pending_work = VecDeque::new();
+        let mut datum_vec = DatumVec::new();
+        let mut row_builder = Row::default();
 
         move |_frontier| {
             fetched_input.for_each(|time, data| {
-                let capability = time.retain(0);
-                for fetched_blob in data.drain(..) {
+                let capabilities = [time.retain(0), time.retain(1)];
+                let panic_on_audit_failure = panic_on_audit_failure.get();
+                for blob in data.drain(..) {
                     pending_work.push_back(PendingWork {
-                        panic_on_audit_failure: panic_on_audit_failure.get(),
-                        capability: capability.clone(),
-                        part: PendingPart::Unparsed(fetched_blob),
-                    })
+                        panic_on_audit_failure,
+                        capabilities: capabilities.clone(),
+                        part: PendingPart::Unparsed(blob),
+                    });
                 }
             });
 
-            // Get dyncfg values once per schedule to amortize the cost of
-            // loading the atomics.
+            // Get dyncfg values once per schedule to amortize the cost of loading the atomics.
             let yield_fuel = cfg.storage_source_decode_fuel();
-            let yield_fn = |_, work| work >= yield_fuel;
-
             let mut work = 0;
-            let start_time = Instant::now();
-            let mut output = updates_output.activate();
-            while !pending_work.is_empty() && !yield_fn(start_time, work) {
-                let done = pending_work.front_mut().unwrap().do_work(
-                    &mut work,
+            let mut ok_output = ok_output.activate();
+            let mut err_output = err_output.activate();
+            while let Some(front) = pending_work.front_mut() {
+                if work >= yield_fuel {
+                    break;
+                }
+                let cap_time = *front.capabilities[0].time();
+                // A session per part: dropping it flushes the container builder, so a
+                // container never mixes records from parts held at different capabilities.
+                let mut ok_session = ok_output.session_with_builder(&front.capabilities[0]);
+                let mut err_session = err_output.session_with_builder(&front.capabilities[1]);
+                let done = decode_part(
+                    &mut front.part,
+                    front.panic_on_audit_failure,
+                    cap_time,
                     &name,
-                    start_time,
-                    yield_fn,
                     &until,
                     map_filter_project.as_ref(),
                     &mut datum_vec,
                     &mut row_builder,
-                    &mut output,
+                    &mut work,
+                    yield_fuel,
+                    |record, time, diff| match record {
+                        Ok(row) => ok_session.give((row.into_owned(), record_time(time), diff)),
+                        Err(err) => err_session.give((err, record_time(time), diff)),
+                    },
                 );
+                drop(ok_session);
+                drop(err_session);
                 if done {
                     pending_work.pop_front();
                 }
@@ -540,15 +645,15 @@ where
         }
     });
 
-    updates_stream
+    (ok_stream, err_stream)
 }
 
 /// Pending work to read from fetched parts
 struct PendingWork {
     /// Whether to panic if a part fails an audit, or to just pass along the audited data.
     panic_on_audit_failure: bool,
-    /// The time at which the work should happen.
-    capability: Capability<(mz_repr::Timestamp, Subtime)>,
+    /// The time at which the work should happen, one capability per operator output.
+    capabilities: [Capability<RefinedTime>; 2],
     /// Pending fetched part.
     part: PendingPart,
 }
@@ -579,167 +684,157 @@ impl PendingPart {
     }
 }
 
-impl PendingWork {
-    /// Perform work, reading from the fetched part, decoding, and sending outputs, while checking
-    /// `yield_fn` whether more fuel is available.
-    fn do_work<YFn, E>(
-        &mut self,
-        work: &mut usize,
-        name: &str,
-        start_time: Instant,
-        yield_fn: YFn,
-        until: &Antichain<Timestamp>,
-        map_filter_project: Option<&MfpPlan>,
-        datum_vec: &mut DatumVec,
-        row_builder: &mut Row,
-        output: &mut OutputBuilderSession<
-            '_,
-            (mz_repr::Timestamp, Subtime),
-            ConsolidatingContainerBuilder<
-                Vec<(Result<Row, E>, (mz_repr::Timestamp, Subtime), Diff)>,
-            >,
-        >,
-    ) -> bool
-    where
-        YFn: Fn(Instant, usize) -> bool,
-        E: timely::ExchangeData + Ord + Clone + Debug + From<DataflowError> + From<EvalError>,
+/// Read `part`, apply the MFP, and hand every record to `give`, stopping once `work` reaches
+/// `yield_fuel`. Returns whether the part is exhausted.
+///
+/// Records carry `cap_time` with its millisecond replaced by the record's own time, so the
+/// caller must emit them at the capability `cap_time` came from.
+fn decode_part<E, F>(
+    part: &mut PendingPart,
+    panic_on_audit_failure: bool,
+    cap_time: RefinedTime,
+    name: &str,
+    until: &Antichain<Timestamp>,
+    map_filter_project: Option<&MfpPlan>,
+    datum_vec: &mut DatumVec,
+    row_builder: &mut Row,
+    work: &mut usize,
+    yield_fuel: usize,
+    mut give: F,
+) -> bool
+where
+    E: timely::ExchangeData + Ord + Clone + Debug + From<DataflowError> + From<EvalError>,
+    F: FnMut(Result<Cow<'_, Row>, E>, RefinedTime, Diff),
+{
+    let fetched_part = part.part_mut();
+    let is_filter_pushdown_audit = fetched_part.is_filter_pushdown_audit();
+    let mut row_buf = None;
+    while let Some(((key, val), time, diff)) =
+        fetched_part.next_with_storage(&mut row_buf, &mut None)
     {
-        let mut session = output.session_with_builder(&self.capability);
-        let fetched_part = self.part.part_mut();
-        let is_filter_pushdown_audit = fetched_part.is_filter_pushdown_audit();
-        let mut row_buf = None;
-        while let Some(((key, val), time, diff)) =
-            fetched_part.next_with_storage(&mut row_buf, &mut None)
-        {
-            if until.less_equal(&time) {
-                continue;
-            }
-            match (key, val) {
-                (SourceData(Ok(row)), ()) => {
-                    if let Some(mfp) = map_filter_project {
-                        // We originally accounted work as the number of outputs, to give downstream
-                        // operators a chance to reduce down anything we've emitted. This mfp call
-                        // might have a restrictive filter, which would have been counted as no
-                        // work. However, in practice, we've been decode_and_mfp be a source of
-                        // interactivity loss during rehydration, so we now also count each mfp
-                        // evaluation against our fuel.
-                        *work += 1;
-                        let arena = mz_repr::RowArena::new();
-                        let mut datums_local = datum_vec.borrow_with(&row);
-                        for result in mfp.evaluate(
-                            &mut datums_local,
-                            &arena,
-                            time,
-                            diff.into(),
-                            |time| !until.less_equal(time),
-                            row_builder,
-                        ) {
-                            // Earlier we decided this Part doesn't need to be fetched, but to
-                            // audit our logic we fetched it any way. If the MFP returned data it
-                            // means our earlier decision to not fetch this part was incorrect.
-                            if let Some(stats) = &is_filter_pushdown_audit {
-                                // NB: The tag added by this scope is used for alerting. The panic
-                                // message may be changed arbitrarily, but the tag key and val must
-                                // stay the same.
-                                sentry::with_scope(
-                                    |scope| {
-                                        scope
-                                            .set_tag("alert_id", "persist_pushdown_audit_violation")
-                                    },
-                                    || {
-                                        error!(
-                                            ?stats,
-                                            name,
-                                            mfp = ?redact(&mfp),
-                                            result = ?redact(&result),
-                                            "persist filter pushdown correctness violation!"
+        if until.less_equal(&time) {
+            continue;
+        }
+        match (key, val) {
+            (SourceData(Ok(row)), ()) => {
+                if let Some(mfp) = map_filter_project {
+                    // We originally accounted work as the number of outputs, to give downstream
+                    // operators a chance to reduce down anything we've emitted. This mfp call
+                    // might have a restrictive filter, which would have been counted as no
+                    // work. However, in practice, we've been decode_and_mfp be a source of
+                    // interactivity loss during rehydration, so we now also count each mfp
+                    // evaluation against our fuel.
+                    *work += 1;
+                    let arena = mz_repr::RowArena::new();
+                    let mut datums_local = datum_vec.borrow_with(&row);
+                    for result in mfp.evaluate(
+                        &mut datums_local,
+                        &arena,
+                        time,
+                        diff.into(),
+                        |time| !until.less_equal(time),
+                        row_builder,
+                    ) {
+                        // Earlier we decided this Part doesn't need to be fetched, but to
+                        // audit our logic we fetched it any way. If the MFP returned data it
+                        // means our earlier decision to not fetch this part was incorrect.
+                        if let Some(stats) = &is_filter_pushdown_audit {
+                            // NB: The tag added by this scope is used for alerting. The panic
+                            // message may be changed arbitrarily, but the tag key and val must
+                            // stay the same.
+                            sentry::with_scope(
+                                |scope| {
+                                    scope.set_tag("alert_id", "persist_pushdown_audit_violation")
+                                },
+                                || {
+                                    error!(
+                                        ?stats,
+                                        name,
+                                        mfp = ?redact(&mfp),
+                                        result = ?redact(&result),
+                                        "persist filter pushdown correctness violation!"
+                                    );
+                                    if panic_on_audit_failure {
+                                        panic!(
+                                            "persist filter pushdown correctness violation! {}",
+                                            name
                                         );
-                                        if self.panic_on_audit_failure {
-                                            panic!(
-                                                "persist filter pushdown correctness violation! {}",
-                                                name
-                                            );
-                                        }
-                                    },
-                                );
-                            }
-                            match result {
-                                Ok((row, time, diff)) => {
-                                    // Additional `until` filtering due to temporal filters.
-                                    if !until.less_equal(&time) {
-                                        let mut emit_time = *self.capability.time();
-                                        emit_time.0 = time;
-                                        session.give((Ok(row), emit_time, diff));
-                                        *work += 1;
                                     }
+                                },
+                            );
+                        }
+                        match result {
+                            Ok((row, time, diff)) => {
+                                // Additional `until` filtering due to temporal filters.
+                                if !until.less_equal(&time) {
+                                    let mut emit_time = cap_time;
+                                    emit_time.0 = time;
+                                    give(Ok(Cow::Owned(row)), emit_time, diff);
+                                    *work += 1;
                                 }
-                                Err((err, time, diff)) => {
-                                    // Additional `until` filtering due to temporal filters.
-                                    if !until.less_equal(&time) {
-                                        let mut emit_time = *self.capability.time();
-                                        emit_time.0 = time;
-                                        session.give((Err(err), emit_time, diff));
-                                        *work += 1;
-                                    }
+                            }
+                            Err((err, time, diff)) => {
+                                // Additional `until` filtering due to temporal filters.
+                                if !until.less_equal(&time) {
+                                    let mut emit_time = cap_time;
+                                    emit_time.0 = time;
+                                    give(Err(err), emit_time, diff);
+                                    *work += 1;
                                 }
                             }
                         }
-                        // At the moment, this is the only case where we can re-use the allocs for
-                        // the `SourceData`/`Row` we decoded. This could be improved if this timely
-                        // operator used a different container than `Vec<Row>`.
-                        drop(datums_local);
-                        row_buf.replace(SourceData(Ok(row)));
-                    } else {
-                        let mut emit_time = *self.capability.time();
-                        emit_time.0 = time;
-                        // Clone row so we retain our row allocation.
-                        session.give((Ok(row.clone()), emit_time, diff.into()));
-                        row_buf.replace(SourceData(Ok(row)));
-                        *work += 1;
-                    }
-                }
-                (SourceData(Err(err)), ()) => {
-                    // A discarded part that turns out to hold an error row is
-                    // as much a pushdown violation as one whose MFP yields
-                    // output: errors must surface regardless of any filter.
-                    // Without this arm the audit was blind to exactly the
-                    // undercounted-err-stats violation class.
-                    if let Some(stats) = &is_filter_pushdown_audit {
-                        sentry::with_scope(
-                            |scope| scope.set_tag("alert_id", "persist_pushdown_audit_violation"),
-                            || {
-                                // `err` is redacted for the same reason the
-                                // `Ok`-row arm redacts its MFP output: these
-                                // events go to Sentry, and a `DecodeError`
-                                // carries the raw source record bytes while
-                                // several `EvalError`s embed user input.
-                                error!(
-                                    ?stats,
-                                    name,
-                                    err = ?redact(&err),
-                                    "persist filter pushdown correctness violation!"
-                                );
-                                if self.panic_on_audit_failure {
-                                    panic!(
-                                        "persist filter pushdown correctness violation! {}",
-                                        name
-                                    );
-                                }
-                            },
-                        );
                     }
-                    let mut emit_time = *self.capability.time();
+                    // The MFP built its output into `row_builder`, so the decoded row's
+                    // allocation is free to go back to `row_buf`.
+                    drop(datums_local);
+                    row_buf.replace(SourceData(Ok(row)));
+                } else {
+                    let mut emit_time = cap_time;
                     emit_time.0 = time;
-                    session.give((Err(E::from(err)), emit_time, diff.into()));
+                    // The output copies the row out, so the allocation stays with `row_buf`.
+                    give(Ok(Cow::Borrowed(&row)), emit_time, diff.into());
+                    row_buf.replace(SourceData(Ok(row)));
                     *work += 1;
                 }
             }
-            if yield_fn(start_time, *work) {
-                return false;
+            (SourceData(Err(err)), ()) => {
+                // A discarded part that turns out to hold an error row is
+                // as much a pushdown violation as one whose MFP yields
+                // output: errors must surface regardless of any filter.
+                // Without this arm the audit was blind to exactly the
+                // undercounted-err-stats violation class.
+                if let Some(stats) = &is_filter_pushdown_audit {
+                    sentry::with_scope(
+                        |scope| scope.set_tag("alert_id", "persist_pushdown_audit_violation"),
+                        || {
+                            // `err` is redacted for the same reason the
+                            // `Ok`-row arm redacts its MFP output: these
+                            // events go to Sentry, and a `DecodeError`
+                            // carries the raw source record bytes while
+                            // several `EvalError`s embed user input.
+                            error!(
+                                ?stats,
+                                name,
+                                err = ?redact(&err),
+                                "persist filter pushdown correctness violation!"
+                            );
+                            if panic_on_audit_failure {
+                                panic!("persist filter pushdown correctness violation! {}", name);
+                            }
+                        },
+                    );
+                }
+                let mut emit_time = cap_time;
+                emit_time.0 = time;
+                give(Err(E::from(err)), emit_time, diff.into());
+                *work += 1;
             }
         }
-        true
+        if *work >= yield_fuel {
+            return false;
+        }
     }
+    true
 }
 
 /// A trait representing a type that can be used in `backpressure`.
diff --git a/src/storage/src/render/sinks.rs b/src/storage/src/render/sinks.rs
index c0d44acf083ec..30029091c6443 100644
--- a/src/storage/src/render/sinks.rs
+++ b/src/storage/src/render/sinks.rs
@@ -73,21 +73,22 @@ pub(crate) fn render_sink<'scope>(
         let mut tokens = vec![];
         let sink_render = get_sink_render_for(&sink.connection);
 
-        let (ok_collection, err_collection, persist_tokens) = persist_source::persist_source(
-            scope,
-            sink.from,
-            Arc::clone(&storage_state.persist_clients),
-            &storage_state.txns_ctx,
-            sink.from_storage_metadata.clone(),
-            None,
-            Some(sink.as_of.clone()),
-            snapshot_mode,
-            timely::progress::Antichain::new(),
-            None,
-            None,
-            async {},
-            error_handler,
-        );
+        let (ok_collection, err_collection, persist_tokens) =
+            persist_source::persist_source::<_, persist_source::RowVecBuilder<Timestamp>>(
+                scope,
+                sink.from,
+                Arc::clone(&storage_state.persist_clients),
+                &storage_state.txns_ctx,
+                sink.from_storage_metadata.clone(),
+                None,
+                Some(sink.as_of.clone()),
+                snapshot_mode,
+                timely::progress::Antichain::new(),
+                None,
+                None,
+                async {},
+                error_handler,
+            );
         tokens.extend(persist_tokens);
 
         let batches = arrange_sink_input(&*sink_render, ok_collection.as_collection());
diff --git a/src/timely-util/src/columnar.rs b/src/timely-util/src/columnar.rs
index 4735a46d2ce76..53386de47132e 100644
--- a/src/timely-util/src/columnar.rs
+++ b/src/timely-util/src/columnar.rs
@@ -34,11 +34,14 @@ use columnar::common::IterOwn;
 use columnar::{Clear, FromBytes, Index, Len};
 use columnar::{Columnar, Ref};
 use differential_dataflow::Hashable;
+use differential_dataflow::collection::containers::Enter;
 use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
 use timely::Accountable;
 use timely::bytes::arc::Bytes;
 use timely::container::{DrainContainer, PushInto, SizableContainer};
 use timely::dataflow::channels::ContainerBytes;
+use timely::progress::Timestamp;
+use timely::progress::timestamp::Refines;
 
 use crate::columnation::ColInternalMerger;
 
@@ -193,6 +196,53 @@ where
     }
 }
 
+/// Re-encodes a column's times into a refining timestamp, so a columnar collection can enter
+/// an iterative scope.
+impl<D, T1, T2, R> Enter<T1, T2> for Column<(D, T1, R)>
+where
+    D: Columnar,
+    T1: Columnar + Timestamp,
+    T2: Columnar + Refines<T1>,
+    R: Columnar,
+    (D, T1, R): Columnar<Container = (D::Container, T1::Container, R::Container)>,
+    (D, T2, R): Columnar<Container = (D::Container, T2::Container, R::Container)>,
+    for<'a> D::Container: columnar::Push<Ref<'a, D>>,
+    for<'a> T2::Container: columnar::Push<&'a T2>,
+    for<'a> R::Container: columnar::Push<Ref<'a, R>>,
+{
+    type InnerContainer = Column<(D, T2, R)>;
+
+    fn enter(self) -> Self::InnerContainer {
+        use columnar::Push;
+        match self {
+            // Only the times change, so the data and diff columns move across whole.
+            Column::Typed((data, times, diffs)) => {
+                let mut inner = T2::Container::default();
+                for time in times.borrow().into_index_iter() {
+                    inner.push(&T2::to_inner(T1::into_owned(time)));
+                }
+                Column::Typed((data, inner, diffs))
+            }
+            // A serialized column owns no typed sub-containers, so only the times are
+            // materialized. The data and diff columns go from their borrowed views
+            // straight into the output allocation, a copy per column rather than a
+            // decode and re-encode per record.
+            serialized => {
+                let (borrowed_data, borrowed_times, borrowed_diffs) = serialized.borrow();
+                let mut times = T2::Container::default();
+                for time in borrowed_times.into_index_iter() {
+                    times.push(&T2::to_inner(T1::into_owned(time)));
+                }
+                let view = (borrowed_data, times.borrow(), borrowed_diffs);
+                let words = indexed::length_in_words(&view);
+                let mut alloc: Vec<u64> = Vec::with_capacity(words);
+                indexed::encode(&mut alloc, &view);
+                Column::Align(alloc)
+            }
+        }
+    }
+}
+
 /// Words per 2 MiB. `length_in_words` returns serialized size in `u64` units,
 /// so this is the page count we round up to. Picked to match
 /// [`builder::ColumnBuilder`]'s output granularity so chunks shipped from the
diff --git a/src/txn-wal/src/operator.rs b/src/txn-wal/src/operator.rs
index 06166c0d502a5..9a8cfd5d488ba 100644
--- a/src/txn-wal/src/operator.rs
+++ b/src/txn-wal/src/operator.rs
@@ -40,11 +40,11 @@ use timely::dataflow::operators::generic::OutputBuilder;
 use timely::dataflow::operators::generic::builder_rc::OperatorBuilder as OperatorBuilderRc;
 use timely::dataflow::operators::vec::{Broadcast, Map};
 use timely::dataflow::operators::{Capture, Leave, Probe};
-use timely::dataflow::{ProbeHandle, Scope, StreamVec};
+use timely::dataflow::{ProbeHandle, Scope, Stream, StreamVec};
 use timely::order::TotalOrder;
 use timely::progress::{Antichain, Timestamp};
 use timely::worker::Worker;
-use timely::{PartialOrder, WorkerConfig};
+use timely::{Container, PartialOrder, WorkerConfig};
 use tracing::debug;
 
 use crate::TxnsCodecDefault;
@@ -114,33 +114,85 @@ where
     C: TxnsCodec + 'static,
     F: Future<Output = PersistClient> + Send + 'static,
 {
-    let unique_id = (name, passthrough.scope().addr()).hashed();
-    let (remap, source_button) = txns_progress_source_global::<K, V, T, D, P, C>(
+    let (progress, source_button) = TxnsProgress::new::<K, V, D, C, F>(
         passthrough.scope(),
         name,
-        ctx.clone(),
-        client_fn(),
+        ctx,
+        client_fn,
         txns_id,
         data_id,
         as_of,
         data_key_schema,
         data_val_schema,
-        unique_id,
-    );
-    // Each of the `txns_frontiers` workers wants the full copy of the remap
-    // information.
-    let remap = remap.broadcast();
-    let (passthrough, frontiers_button) = txns_progress_frontiers::<K, V, T, D, P, C>(
-        remap,
-        passthrough,
-        name,
-        data_id,
-        until,
-        unique_id,
     );
+    let (passthrough, frontiers_button) = progress.translate(passthrough, until);
     (passthrough, vec![source_button, frontiers_button])
 }
 
+/// A subscription to one data shard's remap information, from which any number of streams
+/// read off that shard can have their frontiers translated.
+///
+/// The subscription is the expensive half and does not depend on what is read, so it is
+/// rendered once by [`TxnsProgress::new`]. [`TxnsProgress::translate`] then renders one
+/// passthrough operator per stream, and is generic over the container so streams of
+/// different shapes can share a subscription.
+#[derive(Debug)]
+pub struct TxnsProgress<'scope, T: Timestamp> {
+    /// Broadcast remap stream, one operator per call to `translate` reads it.
+    remap: StreamVec<'scope, T, DataRemapEntry<T>>,
+    name: String,
+    data_id: ShardId,
+    /// Disambiguates the log lines of operators rendered for the same shard.
+    unique_id: u64,
+}
+
+impl<'scope, T> TxnsProgress<'scope, T>
+where
+    T: Timestamp + Lattice + TotalOrder + StepForward + Codec64 + Sync,
+{
+    /// Subscribe to `data_id`'s remap information and broadcast it to every worker.
+    pub fn new<K, V, D, C, F>(
+        scope: Scope<'scope, T>,
+        name: &str,
+        ctx: &TxnsContext,
+        client_fn: impl Fn() -> F,
+        txns_id: ShardId,
+        data_id: ShardId,
+        as_of: T,
+        data_key_schema: Arc<K::Schema>,
+        data_val_schema: Arc<V::Schema>,
+    ) -> (Self, PressOnDropButton)
+    where
+        K: Debug + Codec + Send + Sync,
+        V: Debug + Codec + Send + Sync,
+        D: Debug + Clone + 'static + Monoid + Ord + Codec64 + Send + Sync,
+        C: TxnsCodec + 'static,
+        F: Future<Output = PersistClient> + Send + 'static,
+    {
+        let unique_id = (name, scope.addr()).hashed();
+        let (remap, source_button) = txns_progress_source_global::<K, V, T, D, C>(
+            scope,
+            name,
+            ctx.clone(),
+            client_fn(),
+            txns_id,
+            data_id,
+            as_of,
+            data_key_schema,
+            data_val_schema,
+            unique_id,
+        );
+        // Each of the `txns_frontiers` workers wants the full copy of the remap information.
+        let progress = TxnsProgress {
+            remap: remap.broadcast(),
+            name: name.to_owned(),
+            data_id,
+            unique_id,
+        };
+        (progress, source_button)
+    }
+}
+
 /// Event sent from the subscribe Tokio task to the sync `txns_progress_source`
 /// operator. The task owns the persist resources and the `data_subscribe`
 /// receiver. The operator owns the output capability and drives the frontier.
@@ -165,7 +217,7 @@ enum SourceEvent<T> {
 ///
 /// [reclocking design doc]:
 ///     https://github.com/MaterializeInc/materialize/blob/main/doc/developer/design/20210714_reclocking.md
-fn txns_progress_source_global<'scope, K, V, T, D, P, C>(
+fn txns_progress_source_global<'scope, K, V, T, D, C>(
     scope: Scope<'scope, T>,
     name: &str,
     ctx: TxnsContext,
@@ -182,7 +234,6 @@ where
     V: Debug + Codec + Send + Sync,
     T: Timestamp + Lattice + TotalOrder + StepForward + Codec64 + Sync,
     D: Debug + Clone + 'static + Monoid + Ord + Codec64 + Send + Sync,
-    P: Debug + Clone + 'static,
     C: TxnsCodec + 'static,
 {
     let worker_idx = scope.index();
@@ -333,54 +384,55 @@ where
     (remap_stream, shutdown_button.press_on_drop())
 }
 
-/// The block ordering inside the schedule closure is load-bearing: pending
-/// passthrough input is emitted at the pre-activation capability BEFORE any
-/// capability downgrade, which keeps the differential invariant `send_time <=
-/// record_time` and avoids dropping in-flight rows when the passthrough
-/// frontier crosses `until` in the same activation (SQL-299). Do not reorder.
-fn txns_progress_frontiers<'scope, K, V, T, D, P, C>(
-    remap: StreamVec<'scope, T, DataRemapEntry<T>>,
-    passthrough: StreamVec<'scope, T, P>,
-    name: &str,
-    data_id: ShardId,
-    until: Antichain<T>,
-    unique_id: u64,
-) -> (StreamVec<'scope, T, P>, PressOnDropButton)
+impl<'scope, T> TxnsProgress<'scope, T>
 where
-    K: Debug + Codec,
-    V: Debug + Codec,
     T: Timestamp + Lattice + TotalOrder + StepForward + Codec64,
-    D: Clone + 'static + Monoid + Codec64 + Send + Sync,
-    P: Debug + Clone + 'static,
-    C: TxnsCodec,
 {
-    let scope = passthrough.scope();
-    let name = format!("txns_progress_frontiers({})", name);
-    let mut builder = OperatorBuilderRc::new(name.clone(), scope.clone());
-    let info = builder.operator_info();
-    let name = format!(
-        "{} [{}] {}/{} {:.9}",
-        name,
-        unique_id,
-        scope.index(),
-        scope.peers(),
-        data_id.to_string(),
-    );
-    let (passthrough_output, passthrough_stream) = builder.new_output::<Vec<P>>();
-    let mut passthrough_output = OutputBuilder::from(passthrough_output);
-    // Both inputs are disconnected from the output: capability advancement is
-    // driven manually based on the remap stream and the passthrough frontier.
-    // NB: the output is created BEFORE the inputs on purpose. `new_output`
-    // connects to whatever inputs already exist (here, none); the `[]`
-    // connection arg below records the input-to-output summary but does not by
-    // itself disconnect the output. Creating an input before the output would
-    // silently connect them and break the manual capability management.
-    let mut remap_input = builder.new_input_connection(remap, Pipeline, []);
-    let mut passthrough_input = builder.new_input_connection(passthrough, Pipeline, []);
-
-    let (mut shutdown_handle, shutdown_button) = button(scope, info.address);
-
-    builder.build_reschedule(move |capabilities| {
+    /// Delay `passthrough`'s capability by the subscription's remap, translating the data
+    /// shard's physical frontier into the logical one.
+    ///
+    /// Call once per stream read off the shard. Streams of different container types can
+    /// share one subscription.
+    ///
+    /// The block ordering inside the schedule closure is load-bearing: pending
+    /// passthrough input is emitted at the pre-activation capability BEFORE any
+    /// capability downgrade, which keeps the differential invariant `send_time <=
+    /// record_time` and avoids dropping in-flight rows when the passthrough
+    /// frontier crosses `until` in the same activation (SQL-299). Do not reorder.
+    pub fn translate<C: Container>(
+        &self,
+        passthrough: Stream<'scope, T, C>,
+        until: Antichain<T>,
+    ) -> (Stream<'scope, T, C>, PressOnDropButton) {
+        let remap = self.remap.clone();
+        let (data_id, unique_id) = (self.data_id, self.unique_id);
+        let scope = passthrough.scope();
+        let name = format!("txns_progress_frontiers({})", self.name);
+        let mut builder = OperatorBuilderRc::new(name.clone(), scope.clone());
+        let info = builder.operator_info();
+        let name = format!(
+            "{} [{}] {}/{} {:.9}",
+            name,
+            unique_id,
+            scope.index(),
+            scope.peers(),
+            data_id.to_string(),
+        );
+        let (passthrough_output, passthrough_stream) = builder.new_output::<C>();
+        let mut passthrough_output = OutputBuilder::from(passthrough_output);
+        // Both inputs are disconnected from the output: capability advancement is
+        // driven manually based on the remap stream and the passthrough frontier.
+        // NB: the output is created BEFORE the inputs on purpose. `new_output`
+        // connects to whatever inputs already exist (here, none); the `[]`
+        // connection arg below records the input-to-output summary but does not by
+        // itself disconnect the output. Creating an input before the output would
+        // silently connect them and break the manual capability management.
+        let mut remap_input = builder.new_input_connection(remap, Pipeline, []);
+        let mut passthrough_input = builder.new_input_connection(passthrough, Pipeline, []);
+
+        let (mut shutdown_handle, shutdown_button) = button(scope, info.address);
+
+        builder.build_reschedule(move |capabilities| {
         // The output capability's time tracks how far we've progressed in
         // copying along the passthrough input. `None` indicates that we've
         // dropped the capability to shut down.
@@ -474,7 +526,7 @@ where
             if let Some(cap) = capability.as_ref() {
                 let mut output = passthrough_output.activate();
                 passthrough_input.for_each(|_input_cap, data| {
-                    debug!("{} emitting data {:?}", name, data);
+                    debug!("{} emitting {} records", name, data.record_count());
                     output.session(cap).give_container(data);
                 });
             } else {
@@ -550,7 +602,8 @@ where
         }
     });
 
-    (passthrough_stream, shutdown_button.press_on_drop())
+        (passthrough_stream, shutdown_button.press_on_drop())
+    }
 }
 
 /// The process global [`TxnsRead`] that any operator can communicate with.
@@ -1328,14 +1381,13 @@ mod tests {
         pass: StreamVec<'a, u64, i64>,
         until: Antichain<u64>,
     ) -> (StreamVec<'a, u64, i64>, PressOnDropButton) {
-        txns_progress_frontiers::<String, (), u64, i64, i64, TxnsCodecDefault>(
+        let progress = TxnsProgress {
             remap,
-            pass,
-            "test",
-            ShardId::new(),
-            until,
-            0,
-        )
+            name: "test".into(),
+            data_id: ShardId::new(),
+            unique_id: 0,
+        };
+        progress.translate(pass, until)
     }
 
     /// Generates a random schedule for the no-data-loss fuzz test. Interleaves
diff --git a/test/sqllogictest/autogenerated/mz_internal.slt b/test/sqllogictest/autogenerated/mz_internal.slt
index 66cd3a52e3a4e..9f170e9453025 100644
--- a/test/sqllogictest/autogenerated/mz_internal.slt
+++ b/test/sqllogictest/autogenerated/mz_internal.slt
@@ -149,6 +149,7 @@ memory_bytes  uint8  Approximate␠RAM␠usage,␠in␠bytes.
 disk_bytes  uint8  Approximate␠disk␠usage,␠in␠bytes.
 heap_bytes  uint8  Approximate␠heap␠(RAM␠+␠swap)␠usage,␠in␠bytes.
 heap_limit  uint8  Available␠heap␠(RAM␠+␠swap)␠space,␠in␠bytes.
+swap_bytes  uint8  Approximate␠swap␠usage,␠in␠bytes.
 
 query TTT
 SELECT name, type, comment FROM objects WHERE schema = 'mz_internal' AND object = 'mz_cluster_replica_metrics_history' ORDER BY position
@@ -161,6 +162,7 @@ disk_bytes  uint8  Approximate␠disk␠usage,␠in␠bytes.
 occurred_at  timestamp␠with␠time␠zone  Wall-clock␠timestamp␠at␠which␠the␠event␠occurred.
 heap_bytes  uint8  Approximate␠heap␠(RAM␠+␠swap)␠usage,␠in␠bytes.
 heap_limit  uint8  Available␠heap␠(RAM␠+␠swap)␠space,␠in␠bytes.
+swap_bytes  uint8  Approximate␠swap␠usage,␠in␠bytes.
 
 query TTT
 SELECT name, type, comment FROM objects WHERE schema = 'mz_internal' AND object = 'mz_cluster_replica_statuses' ORDER BY position
@@ -189,6 +191,7 @@ cpu_percent  double␠precision  Approximate␠CPU␠usage,␠in␠percent␠of
 memory_percent  double␠precision  Approximate␠RAM␠usage,␠in␠percent␠of␠the␠total␠allocation.
 disk_percent  double␠precision  Approximate␠disk␠usage,␠in␠percent␠of␠the␠total␠allocation.
 heap_percent  double␠precision  Approximate␠heap␠(RAM␠+␠swap)␠usage,␠in␠percent␠of␠the␠total␠allocation.
+swap_percent  double␠precision  Approximate␠swap␠usage,␠in␠percent␠of␠the␠total␠heap␠allocation.
 
 query TTT
 SELECT name, type, comment FROM objects WHERE schema = 'mz_internal' AND object = 'mz_cluster_replica_utilization_history' ORDER BY position
@@ -199,6 +202,7 @@ cpu_percent  double␠precision  Approximate␠CPU␠usage,␠in␠percent␠of
 memory_percent  double␠precision  Approximate␠RAM␠usage,␠in␠percent␠of␠the␠total␠allocation.
 disk_percent  double␠precision  Approximate␠disk␠usage,␠in␠percent␠of␠the␠total␠allocation.
 heap_percent  double␠precision  Approximate␠heap␠(RAM␠+␠swap)␠usage,␠in␠percent␠of␠the␠total␠allocation.
+swap_percent  double␠precision  Approximate␠swap␠usage,␠in␠percent␠of␠the␠total␠heap␠allocation.
 occurred_at  timestamp␠with␠time␠zone  Wall-clock␠timestamp␠at␠which␠the␠event␠occurred.
 
 query TTT
diff --git a/test/sqllogictest/catalog_server_explain.slt b/test/sqllogictest/catalog_server_explain.slt
index 4fb1faa189f0a..113e1100c41d0 100644
--- a/test/sqllogictest/catalog_server_explain.slt
+++ b/test/sqllogictest/catalog_server_explain.slt
@@ -709,7 +709,7 @@ mz_internal.mz_cluster_replica_metrics_ind:
 
 mz_internal.mz_cluster_replica_metrics:
   →Map/Filter/Project
-    Project: #0..=#4, #6, #7
+    Project: #0..=#4, #6..=#8
       →Non-monotonic TopK
         Group By #0, #1
         Order By #5 desc nulls_first
@@ -8451,8 +8451,8 @@ Explained Query:
   →One-Shot Delta Join [%0:mz_cluster_replicas » %1:mz_cluster_replica_sizes[#0{size}] » %2:mz_cluster_replica_metrics[#0{replica_id}]]
     path %0:
       after %2:
-        Project: #0, #4, #10..=#13
-        Map: ((uint8_to_double(#5{cpu_nano_cores}) / uint8_to_double(case when (0 = uint8_to_numeric(#1{cpu_nano_cores})) then null else #1{cpu_nano_cores} end)) * 100), ((uint8_to_double(#6{memory_bytes}) / uint8_to_double(case when (0 = uint8_to_numeric(#2{memory_bytes})) then null else #2{memory_bytes} end)) * 100), ((uint8_to_double(#7{disk_bytes}) / uint8_to_double(case when (0 = uint8_to_numeric(#3{disk_bytes})) then null else #3{disk_bytes} end)) * 100), ((uint8_to_double(#8{heap_bytes}) / uint8_to_double(case when (0 = uint8_to_numeric(#9{heap_limit})) then null else #9{heap_limit} end)) * 100)
+        Project: #0, #4, #11..=#13, #15, #16
+        Map: ((uint8_to_double(#5{cpu_nano_cores}) / uint8_to_double(case when (0 = uint8_to_numeric(#1{cpu_nano_cores})) then null else #1{cpu_nano_cores} end)) * 100), ((uint8_to_double(#6{memory_bytes}) / uint8_to_double(case when (0 = uint8_to_numeric(#2{memory_bytes})) then null else #2{memory_bytes} end)) * 100), ((uint8_to_double(#7{disk_bytes}) / uint8_to_double(case when (0 = uint8_to_numeric(#3{disk_bytes})) then null else #3{disk_bytes} end)) * 100), uint8_to_double(case when (0 = uint8_to_numeric(#9{heap_limit})) then null else #9{heap_limit} end), ((uint8_to_double(#8{heap_bytes}) / #14) * 100), ((uint8_to_double(#10{swap_bytes}) / #14) * 100)
     →Unarranged Raw Stream
       →Fused with Child Map/Filter/Project
         Project: #0, #3
@@ -8478,8 +8478,8 @@ Explained Query:
   →One-Shot Delta Join [%0:mz_cluster_replicas » %1:mz_cluster_replica_sizes[#0{size}] » %2:mz_cluster_replica_metrics_history[#0{replica_id}]]
     path %0:
       after %2:
-        Project: #0, #4, #11..=#14, #8
-        Map: ((uint8_to_double(#5{cpu_nano_cores}) / uint8_to_double(case when (0 = uint8_to_numeric(#1{cpu_nano_cores})) then null else #1{cpu_nano_cores} end)) * 100), ((uint8_to_double(#6{memory_bytes}) / uint8_to_double(case when (0 = uint8_to_numeric(#2{memory_bytes})) then null else #2{memory_bytes} end)) * 100), ((uint8_to_double(#7{disk_bytes}) / uint8_to_double(case when (0 = uint8_to_numeric(#3{disk_bytes})) then null else #3{disk_bytes} end)) * 100), ((uint8_to_double(#9{heap_bytes}) / uint8_to_double(case when (0 = uint8_to_numeric(#10{heap_limit})) then null else #10{heap_limit} end)) * 100)
+        Project: #0, #4, #12..=#14, #16, #17, #8
+        Map: ((uint8_to_double(#5{cpu_nano_cores}) / uint8_to_double(case when (0 = uint8_to_numeric(#1{cpu_nano_cores})) then null else #1{cpu_nano_cores} end)) * 100), ((uint8_to_double(#6{memory_bytes}) / uint8_to_double(case when (0 = uint8_to_numeric(#2{memory_bytes})) then null else #2{memory_bytes} end)) * 100), ((uint8_to_double(#7{disk_bytes}) / uint8_to_double(case when (0 = uint8_to_numeric(#3{disk_bytes})) then null else #3{disk_bytes} end)) * 100), uint8_to_double(case when (0 = uint8_to_numeric(#10{heap_limit})) then null else #10{heap_limit} end), ((uint8_to_double(#9{heap_bytes}) / #15) * 100), ((uint8_to_double(#11{swap_bytes}) / #15) * 100)
     →Unarranged Raw Stream
       →Fused with Child Map/Filter/Project
         Project: #0, #3
@@ -10527,7 +10527,7 @@ Explained Query:
       →Differential Join %0:l4[#0{entity_name}, #1{name}] » %1[#0{entity_name}, #1{column_name}]
         →Arranged l4
         →Arrange (#0{entity_name}, #1{column_name})
-          →Constant (283 rows)
+          →Constant (284 rows)
   →Return
     →Union
       →Map/Filter/Project
diff --git a/test/sqllogictest/introspection/relations.slt b/test/sqllogictest/introspection/relations.slt
index c000d2f64bb10..e5dd603727872 100644
--- a/test/sqllogictest/introspection/relations.slt
+++ b/test/sqllogictest/introspection/relations.slt
@@ -60,26 +60,27 @@ Feedback  persist_source_backpressure(backpressure(u1))  alloc::vec::Vec<core::c
 FlatMap  ArrangeBy[[Column(0,␠"a"),␠Column(1,␠"b")]]-errors  alloc::vec::Vec<((mz_compute::render::errors::DataflowErrorSer,␠()),␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
 FlatMap  Exchange  alloc::vec::Vec<(u64,␠mz_txn_wal::txn_read::DataRemapEntry<mz_repr::timestamp::Timestamp>)>
 FlatMap  txns_progress_frontiers(u1)  alloc::vec::Vec<mz_txn_wal::txn_read::DataRemapEntry<mz_repr::timestamp::Timestamp>>
+FlatMap  txns_progress_frontiers(u1)  alloc::vec::Vec<mz_txn_wal::txn_read::DataRemapEntry<mz_repr::timestamp::Timestamp>>
 FormArrangementKey  ArrangeBy[[Column(0,␠"a"),␠Column(1,␠"b")]]  mz_timely_util::columnar::Column<((mz_repr::row::Row,␠mz_repr::row::Row),␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
 FormArrangementKey  Concatenate  alloc::vec::Vec<(mz_compute::render::errors::DataflowErrorSer,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
 InputRegion:␠materialize.public.test_primary_idx  BuildRegion:␠materialize.public.test_primary_idx  alloc::vec::Vec<(mz_compute::render::errors::DataflowErrorSer,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
-InputRegion:␠materialize.public.test_primary_idx  BuildRegion:␠materialize.public.test_primary_idx  alloc::vec::Vec<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
-LimitProgress(Dataflow:␠materialize.public.test_primary_idx)  Probe  alloc::vec::Vec<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
+InputRegion:␠materialize.public.test_primary_idx  BuildRegion:␠materialize.public.test_primary_idx  mz_timely_util::columnar::Column<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
+LimitProgress(Dataflow:␠materialize.public.test_primary_idx)  Probe  mz_timely_util::columnar::Column<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
 LogOperatorHydration␠(1)  FormArrangementKey  mz_timely_util::columnar::Column<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
-OkErr  SuppressEarlyProgress  alloc::vec::Vec<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
-SuppressEarlyProgress  LimitProgress(Dataflow:␠materialize.public.test_primary_idx)  alloc::vec::Vec<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
-VecToColumnar  BuildingObject(User(2))  mz_timely_util::columnar::Column<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
+SuppressEarlyProgress  LimitProgress(Dataflow:␠materialize.public.test_primary_idx)  mz_timely_util::columnar::Column<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
 decode_backpressure_probe(u1)  Feedback  alloc::vec::Vec<core::convert::Infallible>
 expire_stream_at(materialize.public.test_primary_idx_export_index_errs)  LogDataflowErrorsStream  alloc::vec::Vec<mz_row_spine::arc_batch::ArcBatch<differential_dataflow::trace::implementations::ord_neu::key_batch::OrdKeyBatch<mz_compute::typedefs::spines::MzStack<((mz_compute::render::errors::DataflowErrorSer,␠()),␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>>>>
 expire_stream_at(materialize.public.test_primary_idx_export_index_oks)  InspectBatch  alloc::vec::Vec<mz_row_spine::arc_batch::ArcBatch<differential_dataflow::trace::implementations::ord_neu::val_batch::OrdValBatch<mz_row_spine::spines::RowRowLayout<((mz_repr::row::Row,␠mz_repr::row::Row),␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>>>>
 granular_backpressure(u1)  shard_source_descs_return(u1)  alloc::vec::Vec<core::convert::Infallible>
-granular_backpressure(u1)  txns_progress_frontiers(u1)  alloc::vec::Vec<(core::result::Result<mz_repr::row::Row,␠mz_compute::render::errors::DataflowErrorSer>,␠(mz_repr::timestamp::Timestamp,␠mz_storage_operators::persist_source::Subtime),␠mz_ore::overflowing::Overflowing<i64>)>
-persist_source::decode_and_mfp(u1)  InspectBatch  alloc::vec::Vec<(core::result::Result<mz_repr::row::Row,␠mz_compute::render::errors::DataflowErrorSer>,␠(mz_repr::timestamp::Timestamp,␠mz_storage_operators::persist_source::Subtime),␠mz_ore::overflowing::Overflowing<i64>)>
+granular_backpressure(u1)  txns_progress_frontiers(u1)  alloc::vec::Vec<(mz_compute::render::errors::DataflowErrorSer,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
+granular_backpressure(u1)  txns_progress_frontiers(u1)  mz_timely_util::columnar::Column<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
+persist_source::decode_and_mfp(u1)  InspectBatch  alloc::vec::Vec<(mz_compute::render::errors::DataflowErrorSer,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
+persist_source::decode_and_mfp(u1)  InspectBatch  mz_timely_util::columnar::Column<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
 persist_source_backpressure(backpressure(u1))  shard_source_fetch(u1)  alloc::vec::Vec<(usize,␠mz_persist_client::fetch::ExchangeableBatchPart<mz_repr::timestamp::Timestamp>)>
 shard_source_descs(u1)  granular_backpressure(u1)  alloc::vec::Vec<(usize,␠mz_persist_client::fetch::ExchangeableBatchPart<mz_repr::timestamp::Timestamp>)>
 shard_source_fetch(u1)  Feedback  alloc::vec::Vec<core::convert::Infallible>
 shard_source_fetch(u1)  persist_source::decode_and_mfp(u1)  alloc::vec::Vec<mz_persist_client::fetch::FetchedBlob<mz_storage_types::sources::SourceData,␠(),␠mz_repr::timestamp::Timestamp,␠i64>>
-txns_progress_frontiers(u1)  OkErr  alloc::vec::Vec<(core::result::Result<mz_repr::row::Row,␠mz_compute::render::errors::DataflowErrorSer>,␠(mz_repr::timestamp::Timestamp,␠mz_storage_operators::persist_source::Subtime),␠mz_ore::overflowing::Overflowing<i64>)>
+txns_progress_frontiers(u1)  SuppressEarlyProgress  mz_timely_util::columnar::Column<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
 txns_progress_source(u1)  FlatMap  alloc::vec::Vec<mz_txn_wal::txn_read::DataRemapEntry<mz_repr::timestamp::Timestamp>>
 
 query IT rowsort
@@ -94,16 +95,14 @@ GROUP BY type;
 1  alloc::vec::Vec<((mz_compute::render::errors::DataflowErrorSer,␠()),␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
 1  alloc::vec::Vec<mz_persist_client::fetch::FetchedBlob<mz_storage_types::sources::SourceData,␠(),␠mz_repr::timestamp::Timestamp,␠i64>>
 1  mz_timely_util::columnar::Column<((mz_repr::row::Row,␠mz_repr::row::Row),␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
+12  mz_timely_util::columnar::Column<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
 2  alloc::vec::Vec<(u64,␠mz_txn_wal::txn_read::DataRemapEntry<mz_repr::timestamp::Timestamp>)>
 2  alloc::vec::Vec<(usize,␠mz_persist_client::fetch::ExchangeableBatchPart<mz_repr::timestamp::Timestamp>)>
-2  alloc::vec::Vec<mz_txn_wal::txn_read::DataRemapEntry<mz_repr::timestamp::Timestamp>>
-4  alloc::vec::Vec<(core::result::Result<mz_repr::row::Row,␠mz_compute::render::errors::DataflowErrorSer>,␠(mz_repr::timestamp::Timestamp,␠mz_storage_operators::persist_source::Subtime),␠mz_ore::overflowing::Overflowing<i64>)>
-4  mz_timely_util::columnar::Column<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
+3  alloc::vec::Vec<mz_txn_wal::txn_read::DataRemapEntry<mz_repr::timestamp::Timestamp>>
 5  alloc::vec::Vec<core::convert::Infallible>
 5  alloc::vec::Vec<mz_row_spine::arc_batch::ArcBatch<differential_dataflow::trace::implementations::ord_neu::key_batch::OrdKeyBatch<mz_compute::typedefs::spines::MzStack<((mz_compute::render::errors::DataflowErrorSer,␠()),␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>>>>
-6  alloc::vec::Vec<(mz_compute::render::errors::DataflowErrorSer,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
-6  alloc::vec::Vec<(mz_repr::row::Row,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
 6  alloc::vec::Vec<mz_row_spine::arc_batch::ArcBatch<differential_dataflow::trace::implementations::ord_neu::val_batch::OrdValBatch<mz_row_spine::spines::RowRowLayout<((mz_repr::row::Row,␠mz_repr::row::Row),␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>>>>
+9  alloc::vec::Vec<(mz_compute::render::errors::DataflowErrorSer,␠mz_repr::timestamp::Timestamp,␠mz_ore::overflowing::Overflowing<i64>)>
 
 query TTT rowsort
 SELECT mdod_from.name AS from_name,
diff --git a/test/sqllogictest/mz_catalog_server_index_accounting.slt b/test/sqllogictest/mz_catalog_server_index_accounting.slt
index 75b12a7d85855..5e47356389bf6 100644
--- a/test/sqllogictest/mz_catalog_server_index_accounting.slt
+++ b/test/sqllogictest/mz_catalog_server_index_accounting.slt
@@ -274,6 +274,7 @@ mz_cluster_replica_metrics  heap_limit
 mz_cluster_replica_metrics  memory_bytes
 mz_cluster_replica_metrics  process_id
 mz_cluster_replica_metrics  replica_id
+mz_cluster_replica_metrics  swap_bytes
 mz_cluster_replica_metrics_history  cpu_nano_cores
 mz_cluster_replica_metrics_history  disk_bytes
 mz_cluster_replica_metrics_history  heap_bytes
@@ -282,6 +283,7 @@ mz_cluster_replica_metrics_history  memory_bytes
 mz_cluster_replica_metrics_history  occurred_at
 mz_cluster_replica_metrics_history  process_id
 mz_cluster_replica_metrics_history  replica_id
+mz_cluster_replica_metrics_history  swap_bytes
 mz_cluster_replica_name_history  id
 mz_cluster_replica_name_history  new_name
 mz_cluster_replica_name_history  occurred_at
diff --git a/test/sqllogictest/system-cluster.slt b/test/sqllogictest/system-cluster.slt
index c3325b8959e6f..8b6f37efd2f51 100644
--- a/test/sqllogictest/system-cluster.slt
+++ b/test/sqllogictest/system-cluster.slt
@@ -410,7 +410,7 @@ ORDER BY r.id;
 ----
 Explained Query:
   Finish order_by=[#0{id} asc nulls_last] output=[#0..=#5]
-    Project (#11{id}, #12{name}, #0{id}, #14{size}, #1{name}, #29)
+    Project (#11{id}, #12{name}, #0{id}, #14{size}, #1{name}, #30)
       Map (((uint8_to_double(#25{memory_bytes}) / uint8_to_double(case when (0 = uint8_to_numeric(#19{memory_bytes})) then null else #19{memory_bytes} end)) * 100))
         Join on=(#0{id} = #13{cluster_id} AND #11{id} = #22{replica_id} AND #14{size} = #15{size}) type=delta
           ArrangeBy keys=[[#0{id}]]