From e5392c7cf5c19b645e0870d495f037642fc3a7f2 Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Wed, 19 Aug 2026 15:55:08 -0400
Subject: [PATCH 01/18] streaming: add the height-erasure seam on Backend

One runtime representation per backend (Backend::Erased) with paired
erase/assume conversions, plus the ErasedNode trait carrying the
height-independent observations (span, hash, len). Local's conversions
are the phantom wrap/unwrap the typed node already is; the Failing,
Charged, and Materializing test backends pass erasure through their
wrappers (Charged settles and reopens its ledger entry, so the census
peak is untouched).

Pure addition: no caller changes, no behavior change. The seam exists
for the erased session plumbing (design/height-erasure.md step 1);
channels and workers move onto it in subsequent commits.

Baseline measured at the parent commit for attribution:
cargo llvm-lines --test pairwise (debug, default features) =
2,884,887 lines / 109,613 copies.
---
 src/conformance/backend.rs                   | 31 +++++++++++-
 src/conformance/backend/tests.rs             | 38 +++++++++++++-
 src/tree/mirror/streaming.rs                 |  2 +-
 src/tree/mirror/streaming/backend.rs         | 52 ++++++++++++++++++++
 src/tree/mirror/streaming/backend/local.rs   | 29 ++++++++++-
 src/tree/mirror/streaming/testing/failing.rs | 28 ++++++++++-
 src/tree/typed/node.rs                       | 12 ++++-
 7 files changed, 185 insertions(+), 7 deletions(-)

diff --git a/src/conformance/backend.rs b/src/conformance/backend.rs
index 6d8390b26..8dae0603e 100644
--- a/src/conformance/backend.rs
+++ b/src/conformance/backend.rs
@@ -60,7 +60,7 @@ use crate::{
     message::Message,
     tree::{
         mirror::streaming::{
-            self, Backend, BoxNodeStream, Leaf, Node, NodeStream, Root,
+            self, Backend, BoxNodeStream, ErasedNode, Leaf, Node, NodeStream, Root,
             convert::Convert,
             materialized,
             window::{FAN, WindowConfig},
@@ -222,6 +222,20 @@ where
     }
 }
 
+impl<E: ErasedNode> ErasedNode for ChargedNode<E> {
+    fn span(&self) -> Span<'_> {
+        self.inner().span()
+    }
+
+    fn hash(&self) -> Hash {
+        self.inner().hash()
+    }
+
+    fn len(&self) -> usize {
+        self.inner().len()
+    }
+}
+
 impl<T, N> Leaf<T> for ChargedNode<N>
 where
     T: Send + Sync + 'static,
@@ -269,8 +283,23 @@ where
     T: Send + Sync + 'static,
 {
     type Node<H: Height> = ChargedNode<B::Node<H>>;
+    type Erased = ChargedNode<B::Erased>;
     type Error = B::Error;
 
+    // Both conversions settle the wrapper's ledger entry and open an
+    // identical one around the re-tagged handle: the running total dips by
+    // one node's bytes between the two calls and never rises, so the
+    // census peak is untouched.
+    fn erase<H: Height>(node: Self::Node<H>) -> Self::Erased {
+        let bytes = node.bytes;
+        ChargedNode::wrap(B::erase(node.into_inner()), bytes)
+    }
+
+    fn assume<H: Height>(erased: Self::Erased) -> Self::Node<H> {
+        let bytes = erased.bytes;
+        ChargedNode::wrap(B::assume(erased.into_inner()), bytes)
+    }
+
     fn node_bytes(children: usize, version_bound: usize) -> usize {
         B::node_bytes(children, version_bound)
     }
diff --git a/src/conformance/backend/tests.rs b/src/conformance/backend/tests.rs
index 758069884..a14550d62 100644
--- a/src/conformance/backend/tests.rs
+++ b/src/conformance/backend/tests.rs
@@ -17,7 +17,7 @@ use crate::{
     message::Message,
     tree::{
         mirror::streaming::{
-            Backend, BoxNodeStream, Leaf, Local, Node, NodeStream, convert::Convert,
+            Backend, BoxNodeStream, ErasedNode, Leaf, Local, Node, NodeStream, convert::Convert,
         },
         typed::{
             self, Hash, Prefix,
@@ -266,13 +266,49 @@ fn bounds_of<T: Send + Sync + 'static, H: Height>(node: &typed::Node<T, H>) -> u
     node.ceiling().as_bytes().len() + node.floor().as_bytes().len()
 }
 
+// The erased observations pass through the row wrapper; the row itself
+// carries no readable state.
+impl<E: ErasedNode> ErasedNode for MaterializedNode<E> {
+    fn span(&self) -> Span<'_> {
+        self.inner.span()
+    }
+
+    fn hash(&self) -> Hash {
+        self.inner.hash()
+    }
+
+    fn len(&self) -> usize {
+        self.inner.len()
+    }
+}
+
 impl<T> Backend<T> for Materializing
 where
     T: Send + Sync + 'static,
 {
     type Node<H: Height> = MaterializedNode<typed::Node<T, H>>;
+    type Erased = MaterializedNode<typed::untyped::Node<T>>;
     type Error = Infallible;
 
+    // Erasure re-tags the store's handle; the resident row rides along
+    // unchanged, so the census this backend exists to exercise sees no
+    // movement from either conversion.
+    fn erase<H: Height>(node: Self::Node<H>) -> Self::Erased {
+        let MaterializedNode { inner, row } = node;
+        MaterializedNode {
+            inner: inner.into_untyped(),
+            row,
+        }
+    }
+
+    fn assume<H: Height>(erased: Self::Erased) -> Self::Node<H> {
+        let MaterializedNode { inner, row } = erased;
+        MaterializedNode {
+            inner: typed::Node::from_untyped(inner),
+            row,
+        }
+    }
+
     fn node_bytes(children: usize, version_bound: usize) -> usize {
         let priced = std::mem::size_of::<MaterializedNode<typed::Node<T, Z>>>()
             + PRICED_HEADER.get()
diff --git a/src/tree/mirror/streaming.rs b/src/tree/mirror/streaming.rs
index e5e389346..f40952555 100644
--- a/src/tree/mirror/streaming.rs
+++ b/src/tree/mirror/streaming.rs
@@ -55,7 +55,7 @@ mod tasks;
 mod testing;
 pub(crate) mod window;
 
-pub use backend::{Backend, Leaf, Local, Node, Root};
+pub use backend::{Backend, ErasedNode, Leaf, Local, Node, Root};
 // The stream vocabulary the backend conformance suite decorates with;
 // crate-visible alongside the suite itself.
 #[cfg(test)]
diff --git a/src/tree/mirror/streaming/backend.rs b/src/tree/mirror/streaming/backend.rs
index 71c69db75..d133b0d45 100644
--- a/src/tree/mirror/streaming/backend.rs
+++ b/src/tree/mirror/streaming/backend.rs
@@ -50,9 +50,42 @@ where
     /// The type of nodes carrying messages of type `T`, indexed by height `H`.
     type Node<H: Height>: Node<T, Height = H, Backend = Self> + Clone + Send + 'static;
 
+    /// One runtime representation shared by every height's
+    /// [`Node<H>`](Self::Node).
+    ///
+    /// The height parameter on [`Node`](Self::Node) is a compile-time tag
+    /// over runtime data that already knows its place in the tree, so a
+    /// backend can forget the tag ([`erase`](Self::erase)) and restore it
+    /// ([`assume`](Self::assume)) without changing the value. The
+    /// session's internal plumbing — its channels, pumps, and walk workers
+    /// — carries this one type where a height-typed payload would
+    /// instantiate the whole machinery once per height.
+    ///
+    /// A backend whose nodes share one representation across heights (as
+    /// [`Local`]'s do) uses that representation directly; a backend with
+    /// genuinely distinct per-height representations supplies a sum of
+    /// them.
+    type Erased: ErasedNode + Clone + Send + 'static;
+
     /// The type of errors returned by this backend.
     type Error: Send + 'static;
 
+    /// Forget a node's height tag.
+    fn erase<H: Height>(node: Self::Node<H>) -> Self::Erased;
+
+    /// Re-tag an erased node at height `H`.
+    ///
+    /// `H` must be the height the node was erased at:
+    /// `assume::<H>(erase::<H>(node)) == node` is the whole contract, and
+    /// a cross-height re-tag is a programmer error whose behavior is
+    /// unspecified. The pairing discipline lives inside the session's
+    /// erased plumbing, witnessed by the prefixes that travel alongside
+    /// every node: an erased prefix's byte length is its height, and
+    /// re-tagging one debug-asserts that length. Peer input cannot reach
+    /// a mispairing — every wire node decodes through height-typed
+    /// readers before it is ever erased.
+    fn assume<H: Height>(erased: Self::Erased) -> Self::Node<H>;
+
     /// Bytes one node value with `children` child entries keeps resident
     /// beyond the replica's own storage, its version bounds (ceiling and
     /// floor together) encoding within `version_bound` bytes.
@@ -250,6 +283,25 @@ pub trait Node<T: Send + Sync + 'static> {
     fn version_bytes(&self) -> usize;
 }
 
+/// The observations a session reads off an erased node: [`Node`]'s
+/// height-independent surface.
+///
+/// Every read here answers exactly as it would on the typed node the value
+/// was erased from — none of [`Node`]'s observations ever depended on the
+/// height tag, so forgetting it loses nothing. Height-*dependent*
+/// operations (exploding to children, reading a leaf's message) stay on
+/// the typed surface, reached by re-tagging ([`Backend::assume`]).
+pub trait ErasedNode {
+    /// The node's version bounds as one causal span ([`Node::span`]).
+    fn span(&self) -> Span<'_>;
+
+    /// The merkle hash of this node ([`Node::hash`]).
+    fn hash(&self) -> Hash;
+
+    /// The number of live leaves under this node, exact ([`Node::len`]).
+    fn len(&self) -> usize;
+}
+
 /// What crosses between backends at the conversion boundary, and the one node
 /// shape every backend must represent faithfully.
 pub trait Leaf<T: Send + Sync + 'static>: Node<T> {
diff --git a/src/tree/mirror/streaming/backend/local.rs b/src/tree/mirror/streaming/backend/local.rs
index e0bec2975..557952fba 100644
--- a/src/tree/mirror/streaming/backend/local.rs
+++ b/src/tree/mirror/streaming/backend/local.rs
@@ -13,7 +13,7 @@ use crate::{
     tree::{
         self,
         mirror::streaming::{
-            Backend, Leaf, Node, Root,
+            Backend, ErasedNode, Leaf, Node, Root,
             backend::{BoxNodeStream, NodeStream},
             convert::Convert,
         },
@@ -56,6 +56,22 @@ impl<T: Send + Sync + 'static, H: Height> Node<T> for typed::Node<T, H> {
     }
 }
 
+// The typed node is `repr(transparent)` over the untyped node, so the
+// erased observations are the same field reads the typed ones are.
+impl<T: Send + Sync + 'static> ErasedNode for typed::untyped::Node<T> {
+    fn span(&self) -> Span<'_> {
+        self.span()
+    }
+
+    fn hash(&self) -> typed::Hash {
+        self.hash()
+    }
+
+    fn len(&self) -> usize {
+        self.len()
+    }
+}
+
 impl<T: Send + Sync + 'static> Leaf<T> for typed::Node<T, Z> {
     fn message(&self) -> &Message<T> {
         self.message()
@@ -96,8 +112,19 @@ const _: () =
 
 impl<T: Send + Sync + 'static> Backend<T> for Local {
     type Node<H: Height> = typed::Node<T, H>;
+    // One representation for every height already: the typed node is a
+    // phantom tag over this, so both conversions are field moves.
+    type Erased = typed::untyped::Node<T>;
     type Error = Infallible;
 
+    fn erase<H: Height>(node: Self::Node<H>) -> Self::Erased {
+        node.into_untyped()
+    }
+
+    fn assume<H: Height>(erased: Self::Erased) -> Self::Node<H> {
+        typed::Node::from_untyped(erased)
+    }
+
     fn node_bytes(children: usize, version_bound: usize) -> usize {
         Local::node_bytes(children, version_bound)
     }
diff --git a/src/tree/mirror/streaming/testing/failing.rs b/src/tree/mirror/streaming/testing/failing.rs
index 654eb60b7..1ab69ff99 100644
--- a/src/tree/mirror/streaming/testing/failing.rs
+++ b/src/tree/mirror/streaming/testing/failing.rs
@@ -15,7 +15,7 @@ use crate::{
     Version,
     message::Message,
     tree::{
-        mirror::streaming::{Backend, Leaf, Node, backend::NodeStream},
+        mirror::streaming::{Backend, ErasedNode, Leaf, Node, backend::NodeStream},
         typed::{
             Hash, Path, Prefix,
             height::{Height, S, Z},
@@ -161,6 +161,20 @@ where
     }
 }
 
+impl<E: ErasedNode> ErasedNode for FailingNode<E> {
+    fn span(&self) -> Span<'_> {
+        self.0.span()
+    }
+
+    fn hash(&self) -> Hash {
+        self.0.hash()
+    }
+
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+}
+
 impl<T, N> Leaf<T> for FailingNode<N>
 where
     T: Send + Sync + 'static,
@@ -189,7 +203,19 @@ where
     T: Send + Sync + 'static,
 {
     type Node<H: Height> = FailingNode<B::Node<H>>;
+    // Erasure passes through the wrapper: fault injection targets the
+    // traversal operations, and re-tagging is not one.
+    type Erased = FailingNode<B::Erased>;
     type Error = Failure<B::Error>;
+
+    fn erase<H: Height>(node: Self::Node<H>) -> Self::Erased {
+        FailingNode(B::erase(node.0))
+    }
+
+    fn assume<H: Height>(erased: Self::Erased) -> Self::Node<H> {
+        FailingNode(B::assume(erased.0))
+    }
+
     // The wrapper adds no resident state: a failing node is the inner
     // backend's node plus fault bookkeeping shared behind it.
     fn node_bytes(children: usize, version_bound: usize) -> usize {
diff --git a/src/tree/typed/node.rs b/src/tree/typed/node.rs
index 81e0eff3e..d76d88a51 100644
--- a/src/tree/typed/node.rs
+++ b/src/tree/typed/node.rs
@@ -155,14 +155,22 @@ where
 }
 
 impl<T, H: Height> Node<T, H> {
-    fn from_untyped(inner: untyped::Node<T>) -> Self {
+    /// Tag an untyped node at height `H`: the caller asserts the height.
+    ///
+    /// The streaming mirror's erasure seam
+    /// ([`Backend::assume`](crate::tree::mirror::streaming::Backend::assume))
+    /// re-tags nodes it erased at the same height; internal tree code tags
+    /// nodes whose height its own traversal establishes.
+    pub(crate) fn from_untyped(inner: untyped::Node<T>) -> Self {
         Self {
             height: PhantomData,
             inner,
         }
     }
 
-    fn into_untyped(self) -> untyped::Node<T> {
+    /// Forget this node's height tag; the inverse of
+    /// [`from_untyped`](Self::from_untyped).
+    pub(crate) fn into_untyped(self) -> untyped::Node<T> {
         self.inner
     }
 

From d1b7f00e41563c80ef3453e8b0873b0c4ee45a42 Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Wed, 19 Aug 2026 16:22:23 -0400
Subject: [PATCH 02/18] streaming: erase the materialized channels' payloads

Every bounded channel in the materialized walk now carries the
height-erased twin of its payload (streaming/erased.rs), behind typed
facades minted per edge: both halves of an edge are created at one
height parameter, so the walk's stage code keeps exactly the typed
surface it had, and the tokio mpsc machinery instantiates once per
backend instead of once per height. ErasedPrefix (the prefix bytes
without the height tag, length re-checked on every re-tag in debug
builds) is the runtime witness traveling with every payload.

The one unerased edge is leaf_requests: its item is already the
single-height Prefix<Z>.

Measured on --test pairwise (debug, default features), parent
2,884,887 lines / 109,613 copies -> 2,609,789 / 94,312 (-9.5%); rows
naming tokio's mpsc fall 632,145 -> 234,535 lines. The remaining
per-height machinery (the async_stream walk generators at ~400k and
the proxy's channels) is the target of the next steps
(design/height-erasure.md steps 3-4).
---
 src/tree/mirror/streaming.rs                  |   1 +
 src/tree/mirror/streaming/erased.rs           | 499 ++++++++++++++++++
 src/tree/mirror/streaming/materialized.rs     |  16 +-
 .../mirror/streaming/materialized/common.rs   |  35 +-
 .../mirror/streaming/materialized/tests.rs    |   3 +-
 .../mirror/streaming/materialized/work.rs     |   5 +-
 .../streaming/materialized/work/assembly.rs   |   9 +-
 .../streaming/materialized/work/levels.rs     |  31 +-
 .../streaming/materialized/work/queues.rs     | 113 ++--
 .../materialized/work/tests/violations.rs     |   7 +-
 src/tree/typed.rs                             |   1 +
 src/tree/typed/prefix.rs                      |  45 ++
 12 files changed, 632 insertions(+), 133 deletions(-)
 create mode 100644 src/tree/mirror/streaming/erased.rs

diff --git a/src/tree/mirror/streaming.rs b/src/tree/mirror/streaming.rs
index f40952555..a55534ff9 100644
--- a/src/tree/mirror/streaming.rs
+++ b/src/tree/mirror/streaming.rs
@@ -45,6 +45,7 @@ mod backend;
 mod channel;
 pub(crate) mod convert;
 mod driver;
+mod erased;
 pub mod materialized;
 mod message;
 mod protocol;
diff --git a/src/tree/mirror/streaming/erased.rs b/src/tree/mirror/streaming/erased.rs
new file mode 100644
index 000000000..1a9ab803b
--- /dev/null
+++ b/src/tree/mirror/streaming/erased.rs
@@ -0,0 +1,499 @@
+//! Height-erased twins of the session's channel payloads, and the typed
+//! facades that are the only way in or out of them.
+//!
+//! Every item the walk's bounded channels carry is height-indexed in the
+//! type system but height-uniform at runtime: nodes erase to one
+//! representation per backend ([`Backend::Erased`]), prefixes to their
+//! bytes ([`ErasedPrefix`]), and nothing else in a payload ever depended
+//! on the height. Minting channels of the erased twins therefore costs
+//! nothing at runtime — every conversion below is a phantom-tag swap over
+//! the value the program already holds — and collapses the channel
+//! machinery from one instantiation per height to one per backend.
+//!
+//! # What the types stop proving, and what catches it instead
+//!
+//! Outside this module, sending a height-5 payload into a height-6 queue
+//! is a compile error, exactly as before: the constructors here pair each
+//! erased channel with typed facades ([`TypedSender`], [`TypedReceiver`],
+//! [`TypedStream`], [`TypedOkStream`]) minted at one height parameter, so
+//! both halves of an edge speak the same height by construction, and a
+//! mispairing can only be authored *inside this module* by wiring a
+//! constructor's two halves to different conversions. That one-module
+//! audit surface is the design's locality argument. At runtime, every
+//! prefix re-tag debug-asserts its byte length against the claimed height
+//! ([`ErasedPrefix::assume`]), and every channel keeps its
+//! [`QueueRole`] height label for the instrumented diagnostics.
+
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use futures::Stream;
+#[cfg(not(test))]
+use tokio_stream::wrappers::ReceiverStream;
+
+use crate::tree::{
+    mirror::streaming::{
+        Backend, Leaf,
+        channel::{QueueRole, Receiver, Sender, channel},
+        materialized::{self, Error},
+        message,
+    },
+    typed::{
+        ErasedPrefix, Hash,
+        height::{Height, S, Z},
+    },
+};
+
+/// [`message::Reply`] with its height forgotten.
+pub(crate) struct Reply<E> {
+    pub replies: Vec<Reaction<E>>,
+}
+
+/// [`message::Reaction`] with its height forgotten.
+pub(crate) enum Reaction<E> {
+    Supply(u8, E),
+    Match,
+    Query(Vec<(u8, Hash)>),
+}
+
+/// [`materialized::Query`] with its height forgotten.
+pub(crate) struct Query<E> {
+    pub prefix: ErasedPrefix,
+    pub ours: Vec<(u8, E)>,
+}
+
+/// [`materialized::Resolution`] with its height forgotten.
+pub(crate) struct Resolution<E> {
+    pub prefix: ErasedPrefix,
+    pub resolved: Vec<(u8, Resolve<E>)>,
+}
+
+/// [`materialized::Resolve`] with its height forgotten.
+pub(crate) enum Resolve<E> {
+    Ready(Option<E>),
+    Pending,
+}
+
+/// Shorthand for the erased node representation of one backend.
+type ErasedOf<B, T> = <B as Backend<T>>::Erased;
+
+/// The typed halves of the outgoing-response edge
+/// ([`reply_channel`]): items are whole replies or the error that ends
+/// the stream.
+pub(crate) type ReplyResultSender<B, T, H> = TypedSender<
+    Result<message::Reply<B, T, H>, Error<<B as Backend<T>>::Error>>,
+    Result<Reply<ErasedOf<B, T>>, Error<<B as Backend<T>>::Error>>,
+>;
+/// The receiving half of [`reply_channel`], as the response stream shape.
+pub(crate) type ReplyResultStream<B, T, H> = TypedStream<
+    Result<message::Reply<B, T, H>, Error<<B as Backend<T>>::Error>>,
+    Result<Reply<ErasedOf<B, T>>, Error<<B as Backend<T>>::Error>>,
+>;
+/// The typed sending half of a query edge ([`query_channel`]).
+pub(crate) type QuerySender<B, T, H> =
+    TypedSender<materialized::Query<B, T, H>, Query<ErasedOf<B, T>>>;
+/// The typed receiving half of a query edge ([`query_channel`]).
+pub(crate) type QueryReceiver<B, T, H> =
+    TypedReceiver<materialized::Query<B, T, H>, Query<ErasedOf<B, T>>>;
+/// The typed sending half of a return edge ([`return_channel`],
+/// [`return_ok_channel`]): one reconciled node per query, in query order.
+pub(crate) type ReturnSender<B, T, H> =
+    TypedSender<Option<<B as Backend<T>>::Node<H>>, Option<ErasedOf<B, T>>>;
+/// The typed receiving half of [`return_channel`].
+pub(crate) type ReturnReceiver<B, T, H> =
+    TypedReceiver<Option<<B as Backend<T>>::Node<H>>, Option<ErasedOf<B, T>>>;
+/// The receiving half of [`return_ok_channel`], as an `Ok`-wrapping stream.
+pub(crate) type ReturnOkStream<B, T, H> = TypedOkStream<
+    Option<<B as Backend<T>>::Node<H>>,
+    Option<ErasedOf<B, T>>,
+    Error<<B as Backend<T>>::Error>,
+>;
+/// The typed sending half of a resolution edge ([`resolution_ok_channel`]).
+pub(crate) type ResolutionSender<B, T, H> =
+    TypedSender<materialized::Resolution<B, T, H>, Resolution<ErasedOf<B, T>>>;
+/// The receiving half of [`resolution_ok_channel`], as an `Ok`-wrapping
+/// stream.
+pub(crate) type ResolutionOkStream<B, T, H> = TypedOkStream<
+    materialized::Resolution<B, T, H>,
+    Resolution<ErasedOf<B, T>>,
+    Error<<B as Backend<T>>::Error>,
+>;
+
+/// Mint the outgoing-response edge: a typed sender and the typed response
+/// stream its receiver drains into.
+pub(crate) fn reply_channel<B, T, H>(
+    role: QueueRole,
+    capacity: usize,
+) -> (ReplyResultSender<B, T, H>, ReplyResultStream<B, T, H>)
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+{
+    let (sender, receiver) = channel(role, capacity);
+    (
+        TypedSender::new(sender, |item: Result<_, _>| {
+            item.map(erase_reply::<B, T, H>)
+        }),
+        TypedStream::new(receiver, |item: Result<_, _>| {
+            item.map(assume_reply::<B, T, H>)
+        }),
+    )
+}
+
+/// Mint one query edge at height `H` (the children's height; the scope
+/// sits at `S<H>`).
+pub(crate) fn query_channel<B, T, H>(
+    role: QueueRole,
+    capacity: usize,
+) -> (QuerySender<B, T, H>, QueryReceiver<B, T, H>)
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+    S<H>: Height,
+{
+    let (sender, receiver) = channel(role, capacity);
+    (
+        TypedSender::new(sender, erase_query::<B, T, H>),
+        TypedReceiver::new(receiver, assume_query::<B, T, H>),
+    )
+}
+
+/// Mint one return edge at height `H`, received item by item.
+pub(crate) fn return_channel<B, T, H>(
+    role: QueueRole,
+    capacity: usize,
+) -> (ReturnSender<B, T, H>, ReturnReceiver<B, T, H>)
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+{
+    let (sender, receiver) = channel(role, capacity);
+    (
+        TypedSender::new(sender, erase_return::<B, T, H>),
+        TypedReceiver::new(receiver, assume_return::<B, T, H>),
+    )
+}
+
+/// Mint one return edge at height `H`, received as an `Ok`-wrapping stream.
+pub(crate) fn return_ok_channel<B, T, H>(
+    role: QueueRole,
+    capacity: usize,
+) -> (ReturnSender<B, T, H>, ReturnOkStream<B, T, H>)
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+{
+    let (sender, receiver) = channel(role, capacity);
+    (
+        TypedSender::new(sender, erase_return::<B, T, H>),
+        TypedOkStream::new(receiver, assume_return::<B, T, H>),
+    )
+}
+
+/// Mint one resolution edge at height `H`, received as an `Ok`-wrapping
+/// stream.
+pub(crate) fn resolution_ok_channel<B, T, H>(
+    role: QueueRole,
+    capacity: usize,
+) -> (ResolutionSender<B, T, H>, ResolutionOkStream<B, T, H>)
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+    S<H>: Height,
+{
+    let (sender, receiver) = channel(role, capacity);
+    (
+        TypedSender::new(sender, erase_resolution::<B, T, H>),
+        TypedOkStream::new(receiver, assume_resolution::<B, T, H>),
+    )
+}
+
+fn erase_reply<B, T, H>(reply: message::Reply<B, T, H>) -> Reply<ErasedOf<B, T>>
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+{
+    Reply {
+        replies: reply
+            .replies
+            .into_iter()
+            .map(|reaction| match reaction {
+                message::Reaction::Supply(radix, node) => Reaction::Supply(radix, B::erase(node)),
+                message::Reaction::Match => Reaction::Match,
+                message::Reaction::Query(listing) => Reaction::Query(listing),
+            })
+            .collect(),
+    }
+}
+
+fn assume_reply<B, T, H>(reply: Reply<ErasedOf<B, T>>) -> message::Reply<B, T, H>
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+{
+    message::Reply {
+        replies: reply
+            .replies
+            .into_iter()
+            .map(|reaction| match reaction {
+                Reaction::Supply(radix, node) => message::Reaction::Supply(radix, B::assume(node)),
+                Reaction::Match => message::Reaction::Match,
+                Reaction::Query(listing) => message::Reaction::Query(listing),
+            })
+            .collect(),
+    }
+}
+
+fn erase_query<B, T, H>(query: materialized::Query<B, T, H>) -> Query<ErasedOf<B, T>>
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+    S<H>: Height,
+{
+    Query {
+        prefix: query.prefix.erase(),
+        ours: query
+            .ours
+            .into_iter()
+            .map(|(radix, node)| (radix, B::erase(node)))
+            .collect(),
+    }
+}
+
+fn assume_query<B, T, H>(query: Query<ErasedOf<B, T>>) -> materialized::Query<B, T, H>
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+    S<H>: Height,
+{
+    materialized::Query {
+        prefix: query.prefix.assume(),
+        ours: query
+            .ours
+            .into_iter()
+            .map(|(radix, node)| (radix, B::assume(node)))
+            .collect(),
+    }
+}
+
+fn erase_resolution<B, T, H>(
+    resolution: materialized::Resolution<B, T, H>,
+) -> Resolution<ErasedOf<B, T>>
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+    S<H>: Height,
+{
+    Resolution {
+        prefix: resolution.prefix.erase(),
+        resolved: resolution
+            .resolved
+            .into_iter()
+            .map(|(radix, slot)| {
+                (
+                    radix,
+                    match slot {
+                        materialized::Resolve::Ready(node) => Resolve::Ready(node.map(B::erase)),
+                        materialized::Resolve::Pending => Resolve::Pending,
+                    },
+                )
+            })
+            .collect(),
+    }
+}
+
+fn assume_resolution<B, T, H>(
+    resolution: Resolution<ErasedOf<B, T>>,
+) -> materialized::Resolution<B, T, H>
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+    S<H>: Height,
+{
+    materialized::Resolution {
+        prefix: resolution.prefix.assume(),
+        resolved: resolution
+            .resolved
+            .into_iter()
+            .map(|(radix, slot)| {
+                (
+                    radix,
+                    match slot {
+                        Resolve::Ready(node) => {
+                            materialized::Resolve::Ready(node.map(B::assume::<H>))
+                        }
+                        Resolve::Pending => materialized::Resolve::Pending,
+                    },
+                )
+            })
+            .collect(),
+    }
+}
+
+fn erase_return<B, T, H>(node: Option<B::Node<H>>) -> Option<ErasedOf<B, T>>
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+{
+    node.map(B::erase)
+}
+
+fn assume_return<B, T, H>(node: Option<ErasedOf<B, T>>) -> Option<B::Node<H>>
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+{
+    node.map(B::assume::<H>)
+}
+
+// --------------------------------------------------------------------------------
+// The typed facades: each pairs one erased channel half with the fixed
+// conversion its constructor minted it with.
+// --------------------------------------------------------------------------------
+
+/// The typed sending half of an erased channel.
+pub(crate) struct TypedSender<M, E> {
+    inner: Sender<E>,
+    erase: fn(M) -> E,
+}
+
+impl<M, E> Clone for TypedSender<M, E> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+            erase: self.erase,
+        }
+    }
+}
+
+impl<M, E: Send> TypedSender<M, E> {
+    fn new(inner: Sender<E>, erase: fn(M) -> E) -> Self {
+        Self { inner, erase }
+    }
+
+    /// Send one typed item, erased in place.
+    ///
+    /// Like the underlying channel's send: an error means the receiving
+    /// half is gone, and the producer should wind down.
+    pub(crate) async fn send(&self, message: M) -> Result<(), ClosedChannel> {
+        self.inner
+            .send((self.erase)(message))
+            .await
+            .map_err(|_| ClosedChannel)
+    }
+}
+
+/// The receiver of a typed send has hung up; the payload is dropped.
+///
+/// The typed sender cannot return the underlying
+/// [`SendError`](tokio::sync::mpsc::error::SendError) because that hands
+/// back the *erased* payload; no caller inspects it — a failed send means
+/// "stop producing" on every edge.
+#[derive(Debug)]
+pub(crate) struct ClosedChannel;
+
+/// The typed receiving half of an erased channel.
+pub(crate) struct TypedReceiver<M, E> {
+    inner: Receiver<E>,
+    assume: fn(E) -> M,
+}
+
+impl<M, E: Send> TypedReceiver<M, E> {
+    fn new(inner: Receiver<E>, assume: fn(E) -> M) -> Self {
+        Self { inner, assume }
+    }
+
+    /// Receive one typed item, re-tagged in place.
+    pub(crate) async fn recv(&mut self) -> Option<M> {
+        self.inner.recv().await.map(self.assume)
+    }
+}
+
+/// The channel receiver as a stream, uniform across the test and
+/// production channel types.
+#[cfg(test)]
+type ReceiverStreamOf<E> = Receiver<E>;
+/// The channel receiver as a stream, uniform across the test and
+/// production channel types.
+#[cfg(not(test))]
+type ReceiverStreamOf<E> = ReceiverStream<E>;
+
+fn receiver_stream<E: Send>(receiver: Receiver<E>) -> ReceiverStreamOf<E> {
+    #[cfg(test)]
+    {
+        receiver
+    }
+    #[cfg(not(test))]
+    {
+        ReceiverStream::new(receiver)
+    }
+}
+
+/// An erased channel's receiving half as a stream of typed items.
+pub(crate) struct TypedStream<M, E> {
+    inner: ReceiverStreamOf<E>,
+    assume: fn(E) -> M,
+}
+
+impl<M, E: Send> TypedStream<M, E> {
+    fn new(inner: Receiver<E>, assume: fn(E) -> M) -> Self {
+        Self {
+            inner: receiver_stream(inner),
+            assume,
+        }
+    }
+}
+
+impl<M, E: Send> Stream for TypedStream<M, E> {
+    type Item = M;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let this = self.get_mut();
+        Pin::new(&mut this.inner)
+            .poll_next(cx)
+            .map(|item| item.map(this.assume))
+    }
+}
+
+/// An erased channel's receiving half as a stream of `Ok`-wrapped typed
+/// items: the shape the assembly and walk consumers pull from.
+pub(crate) struct TypedOkStream<M, E, Err> {
+    inner: ReceiverStreamOf<E>,
+    assume: fn(E) -> M,
+    error: PhantomData<fn() -> Err>,
+}
+
+impl<M, E: Send, Err> TypedOkStream<M, E, Err> {
+    fn new(inner: Receiver<E>, assume: fn(E) -> M) -> Self {
+        Self {
+            inner: receiver_stream(inner),
+            assume,
+            error: PhantomData,
+        }
+    }
+}
+
+impl<M, E: Send, Err> Stream for TypedOkStream<M, E, Err> {
+    type Item = Result<M, Err>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let this = self.get_mut();
+        Pin::new(&mut this.inner)
+            .poll_next(cx)
+            .map(|item| item.map(|item| Ok((this.assume)(item))))
+    }
+}
diff --git a/src/tree/mirror/streaming/materialized.rs b/src/tree/mirror/streaming/materialized.rs
index 931491c37..991ddba7a 100644
--- a/src/tree/mirror/streaming/materialized.rs
+++ b/src/tree/mirror/streaming/materialized.rs
@@ -106,6 +106,7 @@ use crate::tree::{
     mirror::contained,
     mirror::streaming::{
         Backend, Leaf, Node, Root,
+        erased::{QueryReceiver, ReturnSender},
         materialized::{unknown::Unknown, work::Work},
         message::{Greeting, Reaction, Reply},
         protocol::{self, BoxResponses, Requests},
@@ -179,8 +180,7 @@ mod tests;
 pub(super) mod transcript;
 pub(super) mod unknown;
 mod work;
-use channel::{Receiver, Sender};
-use common::*;
+use channel::Receiver;
 // The remote proxy explodes early-supplied whole root children into the
 // same per-child shape the walks consume, with the walks' own helper.
 pub(crate) use common::children_of;
@@ -274,9 +274,9 @@ where
     S<H>: Height,
 {
     /// The prefix at which the resolved node will sit.
-    prefix: Prefix<S<H>>,
+    pub(crate) prefix: Prefix<S<H>>,
     /// The possibly-resolved children of the node.
-    resolved: Vec<(u8, Resolve<B, T, H>)>,
+    pub(crate) resolved: Vec<(u8, Resolve<B, T, H>)>,
 }
 
 /// One child's slot in a [`Resolution`].
@@ -364,9 +364,9 @@ where
     /// absorbed supply ([`SupplyLedger`]).
     ledger: SupplyLedger,
     /// The questions we asked, awaiting their replies in order.
-    queries: Receiver<Query<B, T, H>>,
+    queries: QueryReceiver<B, T, H>,
     /// One resolved scope per query, in query order, to the stage above.
-    returns: Sender<Option<B::Node<S<H>>>>,
+    returns: ReturnSender<B, T, S<H>>,
     /// An elected initiator's opening hand-off: the early-supplied root
     /// radices' survivors, consumed by the first descending stage to answer
     /// the responder's empty queries about them (`None` below it).
@@ -403,7 +403,7 @@ pub struct Completing<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>
     /// Where each requested leaf will sit, one per request, in order.
     queries: Receiver<Prefix<Z>>,
     /// The requested leaves' resolutions, in request order.
-    returns: Sender<Option<B::Node<Z>>>,
+    returns: ReturnSender<B, T, Z>,
     /// The accumulated work to drive the pipeline.
     work: Work<B, T>,
     /// The future result of the pipeline.
@@ -860,7 +860,7 @@ async fn absorb<B, T>(
     ledger: SupplyLedger,
     requests: impl Requests<B, T, Z>,
     mut queries: Receiver<Prefix<Z>>,
-    returns: Sender<Option<B::Node<Z>>>,
+    returns: ReturnSender<B, T, Z>,
     stats: Recorder,
 ) -> Result<(), Error<B::Error>>
 where
diff --git a/src/tree/mirror/streaming/materialized/common.rs b/src/tree/mirror/streaming/materialized/common.rs
index 2f019607b..4eb983357 100644
--- a/src/tree/mirror/streaming/materialized/common.rs
+++ b/src/tree/mirror/streaming/materialized/common.rs
@@ -1,8 +1,6 @@
 use std::pin::pin;
 
-use futures::{StreamExt as _, stream};
-#[cfg(not(test))]
-use tokio_stream::wrappers::ReceiverStream;
+use futures::StreamExt as _;
 
 use crate::tree::{
     mirror::streaming::{Backend, Leaf},
@@ -12,8 +10,6 @@ use crate::tree::{
     },
 };
 
-use super::channel::{QueueRole, Receiver, Sender, channel};
-
 /// Collect one node's children, addressed by radix.
 pub async fn children_of<B, T, H>(
     backend: &B,
@@ -35,32 +31,3 @@ where
     }
     Ok(fan)
 }
-
-/// Create a pair of a sender and a receiver stream, where the receiver
-/// wraps items in `Ok`.
-pub fn ok_channel<T: Send, E>(
-    role: QueueRole,
-    buffer: usize,
-) -> (Sender<T>, OkReceiverStream<T, E>) {
-    ok_channel_with(channel(role, buffer))
-}
-
-fn ok_channel_with<T: Send, E>(
-    (tx, rx): (Sender<T>, Receiver<T>),
-) -> (Sender<T>, OkReceiverStream<T, E>) {
-    #[cfg(test)]
-    {
-        (tx, rx.map(Ok))
-    }
-    #[cfg(not(test))]
-    {
-        (tx, ReceiverStream::new(rx).map(Ok))
-    }
-}
-
-/// The type of a receiver stream wrapping items in `Ok`.
-#[cfg(test)]
-pub type OkReceiverStream<T, E> = stream::Map<Receiver<T>, fn(T) -> Result<T, E>>;
-/// The type of a receiver stream wrapping items in `Ok`.
-#[cfg(not(test))]
-pub type OkReceiverStream<T, E> = stream::Map<ReceiverStream<T>, fn(T) -> Result<T, E>>;
diff --git a/src/tree/mirror/streaming/materialized/tests.rs b/src/tree/mirror/streaming/materialized/tests.rs
index 21b7c3911..4845fd9e6 100644
--- a/src/tree/mirror/streaming/materialized/tests.rs
+++ b/src/tree/mirror/streaming/materialized/tests.rs
@@ -15,6 +15,7 @@ use super::{
     Error, SupplyLedger, Violation, absorb,
     channel::{QueueKind, QueueRole, channel},
 };
+use crate::tree::mirror::streaming::erased;
 use crate::tree::mirror::streaming::stats::Recorder;
 use crate::{
     Version,
@@ -64,7 +65,7 @@ fn absorb_scripted(
     pollster::block_on(queries.send(Prefix::containing(&path))).expect("the loop is live");
     drop(queries);
 
-    let (returns, mut returns_rx) = channel::<Option<typed::Node<(), Z>>>(
+    let (returns, mut returns_rx) = erased::return_channel::<Local, (), Z>(
         QueueRole::new(QueueKind::TerminalLeafResolutions, Z::HEIGHT),
         1,
     );
diff --git a/src/tree/mirror/streaming/materialized/work.rs b/src/tree/mirror/streaming/materialized/work.rs
index 9fce3badb..201f131f7 100644
--- a/src/tree/mirror/streaming/materialized/work.rs
+++ b/src/tree/mirror/streaming/materialized/work.rs
@@ -22,7 +22,8 @@ use super::{progress, transcript};
 use crate::tree::{
     mirror::streaming::{
         Backend, Leaf,
-        materialized::{Error, channel::Sender},
+        erased::ReturnSender,
+        materialized::Error,
         protocol::{BoxResponses, Responses},
         stats::Recorder,
         tasks::{complete, park_after_published_error},
@@ -114,7 +115,7 @@ where
     /// Forward a stream of nodes into an upward return channel.
     fn return_into<H: Height>(
         &mut self,
-        returns: Sender<Option<B::Node<H>>>,
+        returns: ReturnSender<B, T, H>,
         stream: impl Stream<Item = Result<Option<B::Node<H>>, Error<B::Error>>> + Send + 'static,
     ) {
         self.tasks.push(Box::pin(async move {
diff --git a/src/tree/mirror/streaming/materialized/work/assembly.rs b/src/tree/mirror/streaming/materialized/work/assembly.rs
index 108eadc15..728aec2ec 100644
--- a/src/tree/mirror/streaming/materialized/work/assembly.rs
+++ b/src/tree/mirror/streaming/materialized/work/assembly.rs
@@ -10,7 +10,8 @@ use super::{Work, queues::assembly_level_returns};
 use crate::tree::{
     mirror::streaming::{
         Backend, Leaf,
-        materialized::{Error, Resolution, Resolve, channel::Sender},
+        erased::ReturnSender,
+        materialized::{Error, Resolution, Resolve},
         tasks::next_or_cancelled,
     },
     typed::height::{Height, S, Z},
@@ -28,9 +29,9 @@ where
     /// on blocked sender futures remaining independently runnable.
     pub fn assemble<H>(
         &mut self,
-        returns: Sender<Option<B::Node<S<H>>>>,
+        returns: ReturnSender<B, T, S<H>>,
         resolutions: impl Stream<Item = Result<Resolution<B, T, H>, Error<B::Error>>> + Send + 'static,
-    ) -> Sender<Option<B::Node<H>>>
+    ) -> ReturnSender<B, T, H>
     where
         H: Height,
         S<H>: Height,
@@ -46,7 +47,7 @@ where
     /// Assemble leaf resolutions upward with no level beneath them.
     pub fn assemble_leaves(
         &mut self,
-        returns: Sender<Option<B::Node<S<Z>>>>,
+        returns: ReturnSender<B, T, S<Z>>,
         resolutions: impl Stream<Item = Result<Resolution<B, T, Z>, Error<B::Error>>> + Send + 'static,
     ) {
         self.return_into(
diff --git a/src/tree/mirror/streaming/materialized/work/levels.rs b/src/tree/mirror/streaming/materialized/work/levels.rs
index 3829b7a62..2bc5ca0b2 100644
--- a/src/tree/mirror/streaming/materialized/work/levels.rs
+++ b/src/tree/mirror/streaming/materialized/work/levels.rs
@@ -16,9 +16,10 @@ use crate::tree::{
     mirror::contained,
     mirror::streaming::{
         Backend, Leaf, Node, Root,
+        erased::{QueryReceiver, ResolutionOkStream, ReturnSender},
         materialized::{
-            Error, OkReceiverStream, Query, Resolution, Resolve, SupplyLedger, Violation,
-            channel::{Receiver, Sender},
+            Error, Query, Resolution, Resolve, SupplyLedger, Violation,
+            channel::Receiver,
             children_of, fan_listing,
             unknown::{Unknown, unknown, unknown_providing},
             violation,
@@ -62,8 +63,8 @@ where
         their_listing: Vec<(u8, Hash)>,
     ) -> (
         BoxResponses<B, T, UnderRoot, Error<B::Error>>,
-        Receiver<Query<B, T, UnderRoot>>,
-        Sender<Option<B::Node<height::Root>>>,
+        QueryReceiver<B, T, UnderRoot>,
+        ReturnSender<B, T, height::Root>,
         oneshot::Receiver<Vec<(u8, Option<B::Node<UnderRoot>>)>>,
         BoxFuture<'static, Result<Root<B, T>, Error<B::Error>>>,
     )
@@ -163,8 +164,8 @@ where
         requests: impl Requests<B, T, UnderRoot>,
     ) -> (
         BoxResponses<B, T, UnderRoot, Error<B::Error>>,
-        Receiver<Query<B, T, UnderUnderRoot>>,
-        Sender<Option<B::Node<UnderRoot>>>,
+        QueryReceiver<B, T, UnderUnderRoot>,
+        ReturnSender<B, T, UnderRoot>,
         oneshot::Receiver<Vec<(u8, Vec<(u8, B::Node<UnderUnderRoot>)>)>>,
         BoxFuture<'static, Result<Root<B, T>, Error<B::Error>>>,
     )
@@ -265,12 +266,12 @@ where
         early_survivors: Option<oneshot::Receiver<Vec<(u8, Option<B::Node<S<S<H>>>>)>>>,
         early_supplies: Option<oneshot::Receiver<Vec<(u8, Vec<(u8, B::Node<S<S<H>>>)>)>>>,
         requests: impl Requests<B, T, S<S<H>>>,
-        mut queries: Receiver<Query<B, T, S<S<H>>>>,
+        mut queries: QueryReceiver<B, T, S<S<H>>>,
     ) -> (
         BoxResponses<B, T, S<H>, Error<B::Error>>,
-        Receiver<Query<B, T, H>>,
-        OkReceiverStream<Resolution<B, T, S<S<H>>>, Error<B::Error>>,
-        OkReceiverStream<Resolution<B, T, S<H>>, Error<B::Error>>,
+        QueryReceiver<B, T, H>,
+        ResolutionOkStream<B, T, S<S<H>>>,
+        ResolutionOkStream<B, T, S<H>>,
     )
     where
         B: Sync,
@@ -434,12 +435,12 @@ where
         their_version: Version,
         ledger: SupplyLedger,
         requests: impl Requests<B, T, S<Z>>,
-        mut queries: Receiver<Query<B, T, S<Z>>>,
+        mut queries: QueryReceiver<B, T, S<Z>>,
     ) -> (
         BoxResponses<B, T, Z, Error<B::Error>>,
         Receiver<Prefix<Z>>,
-        OkReceiverStream<Resolution<B, T, S<Z>>, Error<B::Error>>,
-        OkReceiverStream<Resolution<B, T, Z>, Error<B::Error>>,
+        ResolutionOkStream<B, T, S<Z>>,
+        ResolutionOkStream<B, T, Z>,
     )
     where
         B: Sync,
@@ -521,10 +522,10 @@ where
         their_version: Version,
         ledger: SupplyLedger,
         requests: impl Requests<B, T, Z>,
-        mut queries: Receiver<Query<B, T, Z>>,
+        mut queries: QueryReceiver<B, T, Z>,
     ) -> (
         BoxResponses<B, T, Z, Error<B::Error>>,
-        OkReceiverStream<Resolution<B, T, Z>, Error<B::Error>>,
+        ResolutionOkStream<B, T, Z>,
     ) {
         let (upper, upper_rx) = terminal_leaf_resolutions();
         let stats = self.stats.clone();
diff --git a/src/tree/mirror/streaming/materialized/work/queues.rs b/src/tree/mirror/streaming/materialized/work/queues.rs
index c61343f29..750b76c14 100644
--- a/src/tree/mirror/streaming/materialized/work/queues.rs
+++ b/src/tree/mirror/streaming/materialized/work/queues.rs
@@ -2,7 +2,10 @@
 //!
 //! Each function names one edge in the protocol dataflow. Keeping capacity
 //! choices here makes them reviewable alongside the exact item type and keeps
-//! queue arithmetic out of the walk itself.
+//! queue arithmetic out of the walk itself. The channels beneath carry the
+//! height-erased payload twins — one channel-machinery instantiation per
+//! backend rather than one per height — behind typed facades minted per
+//! edge (see [`erased`]).
 //!
 //! Recursive query and resolution queues rely on two halves of the walk's
 //! progress invariant: publish a scope's resolution before sending the work
@@ -16,18 +19,17 @@
 //! for every remaining one-slot edge; only the inter-level return boundary
 //! needs a fan.
 
-#[cfg(not(test))]
-use tokio_stream::wrappers::ReceiverStream;
-
 use crate::tree::{
     mirror::streaming::{
         Backend, Leaf,
+        erased::{
+            self, QueryReceiver, QuerySender, ResolutionOkStream, ResolutionSender, ReturnOkStream,
+            ReturnReceiver, ReturnSender,
+        },
         materialized::{
-            Error, OkReceiverStream, Query, Resolution,
+            Error,
             channel::{QueueKind, QueueRole, Receiver, Sender, channel},
-            ok_channel,
         },
-        message::Reply,
         protocol::BoxResponses,
         window::FAN,
     },
@@ -43,7 +45,7 @@ use crate::tree::{
 /// and consuming that reply is sufficient to release the producer. More slots
 /// retain whole messages without breaking another dependency.
 pub(super) fn outgoing_responses<B, T, H>() -> (
-    Sender<Result<Reply<B, T, H>, Error<B::Error>>>,
+    erased::ReplyResultSender<B, T, H>,
     BoxResponses<B, T, H, Error<B::Error>>,
 )
 where
@@ -51,12 +53,9 @@ where
     T: Send + Sync + 'static,
     H: Height,
 {
-    let (sender, receiver) = channel(QueueRole::new(QueueKind::OutgoingResponses, H::HEIGHT), 1);
-    #[cfg(test)]
-    let responses = Box::pin(receiver);
-    #[cfg(not(test))]
-    let responses = Box::pin(ReceiverStream::new(receiver));
-    (sender, responses)
+    let (sender, responses) =
+        erased::reply_channel(QueueRole::new(QueueKind::OutgoingResponses, H::HEIGHT), 1);
+    (sender, Box::pin(responses))
 }
 
 /// Buffer lower-level completions until their enclosing resolution arrives.
@@ -81,16 +80,13 @@ where
 /// stall a session (`underbuffered_mirror_stalls` in the capacity tests
 /// demonstrates it), which is why the session window deliberately never
 /// reaches this constructor.
-pub(super) fn assembly_level_returns<B, T, H>() -> (
-    Sender<Option<B::Node<H>>>,
-    OkReceiverStream<Option<B::Node<H>>, Error<B::Error>>,
-)
+pub(super) fn assembly_level_returns<B, T, H>() -> (ReturnSender<B, T, H>, ReturnOkStream<B, T, H>)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
     H: Height,
 {
-    ok_channel(
+    erased::return_ok_channel::<B, T, H>(
         QueueRole::new(QueueKind::AssemblyLevelReturns, H::HEIGHT),
         FAN,
     )
@@ -100,15 +96,13 @@ where
 ///
 /// The opening emits exactly one query for the root scope, so a second slot
 /// can never be occupied.
-pub(super) fn initiator_root_query<B, T>() -> (
-    Sender<Query<B, T, UnderRoot>>,
-    Receiver<Query<B, T, UnderRoot>>,
-)
+pub(super) fn initiator_root_query<B, T>()
+-> (QuerySender<B, T, UnderRoot>, QueryReceiver<B, T, UnderRoot>)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    channel(
+    erased::query_channel(
         QueueRole::new(QueueKind::InitiatorRootQuery, UnderRoot::HEIGHT),
         1,
     )
@@ -118,15 +112,12 @@ where
 ///
 /// Reconciliation produces exactly one root node and the terminal future
 /// consumes it directly.
-pub(super) fn initiator_root_return<B, T>() -> (
-    Sender<Option<B::Node<Root>>>,
-    Receiver<Option<B::Node<Root>>>,
-)
+pub(super) fn initiator_root_return<B, T>() -> (ReturnSender<B, T, Root>, ReturnReceiver<B, T, Root>)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    channel(
+    erased::return_channel::<B, T, Root>(
         QueueRole::new(QueueKind::InitiatorRootReturn, Root::HEIGHT),
         1,
     )
@@ -137,19 +128,19 @@ where
 /// The opening wire reply and root resolution are published before these
 /// queries, so one slot is the liveness floor. The window widens it so the next
 /// stage can hold a pipeline of disputed children in flight; each buffered
-/// [`Query`] may own a fan of node handles, which is priced by the window's
-/// node budget.
+/// [`Query`](crate::tree::mirror::streaming::materialized::Query) may own a
+/// fan of node handles, which is priced by the window's node budget.
 pub(super) fn responder_child_queries<B, T>(
     capacity: usize,
 ) -> (
-    Sender<Query<B, T, UnderUnderRoot>>,
-    Receiver<Query<B, T, UnderUnderRoot>>,
+    QuerySender<B, T, UnderUnderRoot>,
+    QueryReceiver<B, T, UnderUnderRoot>,
 )
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    channel(
+    erased::query_channel(
         QueueRole::new(QueueKind::ResponderChildQueries, UnderUnderRoot::HEIGHT),
         capacity,
     )
@@ -160,14 +151,14 @@ where
 /// The responder processes exactly one opening request and therefore
 /// publishes exactly one resolution for the root scope.
 pub(super) fn responder_root_resolution<B, T>() -> (
-    Sender<Resolution<B, T, UnderRoot>>,
-    OkReceiverStream<Resolution<B, T, UnderRoot>, Error<B::Error>>,
+    ResolutionSender<B, T, UnderRoot>,
+    ResolutionOkStream<B, T, UnderRoot>,
 )
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    ok_channel(
+    erased::resolution_ok_channel(
         QueueRole::new(QueueKind::ResponderRootResolution, UnderRoot::HEIGHT),
         1,
     )
@@ -179,14 +170,14 @@ where
 /// assembler can consume each return as it arrives. No later return is needed
 /// to unlock the consumer of the buffered one.
 pub(super) fn responder_root_returns<B, T>() -> (
-    Sender<Option<B::Node<UnderRoot>>>,
-    OkReceiverStream<Option<B::Node<UnderRoot>>, Error<B::Error>>,
+    ReturnSender<B, T, UnderRoot>,
+    ReturnOkStream<B, T, UnderRoot>,
 )
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    ok_channel(
+    erased::return_ok_channel::<B, T, UnderRoot>(
         QueueRole::new(QueueKind::ResponderRootReturns, UnderRoot::HEIGHT),
         1,
     )
@@ -200,14 +191,14 @@ where
 /// height, so its capacity is what lets sibling scopes' round trips overlap.
 pub(super) fn internal_child_queries<B, T, H>(
     capacity: usize,
-) -> (Sender<Query<B, T, H>>, Receiver<Query<B, T, H>>)
+) -> (QuerySender<B, T, H>, QueryReceiver<B, T, H>)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
     H: Height,
     S<H>: Height,
 {
-    channel(
+    erased::query_channel(
         QueueRole::new(QueueKind::InternalChildQueries, H::HEIGHT),
         capacity,
     )
@@ -222,8 +213,8 @@ where
 pub(super) fn internal_parent_resolutions<B, T, H>(
     capacity: usize,
 ) -> (
-    Sender<Resolution<B, T, S<S<H>>>>,
-    OkReceiverStream<Resolution<B, T, S<S<H>>>, Error<B::Error>>,
+    ResolutionSender<B, T, S<S<H>>>,
+    ResolutionOkStream<B, T, S<S<H>>>,
 )
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
@@ -233,7 +224,7 @@ where
     S<S<H>>: Height,
     S<S<S<H>>>: Height,
 {
-    ok_channel(
+    erased::resolution_ok_channel(
         QueueRole::new(QueueKind::InternalParentResolutions, <S<S<H>>>::HEIGHT),
         capacity,
     )
@@ -246,10 +237,7 @@ where
 /// them while earlier subtrees are still reconciling.
 pub(super) fn internal_child_resolutions<B, T, H>(
     capacity: usize,
-) -> (
-    Sender<Resolution<B, T, S<H>>>,
-    OkReceiverStream<Resolution<B, T, S<H>>, Error<B::Error>>,
-)
+) -> (ResolutionSender<B, T, S<H>>, ResolutionOkStream<B, T, S<H>>)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
@@ -257,7 +245,7 @@ where
     S<H>: Height,
     S<S<H>>: Height,
 {
-    ok_channel(
+    erased::resolution_ok_channel(
         QueueRole::new(QueueKind::InternalChildResolutions, <S<H>>::HEIGHT),
         capacity,
     )
@@ -268,6 +256,9 @@ where
 /// The corresponding leaf-scope resolution is published first, so one slot is
 /// the liveness floor. This queue is the leaf-height question window: its
 /// capacity is how many requested leaves may await the peer's supplies at once.
+///
+/// The one materialized edge with no erased twin: its item is already the
+/// single-height [`Prefix<Z>`].
 pub(super) fn leaf_requests(capacity: usize) -> (Sender<Prefix<Z>>, Receiver<Prefix<Z>>) {
     channel(QueueRole::new(QueueKind::LeafRequests, Z::HEIGHT), capacity)
 }
@@ -280,15 +271,12 @@ pub(super) fn leaf_requests(capacity: usize) -> (Sender<Prefix<Z>>, Receiver<Pre
 /// buffered resolutions wait on their leaf exchanges.
 pub(super) fn leaf_parent_resolutions<B, T>(
     capacity: usize,
-) -> (
-    Sender<Resolution<B, T, S<Z>>>,
-    OkReceiverStream<Resolution<B, T, S<Z>>, Error<B::Error>>,
-)
+) -> (ResolutionSender<B, T, S<Z>>, ResolutionOkStream<B, T, S<Z>>)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    ok_channel(
+    erased::resolution_ok_channel(
         QueueRole::new(QueueKind::LeafParentResolutions, <S<Z>>::HEIGHT),
         capacity,
     )
@@ -302,15 +290,12 @@ where
 /// scopes await their supplies.
 pub(super) fn leaf_child_resolutions<B, T>(
     capacity: usize,
-) -> (
-    Sender<Resolution<B, T, Z>>,
-    OkReceiverStream<Resolution<B, T, Z>, Error<B::Error>>,
-)
+) -> (ResolutionSender<B, T, Z>, ResolutionOkStream<B, T, Z>)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    ok_channel(
+    erased::resolution_ok_channel(
         QueueRole::new(QueueKind::LeafChildResolutions, Z::HEIGHT),
         capacity,
     )
@@ -327,15 +312,13 @@ where
 /// scopes the memory model already charges, so no knob applies. (Contrast
 /// [`assembly_level_returns`], where one fan is a correctness floor rather
 /// than an amortization.)
-pub(super) fn terminal_leaf_resolutions<B, T>() -> (
-    Sender<Resolution<B, T, Z>>,
-    OkReceiverStream<Resolution<B, T, Z>, Error<B::Error>>,
-)
+pub(super) fn terminal_leaf_resolutions<B, T>()
+-> (ResolutionSender<B, T, Z>, ResolutionOkStream<B, T, Z>)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    ok_channel(
+    erased::resolution_ok_channel(
         QueueRole::new(QueueKind::TerminalLeafResolutions, Z::HEIGHT),
         FAN,
     )
diff --git a/src/tree/mirror/streaming/materialized/work/tests/violations.rs b/src/tree/mirror/streaming/materialized/work/tests/violations.rs
index f1c3359ea..90173d0c2 100644
--- a/src/tree/mirror/streaming/materialized/work/tests/violations.rs
+++ b/src/tree/mirror/streaming/materialized/work/tests/violations.rs
@@ -11,10 +11,9 @@ use crate::{
     Version,
     tree::mirror::streaming::{
         Local,
+        erased::QueryReceiver,
         materialized::{
-            Error, Query, SupplyLedger, Violation, Work,
-            channel::{Receiver, with_schedule},
-            unknown::Unknown,
+            Error, Query, SupplyLedger, Violation, Work, channel::with_schedule, unknown::Unknown,
             work::queues::internal_child_queries,
         },
         message::{Reaction, Reply},
@@ -198,7 +197,7 @@ where
 }
 
 /// Put the script's optional outstanding query into the walk's pairing queue.
-fn query_receiver<H>(query: Option<Query<Local, (), H>>) -> Receiver<Query<Local, (), H>>
+fn query_receiver<H>(query: Option<Query<Local, (), H>>) -> QueryReceiver<Local, (), H>
 where
     H: Height,
     S<H>: Height,
diff --git a/src/tree/typed.rs b/src/tree/typed.rs
index 5b31b7d93..fab783da9 100644
--- a/src/tree/typed.rs
+++ b/src/tree/typed.rs
@@ -32,5 +32,6 @@ pub use hash::Hash;
 pub use levels::{Level, Levels};
 pub use node::{Children, Node};
 pub use path::Path;
+pub(crate) use prefix::ErasedPrefix;
 pub use prefix::Prefix;
 pub use untyped::{Iter, Leaf, RangeOwned};
diff --git a/src/tree/typed/prefix.rs b/src/tree/typed/prefix.rs
index ab7911925..00bb66d33 100644
--- a/src/tree/typed/prefix.rs
+++ b/src/tree/typed/prefix.rs
@@ -23,6 +23,46 @@ pub struct Prefix<H: Height = Z> {
     hash: ArrayVec<[u8; 32]>,
 }
 
+/// A prefix with its height tag forgotten: the same accumulated path
+/// bytes, whose length *is* the height (`32 - height` bytes at `height`).
+///
+/// The typed [`Prefix<H>`] wraps runtime bytes in a compile-time tag; this
+/// is those bytes without the tag, for plumbing that carries prefixes of
+/// every height through one instantiation. [`Prefix::erase`] forgets the
+/// tag and [`ErasedPrefix::assume`] restores it, checking the length
+/// against the claimed height in debug builds.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub(crate) struct ErasedPrefix {
+    hash: ArrayVec<[u8; 32]>,
+}
+
+impl ErasedPrefix {
+    /// Re-tag this prefix at height `H`.
+    ///
+    /// `H` must be the height the prefix was erased at — equivalently,
+    /// `32 - H::HEIGHT` must be its byte length, debug-asserted here. A
+    /// cross-height re-tag is a programmer error in the erased plumbing,
+    /// never a consequence of peer input: every wire prefix decodes
+    /// through the typed reader, which fixes the length from the type.
+    pub fn assume<H: Height>(self) -> Prefix<H> {
+        debug_assert_eq!(
+            self.hash.len(),
+            32 - H::HEIGHT,
+            "an erased prefix re-tags at the height it was erased at",
+        );
+        Prefix {
+            height: PhantomData,
+            hash: self.hash,
+        }
+    }
+}
+
+impl Debug for ErasedPrefix {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.hash.fmt(f)
+    }
+}
+
 impl Prefix<Root> {
     /// Make a new empty prefix.
     pub fn new() -> Self {
@@ -85,6 +125,11 @@ impl<H: Height> Prefix<H> {
         &self.hash
     }
 
+    /// Forget this prefix's height tag; [`ErasedPrefix::assume`] restores it.
+    pub(crate) fn erase(self) -> ErasedPrefix {
+        ErasedPrefix { hash: self.hash }
+    }
+
     /// The prefix naming the height-`H` subtree that contains `path`: its
     /// first `32 - H::HEIGHT` bytes.
     pub fn containing(path: &Path) -> Self {

From bf1a5b4bc61a984e90ede4f94978476b3037922b Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Wed, 19 Aug 2026 17:05:55 -0400
Subject: [PATCH 03/18] streaming: erase the materialized walk's workers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The walk now runs on the erased vocabulary end to end, one
instantiation per backend: Query/Resolution/Resolve are generic over
the erased node representation (their prefix an ErasedPrefix whose
byte length is the height witness), and the level loops, answerer,
resolver, assembler, and deletion-honoring filter are shared bodies
behind thin typed shells. Each shell erases its stage's request stream
on the way in; Work::respond's reply-channel exit re-tags responses at
the stage's height on the way out — the walk's only remaining typed
boundary, plus the two fixed-height root re-tags at the finish
futures.

Erased code reaches the height-typed Backend surface through a
33-arm runtime-to-type dispatch (erased::ops), keyed on the prefix
length so the coordinate and the witness cannot drift apart; the
numbered height aliases it indexes live in typed::height with a
pinned-endpoint tripwire. The Unknown trait tower dissolves into one
prefix-guided recursion (depth bounded by the 32-byte path, boxed per
step exactly as the typed tower was). Step 2's per-payload facades
dissolve with it: the channels carry the erased vocabulary bare, and
their QueueRole height labels stay runtime data for the instrumented
diagnostics and capacity suites.

Measured on --test pairwise (debug, default features):
2,609,789 lines / 94,312 copies -> 1,717,836 / 67,158 (parent
2,884,887 / 109,613; -40.5% cumulative). The materialized-labeled
rows fall 662k -> 274k and async_stream 400k -> 229k; the remaining
per-height machinery is the proxy's (remote-labeled rows: 837k),
design/height-erasure.md step 4.
---
 src/tree/mirror/streaming/erased.rs           | 556 ++++++------------
 src/tree/mirror/streaming/materialized.rs     | 108 ++--
 .../mirror/streaming/materialized/common.rs   |  35 +-
 .../mirror/streaming/materialized/progress.rs |  55 +-
 .../mirror/streaming/materialized/tests.rs    |  17 +-
 .../streaming/materialized/transcript.rs      |  21 +-
 .../mirror/streaming/materialized/unknown.rs  | 183 +++---
 .../streaming/materialized/unknown/tests.rs   |   9 +-
 .../mirror/streaming/materialized/work.rs     |  94 +--
 .../streaming/materialized/work/answer.rs     |  66 +--
 .../streaming/materialized/work/assembly.rs   |  41 +-
 .../streaming/materialized/work/levels.rs     | 273 ++++++---
 .../streaming/materialized/work/queues.rs     | 152 ++---
 .../streaming/materialized/work/resolver.rs   |  35 +-
 .../streaming/materialized/work/tests.rs      |  50 +-
 .../materialized/work/tests/violations.rs     |  46 +-
 src/tree/mirror/streaming/window.rs           |   8 +-
 src/tree/typed/height.rs                      |  33 ++
 src/tree/typed/prefix.rs                      |  26 +
 19 files changed, 881 insertions(+), 927 deletions(-)

diff --git a/src/tree/mirror/streaming/erased.rs b/src/tree/mirror/streaming/erased.rs
index 1a9ab803b..16cb3defb 100644
--- a/src/tree/mirror/streaming/erased.rs
+++ b/src/tree/mirror/streaming/erased.rs
@@ -1,30 +1,44 @@
-//! Height-erased twins of the session's channel payloads, and the typed
-//! facades that are the only way in or out of them.
+//! The height-erased seam of the streaming session: the wire vocabulary's
+//! erased twin, the typed exits, and the dispatch back into the typed
+//! backend surface.
 //!
-//! Every item the walk's bounded channels carry is height-indexed in the
-//! type system but height-uniform at runtime: nodes erase to one
-//! representation per backend ([`Backend::Erased`]), prefixes to their
-//! bytes ([`ErasedPrefix`]), and nothing else in a payload ever depended
-//! on the height. Minting channels of the erased twins therefore costs
-//! nothing at runtime — every conversion below is a phantom-tag swap over
-//! the value the program already holds — and collapses the channel
-//! machinery from one instantiation per height to one per backend.
+//! The materialized walk's payloads and workers are height-uniform at
+//! runtime: nodes erase to one representation per backend
+//! ([`Backend::Erased`]), prefixes to their bytes
+//! ([`ErasedPrefix`](crate::tree::typed::ErasedPrefix)), and nothing else
+//! in a payload ever depended on the height. The walk therefore runs on
+//! erased values — one instantiation of its channels, generators, and
+//! loops per backend, instead of one per height — while the protocol
+//! schedule around it stays fully typed. This module owns the seam
+//! between the two:
+//!
+//! - [`Reply`] and [`Reaction`] are [`message::Reply`]'s and
+//!   [`message::Reaction`]'s erased twins, converted exactly at the
+//!   schedule boundary: [`erase_reply`] where a typed request stream
+//!   enters a walk worker, and [`reply_channel`]'s typed exit where a
+//!   worker's responses become the schedule's typed response stream.
+//!   Every conversion is a phantom-tag swap over values the program
+//!   already holds.
+//! - [`ops`] carries erased node operations back into the height-typed
+//!   [`Backend`] surface, selecting the type-level height from the one
+//!   runtime witness every erased scope carries: its prefix's byte
+//!   length.
 //!
 //! # What the types stop proving, and what catches it instead
 //!
-//! Outside this module, sending a height-5 payload into a height-6 queue
-//! is a compile error, exactly as before: the constructors here pair each
-//! erased channel with typed facades ([`TypedSender`], [`TypedReceiver`],
-//! [`TypedStream`], [`TypedOkStream`]) minted at one height parameter, so
-//! both halves of an edge speak the same height by construction, and a
-//! mispairing can only be authored *inside this module* by wiring a
-//! constructor's two halves to different conversions. That one-module
-//! audit surface is the design's locality argument. At runtime, every
-//! prefix re-tag debug-asserts its byte length against the claimed height
-//! ([`ErasedPrefix::assume`]), and every channel keeps its
-//! [`QueueRole`] height label for the instrumented diagnostics.
+//! Outside the walk, pairing a height-5 payload with a height-6 consumer
+//! is a compile error, exactly as before: the schedule's typestates and
+//! message streams remain height-typed, and this module's two boundary
+//! conversions are minted at one height parameter apiece. Inside the
+//! walk, height agreement is a runtime-witnessed property: every prefix
+//! re-tag debug-asserts its byte length against the claimed height, the
+//! [`ops`] dispatch derives its height from that same length (so the
+//! coordinate and the witness cannot drift apart), and every channel
+//! keeps its [`QueueRole`] height label for
+//! the instrumented diagnostics. The behavioral pins — the alternating
+//! oracle, the violation and capacity suites, the byte-pinned wire
+//! snapshots — exercise exactly these pairings.
 
-use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
@@ -36,16 +50,17 @@ use crate::tree::{
     mirror::streaming::{
         Backend, Leaf,
         channel::{QueueRole, Receiver, Sender, channel},
-        materialized::{self, Error},
+        materialized::Error,
         message,
     },
     typed::{
-        ErasedPrefix, Hash,
-        height::{Height, S, Z},
+        Hash,
+        height::{Height, Z},
     },
 };
 
-/// [`message::Reply`] with its height forgotten.
+/// [`message::Reply`] with its height forgotten: what the walk's workers
+/// produce and consume.
 pub(crate) struct Reply<E> {
     pub replies: Vec<Reaction<E>>,
 }
@@ -57,164 +72,9 @@ pub(crate) enum Reaction<E> {
     Query(Vec<(u8, Hash)>),
 }
 
-/// [`materialized::Query`] with its height forgotten.
-pub(crate) struct Query<E> {
-    pub prefix: ErasedPrefix,
-    pub ours: Vec<(u8, E)>,
-}
-
-/// [`materialized::Resolution`] with its height forgotten.
-pub(crate) struct Resolution<E> {
-    pub prefix: ErasedPrefix,
-    pub resolved: Vec<(u8, Resolve<E>)>,
-}
-
-/// [`materialized::Resolve`] with its height forgotten.
-pub(crate) enum Resolve<E> {
-    Ready(Option<E>),
-    Pending,
-}
-
-/// Shorthand for the erased node representation of one backend.
-type ErasedOf<B, T> = <B as Backend<T>>::Erased;
-
-/// The typed halves of the outgoing-response edge
-/// ([`reply_channel`]): items are whole replies or the error that ends
-/// the stream.
-pub(crate) type ReplyResultSender<B, T, H> = TypedSender<
-    Result<message::Reply<B, T, H>, Error<<B as Backend<T>>::Error>>,
-    Result<Reply<ErasedOf<B, T>>, Error<<B as Backend<T>>::Error>>,
->;
-/// The receiving half of [`reply_channel`], as the response stream shape.
-pub(crate) type ReplyResultStream<B, T, H> = TypedStream<
-    Result<message::Reply<B, T, H>, Error<<B as Backend<T>>::Error>>,
-    Result<Reply<ErasedOf<B, T>>, Error<<B as Backend<T>>::Error>>,
->;
-/// The typed sending half of a query edge ([`query_channel`]).
-pub(crate) type QuerySender<B, T, H> =
-    TypedSender<materialized::Query<B, T, H>, Query<ErasedOf<B, T>>>;
-/// The typed receiving half of a query edge ([`query_channel`]).
-pub(crate) type QueryReceiver<B, T, H> =
-    TypedReceiver<materialized::Query<B, T, H>, Query<ErasedOf<B, T>>>;
-/// The typed sending half of a return edge ([`return_channel`],
-/// [`return_ok_channel`]): one reconciled node per query, in query order.
-pub(crate) type ReturnSender<B, T, H> =
-    TypedSender<Option<<B as Backend<T>>::Node<H>>, Option<ErasedOf<B, T>>>;
-/// The typed receiving half of [`return_channel`].
-pub(crate) type ReturnReceiver<B, T, H> =
-    TypedReceiver<Option<<B as Backend<T>>::Node<H>>, Option<ErasedOf<B, T>>>;
-/// The receiving half of [`return_ok_channel`], as an `Ok`-wrapping stream.
-pub(crate) type ReturnOkStream<B, T, H> = TypedOkStream<
-    Option<<B as Backend<T>>::Node<H>>,
-    Option<ErasedOf<B, T>>,
-    Error<<B as Backend<T>>::Error>,
->;
-/// The typed sending half of a resolution edge ([`resolution_ok_channel`]).
-pub(crate) type ResolutionSender<B, T, H> =
-    TypedSender<materialized::Resolution<B, T, H>, Resolution<ErasedOf<B, T>>>;
-/// The receiving half of [`resolution_ok_channel`], as an `Ok`-wrapping
-/// stream.
-pub(crate) type ResolutionOkStream<B, T, H> = TypedOkStream<
-    materialized::Resolution<B, T, H>,
-    Resolution<ErasedOf<B, T>>,
-    Error<<B as Backend<T>>::Error>,
->;
-
-/// Mint the outgoing-response edge: a typed sender and the typed response
-/// stream its receiver drains into.
-pub(crate) fn reply_channel<B, T, H>(
-    role: QueueRole,
-    capacity: usize,
-) -> (ReplyResultSender<B, T, H>, ReplyResultStream<B, T, H>)
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-{
-    let (sender, receiver) = channel(role, capacity);
-    (
-        TypedSender::new(sender, |item: Result<_, _>| {
-            item.map(erase_reply::<B, T, H>)
-        }),
-        TypedStream::new(receiver, |item: Result<_, _>| {
-            item.map(assume_reply::<B, T, H>)
-        }),
-    )
-}
-
-/// Mint one query edge at height `H` (the children's height; the scope
-/// sits at `S<H>`).
-pub(crate) fn query_channel<B, T, H>(
-    role: QueueRole,
-    capacity: usize,
-) -> (QuerySender<B, T, H>, QueryReceiver<B, T, H>)
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
-{
-    let (sender, receiver) = channel(role, capacity);
-    (
-        TypedSender::new(sender, erase_query::<B, T, H>),
-        TypedReceiver::new(receiver, assume_query::<B, T, H>),
-    )
-}
-
-/// Mint one return edge at height `H`, received item by item.
-pub(crate) fn return_channel<B, T, H>(
-    role: QueueRole,
-    capacity: usize,
-) -> (ReturnSender<B, T, H>, ReturnReceiver<B, T, H>)
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-{
-    let (sender, receiver) = channel(role, capacity);
-    (
-        TypedSender::new(sender, erase_return::<B, T, H>),
-        TypedReceiver::new(receiver, assume_return::<B, T, H>),
-    )
-}
-
-/// Mint one return edge at height `H`, received as an `Ok`-wrapping stream.
-pub(crate) fn return_ok_channel<B, T, H>(
-    role: QueueRole,
-    capacity: usize,
-) -> (ReturnSender<B, T, H>, ReturnOkStream<B, T, H>)
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-{
-    let (sender, receiver) = channel(role, capacity);
-    (
-        TypedSender::new(sender, erase_return::<B, T, H>),
-        TypedOkStream::new(receiver, assume_return::<B, T, H>),
-    )
-}
-
-/// Mint one resolution edge at height `H`, received as an `Ok`-wrapping
-/// stream.
-pub(crate) fn resolution_ok_channel<B, T, H>(
-    role: QueueRole,
-    capacity: usize,
-) -> (ResolutionSender<B, T, H>, ResolutionOkStream<B, T, H>)
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
-{
-    let (sender, receiver) = channel(role, capacity);
-    (
-        TypedSender::new(sender, erase_resolution::<B, T, H>),
-        TypedOkStream::new(receiver, assume_resolution::<B, T, H>),
-    )
-}
-
-fn erase_reply<B, T, H>(reply: message::Reply<B, T, H>) -> Reply<ErasedOf<B, T>>
+/// Erase one typed reply where a schedule-typed request stream enters a
+/// walk worker.
+pub(crate) fn erase_reply<B, T, H>(reply: message::Reply<B, T, H>) -> Reply<B::Erased>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
@@ -233,7 +93,8 @@ where
     }
 }
 
-fn assume_reply<B, T, H>(reply: Reply<ErasedOf<B, T>>) -> message::Reply<B, T, H>
+/// Re-tag one erased reply at the typed exit of [`reply_channel`].
+fn assume_reply<B, T, H>(reply: Reply<B::Erased>) -> message::Reply<B, T, H>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
@@ -252,174 +113,33 @@ where
     }
 }
 
-fn erase_query<B, T, H>(query: materialized::Query<B, T, H>) -> Query<ErasedOf<B, T>>
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
-{
-    Query {
-        prefix: query.prefix.erase(),
-        ours: query
-            .ours
-            .into_iter()
-            .map(|(radix, node)| (radix, B::erase(node)))
-            .collect(),
-    }
-}
-
-fn assume_query<B, T, H>(query: Query<ErasedOf<B, T>>) -> materialized::Query<B, T, H>
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
-{
-    materialized::Query {
-        prefix: query.prefix.assume(),
-        ours: query
-            .ours
-            .into_iter()
-            .map(|(radix, node)| (radix, B::assume(node)))
-            .collect(),
-    }
-}
-
-fn erase_resolution<B, T, H>(
-    resolution: materialized::Resolution<B, T, H>,
-) -> Resolution<ErasedOf<B, T>>
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
-{
-    Resolution {
-        prefix: resolution.prefix.erase(),
-        resolved: resolution
-            .resolved
-            .into_iter()
-            .map(|(radix, slot)| {
-                (
-                    radix,
-                    match slot {
-                        materialized::Resolve::Ready(node) => Resolve::Ready(node.map(B::erase)),
-                        materialized::Resolve::Pending => Resolve::Pending,
-                    },
-                )
-            })
-            .collect(),
-    }
-}
-
-fn assume_resolution<B, T, H>(
-    resolution: Resolution<ErasedOf<B, T>>,
-) -> materialized::Resolution<B, T, H>
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
-{
-    materialized::Resolution {
-        prefix: resolution.prefix.assume(),
-        resolved: resolution
-            .resolved
-            .into_iter()
-            .map(|(radix, slot)| {
-                (
-                    radix,
-                    match slot {
-                        Resolve::Ready(node) => {
-                            materialized::Resolve::Ready(node.map(B::assume::<H>))
-                        }
-                        Resolve::Pending => materialized::Resolve::Pending,
-                    },
-                )
-            })
-            .collect(),
-    }
-}
-
-fn erase_return<B, T, H>(node: Option<B::Node<H>>) -> Option<ErasedOf<B, T>>
+/// The typed exit of [`reply_channel`]: the erased receiver as a stream
+/// of schedule-typed replies.
+pub(crate) struct ReplyResultStream<B, T, H>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
     H: Height,
 {
-    node.map(B::erase)
+    inner: ReceiverStreamOf<Result<Reply<B::Erased>, Error<B::Error>>>,
+    assume: fn(
+        Result<Reply<B::Erased>, Error<B::Error>>,
+    ) -> Result<message::Reply<B, T, H>, Error<B::Error>>,
 }
 
-fn assume_return<B, T, H>(node: Option<ErasedOf<B, T>>) -> Option<B::Node<H>>
+impl<B, T, H> Stream for ReplyResultStream<B, T, H>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
     H: Height,
 {
-    node.map(B::assume::<H>)
-}
-
-// --------------------------------------------------------------------------------
-// The typed facades: each pairs one erased channel half with the fixed
-// conversion its constructor minted it with.
-// --------------------------------------------------------------------------------
-
-/// The typed sending half of an erased channel.
-pub(crate) struct TypedSender<M, E> {
-    inner: Sender<E>,
-    erase: fn(M) -> E,
-}
-
-impl<M, E> Clone for TypedSender<M, E> {
-    fn clone(&self) -> Self {
-        Self {
-            inner: self.inner.clone(),
-            erase: self.erase,
-        }
-    }
-}
-
-impl<M, E: Send> TypedSender<M, E> {
-    fn new(inner: Sender<E>, erase: fn(M) -> E) -> Self {
-        Self { inner, erase }
-    }
-
-    /// Send one typed item, erased in place.
-    ///
-    /// Like the underlying channel's send: an error means the receiving
-    /// half is gone, and the producer should wind down.
-    pub(crate) async fn send(&self, message: M) -> Result<(), ClosedChannel> {
-        self.inner
-            .send((self.erase)(message))
-            .await
-            .map_err(|_| ClosedChannel)
-    }
-}
-
-/// The receiver of a typed send has hung up; the payload is dropped.
-///
-/// The typed sender cannot return the underlying
-/// [`SendError`](tokio::sync::mpsc::error::SendError) because that hands
-/// back the *erased* payload; no caller inspects it — a failed send means
-/// "stop producing" on every edge.
-#[derive(Debug)]
-pub(crate) struct ClosedChannel;
-
-/// The typed receiving half of an erased channel.
-pub(crate) struct TypedReceiver<M, E> {
-    inner: Receiver<E>,
-    assume: fn(E) -> M,
-}
-
-impl<M, E: Send> TypedReceiver<M, E> {
-    fn new(inner: Receiver<E>, assume: fn(E) -> M) -> Self {
-        Self { inner, assume }
-    }
+    type Item = Result<message::Reply<B, T, H>, Error<B::Error>>;
 
-    /// Receive one typed item, re-tagged in place.
-    pub(crate) async fn recv(&mut self) -> Option<M> {
-        self.inner.recv().await.map(self.assume)
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let this = self.get_mut();
+        Pin::new(&mut this.inner)
+            .poll_next(cx)
+            .map(|item| item.map(this.assume))
     }
 }
 
@@ -443,57 +163,121 @@ fn receiver_stream<E: Send>(receiver: Receiver<E>) -> ReceiverStreamOf<E> {
     }
 }
 
-/// An erased channel's receiving half as a stream of typed items.
-pub(crate) struct TypedStream<M, E> {
-    inner: ReceiverStreamOf<E>,
-    assume: fn(E) -> M,
-}
-
-impl<M, E: Send> TypedStream<M, E> {
-    fn new(inner: Receiver<E>, assume: fn(E) -> M) -> Self {
-        Self {
-            inner: receiver_stream(inner),
-            assume,
-        }
-    }
+/// Mint the outgoing-response edge: an erased sender for the response
+/// pump, and the typed response stream the schedule consumes.
+///
+/// The one edge whose two halves speak different vocabularies — erased
+/// in, typed out — and therefore the outgoing half of the walk's typed
+/// boundary. Its height parameter fixes the exit's re-tag; the erased
+/// sender needs none.
+pub(crate) fn reply_channel<B, T, H>(
+    role: QueueRole,
+    capacity: usize,
+) -> (
+    Sender<Result<Reply<B::Erased>, Error<B::Error>>>,
+    ReplyResultStream<B, T, H>,
+)
+where
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
+    H: Height,
+{
+    let (sender, receiver) = channel(role, capacity);
+    (
+        sender,
+        ReplyResultStream {
+            inner: receiver_stream(receiver),
+            assume: |item| item.map(assume_reply::<B, T, H>),
+        },
+    )
 }
 
-impl<M, E: Send> Stream for TypedStream<M, E> {
-    type Item = M;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let this = self.get_mut();
-        Pin::new(&mut this.inner)
-            .poll_next(cx)
-            .map(|item| item.map(this.assume))
+/// Erased node operations dispatched back into the height-typed
+/// [`Backend`] surface.
+///
+/// The backend's traversal operations are generic over type-level
+/// heights; an erased caller selects the height at runtime from the one
+/// witness every erased scope carries — its prefix's byte length — via a
+/// 33-arm match whose arms each instantiate one thin typed call. Deriving
+/// the height from the prefix (rather than threading a separate counter)
+/// is what keeps the coordinate and the witness structurally inseparable.
+pub(crate) mod ops {
+    use super::*;
+    use crate::tree::{
+        mirror::streaming::materialized::children_of as children_of_typed,
+        typed::{ErasedPrefix, height::Pred},
+    };
+
+    /// Select the type-level height matching a runtime *parent* height.
+    ///
+    /// `$H` is bound to the parent's height type within `$body`, and
+    /// `<$H as Pred>::Pred` names the children's. Each arm monomorphizes
+    /// the body once, so bodies must stay thin.
+    macro_rules! at_parent_height {
+        ($height:expr, $H:ident => $body:expr) => {{
+            seq_macro::seq!(N in 1..=32 {
+                match $height {
+                    0 => unreachable!("a leaf-height node has no children"),
+                    #(N => { type $H = crate::tree::typed::height::H~N; $body })*
+                    _ => unreachable!("a tree height is 0..=32"),
+                }
+            })
+        }};
     }
-}
-
-/// An erased channel's receiving half as a stream of `Ok`-wrapped typed
-/// items: the shape the assembly and walk consumers pull from.
-pub(crate) struct TypedOkStream<M, E, Err> {
-    inner: ReceiverStreamOf<E>,
-    assume: fn(E) -> M,
-    error: PhantomData<fn() -> Err>,
-}
 
-impl<M, E: Send, Err> TypedOkStream<M, E, Err> {
-    fn new(inner: Receiver<E>, assume: fn(E) -> M) -> Self {
-        Self {
-            inner: receiver_stream(inner),
-            assume,
-            error: PhantomData,
-        }
+    /// Collect one erased node's children, addressed by radix
+    /// ([`children_of_typed`], erased).
+    ///
+    /// `prefix` is the node's own prefix; its length names the height the
+    /// node is re-tagged at, so a walk cannot explode a node at any level
+    /// other than the one its coordinate claims.
+    pub(crate) async fn children_of<B, T>(
+        backend: &B,
+        prefix: ErasedPrefix,
+        node: B::Erased,
+    ) -> Result<Vec<(u8, B::Erased)>, B::Error>
+    where
+        B: Backend<T, Node<Z>: Leaf<T>>,
+        T: Send + Sync + 'static,
+    {
+        at_parent_height!(prefix.height(), H => {
+            let children =
+                children_of_typed::<B, T, <H as Pred>::Pred>(
+                    backend,
+                    prefix.assume::<H>(),
+                    B::assume::<H>(node),
+                )
+                .await?;
+            Ok(children
+                .into_iter()
+                .map(|(radix, child)| (radix, B::erase(child)))
+                .collect())
+        })
     }
-}
-
-impl<M, E: Send, Err> Stream for TypedOkStream<M, E, Err> {
-    type Item = Result<M, Err>;
 
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let this = self.get_mut();
-        Pin::new(&mut this.inner)
-            .poll_next(cx)
-            .map(|item| item.map(|item| Ok((this.assume)(item))))
+    /// Assemble one erased parent node at `prefix` from one radix-keyed
+    /// child group ([`Backend::parent`], erased).
+    ///
+    /// `prefix` is the parent's own prefix, carrying the same
+    /// length-is-height witness as [`children_of`].
+    pub(crate) async fn parent<B, T>(
+        backend: B,
+        prefix: ErasedPrefix,
+        children: Vec<(u8, Option<B::Erased>)>,
+    ) -> Result<Option<B::Erased>, B::Error>
+    where
+        B: Backend<T, Node<Z>: Leaf<T>>,
+        T: Send + Sync + 'static,
+    {
+        at_parent_height!(prefix.height(), H => {
+            let children = children
+                .into_iter()
+                .map(|(radix, child)| (radix, child.map(B::assume::<<H as Pred>::Pred>)))
+                .collect();
+            Ok(backend
+                .parent::<<H as Pred>::Pred>(prefix.assume::<H>(), children)
+                .await?
+                .map(B::erase))
+        })
     }
 }
diff --git a/src/tree/mirror/streaming/materialized.rs b/src/tree/mirror/streaming/materialized.rs
index 991ddba7a..c283c0aac 100644
--- a/src/tree/mirror/streaming/materialized.rs
+++ b/src/tree/mirror/streaming/materialized.rs
@@ -105,17 +105,17 @@ use std::sync::atomic::{AtomicU64, Ordering};
 use crate::tree::{
     mirror::contained,
     mirror::streaming::{
-        Backend, Leaf, Node, Root,
-        erased::{QueryReceiver, ReturnSender},
-        materialized::{unknown::Unknown, work::Work},
-        message::{Greeting, Reaction, Reply},
+        Backend, ErasedNode, Leaf, Root,
+        erased::{self, Reaction, Reply},
+        materialized::work::Work,
+        message::Greeting,
         protocol::{self, BoxResponses, Requests},
         remote::DEFAULT_TARGET_MESSAGE_SIZE,
         stats::Recorder,
         window::WindowConfig,
     },
     typed::{
-        Hash, Prefix,
+        ErasedPrefix, Hash, Prefix,
         height::{self, Height, S, UnderRoot, UnderUnderRoot, Z},
     },
 };
@@ -180,7 +180,8 @@ mod tests;
 pub(super) mod transcript;
 pub(super) mod unknown;
 mod work;
-use channel::Receiver;
+use channel::{Receiver, Sender};
+use common::*;
 // The remote proxy explodes early-supplied whole root children into the
 // same per-child shape the walks consume, with the walks' own helper.
 pub(crate) use common::children_of;
@@ -252,38 +253,35 @@ impl SupplyLedger {
 /// queue between consecutive same-side stages, and the in-process twin of
 /// the wire's expected scopes.
 ///
-/// `H` is the children's height; the scope sits at `S<H>`, so
-/// `Query<_, _, H>` pairs with [`Reply<_, _, H>`](Reply).
+/// `E` is the backend's erased node representation
+/// ([`Backend::Erased`]); the prefix names the queried scope, and its
+/// byte length is the scope's height witness (see
+/// [`erased`]). A query pairs with the reply at its
+/// children's height, one level below the prefix.
 ///
 /// If we issued a request for a node, `ours` is empty and we expect the
 /// reply to consist entirely of supplied nodes.
-pub struct Query<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height>
-where
-    S<H>: Height,
-{
+pub struct Query<E> {
     /// The prefix at which the resolved node will sit.
-    pub prefix: Prefix<S<H>>,
+    pub prefix: ErasedPrefix,
     /// Our children of the node (empty if we don't have it at all).
-    pub ours: Vec<(u8, B::Node<H>)>,
+    pub ours: Vec<(u8, E)>,
 }
 
 /// One scope's resolution: its children in radix order, each resolved
 /// locally or pending on the stages beneath.
-pub struct Resolution<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height>
-where
-    S<H>: Height,
-{
+pub struct Resolution<E> {
     /// The prefix at which the resolved node will sit.
-    pub(crate) prefix: Prefix<S<H>>,
+    pub(crate) prefix: ErasedPrefix,
     /// The possibly-resolved children of the node.
-    pub(crate) resolved: Vec<(u8, Resolve<B, T, H>)>,
+    pub(crate) resolved: Vec<(u8, Resolve<E>)>,
 }
 
 /// One child's slot in a [`Resolution`].
-pub enum Resolve<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height> {
+pub enum Resolve<E> {
     /// Resolved at the current level: kept, absorbed, or pruned (`None` = gone;
     /// flows into `Backend::parent` as its deletion vocabulary).
-    Ready(Option<B::Node<H>>),
+    Ready(Option<E>),
     /// Resolved elsewhere: filled by the level stream's next item.
     Pending,
 }
@@ -330,7 +328,10 @@ pub struct Start {
 /// second time (the memory model's one-query-per-prefix rule).
 pub struct Connecting<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> {
     our_version: Version,
-    fan: Vec<(u8, B::Node<UnderRoot>)>,
+    /// The root fan, already erased: everything downstream of the
+    /// greeting — the descent's workers included — speaks the erased
+    /// representation.
+    fan: Vec<(u8, B::Erased)>,
 }
 
 /// The version state of a stage that has exchanged greetings with its peer
@@ -349,7 +350,8 @@ pub struct Connected<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>
     /// initiator merges its own fan against to ship its exclusive root
     /// children as the opening's early supplies.
     their_listing: Vec<(u8, Hash)>,
-    fan: Vec<(u8, B::Node<UnderRoot>)>,
+    /// The root fan, erased at greeting time ([`Connecting`]).
+    fan: Vec<(u8, B::Erased)>,
 }
 
 /// A mirror stage inside the descent, consuming [`Reply<B, T, H>`](Reply)
@@ -364,13 +366,18 @@ where
     /// absorbed supply ([`SupplyLedger`]).
     ledger: SupplyLedger,
     /// The questions we asked, awaiting their replies in order.
-    queries: QueryReceiver<B, T, H>,
+    ///
+    /// The payloads are erased ([`Backend::Erased`]); the typestate's
+    /// `H` is what pins this queue to the walk stage that consumes it at
+    /// the right height, and every payload's prefix carries the runtime
+    /// witness.
+    queries: Receiver<Query<B::Erased>>,
     /// One resolved scope per query, in query order, to the stage above.
-    returns: ReturnSender<B, T, S<H>>,
+    returns: Sender<Option<B::Erased>>,
     /// An elected initiator's opening hand-off: the early-supplied root
     /// radices' survivors, consumed by the first descending stage to answer
     /// the responder's empty queries about them (`None` below it).
-    early_survivors: Option<oneshot::Receiver<Vec<(u8, Option<B::Node<H>>)>>>,
+    early_survivors: Option<oneshot::Receiver<Vec<(u8, Option<B::Erased>)>>>,
     /// An elected responder's opening hand-off (`None` below the first
     /// descending stage).
     ///
@@ -378,12 +385,18 @@ where
     /// their own children, consumed by the first descending stage to
     /// resolve its own root-level requests.
     #[allow(clippy::type_complexity)]
-    early_supplies: Option<oneshot::Receiver<Vec<(u8, Vec<(u8, B::Node<H>)>)>>>,
+    early_supplies: Option<oneshot::Receiver<Vec<(u8, Vec<(u8, B::Erased)>)>>>,
     /// The reassembly work accumulated so far; the terminals drive it to
     /// completion.
     work: Work<B, T>,
     /// Resolves to this side's reconciled root once the top return arrives.
     finish: BoxFuture<'static, Result<Root<B, T>, Error<B::Error>>>,
+    /// The stage's height, phantom.
+    ///
+    /// The payloads above are erased; this tag is what the schedule's
+    /// typestates keep proving about them (`PhantomData<fn() -> H>` for
+    /// the auto-trait shortcut; see [`typed::Node`](crate::tree::typed::Node)).
+    height: std::marker::PhantomData<fn() -> H>,
 }
 
 /// The initiator's terminal state: the pending leaf requests, and the
@@ -403,7 +416,7 @@ pub struct Completing<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>
     /// Where each requested leaf will sit, one per request, in order.
     queries: Receiver<Prefix<Z>>,
     /// The requested leaves' resolutions, in request order.
-    returns: ReturnSender<B, T, Z>,
+    returns: Sender<Option<B::Erased>>,
     /// The accumulated work to drive the pipeline.
     work: Work<B, T>,
     /// The future result of the pipeline.
@@ -469,9 +482,11 @@ impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, V: Send> protoco
 pub(crate) async fn greeting_fan<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>(
     backend: &B,
     root: Option<B::Node<height::Root>>,
-) -> Result<Vec<(u8, B::Node<UnderRoot>)>, B::Error> {
+) -> Result<Vec<(u8, B::Erased)>, B::Error> {
     match root {
-        Some(node) => children_of(backend, Prefix::new(), node).await,
+        Some(node) => {
+            erased::ops::children_of(backend, Prefix::new().erase(), B::erase(node)).await
+        }
         None => Ok(Vec::new()),
     }
 }
@@ -484,9 +499,7 @@ pub(crate) async fn greeting_fan<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync
 /// proxy pairs the two positionally, so they must be byte-identical;
 /// routing both through this one function makes drift structurally
 /// impossible rather than a coincidence of two matching code bodies.
-pub(crate) fn fan_listing<N: Node<T>, T: Send + Sync + 'static>(
-    fan: &[(u8, N)],
-) -> Vec<(u8, Hash)> {
+pub(crate) fn fan_listing<E: ErasedNode>(fan: &[(u8, E)]) -> Vec<(u8, Hash)> {
     fan.iter()
         .map(|(radix, node)| (*radix, node.hash()))
         .collect()
@@ -635,6 +648,7 @@ impl<B: Backend<T, Node<Z>: Leaf<T>> + Sync, T: Send + Sync + 'static> protocol:
                 early_supplies: None,
                 work,
                 finish,
+                height: std::marker::PhantomData,
             },
         )
     }
@@ -688,6 +702,7 @@ impl<B: Backend<T, Node<Z>: Leaf<T>> + Sync, T: Send + Sync + 'static> protocol:
                 early_supplies: Some(early),
                 work,
                 finish,
+                height: std::marker::PhantomData,
             },
         )
     }
@@ -707,9 +722,9 @@ impl<B, T, H> protocol::Reply<B, T> for Descending<B, T, S<S<H>>>
 where
     B: Backend<T, Node<Z>: Leaf<T>> + Sync,
     T: Send + Sync + 'static,
-    H: Unknown,
-    S<H>: Unknown,
-    S<S<H>>: Unknown,
+    H: Height,
+    S<H>: Height,
+    S<S<H>>: Height,
     S<S<S<H>>>: Height,
 {
     type Next = Descending<B, T, H>;
@@ -718,7 +733,7 @@ where
         mut self,
         requests: impl Requests<B, T, S<S<H>>>,
     ) -> (BoxResponses<B, T, S<H>, Self::Error>, Self::Next) {
-        let (responses, queries, upper, lower) = self.work.internal_level(
+        let (responses, queries, upper, lower) = self.work.internal_level::<H>(
             self.their_version.clone(),
             self.ledger.clone(),
             self.early_survivors.take(),
@@ -726,8 +741,8 @@ where
             requests,
             self.queries,
         );
-        let returns = self.work.assemble(self.returns, upper);
-        let returns = self.work.assemble(returns, lower);
+        let returns = self.work.assemble(<S<S<H>>>::HEIGHT, self.returns, upper);
+        let returns = self.work.assemble(<S<H>>::HEIGHT, returns, lower);
 
         (
             responses,
@@ -740,6 +755,7 @@ where
                 early_supplies: None,
                 work: self.work,
                 finish: self.finish,
+                height: std::marker::PhantomData,
             },
         )
     }
@@ -766,8 +782,8 @@ where
             requests,
             self.queries,
         );
-        let returns = self.work.assemble(self.returns, upper);
-        let returns = self.work.assemble(returns, lower);
+        let returns = self.work.assemble(<S<Z>>::HEIGHT, self.returns, upper);
+        let returns = self.work.assemble(Z::HEIGHT, returns, lower);
 
         (
             responses,
@@ -821,10 +837,10 @@ where
         requests: impl Requests<B, T, Z>,
     ) -> Result<Root<B, T>, Self::Error> {
         let stats = self.work.stats();
-        let mut absorb = pin!(absorb(
+        let mut absorb = pin!(absorb::<B, T>(
             self.their_version,
             self.ledger,
-            requests,
+            requests.map(erased::erase_reply::<B, T, Z>),
             self.queries,
             self.returns,
             stats,
@@ -858,9 +874,9 @@ where
 async fn absorb<B, T>(
     their_version: Version,
     ledger: SupplyLedger,
-    requests: impl Requests<B, T, Z>,
+    requests: impl futures::Stream<Item = Reply<B::Erased>> + Send,
     mut queries: Receiver<Prefix<Z>>,
-    returns: ReturnSender<B, T, Z>,
+    returns: Sender<Option<B::Erased>>,
     stats: Recorder,
 ) -> Result<(), Error<B::Error>>
 where
diff --git a/src/tree/mirror/streaming/materialized/common.rs b/src/tree/mirror/streaming/materialized/common.rs
index 4eb983357..2f019607b 100644
--- a/src/tree/mirror/streaming/materialized/common.rs
+++ b/src/tree/mirror/streaming/materialized/common.rs
@@ -1,6 +1,8 @@
 use std::pin::pin;
 
-use futures::StreamExt as _;
+use futures::{StreamExt as _, stream};
+#[cfg(not(test))]
+use tokio_stream::wrappers::ReceiverStream;
 
 use crate::tree::{
     mirror::streaming::{Backend, Leaf},
@@ -10,6 +12,8 @@ use crate::tree::{
     },
 };
 
+use super::channel::{QueueRole, Receiver, Sender, channel};
+
 /// Collect one node's children, addressed by radix.
 pub async fn children_of<B, T, H>(
     backend: &B,
@@ -31,3 +35,32 @@ where
     }
     Ok(fan)
 }
+
+/// Create a pair of a sender and a receiver stream, where the receiver
+/// wraps items in `Ok`.
+pub fn ok_channel<T: Send, E>(
+    role: QueueRole,
+    buffer: usize,
+) -> (Sender<T>, OkReceiverStream<T, E>) {
+    ok_channel_with(channel(role, buffer))
+}
+
+fn ok_channel_with<T: Send, E>(
+    (tx, rx): (Sender<T>, Receiver<T>),
+) -> (Sender<T>, OkReceiverStream<T, E>) {
+    #[cfg(test)]
+    {
+        (tx, rx.map(Ok))
+    }
+    #[cfg(not(test))]
+    {
+        (tx, ReceiverStream::new(rx).map(Ok))
+    }
+}
+
+/// The type of a receiver stream wrapping items in `Ok`.
+#[cfg(test)]
+pub type OkReceiverStream<T, E> = stream::Map<Receiver<T>, fn(T) -> Result<T, E>>;
+/// The type of a receiver stream wrapping items in `Ok`.
+#[cfg(not(test))]
+pub type OkReceiverStream<T, E> = stream::Map<ReceiverStream<T>, fn(T) -> Result<T, E>>;
diff --git a/src/tree/mirror/streaming/materialized/progress.rs b/src/tree/mirror/streaming/materialized/progress.rs
index e6beeba24..1495998a7 100644
--- a/src/tree/mirror/streaming/materialized/progress.rs
+++ b/src/tree/mirror/streaming/materialized/progress.rs
@@ -4,14 +4,8 @@ use std::cell::{Cell, RefCell};
 use std::collections::BTreeMap;
 
 use crate::tree::{
-    mirror::streaming::{
-        Backend, Leaf,
-        materialized::{Query, Resolution, Resolve},
-    },
-    typed::{
-        Prefix,
-        height::{Height, S, Z},
-    },
+    mirror::streaming::materialized::{Query, Resolution, Resolve},
+    typed::{ErasedPrefix, Prefix, height::Height},
 };
 
 /// The kind of one observable publication in a work graph.
@@ -440,27 +434,15 @@ pub(super) fn new_work() -> usize {
     })
 }
 
-pub(super) fn wire<H: Height>(work: usize, scope: Prefix<H>) {
+pub(super) fn wire(work: usize, scope: ErasedPrefix) {
     record(work, scope, Kind::Wire);
 }
 
-pub(super) fn initial_query<B, T, H>(work: usize, query: &Query<B, T, H>)
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
-{
+pub(super) fn initial_query<E>(work: usize, query: &Query<E>) {
     record(work, query.prefix, Kind::InitialQuery);
 }
 
-pub(super) fn resolution<B, T, H>(work: usize, resolution: &Resolution<B, T, H>)
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
-{
+pub(super) fn resolution<E>(work: usize, resolution: &Resolution<E>) {
     record(
         work,
         resolution.prefix,
@@ -480,13 +462,7 @@ impl<H: Height> Scoped for Prefix<H> {
     }
 }
 
-impl<B, T, H> Scoped for Query<B, T, H>
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
-{
+impl<E> Scoped for Query<E> {
     fn scope(&self) -> &[u8] {
         self.prefix.as_bytes()
     }
@@ -496,17 +472,11 @@ pub(super) fn dependent(work: usize, item: &impl Scoped) {
     record_bytes(work, item.scope(), Kind::DependentWork);
 }
 
-pub(super) fn ready<H: Height>(work: usize, scope: Prefix<H>) {
+pub(super) fn ready(work: usize, scope: ErasedPrefix) {
     record(work, scope, Kind::Ready);
 }
 
-pub(super) fn parent_resolution<B, T, H>(work: usize, resolution: &Resolution<B, T, H>)
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
-{
+pub(super) fn parent_resolution<E>(work: usize, resolution: &Resolution<E>) {
     record(
         work,
         resolution.prefix,
@@ -516,19 +486,14 @@ where
     );
 }
 
-fn pending<B, T, H>(resolved: &[(u8, Resolve<B, T, H>)]) -> usize
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-{
+fn pending<E>(resolved: &[(u8, Resolve<E>)]) -> usize {
     resolved
         .iter()
         .filter(|(_, slot)| matches!(slot, Resolve::Pending))
         .count()
 }
 
-fn record<H: Height>(work: usize, scope: Prefix<H>, kind: Kind) {
+fn record(work: usize, scope: ErasedPrefix, kind: Kind) {
     record_bytes(work, scope.as_bytes(), kind);
 }
 
diff --git a/src/tree/mirror/streaming/materialized/tests.rs b/src/tree/mirror/streaming/materialized/tests.rs
index 4845fd9e6..18c45f43f 100644
--- a/src/tree/mirror/streaming/materialized/tests.rs
+++ b/src/tree/mirror/streaming/materialized/tests.rs
@@ -22,10 +22,7 @@ use crate::{
     message::Message,
     tree::{
         arb::nth_party,
-        mirror::streaming::{
-            Local,
-            message::{Reaction, Reply},
-        },
+        mirror::streaming::{Backend, Local},
         typed::{
             self, Path, Prefix,
             height::{Height, Z},
@@ -65,14 +62,17 @@ fn absorb_scripted(
     pollster::block_on(queries.send(Prefix::containing(&path))).expect("the loop is live");
     drop(queries);
 
-    let (returns, mut returns_rx) = erased::return_channel::<Local, (), Z>(
+    let (returns, mut returns_rx) = channel::<Option<<Local as Backend<()>>::Erased>>(
         QueueRole::new(QueueKind::TerminalLeafResolutions, Z::HEIGHT),
         1,
     );
 
     let leaf = typed::Node::leaf(leaf_version, Message::new(()));
-    let requests = stream::iter(vec![Reply::<Local, (), Z> {
-        replies: vec![Reaction::Supply(0, leaf)],
+    let requests = stream::iter(vec![erased::Reply {
+        replies: vec![erased::Reaction::Supply(
+            0,
+            <Local as Backend<()>>::erase(leaf),
+        )],
     }]);
 
     let result = pollster::block_on(absorb::<Local, ()>(
@@ -83,7 +83,8 @@ fn absorb_scripted(
         returns,
         Recorder::default(),
     ));
-    let returned = pollster::block_on(async move { returns_rx.recv().await });
+    let returned = pollster::block_on(async move { returns_rx.recv().await })
+        .map(|leaf| leaf.map(<Local as Backend<()>>::assume::<Z>));
     (result, returned)
 }
 
diff --git a/src/tree/mirror/streaming/materialized/transcript.rs b/src/tree/mirror/streaming/materialized/transcript.rs
index 4deecfab4..67fd97180 100644
--- a/src/tree/mirror/streaming/materialized/transcript.rs
+++ b/src/tree/mirror/streaming/materialized/transcript.rs
@@ -21,13 +21,7 @@
 
 use std::cell::RefCell;
 
-use crate::tree::{
-    mirror::streaming::{
-        Backend, Leaf,
-        message::{Reaction, Reply},
-    },
-    typed::height::{Height, Z},
-};
+use crate::tree::mirror::streaming::erased::{Reaction, Reply};
 
 /// One reaction of a captured reply, with every payload erased.
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -91,13 +85,10 @@ pub fn with_transcript<R>(f: impl FnOnce() -> R) -> (R, Transcript) {
     (result, Transcript(sent))
 }
 
-/// Record one outgoing reply, payload-erased.
-pub(super) fn reply<B, T, H>(work: usize, reply: &Reply<B, T, H>)
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-{
+/// Record one outgoing reply, payload-erased; `height` is the reply's
+/// children height (which logical stream it rides), threaded from the
+/// capturing pump's typed exit.
+pub(super) fn reply<E>(work: usize, height: usize, reply: &Reply<E>) {
     let labels = reply
         .replies
         .iter()
@@ -113,7 +104,7 @@ where
         if let Some(sent) = sent.borrow_mut().as_mut() {
             sent.push(Sent {
                 work,
-                height: H::HEIGHT,
+                height,
                 labels,
             });
         }
diff --git a/src/tree/mirror/streaming/materialized/unknown.rs b/src/tree/mirror/streaming/materialized/unknown.rs
index d4de629d2..4a5f19d47 100644
--- a/src/tree/mirror/streaming/materialized/unknown.rs
+++ b/src/tree/mirror/streaming/materialized/unknown.rs
@@ -14,24 +14,23 @@
 //! single recursing node, so it stays constant-memory and reusable across the
 //! in-memory and persistent backends alike.
 //!
-//! Every level returns a [`BoxFuture`]: an `impl Future` return would nest
-//! each level's `async` type inside the next, ballooning the compiler's type
-//! exponentially over the 32-level descent. Erasing to a trait object at each
-//! step keeps the type flat, and its `Send`-ness asserted rather than proven
-//! through the whole tower.
+//! The walk runs on erased nodes, its level named by its prefix's byte
+//! length: one instantiation per backend, where a height-typed recursion
+//! would mint one per level. Each recursive call boxes its future
+//! ([`BoxFuture`]) exactly as the typed tower did — the type stays flat —
+//! and the depth is bounded by the prefix's remaining height, at most 32,
+//! so the recursion is stack-safe by construction rather than by input
+//! goodwill.
 
-use futures::future::{self, BoxFuture, FutureExt};
+use futures::future::{BoxFuture, FutureExt};
 
 use before::Dominance;
 
 use crate::{
     Version, causally,
     tree::{
-        mirror::streaming::{Backend, Leaf, Node, materialized::children_of, stats::Recorder},
-        typed::{
-            Prefix,
-            height::{Height, S, Z},
-        },
+        mirror::streaming::{Backend, ErasedNode, Leaf, erased::ops, stats::Recorder},
+        typed::{ErasedPrefix, height::Z},
     },
 };
 
@@ -41,7 +40,7 @@ use crate::{
 ///
 /// A concurrent ceiling is beyond the known-at range and is *not* known:
 /// it carries history the counterparty has never seen.
-pub(super) fn known<T: Send + Sync + 'static>(node: &impl Node<T>, version: &Version) -> bool {
+pub(super) fn known(node: &impl ErasedNode, version: &Version) -> bool {
     causally::before(version).contains(node.span().hi())
 }
 
@@ -56,14 +55,14 @@ pub(super) fn known<T: Send + Sync + 'static>(node: &impl Node<T>, version: &Ver
 /// [`Between`](Dominance::Between) means mixed, so the
 /// caller descends.
 ///
-/// The backend hands out its own stored bounds ([`Node::span`]) and the
-/// span answers in one fused walk that decodes `known` once, where
+/// The backend hands out its own stored bounds ([`ErasedNode::span`]) and
+/// the span answers in one fused walk that decodes `known` once, where
 /// placing the two bounds separately would decode it once per bound;
 /// the span's ordering is the backend's construction-time obligation,
 /// so no validating comparison is paid per classification. The cheap
 /// unknown-subtree exit survives the fusion: `floor <= known` refuted
 /// is the whole verdict, decided at the first refuting interval.
-fn knowledge<T: Send + Sync + 'static>(node: &impl Node<T>, known: &Version) -> Dominance {
+fn knowledge(node: &impl ErasedNode, known: &Version) -> Dominance {
     node.span().dominance(known)
 }
 
@@ -75,19 +74,54 @@ fn knowledge<T: Send + Sync + 'static>(node: &impl Node<T>, known: &Version) ->
 /// [`messages_shed`](crate::SessionStats::messages_shed): one per dropped
 /// leaf, a whole subtree's exact leaf count when the cached version bounds
 /// prune it without descending.
-pub(super) fn unknown<'a, B, T, H>(
+pub(super) fn unknown<'a, B, T>(
     backend: &'a B,
     known: &'a Version,
-    prefix: Prefix<H>,
-    node: B::Node<H>,
+    prefix: ErasedPrefix,
+    node: B::Erased,
     stats: &'a Recorder,
-) -> BoxFuture<'a, Result<Option<B::Node<H>>, B::Error>>
+) -> BoxFuture<'a, Result<Option<B::Erased>, B::Error>>
 where
     B: Backend<T, Node<Z>: Leaf<T>> + Sync,
     T: Send + Sync + 'static,
-    H: Unknown,
 {
-    H::unknown(backend, known, prefix, node, stats)
+    async move {
+        if prefix.height() == 0 {
+            // A leaf is known iff its ceiling is causally at or before
+            // `known`; a concurrent ceiling is beyond the known-at range,
+            // so those survive.
+            let verdict = Some(node).filter(|node| !self::known(node, known));
+            if verdict.is_none() {
+                stats.shed(1);
+            }
+            return Ok(verdict);
+        }
+
+        match knowledge(&node, known) {
+            // Wholly unknown: the whole subtree travels.
+            Dominance::Before => return Ok(Some(node)),
+            // Wholly known: nothing under the node needs to travel.
+            Dominance::After => {
+                stats.shed(node.len() as u64);
+                return Ok(None);
+            }
+            Dominance::Between => {}
+        }
+
+        // Mixed: descend. Explode just this node one level, prune its
+        // children, and reassemble the survivors from the pruned radix
+        // group — `None` entries are the children that pruned away. A group
+        // that prunes away entirely reassembles to `None`, reporting the
+        // whole node known one level up.
+        let children = ops::children_of(backend, prefix, node).await?;
+        let mut group = Vec::with_capacity(children.len());
+        for (radix, child) in children {
+            let survivor = unknown(backend, known, prefix.push(radix), child, stats).await?;
+            group.push((radix, survivor));
+        }
+        ops::parent(backend.clone(), prefix, group).await
+    }
+    .boxed()
 }
 
 /// The top of the recursion, exposed: prune one subtree and report both the
@@ -96,23 +130,21 @@ where
 /// Reporting the children lets an answerer emit them as `Supply` reactions
 /// without re-querying the prefix it just explored (the one-query-per-prefix
 /// invariant; see [`super`]).
-pub(super) async fn unknown_providing<B, T, H>(
+pub(super) async fn unknown_providing<B, T>(
     backend: &B,
     known: &Version,
-    prefix: Prefix<S<H>>,
-    node: B::Node<S<H>>,
+    prefix: ErasedPrefix,
+    node: B::Erased,
     stats: &Recorder,
-) -> Result<(Option<B::Node<S<H>>>, Vec<(u8, B::Node<H>)>), B::Error>
+) -> Result<(Option<B::Erased>, Vec<(u8, B::Erased)>), B::Error>
 where
     B: Backend<T, Node<Z>: Leaf<T>> + Sync,
     T: Send + Sync + 'static,
-    H: Unknown,
-    S<H>: Height,
 {
     match knowledge(&node, known) {
         // Wholly unknown: the whole subtree travels.
         Dominance::Before => {
-            let children = children_of(backend, prefix, node.clone()).await?;
+            let children = ops::children_of(backend, prefix, node.clone()).await?;
             return Ok((Some(node), children));
         }
         // Wholly known: nothing under the node needs to travel.
@@ -125,103 +157,20 @@ where
 
     // Mixed: prune the children one by one; the surviving group is both the
     // provision list and the material `parent` rebuilds the survivor from.
-    let children = children_of(backend, prefix, node).await?;
+    let children = ops::children_of(backend, prefix, node).await?;
     let mut group = Vec::with_capacity(children.len());
     let mut survivors = Vec::new();
     for (radix, child) in children {
-        let survivor = H::unknown(backend, known, prefix.push(radix), child, stats).await?;
+        let survivor = unknown(backend, known, prefix.push(radix), child, stats).await?;
         if let Some(survivor) = &survivor {
             survivors.push((radix, survivor.clone()));
         }
         group.push((radix, survivor));
     }
-    Ok((backend.clone().parent(prefix, group).await?, survivors))
-}
-
-/// The inductive step of the streaming filter, implemented per [`Height`].
-///
-/// Each level classifies a node by its memoized version bounds before
-/// descending, reproducing the verdicts of
-/// [`traverse::unknown::Unknown`](crate::tree::traverse::unknown::Unknown)
-/// node for node.
-pub trait Unknown: Height {
-    /// Prune one node at this height. See [`unknown`].
-    fn unknown<'a, B, T>(
-        backend: &'a B,
-        known: &'a Version,
-        prefix: Prefix<Self>,
-        node: B::Node<Self>,
-        stats: &'a Recorder,
-    ) -> BoxFuture<'a, Result<Option<B::Node<Self>>, B::Error>>
-    where
-        B: Backend<T, Node<Z>: Leaf<T>> + Sync,
-        T: Send + Sync + 'static;
-}
-
-impl Unknown for Z {
-    fn unknown<'a, B, T>(
-        _backend: &'a B,
-        known: &'a Version,
-        _prefix: Prefix<Z>,
-        node: B::Node<Z>,
-        stats: &'a Recorder,
-    ) -> BoxFuture<'a, Result<Option<B::Node<Z>>, B::Error>>
-    where
-        B: Backend<T, Node<Z>: Leaf<T>> + Sync,
-        T: Send + Sync + 'static,
-    {
-        // A leaf is known iff its ceiling is causally at or before `known`;
-        // a concurrent ceiling is beyond the known-at range, so those survive.
-        let verdict = Some(node).filter(|node| !self::known(node, known));
-        if verdict.is_none() {
-            stats.shed(1);
-        }
-        future::ready(Ok(verdict)).boxed()
-    }
-}
-
-impl<H> Unknown for S<H>
-where
-    H: Unknown,
-    S<H>: Height,
-{
-    fn unknown<'a, B, T>(
-        backend: &'a B,
-        known: &'a Version,
-        prefix: Prefix<S<H>>,
-        node: B::Node<S<H>>,
-        stats: &'a Recorder,
-    ) -> BoxFuture<'a, Result<Option<B::Node<S<H>>>, B::Error>>
-    where
-        B: Backend<T, Node<Z>: Leaf<T>> + Sync,
-        T: Send + Sync + 'static,
-    {
-        Box::pin(async move {
-            match knowledge(&node, known) {
-                // Wholly unknown: the whole subtree travels.
-                Dominance::Before => return Ok(Some(node)),
-                // Wholly known: nothing under the node needs to travel.
-                Dominance::After => {
-                    stats.shed(node.len() as u64);
-                    return Ok(None);
-                }
-                Dominance::Between => {}
-            }
-
-            // Mixed: descend. Explode just this node one level, prune its
-            // children, and reassemble the survivors from the pruned radix
-            // group — `None` entries are the children that pruned away. A group
-            // that prunes away entirely reassembles to `None`, reporting the
-            // whole node known one level up.
-            let children = children_of(backend, prefix, node).await?;
-            let mut group = Vec::with_capacity(children.len());
-            for (radix, child) in children {
-                let survivor = H::unknown(backend, known, prefix.push(radix), child, stats).await?;
-                group.push((radix, survivor));
-            }
-            backend.clone().parent(prefix, group).await
-        })
-    }
+    Ok((
+        ops::parent(backend.clone(), prefix, group).await?,
+        survivors,
+    ))
 }
 
 #[cfg(test)]
diff --git a/src/tree/mirror/streaming/materialized/unknown/tests.rs b/src/tree/mirror/streaming/materialized/unknown/tests.rs
index f60e0ac1a..cc5151143 100644
--- a/src/tree/mirror/streaming/materialized/unknown/tests.rs
+++ b/src/tree/mirror/streaming/materialized/unknown/tests.rs
@@ -11,7 +11,7 @@ use crate::{
     message::Message,
     tree::{
         arb::nth_party,
-        mirror::streaming::{Local, materialized::unknown::unknown},
+        mirror::streaming::{Backend, Local, materialized::unknown::unknown},
         traverse::{Action, act, unknown::Unknown},
         typed::{self, Path, Prefix, height::Root},
     },
@@ -54,14 +54,15 @@ fn stream_prune(
     known: &Version,
 ) -> Option<typed::node::Root<()>> {
     root.and_then(|node| {
-        pollster::block_on(unknown::<Local, (), Root>(
+        pollster::block_on(unknown::<Local, ()>(
             &Local,
             known,
-            Prefix::new(),
-            node,
+            Prefix::new().erase(),
+            <Local as Backend<()>>::erase(node),
             &Recorder::default(),
         ))
         .unwrap_or_else(|e| match e {})
+        .map(<Local as Backend<()>>::assume::<Root>)
     })
 }
 
diff --git a/src/tree/mirror/streaming/materialized/work.rs b/src/tree/mirror/streaming/materialized/work.rs
index 201f131f7..0a41b15e2 100644
--- a/src/tree/mirror/streaming/materialized/work.rs
+++ b/src/tree/mirror/streaming/materialized/work.rs
@@ -5,11 +5,17 @@
 //! reconstructs their resolved scopes upward. The terminal protocol state
 //! drives the accumulated tasks and its final result through one shared
 //! fail-fast completion primitive.
+//!
+//! The walks and pumps run on the erased vocabulary (see
+//! [`erased`]): one instantiation
+//! per backend. The typed surface is the thin boundary the protocol
+//! schedule sees — [`Work::respond`]'s [`BoxResponses`] exit re-tags each
+//! outgoing reply at its stage's height, and each walk's public method
+//! erases its typed request stream on the way in.
 
-use std::pin::pin;
+use std::pin::Pin;
 
-use futures::{Stream, future::BoxFuture};
-use tokio_stream::StreamExt;
+use futures::{Stream, StreamExt, future::BoxFuture};
 
 mod answer;
 mod assembly;
@@ -21,10 +27,9 @@ mod resolver;
 use super::{progress, transcript};
 use crate::tree::{
     mirror::streaming::{
-        Backend, Leaf,
-        erased::ReturnSender,
-        materialized::Error,
-        protocol::{BoxResponses, Responses},
+        Backend, Leaf, erased,
+        materialized::{Error, channel::Sender},
+        protocol::BoxResponses,
         stats::Recorder,
         tasks::{complete, park_after_published_error},
         window::Window,
@@ -79,47 +84,31 @@ where
         self.stats.clone()
     }
 
-    /// Add a task which actively drives a response stream.
-    ///
-    /// One buffered response is sufficient: whenever the pump blocks, that
-    /// response is already available to advance the counterparty and release
-    /// the slot. Buffering a fan would retain whole protocol messages without
-    /// breaking any additional dependency.
+    /// Add a task which actively drives a response stream, and return the
+    /// stream's typed exit: the one point where a walk's erased replies
+    /// re-tag at their stage's height.
     fn respond<H: Height>(
         &mut self,
-        messages: impl Responses<B, T, H, Error<B::Error>>,
+        messages: impl Stream<Item = Result<erased::Reply<B::Erased>, Error<B::Error>>> + Send + 'static,
     ) -> BoxResponses<B, T, H, Error<B::Error>> {
-        let (send, responses) = outgoing_responses();
-        #[cfg(test)]
-        let work = self.trace_id;
-        self.tasks.push(Box::pin(async move {
-            let mut messages = pin!(messages);
-            while let Some(item) = messages.next().await {
-                // Capture the payload-erased wire transcript at the pump:
-                // per-stream pull order is exactly the wire order.
-                #[cfg(test)]
-                if let Ok(reply) = &item {
-                    transcript::reply(work, reply);
-                }
-                let failed = item.is_err();
-                if send.send(item).await.is_err() {
-                    return Ok(());
-                }
-                park_after_published_error(failed).await;
-            }
-            Ok::<(), Error<B::Error>>(())
-        }));
-        responses
+        let (send, responses) = outgoing_responses::<B, T, H>();
+        self.tasks.push(Box::pin(pump(
+            Box::pin(messages),
+            send,
+            #[cfg(test)]
+            (self.trace_id, H::HEIGHT),
+        )));
+        Box::pin(responses)
     }
 
     /// Forward a stream of nodes into an upward return channel.
-    fn return_into<H: Height>(
+    fn return_into(
         &mut self,
-        returns: ReturnSender<B, T, H>,
-        stream: impl Stream<Item = Result<Option<B::Node<H>>, Error<B::Error>>> + Send + 'static,
+        returns: Sender<Option<B::Erased>>,
+        stream: impl Stream<Item = Result<Option<B::Erased>, Error<B::Error>>> + Send + 'static,
     ) {
         self.tasks.push(Box::pin(async move {
-            let mut stream = pin!(stream);
+            let mut stream = std::pin::pin!(stream);
             while let Some(item) = stream.next().await {
                 if returns.send(item?).await.is_err() {
                     return Ok(());
@@ -138,5 +127,32 @@ where
     }
 }
 
+/// Drive one walk's response stream into its outgoing edge.
+///
+/// One buffered response is sufficient: whenever the pump blocks, that
+/// response is already available to advance the counterparty and release
+/// the slot. Buffering a fan would retain whole protocol messages without
+/// breaking another dependency.
+async fn pump<E: Send, Err: Send + 'static>(
+    mut messages: Pin<Box<dyn Stream<Item = Result<erased::Reply<E>, Error<Err>>> + Send>>,
+    send: Sender<Result<erased::Reply<E>, Error<Err>>>,
+    #[cfg(test)] (work, height): (usize, usize),
+) -> Result<(), Error<Err>> {
+    while let Some(item) = messages.next().await {
+        // Capture the payload-erased wire transcript at the pump:
+        // per-stream pull order is exactly the wire order.
+        #[cfg(test)]
+        if let Ok(reply) = &item {
+            transcript::reply(work, height, reply);
+        }
+        let failed = item.is_err();
+        if send.send(item).await.is_err() {
+            return Ok(());
+        }
+        park_after_published_error(failed).await;
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests;
diff --git a/src/tree/mirror/streaming/materialized/work/answer.rs b/src/tree/mirror/streaming/materialized/work/answer.rs
index e65a84020..d3bdc5041 100644
--- a/src/tree/mirror/streaming/materialized/work/answer.rs
+++ b/src/tree/mirror/streaming/materialized/work/answer.rs
@@ -4,23 +4,23 @@ use crate::{
     Version,
     tree::{
         mirror::streaming::{
-            Backend, Leaf, Node,
+            Backend, ErasedNode, Leaf,
+            erased::{Reaction, ops},
             materialized::{
-                Query, Resolve, Violation, children_of,
-                unknown::{Unknown, known, unknown},
+                Query, Resolve, Violation,
+                unknown::{known, unknown},
             },
-            message::Reaction,
             stats::Recorder,
         },
-        typed::{
-            Hash, Prefix,
-            height::{Height, S, Z},
-        },
+        typed::{ErasedPrefix, Hash, Prefix, height::Z},
     },
 };
 
 /// Answer one nonempty internal query by merge-joining both child listings.
 ///
+/// `prefix` names the queried scope; `ours` are our children of it, one
+/// level below.
+///
 /// This merge-join is the chokepoint where
 /// [`disputed_scopes`](crate::SessionStats::disputed_scopes) is counted: it
 /// runs exactly once per scope this side resolves, and the scope was a
@@ -28,27 +28,25 @@ use crate::{
 /// held the subtree) and some child failed to match. An all-match join is a
 /// confirmation, not a dispute, and a one-sided join is a request being
 /// served.
-pub(super) async fn internal<B, T, H>(
+#[allow(clippy::type_complexity)]
+pub(super) async fn internal<B, T>(
     backend: &B,
     their_version: &Version,
-    prefix: Prefix<S<S<H>>>,
-    ours: Vec<(u8, B::Node<S<H>>)>,
+    prefix: ErasedPrefix,
+    ours: Vec<(u8, B::Erased)>,
     theirs: Vec<(u8, Hash)>,
     stats: &Recorder,
 ) -> Result<
     (
-        Vec<Reaction<B, T, S<H>>>,
-        Vec<Query<B, T, H>>,
-        Vec<(u8, Resolve<B, T, S<H>>)>,
+        Vec<Reaction<B::Erased>>,
+        Vec<Query<B::Erased>>,
+        Vec<(u8, Resolve<B::Erased>)>,
     ),
     B::Error,
 >
 where
     B: Backend<T, Node<Z>: Leaf<T>> + Sync,
     T: Send + Sync + 'static,
-    H: Unknown,
-    S<H>: Unknown,
-    S<S<H>>: Height,
 {
     let mut reactions = Vec::new();
     let mut asked = Vec::new();
@@ -68,7 +66,7 @@ where
             EitherOrBoth::Both((radix, node), _) => {
                 differed = true;
                 let prefix = prefix.push(radix);
-                let ours = children_of(backend, prefix, node).await?;
+                let ours = ops::children_of(backend, prefix, node).await?;
                 reactions.push(Reaction::Query(
                     ours.iter()
                         .map(|(radix, child)| (*radix, child.hash()))
@@ -113,21 +111,14 @@ where
 /// were non-empty and some leaf sat on one side alone. Each exclusive local
 /// leaf the causal filter drops is one deletion honored
 /// ([`messages_shed`](crate::SessionStats::messages_shed)).
-pub(super) fn leaf_parent<B, T>(
+#[allow(clippy::type_complexity)]
+pub(super) fn leaf_parent<E: ErasedNode + Clone>(
     their_version: &Version,
-    prefix: Prefix<S<Z>>,
-    ours: Vec<(u8, B::Node<Z>)>,
+    prefix: ErasedPrefix,
+    ours: Vec<(u8, E)>,
     theirs: Vec<(u8, Hash)>,
     stats: &Recorder,
-) -> (
-    Vec<Reaction<B, T, Z>>,
-    Vec<Prefix<Z>>,
-    Vec<(u8, Resolve<B, T, Z>)>,
-)
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-{
+) -> (Vec<Reaction<E>>, Vec<Prefix<Z>>, Vec<(u8, Resolve<E>)>) {
     let mut reactions = Vec::new();
     let mut asked = Vec::new();
     let mut resolved = Vec::new();
@@ -156,7 +147,10 @@ where
             EitherOrBoth::Right((radix, _)) => {
                 differed = true;
                 reactions.push(Reaction::Query(Vec::new()));
-                asked.push(prefix.push(radix));
+                // A leaf-parent scope's child prefix is a full 32-byte
+                // path: the length witness makes the leaf-height re-tag
+                // exact.
+                asked.push(prefix.push(radix).assume::<Z>());
                 resolved.push((radix, Resolve::Pending));
             }
         }
@@ -176,17 +170,13 @@ where
 /// listing here is a protocol violation), so no dispute is counted. A
 /// requested leaf the causal filter drops is one deletion honored
 /// ([`messages_shed`](crate::SessionStats::messages_shed)).
-pub(super) fn leaf<B, T>(
+pub(super) fn leaf<E: ErasedNode + Clone>(
     their_version: &Version,
     radix: u8,
-    node: B::Node<Z>,
+    node: E,
     listing: Vec<(u8, Hash)>,
     stats: &Recorder,
-) -> Result<(Vec<Reaction<B, T, Z>>, Option<B::Node<Z>>), Violation>
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-{
+) -> Result<(Vec<Reaction<E>>, Option<E>), Violation> {
     if !listing.is_empty() {
         return Err(Violation::UnexpectedQuery);
     }
diff --git a/src/tree/mirror/streaming/materialized/work/assembly.rs b/src/tree/mirror/streaming/materialized/work/assembly.rs
index 728aec2ec..c35113f2b 100644
--- a/src/tree/mirror/streaming/materialized/work/assembly.rs
+++ b/src/tree/mirror/streaming/materialized/work/assembly.rs
@@ -10,11 +10,11 @@ use super::{Work, queues::assembly_level_returns};
 use crate::tree::{
     mirror::streaming::{
         Backend, Leaf,
-        erased::ReturnSender,
-        materialized::{Error, Resolution, Resolve},
+        erased::ops,
+        materialized::{Error, Resolution, Resolve, channel::Sender},
         tasks::next_or_cancelled,
     },
-    typed::height::{Height, S, Z},
+    typed::height::Z,
 };
 
 impl<B, T> Work<B, T>
@@ -24,19 +24,19 @@ where
 {
     /// Assemble one level upward and return its lower-level sender.
     ///
+    /// `height` is the resolutions' children height, labeling the level
+    /// boundary's queue for the instrumented diagnostics.
+    ///
     /// A full fan lets every lower scope enqueue before the parent resolution
     /// containing its [`Resolve::Pending`] slots is published, without relying
     /// on blocked sender futures remaining independently runnable.
-    pub fn assemble<H>(
+    pub fn assemble(
         &mut self,
-        returns: ReturnSender<B, T, S<H>>,
-        resolutions: impl Stream<Item = Result<Resolution<B, T, H>, Error<B::Error>>> + Send + 'static,
-    ) -> ReturnSender<B, T, H>
-    where
-        H: Height,
-        S<H>: Height,
-    {
-        let (level, level_rx) = assembly_level_returns::<B, T, H>();
+        height: usize,
+        returns: Sender<Option<B::Erased>>,
+        resolutions: impl Stream<Item = Result<Resolution<B::Erased>, Error<B::Error>>> + Send + 'static,
+    ) -> Sender<Option<B::Erased>> {
+        let (level, level_rx) = assembly_level_returns::<B, T>(height);
         self.return_into(
             returns,
             assemble(self.backend.clone(), resolutions, level_rx),
@@ -47,8 +47,8 @@ where
     /// Assemble leaf resolutions upward with no level beneath them.
     pub fn assemble_leaves(
         &mut self,
-        returns: ReturnSender<B, T, S<Z>>,
-        resolutions: impl Stream<Item = Result<Resolution<B, T, Z>, Error<B::Error>>> + Send + 'static,
+        returns: Sender<Option<B::Erased>>,
+        resolutions: impl Stream<Item = Result<Resolution<B::Erased>, Error<B::Error>>> + Send + 'static,
     ) {
         self.return_into(
             returns,
@@ -62,13 +62,14 @@ where
 /// Pairing is positional: resolutions arrive in query order and `level`
 /// carries one item per `Pending` in that same order. An empty resolution
 /// reaches [`Backend::parent`] with an empty group and resolves to `None`.
-pub(super) fn assemble<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height>(
+pub(super) fn assemble<B, T>(
     backend: B,
-    resolutions: impl Stream<Item = Result<Resolution<B, T, H>, Error<B::Error>>> + Send,
-    level: impl Stream<Item = Result<Option<B::Node<H>>, Error<B::Error>>> + Send,
-) -> impl Stream<Item = Result<Option<B::Node<S<H>>>, Error<B::Error>>> + Send
+    resolutions: impl Stream<Item = Result<Resolution<B::Erased>, Error<B::Error>>> + Send,
+    level: impl Stream<Item = Result<Option<B::Erased>, Error<B::Error>>> + Send,
+) -> impl Stream<Item = Result<Option<B::Erased>, Error<B::Error>>> + Send
 where
-    S<H>: Height,
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
 {
     try_stream! {
         let mut level = pin!(level.fuse());
@@ -86,7 +87,7 @@ where
                     }
                 }));
             }
-            yield backend.clone().parent(prefix, children).await?;
+            yield ops::parent(backend.clone(), prefix, children).await?;
         }
     }
 }
diff --git a/src/tree/mirror/streaming/materialized/work/levels.rs b/src/tree/mirror/streaming/materialized/work/levels.rs
index 2bc5ca0b2..2254aef58 100644
--- a/src/tree/mirror/streaming/materialized/work/levels.rs
+++ b/src/tree/mirror/streaming/materialized/work/levels.rs
@@ -1,13 +1,19 @@
 //! Phase-specific materialized reconciliation walks.
+//!
+//! Every walk body runs on the erased vocabulary — one instantiation per
+//! backend — behind a thin typed method that erases the stage's request
+//! stream on the way in and re-tags its responses on the way out
+//! ([`Work::respond`]). The generic methods carry the type-level height
+//! the schedule proves; the walk bodies carry it as the runtime witness
+//! every scope's prefix length *is*.
 
 use std::collections::BTreeMap;
 use std::pin::pin;
 
 use async_stream::try_stream;
 use before::Version;
-use futures::future::BoxFuture;
+use futures::{Stream, StreamExt, future::BoxFuture, stream::BoxStream};
 use tokio::sync::oneshot;
-use tokio_stream::StreamExt;
 
 use super::{Work, answer, assembly::assemble, queues::*, resolver::Resolver};
 #[cfg(test)]
@@ -15,16 +21,15 @@ use crate::tree::mirror::streaming::materialized::progress;
 use crate::tree::{
     mirror::contained,
     mirror::streaming::{
-        Backend, Leaf, Node, Root,
-        erased::{QueryReceiver, ResolutionOkStream, ReturnSender},
+        Backend, ErasedNode, Leaf, Root,
+        erased::{self, Reaction, Reply},
         materialized::{
-            Error, Query, Resolution, Resolve, SupplyLedger, Violation,
-            channel::Receiver,
-            children_of, fan_listing,
-            unknown::{Unknown, unknown, unknown_providing},
+            Error, OkReceiverStream, Query, Resolution, Resolve, SupplyLedger, Violation,
+            channel::{Receiver, Sender},
+            fan_listing,
+            unknown::{unknown, unknown_providing},
             violation,
         },
-        message::{self, Reaction, Reply},
         protocol::{BoxResponses, Requests},
         tasks::next_or_cancelled,
     },
@@ -34,6 +39,11 @@ use crate::tree::{
     },
 };
 
+/// A request stream already erased and boxed at the walk boundary: what
+/// every walk body consumes, so each body instantiates once per backend
+/// rather than once per concrete schedule stream.
+type Replies<E> = BoxStream<'static, Reply<E>>;
+
 impl<B, T> Work<B, T>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
@@ -55,23 +65,24 @@ where
     /// handed to the next level through the returned channel, so the root
     /// resolution answers the responder's now-vestigial empty queries from
     /// local state instead of re-walking the subtrees.
+    #[allow(clippy::type_complexity)]
     pub fn initiator_level(
         &mut self,
         their_version: Version,
         ceiling: Version,
-        fan: Vec<(u8, B::Node<UnderRoot>)>,
+        fan: Vec<(u8, B::Erased)>,
         their_listing: Vec<(u8, Hash)>,
     ) -> (
         BoxResponses<B, T, UnderRoot, Error<B::Error>>,
-        QueryReceiver<B, T, UnderRoot>,
-        ReturnSender<B, T, height::Root>,
-        oneshot::Receiver<Vec<(u8, Option<B::Node<UnderRoot>>)>>,
+        Receiver<Query<B::Erased>>,
+        Sender<Option<B::Erased>>,
+        oneshot::Receiver<Vec<(u8, Option<B::Erased>)>>,
         BoxFuture<'static, Result<Root<B, T>, Error<B::Error>>>,
     )
     where
         B: Sync,
     {
-        let (queries, queries_rx) = initiator_root_query();
+        let (queries, queries_rx) = initiator_root_query::<B, T>();
         let (returns, mut returns_rx) = initiator_root_return::<B, T>();
         let (early_tx, early_rx) = oneshot::channel();
         let backend = self.backend();
@@ -80,6 +91,7 @@ where
         let trace_id = self.trace_id;
 
         let responses = try_stream! {
+            let root_scope = Prefix::new().erase();
             // The Left-arm-only merge over (fan, their listing): exclusive
             // root children, pruned, in radix order. Asking no question, it
             // adds no question-owner anywhere: every scope keeps exactly one.
@@ -97,10 +109,10 @@ where
             let mut early = Vec::new();
             for (radix, node) in exclusive {
                 let survivor =
-                    unknown(&backend, &their_version, Prefix::new().push(radix), node, &stats)
+                    unknown(&backend, &their_version, root_scope.push(radix), node, &stats)
                         .await?;
                 if let Some(survivor) = &survivor {
-                    supplies.push(message::Reaction::Supply(radix, survivor.clone()));
+                    supplies.push(Reaction::Supply(radix, survivor.clone()));
                 }
                 early.push((radix, survivor));
             }
@@ -108,14 +120,14 @@ where
             // never waits: its first query cannot arrive earlier.
             let _ = early_tx.send(early);
             #[cfg(test)]
-            progress::wire(trace_id, Prefix::new());
+            progress::wire(trace_id, root_scope);
             yield Reply {
-                replies: std::iter::once(message::Reaction::Query(fan_listing(&fan)))
+                replies: std::iter::once(Reaction::Query(fan_listing(&fan)))
                     .chain(supplies)
                     .collect(),
             };
             let query = Query {
-                prefix: Prefix::new(),
+                prefix: root_scope,
                 ours: fan,
             };
             #[cfg(test)]
@@ -127,11 +139,17 @@ where
 
         let finish = Box::pin(async move {
             let root = next_or_cancelled(returns_rx.recv()).await;
-            Ok(Root { ceiling, root })
+            Ok(Root {
+                ceiling,
+                // The root return is this walk's one fixed-height re-tag:
+                // the initiator's single return channel carries exactly the
+                // reconciled root.
+                root: root.map(B::assume::<height::Root>),
+            })
         });
 
         (
-            self.respond(responses),
+            self.respond::<UnderRoot>(responses),
             queries_rx,
             returns,
             early_rx,
@@ -160,40 +178,43 @@ where
         their_version: Version,
         ledger: SupplyLedger,
         ceiling: Version,
-        fan: Vec<(u8, B::Node<UnderRoot>)>,
+        fan: Vec<(u8, B::Erased)>,
         requests: impl Requests<B, T, UnderRoot>,
     ) -> (
         BoxResponses<B, T, UnderRoot, Error<B::Error>>,
-        QueryReceiver<B, T, UnderUnderRoot>,
-        ReturnSender<B, T, UnderRoot>,
-        oneshot::Receiver<Vec<(u8, Vec<(u8, B::Node<UnderUnderRoot>)>)>>,
+        Receiver<Query<B::Erased>>,
+        Sender<Option<B::Erased>>,
+        oneshot::Receiver<Vec<(u8, Vec<(u8, B::Erased)>)>>,
         BoxFuture<'static, Result<Root<B, T>, Error<B::Error>>>,
     )
     where
         B: Sync,
     {
+        let requests: Replies<B::Erased> =
+            Box::pin(requests.map(erased::erase_reply::<B, T, UnderRoot>));
         let backend = self.backend();
         let stats = self.stats.clone();
         let (asked, asked_rx) =
-            responder_child_queries(self.window.capacity(UnderUnderRoot::HEIGHT));
-        let (resolution, resolution_rx) = responder_root_resolution();
+            responder_child_queries::<B, T>(self.window.capacity(UnderUnderRoot::HEIGHT));
+        let (resolution, resolution_rx) = responder_root_resolution::<B, T>();
         let (early_tx, early_rx) = oneshot::channel();
         let assembling = backend.clone();
         #[cfg(test)]
         let trace_id = self.trace_id;
 
         let responses = try_stream! {
-            let mut requests = pin!(requests);
+            let mut requests = requests;
+            let root_scope = Prefix::new().erase();
             let Some(Reply { replies }) = requests.next().await else {
                 return violation(Violation::UnansweredQuery)?;
             };
             let mut reactions = replies.into_iter();
-            let Some(message::Reaction::Query(theirs)) = reactions.next() else {
+            let Some(Reaction::Query(theirs)) = reactions.next() else {
                 return violation(Violation::UnexpectedQuery)?;
             };
             let mut early = Vec::new();
             for reaction in reactions {
-                let message::Reaction::Supply(radix, node) = reaction else {
+                let Reaction::Supply(radix, node) = reaction else {
                     return violation(Violation::UnexpectedQuery)?;
                 };
                 // Early supplies are absorbed here, ahead of the descent's
@@ -206,7 +227,7 @@ where
                 }
                 ledger.absorb(node.len() as u64)?;
                 let children =
-                    children_of(&backend, Prefix::new().push(radix), node).await?;
+                    erased::ops::children_of(&backend, root_scope.push(radix), node).await?;
                 early.push((radix, children));
             }
             // Filled before this reply yields, so the level consuming it
@@ -214,13 +235,13 @@ where
             let _ = early_tx.send(early);
             let ours = fan;
             let (reactions, next_queries, resolved) =
-                answer::internal(&backend, &their_version, Prefix::new(), ours, theirs, &stats)
+                answer::internal(&backend, &their_version, root_scope, ours, theirs, &stats)
                     .await?;
             yield_resolve_query!(
-                trace_id, Prefix::new();
+                trace_id, root_scope;
                 yield Reply { replies: reactions };
                 resolution => Resolution {
-                    prefix: Prefix::new(),
+                    prefix: root_scope,
                     resolved,
                 };
                 asked => next_queries;
@@ -234,14 +255,29 @@ where
             let root = next_or_cancelled(assembled.next()).await;
             Ok(Root {
                 ceiling,
-                root: root?,
+                // The responder's root assembles at the top of the return
+                // chain: the same one fixed-height re-tag as the
+                // initiator's.
+                root: root?.map(B::assume::<height::Root>),
             })
         });
 
-        (self.respond(responses), asked_rx, returns, early_rx, finish)
+        (
+            self.respond::<UnderRoot>(responses),
+            asked_rx,
+            returns,
+            early_rx,
+            finish,
+        )
     }
 
-    /// Walk an internal level, where disputes recur into another internal level.
+    /// Walk an internal level, where disputes recur into another internal
+    /// level.
+    ///
+    /// `H` is the height the walk's dependent queries descend to; the
+    /// walk's own scopes sit two levels above it, exactly as the schedule's
+    /// [`Reply`](crate::tree::mirror::streaming::protocol::Reply)
+    /// transition demands.
     ///
     /// The two `early_*` channels are the opening exchange's hand-off into
     /// the one instance that resolves root scopes; every deeper instance
@@ -263,38 +299,86 @@ where
         &mut self,
         their_version: Version,
         ledger: SupplyLedger,
-        early_survivors: Option<oneshot::Receiver<Vec<(u8, Option<B::Node<S<S<H>>>>)>>>,
-        early_supplies: Option<oneshot::Receiver<Vec<(u8, Vec<(u8, B::Node<S<S<H>>>)>)>>>,
+        early_survivors: Option<oneshot::Receiver<Vec<(u8, Option<B::Erased>)>>>,
+        early_supplies: Option<oneshot::Receiver<Vec<(u8, Vec<(u8, B::Erased)>)>>>,
         requests: impl Requests<B, T, S<S<H>>>,
-        mut queries: QueryReceiver<B, T, S<S<H>>>,
+        queries: Receiver<Query<B::Erased>>,
     ) -> (
         BoxResponses<B, T, S<H>, Error<B::Error>>,
-        QueryReceiver<B, T, H>,
-        ResolutionOkStream<B, T, S<S<H>>>,
-        ResolutionOkStream<B, T, S<H>>,
+        Receiver<Query<B::Erased>>,
+        OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
+        OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
+    )
+    where
+        B: Sync,
+        H: Height,
+        S<H>: Height,
+        S<S<H>>: Height,
+    {
+        let requests: Replies<B::Erased> =
+            Box::pin(requests.map(erased::erase_reply::<B, T, S<S<H>>>));
+        let (responses, asked_rx, upper_rx, lower_rx) = self.internal_walk(
+            their_version,
+            ledger,
+            early_survivors,
+            early_supplies,
+            requests,
+            queries,
+            H::HEIGHT,
+        );
+        (
+            self.respond::<S<H>>(responses),
+            asked_rx,
+            upper_rx,
+            lower_rx,
+        )
+    }
+
+    /// The internal walk's body, shared by every height:
+    /// [`internal_level`](Self::internal_level) with the descent height as
+    /// the runtime datum it already is everywhere below the types.
+    // The argument list is the stage's dataflow, one edge per argument;
+    // bundling edges into a struct would only rename the arity.
+    #[allow(clippy::too_many_arguments, clippy::type_complexity)]
+    fn internal_walk(
+        &mut self,
+        their_version: Version,
+        ledger: SupplyLedger,
+        early_survivors: Option<oneshot::Receiver<Vec<(u8, Option<B::Erased>)>>>,
+        early_supplies: Option<oneshot::Receiver<Vec<(u8, Vec<(u8, B::Erased)>)>>>,
+        requests: Replies<B::Erased>,
+        mut queries: Receiver<Query<B::Erased>>,
+        asked_height: usize,
+    ) -> (
+        impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>> + Send + 'static + use<B, T>,
+        Receiver<Query<B::Erased>>,
+        OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
+        OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
     )
     where
         B: Sync,
-        H: Unknown,
-        S<H>: Unknown,
-        S<S<H>>: Unknown,
-        S<S<S<H>>>: Height,
     {
         let backend = self.backend();
         let stats = self.stats.clone();
-        let (asked, asked_rx) = internal_child_queries(self.window.capacity(H::HEIGHT));
-        let (upper, upper_rx) =
-            internal_parent_resolutions(self.window.capacity(<S<S<H>>>::HEIGHT));
-        let (lower, lower_rx) = internal_child_resolutions(self.window.capacity(<S<H>>::HEIGHT));
+        let (asked, asked_rx) =
+            internal_child_queries::<B, T>(asked_height, self.window.capacity(asked_height));
+        let (upper, upper_rx) = internal_parent_resolutions::<B, T>(
+            asked_height + 2,
+            self.window.capacity(asked_height + 2),
+        );
+        let (lower, lower_rx) = internal_child_resolutions::<B, T>(
+            asked_height + 1,
+            self.window.capacity(asked_height + 1),
+        );
         #[cfg(test)]
         let trace_id = self.trace_id;
 
         let responses = try_stream! {
-            let mut requests = pin!(requests);
+            let mut requests = requests;
             let mut early_survivors = early_survivors;
-            let mut survivors: Option<BTreeMap<u8, Option<B::Node<S<S<H>>>>>> = None;
+            let mut survivors: Option<BTreeMap<u8, Option<B::Erased>>> = None;
             let mut early_supplies = early_supplies;
-            let mut supplied: Option<BTreeMap<u8, Vec<(u8, B::Node<S<S<H>>>)>>> = None;
+            let mut supplied: Option<BTreeMap<u8, Vec<(u8, B::Erased)>>> = None;
             while let Some(query) = queries.recv().await {
                 let Some(Reply { replies }) = requests.next().await else {
                     return violation(Violation::UnansweredQuery)?;
@@ -343,7 +427,8 @@ where
                     }
                 }
 
-                let mut resolver = Resolver::new(query, &their_version, &ledger, stats.clone());
+                let mut resolver =
+                    Resolver::<B, T>::new(query, &their_version, &ledger, stats.clone());
                 for reaction in replies {
                     let Some((prefix, radix, node, listing)) = resolver.react(reaction)? else {
                         continue;
@@ -389,7 +474,7 @@ where
                         continue;
                     }
 
-                    let children = children_of(&backend, child_prefix, node).await?;
+                    let children = erased::ops::children_of(&backend, child_prefix, node).await?;
                     let (reactions, next_queries, resolved) = answer::internal(
                         &backend,
                         &their_version,
@@ -426,7 +511,7 @@ where
             }
         };
 
-        (self.respond(responses), asked_rx, upper_rx, lower_rx)
+        (responses, asked_rx, upper_rx, lower_rx)
     }
 
     /// Walk leaf parents, where disputes compare version-addressed leaves.
@@ -435,12 +520,36 @@ where
         their_version: Version,
         ledger: SupplyLedger,
         requests: impl Requests<B, T, S<Z>>,
-        mut queries: QueryReceiver<B, T, S<Z>>,
+        queries: Receiver<Query<B::Erased>>,
     ) -> (
         BoxResponses<B, T, Z, Error<B::Error>>,
         Receiver<Prefix<Z>>,
-        ResolutionOkStream<B, T, S<Z>>,
-        ResolutionOkStream<B, T, Z>,
+        OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
+        OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
+    )
+    where
+        B: Sync,
+    {
+        let requests: Replies<B::Erased> =
+            Box::pin(requests.map(erased::erase_reply::<B, T, S<Z>>));
+        let (responses, asked_rx, upper_rx, lower_rx) =
+            self.leaf_parent_walk(their_version, ledger, requests, queries);
+        (self.respond::<Z>(responses), asked_rx, upper_rx, lower_rx)
+    }
+
+    /// The leaf-parent walk's body ([`leaf_parent_level`](Self::leaf_parent_level)).
+    #[allow(clippy::type_complexity)]
+    fn leaf_parent_walk(
+        &mut self,
+        their_version: Version,
+        ledger: SupplyLedger,
+        requests: Replies<B::Erased>,
+        mut queries: Receiver<Query<B::Erased>>,
+    ) -> (
+        impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>> + Send + 'static + use<B, T>,
+        Receiver<Prefix<Z>>,
+        OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
+        OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
     )
     where
         B: Sync,
@@ -448,19 +557,21 @@ where
         let backend = self.backend();
         let stats = self.stats.clone();
         let (asked, asked_rx) = leaf_requests(self.window.capacity(Z::HEIGHT));
-        let (upper, upper_rx) = leaf_parent_resolutions(self.window.capacity(<S<Z>>::HEIGHT));
-        let (lower, lower_rx) = leaf_child_resolutions(self.window.capacity(Z::HEIGHT));
+        let (upper, upper_rx) =
+            leaf_parent_resolutions::<B, T>(self.window.capacity(<S<Z>>::HEIGHT));
+        let (lower, lower_rx) = leaf_child_resolutions::<B, T>(self.window.capacity(Z::HEIGHT));
         #[cfg(test)]
         let trace_id = self.trace_id;
 
         let responses = try_stream! {
-            let mut requests = pin!(requests);
+            let mut requests = requests;
             while let Some(query) = queries.recv().await {
                 let Some(Reply { replies }) = requests.next().await else {
                     return violation(Violation::UnansweredQuery)?;
                 };
 
-                let mut resolver = Resolver::new(query, &their_version, &ledger, stats.clone());
+                let mut resolver =
+                    Resolver::<B, T>::new(query, &their_version, &ledger, stats.clone());
                 for reaction in replies {
                     let Some((prefix, radix, node, listing)) = resolver.react(reaction)? else {
                         continue;
@@ -483,7 +594,7 @@ where
                         continue;
                     }
 
-                    let leaves = children_of(&backend, child_prefix, node).await?;
+                    let leaves = erased::ops::children_of(&backend, child_prefix, node).await?;
                     let (replies, next_queries, resolved) =
                         answer::leaf_parent(&their_version, child_prefix, leaves, listing, &stats);
                     yield_resolve_query!(
@@ -513,7 +624,7 @@ where
             }
         };
 
-        (self.respond(responses), asked_rx, upper_rx, lower_rx)
+        (responses, asked_rx, upper_rx, lower_rx)
     }
 
     /// Walk leaves, where every query is a terminal request.
@@ -522,24 +633,42 @@ where
         their_version: Version,
         ledger: SupplyLedger,
         requests: impl Requests<B, T, Z>,
-        mut queries: QueryReceiver<B, T, Z>,
+        queries: Receiver<Query<B::Erased>>,
     ) -> (
         BoxResponses<B, T, Z, Error<B::Error>>,
-        ResolutionOkStream<B, T, Z>,
+        OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
+    ) {
+        let requests: Replies<B::Erased> = Box::pin(requests.map(erased::erase_reply::<B, T, Z>));
+        let (responses, upper_rx) = self.leaf_walk(their_version, ledger, requests, queries);
+        (self.respond::<Z>(responses), upper_rx)
+    }
+
+    /// The leaf walk's body ([`leaf_level`](Self::leaf_level)).
+    #[allow(clippy::type_complexity)]
+    fn leaf_walk(
+        &mut self,
+        their_version: Version,
+        ledger: SupplyLedger,
+        requests: Replies<B::Erased>,
+        mut queries: Receiver<Query<B::Erased>>,
+    ) -> (
+        impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>> + Send + 'static + use<B, T>,
+        OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
     ) {
-        let (upper, upper_rx) = terminal_leaf_resolutions();
+        let (upper, upper_rx) = terminal_leaf_resolutions::<B, T>();
         let stats = self.stats.clone();
         #[cfg(test)]
         let trace_id = self.trace_id;
 
         let responses = try_stream! {
-            let mut requests = pin!(requests);
+            let mut requests = requests;
             while let Some(query) = queries.recv().await {
                 let Some(Reply { replies }) = requests.next().await else {
                     return violation(Violation::UnansweredQuery)?;
                 };
 
-                let mut resolver = Resolver::new(query, &their_version, &ledger, stats.clone());
+                let mut resolver =
+                    Resolver::<B, T>::new(query, &their_version, &ledger, stats.clone());
                 for reaction in replies {
                     let Some((prefix, radix, node, listing)) = resolver.react(reaction)? else {
                         continue;
@@ -568,6 +697,6 @@ where
             }
         };
 
-        (self.respond(responses), upper_rx)
+        (responses, upper_rx)
     }
 }
diff --git a/src/tree/mirror/streaming/materialized/work/queues.rs b/src/tree/mirror/streaming/materialized/work/queues.rs
index 750b76c14..dd36a5206 100644
--- a/src/tree/mirror/streaming/materialized/work/queues.rs
+++ b/src/tree/mirror/streaming/materialized/work/queues.rs
@@ -1,11 +1,13 @@
-//! Typed channel constructors for the materialized walk.
+//! Channel constructors for the materialized walk.
 //!
 //! Each function names one edge in the protocol dataflow. Keeping capacity
 //! choices here makes them reviewable alongside the exact item type and keeps
-//! queue arithmetic out of the walk itself. The channels beneath carry the
-//! height-erased payload twins — one channel-machinery instantiation per
-//! backend rather than one per height — behind typed facades minted per
-//! edge (see [`erased`]).
+//! queue arithmetic out of the walk itself. Every edge carries the erased
+//! payload vocabulary — one channel-machinery instantiation per backend —
+//! and keeps its height as the runtime [`QueueRole`] label the walk
+//! threads through (the instrumented diagnostics and capacity tests key
+//! on it). The one typed exception is [`leaf_requests`], whose item is
+//! already the single-height [`Prefix<Z>`].
 //!
 //! Recursive query and resolution queues rely on two halves of the walk's
 //! progress invariant: publish a scope's resolution before sending the work
@@ -22,15 +24,12 @@
 use crate::tree::{
     mirror::streaming::{
         Backend, Leaf,
-        erased::{
-            self, QueryReceiver, QuerySender, ResolutionOkStream, ResolutionSender, ReturnOkStream,
-            ReturnReceiver, ReturnSender,
-        },
+        erased::{self, Reply, ReplyResultStream},
         materialized::{
-            Error,
+            Error, OkReceiverStream, Query, Resolution,
             channel::{QueueKind, QueueRole, Receiver, Sender, channel},
+            ok_channel,
         },
-        protocol::BoxResponses,
         window::FAN,
     },
     typed::{
@@ -45,21 +44,21 @@ use crate::tree::{
 /// and consuming that reply is sufficient to release the producer. More slots
 /// retain whole messages without breaking another dependency.
 pub(super) fn outgoing_responses<B, T, H>() -> (
-    erased::ReplyResultSender<B, T, H>,
-    BoxResponses<B, T, H, Error<B::Error>>,
+    Sender<Result<Reply<B::Erased>, Error<B::Error>>>,
+    ReplyResultStream<B, T, H>,
 )
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
     H: Height,
 {
-    let (sender, responses) =
-        erased::reply_channel(QueueRole::new(QueueKind::OutgoingResponses, H::HEIGHT), 1);
-    (sender, Box::pin(responses))
+    erased::reply_channel::<B, T, H>(QueueRole::new(QueueKind::OutgoingResponses, H::HEIGHT), 1)
 }
 
 /// Buffer lower-level completions until their enclosing resolution arrives.
 ///
+/// `height` is the completions' own height, the level boundary's label.
+///
 /// Processing one incoming reply can launch a full fan of disputed child
 /// scopes. Their lower assemblers may finish immediately and send completed
 /// nodes here, but this queue's consumer first waits for the enclosing parent
@@ -80,29 +79,29 @@ where
 /// stall a session (`underbuffered_mirror_stalls` in the capacity tests
 /// demonstrates it), which is why the session window deliberately never
 /// reaches this constructor.
-pub(super) fn assembly_level_returns<B, T, H>() -> (ReturnSender<B, T, H>, ReturnOkStream<B, T, H>)
+pub(super) fn assembly_level_returns<B, T>(
+    height: usize,
+) -> (
+    Sender<Option<B::Erased>>,
+    OkReceiverStream<Option<B::Erased>, Error<B::Error>>,
+)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
-    H: Height,
 {
-    erased::return_ok_channel::<B, T, H>(
-        QueueRole::new(QueueKind::AssemblyLevelReturns, H::HEIGHT),
-        FAN,
-    )
+    ok_channel(QueueRole::new(QueueKind::AssemblyLevelReturns, height), FAN)
 }
 
 /// Carry the initiator's single root query.
 ///
 /// The opening emits exactly one query for the root scope, so a second slot
 /// can never be occupied.
-pub(super) fn initiator_root_query<B, T>()
--> (QuerySender<B, T, UnderRoot>, QueryReceiver<B, T, UnderRoot>)
+pub(super) fn initiator_root_query<B, T>() -> (Sender<Query<B::Erased>>, Receiver<Query<B::Erased>>)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    erased::query_channel(
+    channel(
         QueueRole::new(QueueKind::InitiatorRootQuery, UnderRoot::HEIGHT),
         1,
     )
@@ -112,12 +111,13 @@ where
 ///
 /// Reconciliation produces exactly one root node and the terminal future
 /// consumes it directly.
-pub(super) fn initiator_root_return<B, T>() -> (ReturnSender<B, T, Root>, ReturnReceiver<B, T, Root>)
+pub(super) fn initiator_root_return<B, T>()
+-> (Sender<Option<B::Erased>>, Receiver<Option<B::Erased>>)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    erased::return_channel::<B, T, Root>(
+    channel(
         QueueRole::new(QueueKind::InitiatorRootReturn, Root::HEIGHT),
         1,
     )
@@ -128,19 +128,16 @@ where
 /// The opening wire reply and root resolution are published before these
 /// queries, so one slot is the liveness floor. The window widens it so the next
 /// stage can hold a pipeline of disputed children in flight; each buffered
-/// [`Query`](crate::tree::mirror::streaming::materialized::Query) may own a
-/// fan of node handles, which is priced by the window's node budget.
+/// [`Query`] may own a fan of node handles, which is priced by the window's
+/// node budget.
 pub(super) fn responder_child_queries<B, T>(
     capacity: usize,
-) -> (
-    QuerySender<B, T, UnderUnderRoot>,
-    QueryReceiver<B, T, UnderUnderRoot>,
-)
+) -> (Sender<Query<B::Erased>>, Receiver<Query<B::Erased>>)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    erased::query_channel(
+    channel(
         QueueRole::new(QueueKind::ResponderChildQueries, UnderUnderRoot::HEIGHT),
         capacity,
     )
@@ -151,14 +148,14 @@ where
 /// The responder processes exactly one opening request and therefore
 /// publishes exactly one resolution for the root scope.
 pub(super) fn responder_root_resolution<B, T>() -> (
-    ResolutionSender<B, T, UnderRoot>,
-    ResolutionOkStream<B, T, UnderRoot>,
+    Sender<Resolution<B::Erased>>,
+    OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
 )
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    erased::resolution_ok_channel(
+    ok_channel(
         QueueRole::new(QueueKind::ResponderRootResolution, UnderRoot::HEIGHT),
         1,
     )
@@ -170,14 +167,14 @@ where
 /// assembler can consume each return as it arrives. No later return is needed
 /// to unlock the consumer of the buffered one.
 pub(super) fn responder_root_returns<B, T>() -> (
-    ReturnSender<B, T, UnderRoot>,
-    ReturnOkStream<B, T, UnderRoot>,
+    Sender<Option<B::Erased>>,
+    OkReceiverStream<Option<B::Erased>, Error<B::Error>>,
 )
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    erased::return_ok_channel::<B, T, UnderRoot>(
+    ok_channel(
         QueueRole::new(QueueKind::ResponderRootReturns, UnderRoot::HEIGHT),
         1,
     )
@@ -185,68 +182,74 @@ where
 
 /// Buffer the child queries emitted by one internal walk, window-wide.
 ///
+/// `height` is the children's height: the walk's dependent queries descend
+/// to it, and it labels the edge.
+///
 /// The corresponding child resolution is published first, so one slot is the
 /// liveness floor. This queue is the in-flight question window itself: its
 /// occupancy is the number of disputed scopes awaiting wire replies at this
 /// height, so its capacity is what lets sibling scopes' round trips overlap.
-pub(super) fn internal_child_queries<B, T, H>(
+pub(super) fn internal_child_queries<B, T>(
+    height: usize,
     capacity: usize,
-) -> (QuerySender<B, T, H>, QueryReceiver<B, T, H>)
+) -> (Sender<Query<B::Erased>>, Receiver<Query<B::Erased>>)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
 {
-    erased::query_channel(
-        QueueRole::new(QueueKind::InternalChildQueries, H::HEIGHT),
+    channel(
+        QueueRole::new(QueueKind::InternalChildQueries, height),
         capacity,
     )
 }
 
 /// Buffer parent-scope resolutions produced by an internal walk, window-wide.
 ///
+/// `height` is the parent resolutions' own height (two above the walk's
+/// dependent queries).
+///
 /// Before each parent resolution is sent, all work capable of fulfilling its
 /// `Pending` slots has been launched, so one slot is the liveness floor. But a
 /// resolution is consumed only as its subtree completes, so a one-slot edge
 /// stalls the walk two scopes in; the window lets it run ahead.
-pub(super) fn internal_parent_resolutions<B, T, H>(
+pub(super) fn internal_parent_resolutions<B, T>(
+    height: usize,
     capacity: usize,
 ) -> (
-    ResolutionSender<B, T, S<S<H>>>,
-    ResolutionOkStream<B, T, S<S<H>>>,
+    Sender<Resolution<B::Erased>>,
+    OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
 )
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
-    S<S<H>>: Height,
-    S<S<S<H>>>: Height,
 {
-    erased::resolution_ok_channel(
-        QueueRole::new(QueueKind::InternalParentResolutions, <S<S<H>>>::HEIGHT),
+    ok_channel(
+        QueueRole::new(QueueKind::InternalParentResolutions, height),
         capacity,
     )
 }
 
 /// Buffer child-scope resolutions produced by an internal walk, window-wide.
 ///
+/// `height` is the child resolutions' own height (one above the walk's
+/// dependent queries).
+///
 /// Each resolution is published before its corresponding child queries, so one
 /// slot is the liveness floor; the window lets the walk publish a pipeline of
 /// them while earlier subtrees are still reconciling.
-pub(super) fn internal_child_resolutions<B, T, H>(
+pub(super) fn internal_child_resolutions<B, T>(
+    height: usize,
     capacity: usize,
-) -> (ResolutionSender<B, T, S<H>>, ResolutionOkStream<B, T, S<H>>)
+) -> (
+    Sender<Resolution<B::Erased>>,
+    OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
+)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
-    S<S<H>>: Height,
 {
-    erased::resolution_ok_channel(
-        QueueRole::new(QueueKind::InternalChildResolutions, <S<H>>::HEIGHT),
+    ok_channel(
+        QueueRole::new(QueueKind::InternalChildResolutions, height),
         capacity,
     )
 }
@@ -256,9 +259,6 @@ where
 /// The corresponding leaf-scope resolution is published first, so one slot is
 /// the liveness floor. This queue is the leaf-height question window: its
 /// capacity is how many requested leaves may await the peer's supplies at once.
-///
-/// The one materialized edge with no erased twin: its item is already the
-/// single-height [`Prefix<Z>`].
 pub(super) fn leaf_requests(capacity: usize) -> (Sender<Prefix<Z>>, Receiver<Prefix<Z>>) {
     channel(QueueRole::new(QueueKind::LeafRequests, Z::HEIGHT), capacity)
 }
@@ -271,12 +271,15 @@ pub(super) fn leaf_requests(capacity: usize) -> (Sender<Prefix<Z>>, Receiver<Pre
 /// buffered resolutions wait on their leaf exchanges.
 pub(super) fn leaf_parent_resolutions<B, T>(
     capacity: usize,
-) -> (ResolutionSender<B, T, S<Z>>, ResolutionOkStream<B, T, S<Z>>)
+) -> (
+    Sender<Resolution<B::Erased>>,
+    OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
+)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    erased::resolution_ok_channel(
+    ok_channel(
         QueueRole::new(QueueKind::LeafParentResolutions, <S<Z>>::HEIGHT),
         capacity,
     )
@@ -290,12 +293,15 @@ where
 /// scopes await their supplies.
 pub(super) fn leaf_child_resolutions<B, T>(
     capacity: usize,
-) -> (ResolutionSender<B, T, Z>, ResolutionOkStream<B, T, Z>)
+) -> (
+    Sender<Resolution<B::Erased>>,
+    OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
+)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    erased::resolution_ok_channel(
+    ok_channel(
         QueueRole::new(QueueKind::LeafChildResolutions, Z::HEIGHT),
         capacity,
     )
@@ -312,13 +318,15 @@ where
 /// scopes the memory model already charges, so no knob applies. (Contrast
 /// [`assembly_level_returns`], where one fan is a correctness floor rather
 /// than an amortization.)
-pub(super) fn terminal_leaf_resolutions<B, T>()
--> (ResolutionSender<B, T, Z>, ResolutionOkStream<B, T, Z>)
+pub(super) fn terminal_leaf_resolutions<B, T>() -> (
+    Sender<Resolution<B::Erased>>,
+    OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
+)
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
 {
-    erased::resolution_ok_channel(
+    ok_channel(
         QueueRole::new(QueueKind::TerminalLeafResolutions, Z::HEIGHT),
         FAN,
     )
diff --git a/src/tree/mirror/streaming/materialized/work/resolver.rs b/src/tree/mirror/streaming/materialized/work/resolver.rs
index 43cced73d..a5359aa50 100644
--- a/src/tree/mirror/streaming/materialized/work/resolver.rs
+++ b/src/tree/mirror/streaming/materialized/work/resolver.rs
@@ -5,28 +5,26 @@ use crate::{
     tree::{
         mirror::contained,
         mirror::streaming::{
-            Backend, Leaf, Node,
+            Backend, ErasedNode, Leaf,
+            erased::Reaction,
             materialized::{Error, Query, Resolution, Resolve, SupplyLedger, Violation, violation},
-            message::Reaction,
             stats::Recorder,
         },
-        typed::{
-            Hash, Prefix,
-            height::{Height, S, Z},
-        },
+        typed::{ErasedPrefix, Hash, height::Z},
     },
 };
 
 /// One query's reaction loop: pairs the held children against the reply's
 /// reactions in order, accumulating the scope's [`Resolution`] and reporting
 /// each counterparty fault as its exact [`Violation`].
-pub struct Resolver<'v, B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height>
+pub struct Resolver<'v, B, T>
 where
-    S<H>: Height,
+    B: Backend<T, Node<Z>: Leaf<T>>,
+    T: Send + Sync + 'static,
 {
-    prefix: Prefix<S<H>>,
-    fan: Peekable<std::vec::IntoIter<(u8, B::Node<H>)>>,
-    resolved: Vec<(u8, Resolve<B, T, H>)>,
+    prefix: ErasedPrefix,
+    fan: Peekable<std::vec::IntoIter<(u8, B::Erased)>>,
+    resolved: Vec<(u8, Resolve<B::Erased>)>,
     /// The peer's declared greeting version: every supplied subtree's
     /// ceiling must be contained in it
     /// ([`Violation::UncontainedSupply`]).
@@ -41,15 +39,13 @@ where
     stats: Recorder,
 }
 
-impl<'v, B, T, H> Resolver<'v, B, T, H>
+impl<'v, B, T> Resolver<'v, B, T>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
 {
     pub fn new(
-        Query { prefix, ours }: Query<B, T, H>,
+        Query { prefix, ours }: Query<B::Erased>,
         their_version: &'v Version,
         ledger: &'v SupplyLedger,
         stats: Recorder,
@@ -64,10 +60,11 @@ where
         }
     }
 
+    #[allow(clippy::type_complexity)]
     pub fn react(
         &mut self,
-        reaction: Reaction<B, T, H>,
-    ) -> Result<Option<(Prefix<S<H>>, u8, B::Node<H>, Vec<(u8, Hash)>)>, Error<B::Error>> {
+        reaction: Reaction<B::Erased>,
+    ) -> Result<Option<(ErasedPrefix, u8, B::Erased, Vec<(u8, Hash)>)>, Error<B::Error>> {
         match reaction {
             Reaction::Match => {
                 let Some((radix, node)) = self.fan.next() else {
@@ -113,7 +110,7 @@ where
         Ok(None)
     }
 
-    pub fn ready(&mut self, radix: u8, node: Option<B::Node<H>>) {
+    pub fn ready(&mut self, radix: u8, node: Option<B::Erased>) {
         self.resolved.push((radix, Resolve::Ready(node)));
     }
 
@@ -121,7 +118,7 @@ where
         self.resolved.push((radix, Resolve::Pending));
     }
 
-    pub fn finish(mut self) -> Result<Resolution<B, T, H>, Error<B::Error>> {
+    pub fn finish(mut self) -> Result<Resolution<B::Erased>, Error<B::Error>> {
         if self.fan.next().is_some() {
             violation(Violation::UnfinishedReply)
         } else {
diff --git a/src/tree/mirror/streaming/materialized/work/tests.rs b/src/tree/mirror/streaming/materialized/work/tests.rs
index 9ab2cdefb..cc255ff81 100644
--- a/src/tree/mirror/streaming/materialized/work/tests.rs
+++ b/src/tree/mirror/streaming/materialized/work/tests.rs
@@ -33,6 +33,15 @@ use crate::{
     },
 };
 
+/// The in-memory backend's erased node representation, which resolutions
+/// and level returns carry.
+type Erased = <Local as Backend<()>>::Erased;
+
+/// Erase one typed leaf the way the walk's payloads carry it.
+fn erased(node: typed::Node<(), Z>) -> Erased {
+    <Local as Backend<()>>::erase(node)
+}
+
 /// A distinct leaf per call: the versions differ so hashes do.
 fn leaf(version: &mut Version) -> typed::Node<(), Z> {
     version.tick(&nth_party(0));
@@ -61,8 +70,8 @@ fn parent_of(
     pollster::block_on(Local.parent(prefix, children)).unwrap_or_else(|e| match e {})
 }
 
-type Item = Result<Resolution<Local, (), Z>, Error<Infallible>>;
-type Level = Result<Option<typed::Node<(), Z>>, Error<Infallible>>;
+type Item = Result<Resolution<Erased>, Error<Infallible>>;
+type Level = Result<Option<Erased>, Error<Infallible>>;
 
 /// A work error cancels parked peers and retains its original error identity.
 #[test]
@@ -96,9 +105,10 @@ fn work_failure_preempts_parked_tasks() {
 fn assembled(
     resolutions: Vec<Item>,
     level: Vec<Level>,
-) -> Vec<Result<Option<typed::Node<(), S<Z>>>, Error<Infallible>>> {
+) -> Vec<Result<Option<Erased>, Error<Infallible>>> {
     pollster::block_on(
-        assemble(Local, stream::iter(resolutions), stream::iter(level)).collect::<Vec<_>>(),
+        assemble::<Local, ()>(Local, stream::iter(resolutions), stream::iter(level))
+            .collect::<Vec<_>>(),
     )
 }
 
@@ -110,16 +120,16 @@ fn fills_pendings_in_order() {
     let (a, b, c) = (leaf(&mut version), leaf(&mut version), leaf(&mut version));
 
     let resolution = Resolution {
-        prefix: parent_prefix(3),
+        prefix: parent_prefix(3).erase(),
         resolved: vec![
             (1, Resolve::Pending),
-            (2, Resolve::Ready(Some(b.clone()))),
+            (2, Resolve::Ready(Some(erased(b.clone())))),
             (5, Resolve::Pending),
         ],
     };
     let output = assembled(
         vec![Ok(resolution)],
-        vec![Ok(Some(a.clone())), Ok(Some(c.clone()))],
+        vec![Ok(Some(erased(a.clone()))), Ok(Some(erased(c.clone())))],
     );
 
     let expected = parent_of(
@@ -143,9 +153,9 @@ fn ready_none_is_deletion() {
     let a = leaf(&mut version);
 
     let resolution = Resolution {
-        prefix: parent_prefix(3),
+        prefix: parent_prefix(3).erase(),
         resolved: vec![
-            (1, Resolve::Ready(Some(a.clone()))),
+            (1, Resolve::Ready(Some(erased(a.clone())))),
             (2, Resolve::Ready(None)),
         ],
     };
@@ -166,7 +176,7 @@ fn ready_none_is_deletion() {
 #[test]
 fn empty_resolution_assembles_to_none() {
     let resolution = Resolution {
-        prefix: parent_prefix(3),
+        prefix: parent_prefix(3).erase(),
         resolved: vec![],
     };
     let output = assembled(vec![Ok(resolution)], vec![]);
@@ -178,7 +188,7 @@ fn empty_resolution_assembles_to_none() {
 #[test]
 fn all_deleted_resolution_assembles_to_none() {
     let resolution = Resolution {
-        prefix: parent_prefix(3),
+        prefix: parent_prefix(3).erase(),
         resolved: vec![(1, Resolve::Ready(None)), (2, Resolve::Ready(None))],
     };
     let output = assembled(vec![Ok(resolution)], vec![]);
@@ -192,22 +202,22 @@ fn chains_two_instances() {
     let mut version = Version::new();
     let (a, b) = (leaf(&mut version), leaf(&mut version));
 
-    let lower: Vec<Result<Resolution<Local, (), Z>, Error<Infallible>>> = vec![Ok(Resolution {
-        prefix: parent_prefix(3),
+    let lower: Vec<Item> = vec![Ok(Resolution {
+        prefix: parent_prefix(3).erase(),
         resolved: vec![
-            (1, Resolve::Ready(Some(a.clone()))),
-            (7, Resolve::Ready(Some(b.clone()))),
+            (1, Resolve::Ready(Some(erased(a.clone())))),
+            (7, Resolve::Ready(Some(erased(b.clone())))),
         ],
     })];
-    let upper: Vec<Result<Resolution<Local, (), S<Z>>, Error<Infallible>>> = vec![Ok(Resolution {
-        prefix: parent_prefix(3).pop().0,
+    let upper: Vec<Item> = vec![Ok(Resolution {
+        prefix: parent_prefix(3).pop().0.erase(),
         resolved: vec![(3, Resolve::Pending)],
     })];
 
-    let chained = assemble(
+    let chained = assemble::<Local, ()>(
         Local,
         stream::iter(upper),
-        assemble(Local, stream::iter(lower), stream::empty()),
+        assemble::<Local, ()>(Local, stream::iter(lower), stream::empty()),
     );
     let output =
         pollster::block_on(chained.try_collect::<Vec<_>>()).expect("no errors were fed in");
@@ -242,7 +252,7 @@ fn resolution_error_passes_through() {
 #[test]
 fn level_error_passes_through() {
     let resolution = Resolution {
-        prefix: parent_prefix(3),
+        prefix: parent_prefix(3).erase(),
         resolved: vec![(1, Resolve::Pending)],
     };
     let output = assembled(
diff --git a/src/tree/mirror/streaming/materialized/work/tests/violations.rs b/src/tree/mirror/streaming/materialized/work/tests/violations.rs
index 90173d0c2..b52e40df5 100644
--- a/src/tree/mirror/streaming/materialized/work/tests/violations.rs
+++ b/src/tree/mirror/streaming/materialized/work/tests/violations.rs
@@ -10,10 +10,10 @@ use crate::tree::mirror::streaming::stats::Recorder;
 use crate::{
     Version,
     tree::mirror::streaming::{
-        Local,
-        erased::QueryReceiver,
+        Backend, Local,
         materialized::{
-            Error, Query, SupplyLedger, Violation, Work, channel::with_schedule, unknown::Unknown,
+            Error, Query, SupplyLedger, Violation, Work,
+            channel::{Receiver, with_schedule},
             work::queues::internal_child_queries,
         },
         message::{Reaction, Reply},
@@ -25,6 +25,10 @@ use crate::{
         height::{Height, S, Z},
     },
 };
+
+/// The in-memory backend's erased node representation, which the walk's
+/// query queues carry.
+type Erased = <Local as Backend<()>>::Erased;
 /// One deliberately malformed counterparty script and the exact violation it
 /// must surface.
 #[derive(Clone, Copy, Debug)]
@@ -98,11 +102,7 @@ fn violation_script<H>(
     injection: Injection,
     parent: u8,
     radixes: &BTreeSet<u8>,
-) -> (
-    Option<Query<Local, (), H>>,
-    Vec<Reply<Local, (), H>>,
-    Version,
-)
+) -> (Option<Query<Erased>>, Vec<Reply<Local, (), H>>, Version)
 where
     H: TestHeight,
     S<H>: Height,
@@ -119,8 +119,11 @@ where
     path[0] = parent;
     let prefix = Prefix::<S<H>>::containing(&Path::from(path));
     let query = Query {
-        prefix,
-        ours: ours.clone(),
+        prefix: prefix.erase(),
+        ours: ours
+            .iter()
+            .map(|(radix, node)| (*radix, <Local as Backend<()>>::erase(node.clone())))
+            .collect(),
     };
 
     let matches = || {
@@ -167,7 +170,7 @@ where
             let radix = *radixes.first().expect("the strategy produces a child");
             (
                 Some(Query {
-                    prefix,
+                    prefix: prefix.erase(),
                     ours: Vec::new(),
                 }),
                 vec![Reply {
@@ -184,7 +187,7 @@ where
             let radix = *radixes.first().expect("the strategy produces a child");
             (
                 Some(Query {
-                    prefix,
+                    prefix: prefix.erase(),
                     ours: Vec::new(),
                 }),
                 vec![Reply {
@@ -196,13 +199,14 @@ where
     (query, replies, declared)
 }
 
-/// Put the script's optional outstanding query into the walk's pairing queue.
-fn query_receiver<H>(query: Option<Query<Local, (), H>>) -> QueryReceiver<Local, (), H>
+/// Put the script's optional outstanding query into the walk's pairing
+/// queue, labeled at the script's height.
+fn query_receiver<H>(query: Option<Query<Erased>>) -> Receiver<Query<Erased>>
 where
     H: Height,
     S<H>: Height,
 {
-    let (queries, queries_rx) = internal_child_queries::<Local, (), H>(1);
+    let (queries, queries_rx) = internal_child_queries::<Local, ()>(H::HEIGHT, 1);
     if let Some(query) = query {
         pollster::block_on(queries.send(query)).expect("the walk is live");
     }
@@ -242,7 +246,7 @@ trait InjectHeight: TestHeight {
 impl InjectHeight for Z {
     fn inject(injection: Injection, parent: u8, radixes: &BTreeSet<u8>) -> Violation {
         let (query, requests, declared) = violation_script::<Self>(injection, parent, radixes);
-        let queries = query_receiver(query);
+        let queries = query_receiver::<Self>(query);
         let mut work = Work::new(Local, Window::FLOOR, Recorder::default());
         let (responses, _resolutions) = work.leaf_level(
             declared,
@@ -257,7 +261,7 @@ impl InjectHeight for Z {
 impl InjectHeight for S<Z> {
     fn inject(injection: Injection, parent: u8, radixes: &BTreeSet<u8>) -> Violation {
         let (query, requests, declared) = violation_script::<Self>(injection, parent, radixes);
-        let queries = query_receiver(query);
+        let queries = query_receiver::<Self>(query);
         let mut work = Work::new(Local, Window::FLOOR, Recorder::default());
         let (responses, _asked, _upper, _lower) = work.leaf_parent_level(
             declared,
@@ -271,14 +275,14 @@ impl InjectHeight for S<Z> {
 
 impl<H> InjectHeight for S<S<H>>
 where
-    H: TestHeight + Unknown,
-    S<H>: Unknown,
-    S<S<H>>: TestHeight + Unknown,
+    H: TestHeight,
+    S<H>: Height,
+    S<S<H>>: TestHeight,
     S<S<S<H>>>: Height,
 {
     fn inject(injection: Injection, parent: u8, radixes: &BTreeSet<u8>) -> Violation {
         let (query, requests, declared) = violation_script::<Self>(injection, parent, radixes);
-        let queries = query_receiver(query);
+        let queries = query_receiver::<Self>(query);
         let mut work = Work::new(Local, Window::FLOOR, Recorder::default());
         let (responses, _asked, _upper, _lower) = work.internal_level::<H>(
             declared,
diff --git a/src/tree/mirror/streaming/window.rs b/src/tree/mirror/streaming/window.rs
index e06bf9310..08ff08dd3 100644
--- a/src/tree/mirror/streaming/window.rs
+++ b/src/tree/mirror/streaming/window.rs
@@ -16,7 +16,7 @@
 //! capacities** using what the two replicas exchange in their greetings —
 //! exact set sizes and version-size bounds — priced through the storage
 //! backend's own cost function
-//! ([`Backend::node_bytes`](super::Backend::node_bytes)). Channels stay
+//! ([`Backend::node_bytes`]). Channels stay
 //! plain bounded queues; the [link](crate::link) remains the only
 //! backpressure boundary with runtime semantics.
 //!
@@ -120,7 +120,7 @@
 //!   its own producer — the premise the session's whole liveness argument
 //!   already rests on.
 
-use super::{Local, materialized::Resolve};
+use super::{Backend, Local, materialized::Resolve};
 use crate::link::STREAM_COUNT;
 use crate::tree::typed::{self, Prefix, height::Z};
 
@@ -152,7 +152,7 @@ const KEY_DEPTH: usize = 32;
 /// layout pads the real slots beyond this constant and owes that padding
 /// to its own `node_bytes` price.
 const REFERENCE_SLOT_BYTES: usize = std::mem::size_of::<(u8, typed::Node<(), Z>)>()
-    + std::mem::size_of::<(u8, Resolve<Local, (), Z>)>()
+    + std::mem::size_of::<(u8, Resolve<<Local as Backend<()>>::Erased>)>()
     + std::mem::size_of::<(u8, typed::Hash)>();
 
 /// Fixed in-memory bytes per buffered scope beyond its per-child slots:
@@ -328,7 +328,7 @@ impl Window {
     /// materialized, so the pair sum there is a priced envelope, pinned
     /// against reality by the census suite's reconciled-bound
     /// measurements. `node_bytes` must be an upper bound and monotone in
-    /// both arguments ([`Backend::node_bytes`](super::Backend::node_bytes)),
+    /// both arguments ([`Backend::node_bytes`]),
     /// so evaluating it at quantiles keeps the whole charge an upper
     /// bound; monotonicity is spot-checked here in debug builds.
     pub(crate) fn from_budget(
diff --git a/src/tree/typed/height.rs b/src/tree/typed/height.rs
index 854bca832..b9c47ac63 100644
--- a/src/tree/typed/height.rs
+++ b/src/tree/typed/height.rs
@@ -132,6 +132,39 @@ pub type Root =
 //  0 1 2 3 4 5 6 7 8 9 a b c d e f
     Z>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 
+/// Numbered aliases `H0` (= [`Z`]) through `H32` (= [`Root`]), one per
+/// height.
+///
+/// The vocabulary a runtime-to-type dispatch table indexes with
+/// `seq_macro` ident pasting, which can splice a numbered name but cannot
+/// build an `S<…>` chain (see the erased plumbing's `at_parent_height!`).
+/// Each alias is one successor over its predecessor by construction of
+/// the emitting macro, so a name always denotes its own number's height.
+macro_rules! alias_heights {
+    (@emit $t:ty; $name:ident $($rest:ident)*) => {
+        pub(crate) type $name = $t;
+        alias_heights!(@emit S<$t>; $($rest)*);
+    };
+    (@emit $t:ty;) => {};
+    ($($name:ident)*) => {
+        alias_heights!(@emit Z; $($name)*);
+    };
+}
+
+#[rustfmt::skip]
+alias_heights!(
+    H0  H1  H2  H3  H4  H5  H6  H7
+    H8  H9  H10 H11 H12 H13 H14 H15
+    H16 H17 H18 H19 H20 H21 H22 H23
+    H24 H25 H26 H27 H28 H29 H30 H31
+    H32
+);
+
+/// The table's endpoints are what their names claim; each alias being one
+/// successor over its predecessor by construction, every name between
+/// denotes its own number's height.
+const _: () = assert!(H0::HEIGHT == 0 && H32::HEIGHT == 32);
+
 mod sealed {
     use super::*;
     pub trait Sealed {}
diff --git a/src/tree/typed/prefix.rs b/src/tree/typed/prefix.rs
index 00bb66d33..ff08226a9 100644
--- a/src/tree/typed/prefix.rs
+++ b/src/tree/typed/prefix.rs
@@ -55,6 +55,32 @@ impl ErasedPrefix {
             hash: self.hash,
         }
     }
+
+    /// The height this prefix sits at: its byte length's complement,
+    /// exactly the `H::HEIGHT` of the [`Prefix<H>`] it erases.
+    pub fn height(&self) -> usize {
+        32 - self.hash.len()
+    }
+
+    /// The accumulated path bytes, shallowest-first ([`Prefix::as_bytes`]).
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.hash
+    }
+
+    /// Push one hash byte onto the end of the prefix, descending one
+    /// height ([`Prefix::push`]).
+    ///
+    /// # Panics
+    ///
+    /// If the prefix is already at height zero (a full 32-byte path).
+    pub fn push(mut self, byte: u8) -> ErasedPrefix {
+        assert!(
+            self.height() > 0,
+            "a leaf-height prefix has no level to descend into",
+        );
+        self.hash.push(byte);
+        self
+    }
 }
 
 impl Debug for ErasedPrefix {

From d8bef16b93d1cbf782e256538dfae8bcbb57754e Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Wed, 19 Aug 2026 17:52:12 -0400
Subject: [PATCH 04/18] streaming: erase the remote proxy's scopes, adapter,
 and pumps

The proxy joins the walk on the erased vocabulary. Scope collapses to
one type whose parent prefix is the height witness; the adapter's
encode/decode workers, the reply pumps, and the encoders are shared
bodies behind thin typed phase methods, with the decoded-reply exit
re-tagging at each stage's height exactly like the walk's respond. Two
new dispatches (erased::ops::{leaves, assemble}) carry the stream-shaped
backend operations, and the proxy's progress trace takes its heights as
the runtime data they already were.

Measured on --test pairwise (debug, default features):
1,717,836 lines / 67,158 copies -> 1,039,534 / 41,172. The
remote-labeled rows fall 837k -> 162k, tokio-mpsc-naming rows to 29k.
Cumulative from the parent: 2,884,887 / 109,613 -> 1,039,534 / 41,172
(-64% lines, -62% copies), completing design/height-erasure.md
steps 1-4. The wire snapshots are byte-identical throughout.
---
 src/tree/mirror/streaming/erased.rs           |  87 ++++++-
 .../streaming/materialized/work/queues.rs     |   7 +-
 .../mirror/streaming/remote/adapter/decode.rs | 159 +++++------
 .../mirror/streaming/remote/adapter/encode.rs |  56 ++--
 .../mirror/streaming/remote/adapter/scope.rs  |  50 ++--
 .../remote/adapter/tests/backend_errors.rs    |  13 +-
 .../remote/adapter/tests/fan_occupancy.rs     |  13 +-
 .../remote/adapter/tests/malformed.rs         |  86 +++---
 .../streaming/remote/adapter/tests/opening.rs |  54 ++--
 .../streaming/remote/adapter/tests/parking.rs |  25 +-
 .../remote/adapter/tests/properties.rs        |  93 +++----
 .../streaming/remote/adapter/tests/runs.rs    |  20 +-
 src/tree/mirror/streaming/remote/proxy.rs     |   6 +-
 .../mirror/streaming/remote/proxy/state.rs    |  21 +-
 .../mirror/streaming/remote/proxy/work.rs     |  57 ++--
 .../streaming/remote/proxy/work/encode.rs     |  70 ++---
 .../streaming/remote/proxy/work/progress.rs   |  21 +-
 .../streaming/remote/proxy/work/pump.rs       | 246 +++++++++++-------
 .../streaming/remote/proxy/work/queues.rs     |  39 ++-
 src/tree/typed/prefix.rs                      |  14 +
 20 files changed, 629 insertions(+), 508 deletions(-)

diff --git a/src/tree/mirror/streaming/erased.rs b/src/tree/mirror/streaming/erased.rs
index 16cb3defb..3fb93ec99 100644
--- a/src/tree/mirror/streaming/erased.rs
+++ b/src/tree/mirror/streaming/erased.rs
@@ -50,7 +50,6 @@ use crate::tree::{
     mirror::streaming::{
         Backend, Leaf,
         channel::{QueueRole, Receiver, Sender, channel},
-        materialized::Error,
         message,
     },
     typed::{
@@ -114,26 +113,26 @@ where
 }
 
 /// The typed exit of [`reply_channel`]: the erased receiver as a stream
-/// of schedule-typed replies.
-pub(crate) struct ReplyResultStream<B, T, H>
+/// of schedule-typed replies. `Err` is the session's error type, passed
+/// through untouched.
+pub(crate) struct ReplyResultStream<B, T, H, Err>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
     H: Height,
 {
-    inner: ReceiverStreamOf<Result<Reply<B::Erased>, Error<B::Error>>>,
-    assume: fn(
-        Result<Reply<B::Erased>, Error<B::Error>>,
-    ) -> Result<message::Reply<B, T, H>, Error<B::Error>>,
+    inner: ReceiverStreamOf<Result<Reply<B::Erased>, Err>>,
+    assume: fn(Result<Reply<B::Erased>, Err>) -> Result<message::Reply<B, T, H>, Err>,
 }
 
-impl<B, T, H> Stream for ReplyResultStream<B, T, H>
+impl<B, T, H, Err> Stream for ReplyResultStream<B, T, H, Err>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
     H: Height,
+    Err: Send,
 {
-    type Item = Result<message::Reply<B, T, H>, Error<B::Error>>;
+    type Item = Result<message::Reply<B, T, H>, Err>;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         let this = self.get_mut();
@@ -170,17 +169,18 @@ fn receiver_stream<E: Send>(receiver: Receiver<E>) -> ReceiverStreamOf<E> {
 /// in, typed out — and therefore the outgoing half of the walk's typed
 /// boundary. Its height parameter fixes the exit's re-tag; the erased
 /// sender needs none.
-pub(crate) fn reply_channel<B, T, H>(
+pub(crate) fn reply_channel<B, T, H, Err>(
     role: QueueRole,
     capacity: usize,
 ) -> (
-    Sender<Result<Reply<B::Erased>, Error<B::Error>>>,
-    ReplyResultStream<B, T, H>,
+    Sender<Result<Reply<B::Erased>, Err>>,
+    ReplyResultStream<B, T, H, Err>,
 )
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
     H: Height,
+    Err: Send,
 {
     let (sender, receiver) = channel(role, capacity);
     (
@@ -202,9 +202,13 @@ where
 /// the height from the prefix (rather than threading a separate counter)
 /// is what keeps the coordinate and the witness structurally inseparable.
 pub(crate) mod ops {
+    use futures::StreamExt;
+
     use super::*;
     use crate::tree::{
-        mirror::streaming::materialized::children_of as children_of_typed,
+        mirror::streaming::{
+            backend::BoxNodeStream, materialized::children_of as children_of_typed,
+        },
         typed::{ErasedPrefix, height::Pred},
     };
 
@@ -225,6 +229,19 @@ pub(crate) mod ops {
         }};
     }
 
+    /// Select the type-level height matching a runtime height, leaves
+    /// included: [`at_parent_height!`] minus the nonzero premise.
+    macro_rules! at_height {
+        ($height:expr, $H:ident => $body:expr) => {{
+            seq_macro::seq!(N in 0..=32 {
+                match $height {
+                    #(N => { type $H = crate::tree::typed::height::H~N; $body })*
+                    _ => unreachable!("a tree height is 0..=32"),
+                }
+            })
+        }};
+    }
+
     /// Collect one erased node's children, addressed by radix
     /// ([`children_of_typed`], erased).
     ///
@@ -280,4 +297,48 @@ pub(crate) mod ops {
                 .map(B::erase))
         })
     }
+
+    /// Walk every leaf beneath an erased node, in ascending path order
+    /// ([`Backend::leaves`], erased).
+    ///
+    /// The yielded leaves stay typed: `Z` is a single height, so nothing
+    /// about a leaf ever needed erasing.
+    pub(crate) fn leaves<B, T>(
+        backend: B,
+        prefix: ErasedPrefix,
+        node: B::Erased,
+    ) -> BoxNodeStream<'static, B, T, Z>
+    where
+        B: Backend<T, Node<Z>: Leaf<T>>,
+        T: Send + Sync + 'static,
+    {
+        at_height!(prefix.height(), H => {
+            Box::pin(backend.leaves::<H>(prefix.assume::<H>(), B::assume::<H>(node)))
+        })
+    }
+
+    /// Assemble a strictly ascending leaf stream into erased nodes at
+    /// `height`, one per maximal same-prefix run, in run order
+    /// ([`Backend::assemble`], erased).
+    ///
+    /// The one dispatch keyed by an explicit height rather than a prefix:
+    /// its input is a whole leaf stream, and the target height is the
+    /// consuming scope's — whose prefix length the caller derives it from.
+    pub(crate) fn assemble<B, T>(
+        backend: B,
+        height: usize,
+        leaves: BoxNodeStream<'static, B, T, Z>,
+    ) -> Pin<Box<dyn Stream<Item = Result<(ErasedPrefix, B::Erased), B::Error>> + Send>>
+    where
+        B: Backend<T, Node<Z>: Leaf<T>>,
+        T: Send + Sync + 'static,
+    {
+        at_height!(height, H => {
+            Box::pin(
+                backend
+                    .assemble::<H>(leaves)
+                    .map(|item| item.map(|(prefix, node)| (prefix.erase(), B::erase(node)))),
+            )
+        })
+    }
 }
diff --git a/src/tree/mirror/streaming/materialized/work/queues.rs b/src/tree/mirror/streaming/materialized/work/queues.rs
index dd36a5206..fc1285e58 100644
--- a/src/tree/mirror/streaming/materialized/work/queues.rs
+++ b/src/tree/mirror/streaming/materialized/work/queues.rs
@@ -45,14 +45,17 @@ use crate::tree::{
 /// retain whole messages without breaking another dependency.
 pub(super) fn outgoing_responses<B, T, H>() -> (
     Sender<Result<Reply<B::Erased>, Error<B::Error>>>,
-    ReplyResultStream<B, T, H>,
+    ReplyResultStream<B, T, H, Error<B::Error>>,
 )
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
     H: Height,
 {
-    erased::reply_channel::<B, T, H>(QueueRole::new(QueueKind::OutgoingResponses, H::HEIGHT), 1)
+    erased::reply_channel::<B, T, H, Error<B::Error>>(
+        QueueRole::new(QueueKind::OutgoingResponses, H::HEIGHT),
+        1,
+    )
 }
 
 /// Buffer lower-level completions until their enclosing resolution arrives.
diff --git a/src/tree/mirror/streaming/remote/adapter/decode.rs b/src/tree/mirror/streaming/remote/adapter/decode.rs
index d08d55011..819e637af 100644
--- a/src/tree/mirror/streaming/remote/adapter/decode.rs
+++ b/src/tree/mirror/streaming/remote/adapter/decode.rs
@@ -10,15 +10,11 @@ use crate::tree::{
     mirror::streaming::{
         Backend, Leaf,
         backend::BoxNodeStream,
-        convert::Convert,
+        erased::{Reaction as ProtocolReaction, Reply, ops},
         materialized::SupplyLedger,
-        message::{Reaction as ProtocolReaction, Reply},
         window::FAN,
     },
-    typed::{
-        Hash, Path, Prefix,
-        height::{Height, S, UnderRoot, Z},
-    },
+    typed::{ErasedPrefix, Hash, Path, Prefix, height::Z},
 };
 
 use super::{
@@ -29,13 +25,8 @@ use super::{
 
 use serde::de::DeserializeOwned;
 /// One reconstructed reply and any questions it asks next.
-pub struct Decoded<B, T, H, Q>
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-{
-    pub reply: Reply<B, T, H>,
+pub struct Decoded<E, Q> {
+    pub reply: Reply<E>,
     pub questions: Q,
 }
 
@@ -46,11 +37,7 @@ where
 /// validated the listing's canonical order, so synthesizing the one-query
 /// reply and its root scope is infallible. An empty listing replays an empty
 /// opening `Query` — the empty-tree initiator's "send everything".
-pub fn opening_reply<B, T>(listing: Vec<(u8, Hash)>) -> (Reply<B, T, UnderRoot>, Scope<UnderRoot>)
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-{
+pub fn opening_reply<E>(listing: Vec<(u8, Hash)>) -> (Reply<E>, Scope) {
     let scope = Scope::opening(&listing);
     (
         Reply {
@@ -61,14 +48,15 @@ where
 }
 
 /// Incrementally decode the initiator's opening-supply reply into whole
-/// height-`G` nodes with their root radices, in ascending radix order.
+/// nodes one level under `parent`, with their root radices, in ascending
+/// radix order.
 ///
 /// The wire shape is one supplies-only reply — empty when deletion pruning
-/// left nothing to ship — whose leaf records group into height-`G`
-/// subtrees by their version-derived paths under `parent`, followed by the
-/// stream end. Unlike [`decode_reply`], which materializes one whole reply
-/// before yielding it, this stream yields each assembled node as soon as
-/// its group completes: the consumer pairs supplies with the responder's
+/// left nothing to ship — whose leaf records group into subtrees one level
+/// under `parent` by their version-derived paths, followed by the stream
+/// end. Unlike [`decode_reply`], which materializes one whole reply before
+/// yielding it, this stream yields each assembled node as soon as its
+/// group completes: the consumer pairs supplies with the responder's
 /// root-level requests one radix at a time, so a later group's bulk never
 /// gates an earlier group's absorption.
 ///
@@ -77,18 +65,16 @@ where
 /// [`DecodeError::OversizedVersion`] session violation. `ledger` is the
 /// session's declared-`set_len` allowance, charged per record before the
 /// payload takes custody ([`DecodeError::OverdrawnSupply`]).
-pub fn early_supplies<B, T, G, F>(
+pub fn early_supplies<B, T, F>(
     backend: B,
     version_bytes: u64,
     ledger: SupplyLedger,
-    parent: Prefix<S<G>>,
+    parent: ErasedPrefix,
     frames: F,
-) -> impl Stream<Item = Result<(u8, B::Node<G>), DecodeError<B::Error>>> + Send
+) -> impl Stream<Item = Result<(u8, B::Erased), DecodeError<B::Error>>> + Send
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: DeserializeOwned + Send + Sync + 'static,
-    G: Convert,
-    S<G>: Height,
     F: Stream<Item = Frame<T>> + Unpin + Send + 'static,
 {
     try_stream! {
@@ -99,8 +85,12 @@ where
         #[cfg(test)]
         let leaves = leaves.inspect(|_| fan_probe::on_recv());
         let leaves: BoxNodeStream<'static, B, T, Z> = Box::pin(leaves);
-        let mut assembled = pin!(backend.clone().assemble::<G>(leaves));
-        let mut read = pin!(read_early::<B, T, G, _>(
+        let mut assembled = pin!(ops::assemble(
+            backend.clone(),
+            parent.height() - 1,
+            leaves
+        ));
+        let mut read = pin!(read_early::<B, T, _>(
             version_bytes,
             &ledger,
             parent,
@@ -142,21 +132,19 @@ where
 
 /// Read the opening-supply reply's frames — supplies only, one reply,
 /// nothing after it — streaming its leaves to assembly.
-async fn read_early<B, T, G, F>(
+async fn read_early<B, T, F>(
     version_bytes: u64,
     ledger: &SupplyLedger,
-    parent: Prefix<S<G>>,
+    parent: ErasedPrefix,
     mut frames: F,
     leaves: mpsc::Sender<Result<(Prefix<Z>, B::Node<Z>), B::Error>>,
 ) -> Result<(), DecodeError<B::Error>>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: DeserializeOwned + Send + Sync + 'static,
-    G: Height,
-    S<G>: Height,
     F: Stream<Item = Frame<T>> + Unpin,
 {
-    let mut supplies = SupplyRuns::<G>::new(version_bytes);
+    let mut supplies = SupplyRuns::new(version_bytes);
     let mut any = false;
     loop {
         let Some(frame) = frames.next().await else {
@@ -211,19 +199,16 @@ where
 }
 
 /// Decode one non-leaf reply and derive the lower questions it asks.
-pub async fn decode_reply<B, T, H, F>(
+pub async fn decode_reply<B, T, F>(
     backend: B,
     version_bytes: u64,
     ledger: SupplyLedger,
-    scope: Scope<S<H>>,
+    scope: Scope,
     frames: &mut F,
-) -> Result<Decoded<B, T, S<H>, Vec<Scope<H>>>, DecodeError<B::Error>>
+) -> Result<Decoded<B::Erased, Vec<Scope>>, DecodeError<B::Error>>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: DeserializeOwned + Send + Sync + 'static,
-    H: Height,
-    S<H>: Convert,
-    S<S<H>>: Height,
     F: Stream<Item = Frame<T>> + Unpin,
 {
     decode(
@@ -245,9 +230,9 @@ pub async fn decode_leaf_reply<B, T, F>(
     backend: B,
     version_bytes: u64,
     ledger: SupplyLedger,
-    scope: Scope<Z>,
+    scope: Scope,
     frames: &mut F,
-) -> Result<Decoded<B, T, Z, Vec<Scope<Z>>>, DecodeError<B::Error>>
+) -> Result<Decoded<B::Erased, Vec<Scope>>, DecodeError<B::Error>>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: DeserializeOwned + Send + Sync + 'static,
@@ -270,22 +255,23 @@ where
     .await
 }
 
-async fn decode<B, T, H, F, Q, N>(
+async fn decode<B, T, F, Q, N>(
     backend: B,
     version_bytes: u64,
     ledger: SupplyLedger,
-    scope: Scope<H>,
+    scope: Scope,
     frames: &mut F,
     question: Q,
-) -> Result<Decoded<B, T, H, Vec<N>>, DecodeError<B::Error>>
+) -> Result<Decoded<B::Erased, Vec<N>>, DecodeError<B::Error>>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: DeserializeOwned + Send + Sync + 'static,
-    H: Convert,
-    S<H>: Height,
     F: Stream<Item = Frame<T>> + Unpin,
-    Q: FnMut(&mut Scope<H>, &[(u8, Hash)]) -> Result<N, ScopeError>,
+    Q: FnMut(&mut Scope, &[(u8, Hash)]) -> Result<N, ScopeError>,
 {
+    // The reply's supplied runs group into nodes one level under the
+    // scope's parent: the scope's own children height.
+    let children_height = scope.parent().height() - 1;
     // One fan of buffered leaves, amortizing the reader/assembler waker
     // round trip over runs of consecutive leaves instead of paying it per
     // leaf. The capacity is load-bearing for liveness: the channel must
@@ -297,8 +283,8 @@ where
     // reader's hand per reply stream, at `node_bytes(0, version_bound)`
     // plus the slot itself (the window's supply-decode envelope).
     let (tx, rx) = mpsc::channel::<Result<(Prefix<Z>, B::Node<Z>), B::Error>>(FAN);
-    let read = read_reply::<B, T, H, _, _, _>(version_bytes, &ledger, scope, frames, question, tx);
-    let assemble = assemble_supplies::<B, T, H>(backend, rx);
+    let read = read_reply::<B, T, _, _, _>(version_bytes, &ledger, scope, frames, question, tx);
+    let assemble = assemble_supplies::<B, T>(backend, children_height, rx);
     let (read, assembled) = futures::future::join(read, assemble).await;
     let Some(ReadReply {
         skeleton,
@@ -309,26 +295,24 @@ where
         assembled?;
         unreachable!("the assembler accepts leaves until it returns an error")
     };
-    let reply = reify(skeleton, assembled?);
+    let reply = reify::<B::Erased>(skeleton, assembled?);
     Ok(Decoded { reply, questions })
 }
 
 /// Read and validate exactly one reply while streaming its leaves to assembly.
-async fn read_reply<B, T, H, F, Q, N>(
+async fn read_reply<B, T, F, Q, N>(
     version_bytes: u64,
     ledger: &SupplyLedger,
-    mut scope: Scope<H>,
+    mut scope: Scope,
     frames: &mut F,
     mut question: Q,
     leaves: mpsc::Sender<Result<(Prefix<Z>, B::Node<Z>), B::Error>>,
-) -> Result<Option<ReadReply<H, N>>, DecodeError<B::Error>>
+) -> Result<Option<ReadReply<N>>, DecodeError<B::Error>>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: DeserializeOwned + Send + Sync + 'static,
-    H: Height,
-    S<H>: Height,
     F: Stream<Item = Frame<T>> + Unpin,
-    Q: FnMut(&mut Scope<H>, &[(u8, Hash)]) -> Result<N, ScopeError>,
+    Q: FnMut(&mut Scope, &[(u8, Hash)]) -> Result<N, ScopeError>,
 {
     let mut read = ReadReply::new(version_bytes);
     loop {
@@ -404,21 +388,22 @@ where
     Ok(Some(read))
 }
 
-/// Fold the reply's one-slot leaf stream into complete height-`H` nodes.
-async fn assemble_supplies<B, T, H>(
+/// Fold the reply's one-slot leaf stream into complete nodes at the
+/// scope's children height.
+async fn assemble_supplies<B, T>(
     backend: B,
+    height: usize,
     leaves: mpsc::Receiver<Result<(Prefix<Z>, B::Node<Z>), B::Error>>,
-) -> Result<Vec<(Prefix<H>, B::Node<H>)>, DecodeError<B::Error>>
+) -> Result<Vec<(ErasedPrefix, B::Erased)>, DecodeError<B::Error>>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
-    H: Convert,
 {
     let leaves = ReceiverStream::new(leaves);
     #[cfg(test)]
     let leaves = leaves.inspect(|_| fan_probe::on_recv());
-    let leaves: BoxNodeStream<'_, B, T, Z> = Box::pin(leaves);
-    let mut assembled = pin!(backend.assemble::<H>(leaves));
+    let leaves: BoxNodeStream<'static, B, T, Z> = Box::pin(leaves);
+    let mut assembled = pin!(ops::assemble(backend, height, leaves));
     let mut nodes = Vec::new();
     while let Some(item) = assembled.next().await {
         nodes.push(item.map_err(DecodeError::Backend)?);
@@ -427,12 +412,7 @@ where
 }
 
 /// Replace supplied-prefix placeholders with the nodes assembled for them.
-fn reify<B, T, H>(skeleton: Vec<Skeleton<H>>, nodes: Vec<(Prefix<H>, B::Node<H>)>) -> Reply<B, T, H>
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-    H: Height,
-{
+fn reify<E>(skeleton: Vec<Skeleton>, nodes: Vec<(ErasedPrefix, E)>) -> Reply<E> {
     let mut nodes = nodes.into_iter();
     let replies = skeleton
         .into_iter()
@@ -458,13 +438,13 @@ where
     Reply { replies }
 }
 
-struct ReadReply<H: Height, N> {
-    skeleton: Vec<Skeleton<H>>,
+struct ReadReply<N> {
+    skeleton: Vec<Skeleton>,
     questions: Vec<N>,
-    supplies: SupplyRuns<H>,
+    supplies: SupplyRuns,
 }
 
-impl<H: Height, N> ReadReply<H, N> {
+impl<N> ReadReply<N> {
     fn new(version_bytes: u64) -> Self {
         Self {
             skeleton: Vec::new(),
@@ -474,16 +454,16 @@ impl<H: Height, N> ReadReply<H, N> {
     }
 }
 
-struct SupplyRuns<H: Height> {
+struct SupplyRuns {
     /// The peer's greeting-declared `max_version_bytes`, covering every
     /// version its tree materializes and so every version it may supply.
     version_bytes: u64,
     previous_leaf: Option<Prefix<Z>>,
-    current: Option<Prefix<H>>,
+    current: Option<ErasedPrefix>,
     previous_radix: Option<u8>,
 }
 
-impl<H: Height> SupplyRuns<H> {
+impl SupplyRuns {
     fn new(version_bytes: u64) -> Self {
         Self {
             version_bytes,
@@ -498,14 +478,15 @@ impl<H: Height> SupplyRuns<H> {
     }
 
     /// Validate one supplied leaf and identify the start of a new run.
+    ///
+    /// The run boundary sits one level under `expected_parent`: the
+    /// supplied leaf's path must extend the parent prefix, and the byte
+    /// after it is the run's radix.
     fn observe<E>(
         &mut self,
-        expected_parent: Prefix<S<H>>,
+        expected_parent: ErasedPrefix,
         version: &crate::Version,
-    ) -> Result<(Prefix<Z>, Option<(u8, Prefix<H>)>), DecodeError<E>>
-    where
-        S<H>: Height,
-    {
+    ) -> Result<(Prefix<Z>, Option<(u8, ErasedPrefix)>), DecodeError<E>> {
         // The declared aggregate covers every version the peer's tree
         // materializes, so every version it supplies must encode within
         // it; one arriving over the declaration voids the premise the
@@ -520,14 +501,16 @@ impl<H: Height> SupplyRuns<H> {
         }
         let path = Path::for_leaf(version);
         let leaf_prefix = Prefix::<Z>::containing(&path);
-        let node_prefix = Prefix::<H>::containing(&path);
-        let (parent, radix) = node_prefix.pop();
-        if parent != expected_parent {
+        let path_bytes = <[u8; 32]>::from(path);
+        let parent_len = expected_parent.as_bytes().len();
+        if &path_bytes[..parent_len] != expected_parent.as_bytes() {
             return Err(DecodeError::LeafOutsideScope {
                 expected: expected_parent.as_bytes().to_vec(),
                 actual: path.into(),
             });
         }
+        let radix = path_bytes[parent_len];
+        let node_prefix = expected_parent.push(radix);
         if let Some(previous) = self
             .previous_leaf
             .filter(|previous| *previous >= leaf_prefix)
@@ -556,10 +539,10 @@ impl<H: Height> SupplyRuns<H> {
     }
 }
 
-enum Skeleton<H: Height> {
+enum Skeleton {
     Match,
     Query(Vec<(u8, Hash)>),
-    Supply { radix: u8, prefix: Prefix<H> },
+    Supply { radix: u8, prefix: ErasedPrefix },
 }
 
 /// Test-gated occupancy probe for the reader/assembler fan channels.
diff --git a/src/tree/mirror/streaming/remote/adapter/encode.rs b/src/tree/mirror/streaming/remote/adapter/encode.rs
index b624ec92d..a2231a9c6 100644
--- a/src/tree/mirror/streaming/remote/adapter/encode.rs
+++ b/src/tree/mirror/streaming/remote/adapter/encode.rs
@@ -6,13 +6,9 @@ use futures::{Stream, StreamExt};
 use crate::tree::{
     mirror::streaming::{
         Backend, Leaf, Node,
-        convert::Convert,
-        message::{Reaction as ProtocolReaction, Reply},
-    },
-    typed::{
-        Hash, Path, Prefix,
-        height::{Height, S, UnderRoot, Z},
+        erased::{Reaction as ProtocolReaction, Reply, ops},
     },
+    typed::{ErasedPrefix, Hash, Path, Prefix, height::Z},
 };
 
 use super::{
@@ -60,13 +56,9 @@ pub type Frames<T, E, Q> =
 /// root children; they alone occupy wire frames, as the opening-supply
 /// reply on the initiator's first stream.
 #[allow(clippy::type_complexity)]
-pub fn opening_parts<B, T>(
-    reply: Reply<B, T, UnderRoot>,
-) -> Result<(Vec<(u8, Hash)>, Vec<ProtocolReaction<B, T, UnderRoot>>), OpeningError>
-where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
-{
+pub fn opening_parts<E>(
+    reply: Reply<E>,
+) -> Result<(Vec<(u8, Hash)>, Vec<ProtocolReaction<E>>), OpeningError> {
     let mut reactions = reply.replies.into_iter();
     let Some(first) = reactions.next() else {
         return Err(OpeningError::Empty);
@@ -86,18 +78,15 @@ where
 }
 
 /// Encode one non-leaf reply and derive the lower questions it asks.
-pub fn encode_reply<B, T, H>(
+pub fn encode_reply<B, T>(
     backend: B,
     budget: RunBudget,
-    scope: Scope<S<H>>,
-    reply: Reply<B, T, S<H>>,
-) -> Frames<T, B::Error, Scope<H>>
+    scope: Scope,
+    reply: Reply<B::Erased>,
+) -> Frames<T, B::Error, Scope>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
-    H: Height,
-    S<H>: Convert,
-    S<S<H>>: Height,
 {
     render(
         backend,
@@ -124,9 +113,9 @@ where
 pub fn encode_leaf_reply<B, T>(
     backend: B,
     budget: RunBudget,
-    scope: Scope<Z>,
-    reply: Reply<B, T, Z>,
-) -> Frames<T, B::Error, Scope<Z>>
+    scope: Scope,
+    reply: Reply<B::Erased>,
+) -> Frames<T, B::Error, Scope>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
@@ -155,20 +144,17 @@ where
     )
 }
 
-fn render<B, T, H, Q, D>(
+fn render<B, T, D>(
     backend: B,
     budget: RunBudget,
-    mut scope: Scope<H>,
-    reply: Reply<B, T, H>,
+    mut scope: Scope,
+    reply: Reply<B::Erased>,
     mut derive: D,
-) -> Frames<T, B::Error, Q>
+) -> Frames<T, B::Error, Scope>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
-    H: Convert,
-    S<H>: Height,
-    Q: Send + 'static,
-    D: FnMut(&mut Scope<H>, &ProtocolReaction<B, T, H>) -> Result<Option<Q>, ScopeError>
+    D: FnMut(&mut Scope, &ProtocolReaction<B::Erased>) -> Result<Option<Scope>, ScopeError>
         + Send
         + 'static,
 {
@@ -200,7 +186,7 @@ where
                 ProtocolReaction::Supply(radix, node) => {
                     debug_assert!(question.is_none());
                     let expected = scope.supplied(radix);
-                    let mut leaves = pin!(backend.clone().leaves(expected, node));
+                    let mut leaves = pin!(ops::leaves(backend.clone(), expected, node));
                     let mut previous = None;
                     // One run accumulates this reaction's leaves; it flushes
                     // when the next record would push its wire frame past
@@ -264,11 +250,11 @@ where
     })
 }
 
-fn validate_leaf<H: Height>(expected: Prefix<H>, previous: Option<Prefix<Z>>, current: Prefix<Z>) {
+fn validate_leaf(expected: ErasedPrefix, previous: Option<Prefix<Z>>, current: Prefix<Z>) {
     let path = Path::from(current);
     assert_eq!(
-        Prefix::<H>::containing(&path),
-        expected,
+        &<[u8; 32]>::from(path)[..expected.as_bytes().len()],
+        expected.as_bytes(),
         "a backend enumerates leaves beneath the requested node prefix",
     );
     if let Some(previous) = previous {
diff --git a/src/tree/mirror/streaming/remote/adapter/scope.rs b/src/tree/mirror/streaming/remote/adapter/scope.rs
index 99895e65d..3e94f1164 100644
--- a/src/tree/mirror/streaming/remote/adapter/scope.rs
+++ b/src/tree/mirror/streaming/remote/adapter/scope.rs
@@ -1,29 +1,23 @@
-use crate::tree::typed::{
-    Hash, Prefix,
-    height::{Height, S, UnderRoot, Z},
-};
+use crate::tree::typed::{ErasedPrefix, Hash, Prefix};
 
 /// The local knowledge needed to interpret one future prefix-free reply.
 ///
-/// `parent` names the scope whose height-`H` children the reply discusses;
-/// `children` preserves the positional radices from the `Query` which created
-/// it. Supplies remain self-keying and therefore do not advance `next`.
+/// `parent` names the scope whose children the reply discusses — its byte
+/// length is the scope's height witness, exactly one level above the
+/// children (see [`erased`](crate::tree::mirror::streaming::erased)) —
+/// and `children` preserves the positional radices from the `Query` which
+/// created it. Supplies remain self-keying and therefore do not advance
+/// `next`.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Scope<H: Height>
-where
-    S<H>: Height,
-{
-    parent: Prefix<S<H>>,
+pub struct Scope {
+    parent: ErasedPrefix,
     children: Vec<u8>,
     next: usize,
 }
 
-impl<H: Height> Scope<H>
-where
-    S<H>: Height,
-{
+impl Scope {
     /// Record the question represented by `listing` at `parent`.
-    pub fn new(parent: Prefix<S<H>>, listing: &[(u8, Hash)]) -> Self {
+    pub fn new(parent: ErasedPrefix, listing: &[(u8, Hash)]) -> Self {
         Self {
             parent,
             children: listing.iter().map(|(radix, _)| *radix).collect(),
@@ -32,7 +26,7 @@ where
     }
 
     /// The parent prefix against which keyed supplies are validated.
-    pub fn parent(&self) -> Prefix<S<H>> {
+    pub fn parent(&self) -> ErasedPrefix {
         self.parent
     }
 
@@ -43,21 +37,27 @@ where
     }
 
     /// Resolve the next positional reaction to its child radix and prefix.
-    pub fn next(&mut self) -> Option<(u8, Prefix<H>)> {
+    pub fn next(&mut self) -> Option<(u8, ErasedPrefix)> {
         let radix = *self.children.get(self.next)?;
         self.next += 1;
         Some((radix, self.parent.push(radix)))
     }
 
     /// Resolve a keyed supply to its claimed child prefix.
-    pub fn supplied(&self, radix: u8) -> Prefix<H> {
+    pub fn supplied(&self, radix: u8) -> ErasedPrefix {
         self.parent.push(radix)
     }
-}
 
-impl Scope<Z> {
     /// Retain the one leaf position requested by a terminal empty query.
-    pub fn leaf(prefix: Prefix<Z>) -> Self {
+    ///
+    /// `prefix` is the requested leaf's full path, so the derived scope
+    /// sits one level above the leaves.
+    pub fn leaf(prefix: ErasedPrefix) -> Self {
+        debug_assert_eq!(
+            prefix.height(),
+            0,
+            "a terminal request names a full leaf path",
+        );
         let (parent, radix) = prefix.pop();
         Self {
             parent,
@@ -65,11 +65,9 @@ impl Scope<Z> {
             next: 0,
         }
     }
-}
 
-impl Scope<UnderRoot> {
     /// Record the initiator's opening question about the root's children.
     pub fn opening(listing: &[(u8, Hash)]) -> Self {
-        Self::new(Prefix::new(), listing)
+        Self::new(Prefix::new().erase(), listing)
     }
 }
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/backend_errors.rs b/src/tree/mirror/streaming/remote/adapter/tests/backend_errors.rs
index 541a44a71..0eb0dff9e 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/backend_errors.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/backend_errors.rs
@@ -6,8 +6,8 @@ use futures::{StreamExt, stream};
 
 use crate::tree::{
     mirror::streaming::{
-        Failing, FailingNode, Failure, Local, Operation,
-        message::{Reaction, Reply},
+        Backend, Failing, FailingNode, Failure, Local, Operation,
+        erased::{Reaction, Reply},
     },
     typed::{
         self, Prefix,
@@ -68,7 +68,8 @@ where
 
         for fail_after in 0..Self::HEIGHT {
             let backend = Failing::after(Local, fail_after);
-            let supply = FailingNode::new(Self::node(leaf));
+            let supply =
+                <Failing<Local> as Backend<u64>>::erase(FailingNode::new(Self::node(leaf)));
             let replies = if supply_radix < u8::MAX {
                 vec![
                     Reaction::Supply(supply_radix, supply),
@@ -83,7 +84,7 @@ where
             let mut encoded = encode_reply(
                 backend.clone(),
                 RunBudget::default(),
-                Scope::new(parent, &listing),
+                Scope::new(parent.erase(), &listing),
                 Reply { replies },
             );
             let (yielded, error, ended) = runtime.block_on(async {
@@ -129,11 +130,11 @@ where
                 sentinel.clone(),
             ]);
             let error = runtime
-                .block_on(decode_reply::<Failing<Local>, u64, H, _>(
+                .block_on(decode_reply::<Failing<Local>, u64, _>(
                     backend.clone(),
                     u64::MAX,
                     unbounded(),
-                    Scope::new(parent, &[]),
+                    Scope::new(parent.erase(), &[]),
                     &mut frames,
                 ))
                 .err()
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/fan_occupancy.rs b/src/tree/mirror/streaming/remote/adapter/tests/fan_occupancy.rs
index f740d6c04..5a3d67f5a 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/fan_occupancy.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/fan_occupancy.rs
@@ -27,10 +27,7 @@ use crate::{
             remote::codec::{Flow, Frame, LeafRun, Reaction as WireReaction},
             window::FAN,
         },
-        typed::{
-            Path, Prefix,
-            height::{UnderRoot, UnderUnderRoot},
-        },
+        typed::{Path, Prefix},
     },
 };
 
@@ -82,11 +79,11 @@ fn peak_occupancy(mut input: impl Stream<Item = Frame<u64>> + Unpin) -> usize {
     let runtime = super::runtime();
     fan_probe::reset();
     runtime.block_on(async {
-        decode_reply::<Local, u64, UnderUnderRoot, _>(
+        decode_reply::<Local, u64, _>(
             Local,
             u64::MAX,
             unbounded(),
-            Scope::<UnderRoot>::opening(&[]),
+            Scope::opening(&[]),
             &mut input,
         )
         .await
@@ -134,11 +131,11 @@ fn eager_early_supplies_ride_the_same_ceiling() {
     let runtime = super::runtime();
     fan_probe::reset();
     runtime.block_on(async {
-        let assembled: Vec<_> = early_supplies::<Local, u64, UnderRoot, _>(
+        let assembled: Vec<_> = early_supplies::<Local, u64, _>(
             Local,
             u64::MAX,
             unbounded(),
-            Prefix::new(),
+            Prefix::new().erase(),
             stream::iter(frames(&leaves)),
         )
         .try_collect()
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs b/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs
index cc213e333..54cd4c4f4 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs
@@ -11,7 +11,7 @@ use crate::{
         mirror::streaming::{Backend, Local},
         typed::{
             Path, Prefix,
-            height::{S, UnderRoot, UnderUnderRoot, Z},
+            height::{S, UnderRoot, Z},
         },
     },
 };
@@ -23,7 +23,7 @@ use super::{
     },
     LeafCase, hash, leaf_run, runtime, unbounded,
 };
-use crate::tree::mirror::streaming::message::{Reaction, Reply};
+use crate::tree::mirror::streaming::erased::{Reaction, Reply};
 use crate::tree::mirror::streaming::remote::codec::{
     DecodeLeafError, End, Flow, Frame, LeafRun, Reaction as WireReaction, RunBudget,
 };
@@ -44,7 +44,7 @@ fn bare_end_cannot_follow_reactions() {
             Local,
             u64::MAX,
             unbounded(),
-            Scope::new(parent, &[(0, hash(0))]),
+            Scope::new(parent.erase(), &[(0, hash(0))]),
             &mut frames,
         )
         .await
@@ -66,7 +66,7 @@ fn stream_exhaustion_before_a_boundary_is_truncation() {
             Local,
             u64::MAX,
             unbounded(),
-            Scope::new(parent, &[(0, hash(0))]),
+            Scope::new(parent.erase(), &[(0, hash(0))]),
             &mut frames,
         )
         .await
@@ -95,11 +95,11 @@ fn an_unpositioned_match_is_rejected_in_both_directions() {
 
     let decode_error = runtime().block_on(async {
         let mut frames = stream::iter(frames);
-        decode_reply::<Local, (), Z, _>(
+        decode_reply::<Local, (), _>(
             Local,
             u64::MAX,
             unbounded(),
-            Scope::new(parent, &[(1, hash(1))]),
+            Scope::new(parent.erase(), &[(1, hash(1))]),
             &mut frames,
         )
         .await
@@ -111,14 +111,14 @@ fn an_unpositioned_match_is_rejected_in_both_directions() {
         DecodeError::Scope(ScopeError::UnpositionedMatch)
     ));
 
-    let reply = Reply::<Local, (), S<Z>> {
+    let reply = Reply::<<Local as Backend<()>>::Erased> {
         replies: vec![Reaction::Match, Reaction::Match],
     };
     let encode_error = runtime().block_on(async {
         encode_reply(
             Local,
             RunBudget::default(),
-            Scope::new(parent, &[(1, hash(1))]),
+            Scope::new(parent.erase(), &[(1, hash(1))]),
             reply,
         )
         .try_collect::<Vec<_>>()
@@ -145,11 +145,11 @@ fn an_unpositioned_query_is_rejected_in_both_directions() {
 
     let decode_error = runtime().block_on(async {
         let mut frames = stream::iter(frames);
-        decode_reply::<Local, (), Z, _>(
+        decode_reply::<Local, (), _>(
             Local,
             u64::MAX,
             unbounded(),
-            Scope::new(parent, &[]),
+            Scope::new(parent.erase(), &[]),
             &mut frames,
         )
         .await
@@ -161,15 +161,20 @@ fn an_unpositioned_query_is_rejected_in_both_directions() {
         DecodeError::Scope(ScopeError::UnpositionedQuery)
     ));
 
-    let reply = Reply::<Local, (), S<Z>> {
+    let reply = Reply::<<Local as Backend<()>>::Erased> {
         replies: vec![Reaction::Query(listing)],
     };
     let encode_error = runtime().block_on(async {
-        encode_reply(Local, RunBudget::default(), Scope::new(parent, &[]), reply)
-            .try_collect::<Vec<_>>()
-            .await
-            .err()
-            .expect("an unpositioned query cannot be put on the wire")
+        encode_reply(
+            Local,
+            RunBudget::default(),
+            Scope::new(parent.erase(), &[]),
+            reply,
+        )
+        .try_collect::<Vec<_>>()
+        .await
+        .err()
+        .expect("an unpositioned query cannot be put on the wire")
     });
     assert!(matches!(
         encode_error,
@@ -207,14 +212,14 @@ fn leaf_query_matrix_is_exhaustive() {
             let expected_frame =
                 Frame::Reaction(WireReaction::Query(query_listing.clone()), Flow::End);
 
-            let reply = Reply::<Local, (), Z> {
+            let reply = Reply::<<Local as Backend<()>>::Erased> {
                 replies: vec![Reaction::Query(query_listing.clone())],
             };
             let encoded = runtime().block_on(async {
                 encode_leaf_reply(
                     Local,
                     RunBudget::default(),
-                    Scope::new(parent, &scope_listing),
+                    Scope::new(parent.erase(), &scope_listing),
                     reply,
                 )
                 .map_ok(|encoded| encoded.into_parts())
@@ -232,7 +237,7 @@ fn leaf_query_matrix_is_exhaustive() {
                         panic!("a leaf query encodes as exactly one frame")
                     };
                     assert_eq!(frame, &expected_frame);
-                    assert_eq!(question, &Some(Scope::leaf(parent.push(radix))));
+                    assert_eq!(question, &Some(Scope::leaf(parent.push(radix).erase())));
                 }
             }
             checked += 1;
@@ -243,7 +248,7 @@ fn leaf_query_matrix_is_exhaustive() {
                     Local,
                     u64::MAX,
                     unbounded(),
-                    Scope::new(parent, &scope_listing),
+                    Scope::new(parent.erase(), &scope_listing),
                     &mut frames,
                 )
                 .await
@@ -255,7 +260,10 @@ fn leaf_query_matrix_is_exhaustive() {
                 }
                 None => {
                     let decoded = decoded.expect("this matrix cell must decode");
-                    assert_eq!(decoded.questions, vec![Scope::leaf(parent.push(radix))]);
+                    assert_eq!(
+                        decoded.questions,
+                        vec![Scope::leaf(parent.push(radix).erase())]
+                    );
                     let [Reaction::Query(listing)] = decoded.reply.replies.as_slice() else {
                         panic!("the decoded reaction must remain a query")
                     };
@@ -280,7 +288,7 @@ fn stream_end_is_not_a_protocol_reply() {
             Local,
             u64::MAX,
             unbounded(),
-            Scope::new(parent, &[]),
+            Scope::new(parent.erase(), &[]),
             &mut frames,
         ))
         .err()
@@ -333,26 +341,24 @@ fn a_multi_leaf_run_is_one_supplied_subtree() {
             Flow::End,
         ),
     ];
-    let scope = Scope::<UnderRoot>::opening(&[]);
+    let scope = Scope::opening(&[]);
 
     let reencoded = runtime().block_on(async {
         let mut input = stream::iter(frames.clone());
-        let decoded = decode_reply::<Local, u64, UnderUnderRoot, _>(
-            Local,
-            u64::MAX,
-            unbounded(),
-            scope.clone(),
-            &mut input,
-        )
-        .await
-        .expect("ascending in-scope leaves assemble");
+        let decoded =
+            decode_reply::<Local, u64, _>(Local, u64::MAX, unbounded(), scope.clone(), &mut input)
+                .await
+                .expect("ascending in-scope leaves assemble");
         assert_eq!(decoded.reply.replies.len(), 1);
         let [Reaction::Supply(_, node)] = decoded.reply.replies.as_slice() else {
             panic!("one leaf run must become one supplied node")
         };
         let supplied_prefix = Prefix::<UnderRoot>::containing(&leaves[0].2);
         let rebuilt = Local
-            .leaves(supplied_prefix, node.clone())
+            .leaves(
+                supplied_prefix,
+                <Local as Backend<u64>>::assume::<UnderRoot>(node.clone()),
+            )
             .try_collect::<Vec<_>>()
             .await
             .expect("the local backend is infallible");
@@ -395,7 +401,7 @@ fn leaf_order_is_enforced_within_one_run() {
 
     let error = runtime().block_on(async {
         let mut input = stream::iter(frames);
-        decode_reply::<Local, u64, UnderUnderRoot, _>(
+        decode_reply::<Local, u64, _>(
             Local,
             u64::MAX,
             unbounded(),
@@ -440,7 +446,7 @@ fn leaf_scope_is_enforced_within_one_run() {
             Local,
             u64::MAX,
             unbounded(),
-            Scope::new(parent, &[]),
+            Scope::new(parent.erase(), &[]),
             &mut input,
         )
         .await
@@ -472,7 +478,7 @@ fn a_zero_length_record_fails_as_a_version_decode_error() {
 
     let error = runtime().block_on(async {
         let mut input = stream::iter(frames);
-        decode_reply::<Local, u64, UnderUnderRoot, _>(
+        decode_reply::<Local, u64, _>(
             Local,
             u64::MAX,
             unbounded(),
@@ -513,7 +519,7 @@ fn a_version_over_the_declared_bound_is_rejected() {
             Local,
             declared,
             unbounded(),
-            Scope::new(parent, &[]),
+            Scope::new(parent.erase(), &[]),
             &mut input,
         )
         .await
@@ -526,7 +532,7 @@ fn a_version_over_the_declared_bound_is_rejected() {
             Local,
             declared - 1,
             unbounded(),
-            Scope::new(parent, &[]),
+            Scope::new(parent.erase(), &[]),
             &mut input,
         )
         .await
@@ -601,7 +607,7 @@ fn a_reply_past_the_declared_set_len_fails_at_its_first_over_record() {
         let (live, _) = census::read();
         let decoded = runtime().block_on(async {
             let mut input = stream::iter(frames);
-            decode_reply::<Local, u64, UnderUnderRoot, _>(
+            decode_reply::<Local, u64, _>(
                 Local,
                 u64::MAX,
                 SupplyLedger::new(declared),
@@ -676,7 +682,7 @@ fn a_supply_run_cannot_resume_after_another_reaction() {
 
     let error = runtime().block_on(async {
         let mut input = stream::iter(frames);
-        decode_reply::<Local, u64, UnderUnderRoot, _>(
+        decode_reply::<Local, u64, _>(
             Local,
             u64::MAX,
             unbounded(),
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/opening.rs b/src/tree/mirror/streaming/remote/adapter/tests/opening.rs
index db221aed8..5f9631b25 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/opening.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/opening.rs
@@ -15,8 +15,8 @@ use futures::{TryStreamExt, stream};
 use crate::message::Message;
 use crate::tree::{
     mirror::streaming::{
-        Local,
-        message::{Reaction, Reply},
+        Backend, Local,
+        erased::{Reaction, Reply},
         remote::codec::{End, Flow, Frame, Reaction as WireReaction},
     },
     typed::{
@@ -25,6 +25,11 @@ use crate::tree::{
     },
 };
 
+/// One erased opening node over the unit payload.
+fn erased(node: typed::Node<(), UnderRoot>) -> <Local as Backend<()>>::Erased {
+    <Local as Backend<()>>::erase(node)
+}
+
 use super::{
     super::{DecodeError, OpeningError, Scope, early_supplies, opening_parts, opening_reply},
     LeafCase, hash, leaf_run, runtime, unbounded,
@@ -54,7 +59,7 @@ where
 #[test]
 fn opening_listing_agrees_with_greeting_replay() {
     let listing = vec![(3, hash(1)), (9, hash(2))];
-    let reply = Reply::<Local, (), UnderRoot> {
+    let reply = Reply::<<Local as Backend<()>>::Erased> {
         replies: vec![Reaction::Query(listing.clone())],
     };
 
@@ -63,7 +68,8 @@ fn opening_listing_agrees_with_greeting_replay() {
     assert!(supplies.is_empty(), "no supplies trailed the question");
     let scope = Scope::opening(&split);
 
-    let (replayed, replayed_scope) = opening_reply::<Local, ()>(listing.clone());
+    let (replayed, replayed_scope) =
+        opening_reply::<<Local as Backend<()>>::Erased>(listing.clone());
     assert_eq!(replayed_scope, scope);
     let [Reaction::Query(replayed)] = replayed.replies.as_slice() else {
         panic!("the replayed opening must remain one query")
@@ -75,11 +81,11 @@ fn opening_listing_agrees_with_greeting_replay() {
 #[test]
 fn opening_supplies_split_off_the_question() {
     let listing = vec![(3, hash(1))];
-    let reply = Reply::<Local, (), UnderRoot> {
+    let reply = Reply::<<Local as Backend<()>>::Erased> {
         replies: vec![
             Reaction::Query(listing.clone()),
-            Reaction::Supply(5, UnderRoot::node()),
-            Reaction::Supply(9, UnderRoot::node()),
+            Reaction::Supply(5, erased(UnderRoot::node())),
+            Reaction::Supply(9, erased(UnderRoot::node())),
         ],
     };
     let (split, supplies) = opening_parts(reply).expect("canonical opening with supplies");
@@ -99,7 +105,7 @@ fn opening_supplies_split_off_the_question() {
 /// scope holding no positional children.
 #[test]
 fn empty_listing_replays_the_empty_opening() {
-    let (replayed, mut scope) = opening_reply::<Local, ()>(Vec::new());
+    let (replayed, mut scope) = opening_reply::<<Local as Backend<()>>::Erased>(Vec::new());
     let [Reaction::Query(listing)] = replayed.replies.as_slice() else {
         panic!("the replayed opening must be one query")
     };
@@ -146,11 +152,11 @@ fn opening_supplies_decode_by_radix_group() {
 
     let decoded: Vec<(u8, _)> = runtime()
         .block_on(
-            early_supplies::<Local, u64, UnderRoot, _>(
+            early_supplies::<Local, u64, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
-                Prefix::new(),
+                Prefix::new().erase(),
                 stream::iter(frames),
             )
             .try_collect(),
@@ -193,11 +199,11 @@ fn opening_supplies_past_the_declared_set_len_are_rejected() {
 
     let error = runtime()
         .block_on(async {
-            early_supplies::<Local, u64, UnderRoot, _>(
+            early_supplies::<Local, u64, _>(
                 Local,
                 u64::MAX,
                 SupplyLedger::new(1),
-                Prefix::new(),
+                Prefix::new().erase(),
                 stream::iter(frames),
             )
             .try_collect::<Vec<_>>()
@@ -220,11 +226,11 @@ fn empty_opening_supply_reply_decodes_to_nothing() {
     let frames: Vec<Frame<u64>> = vec![Frame::End(End::Reply)];
     let decoded: Vec<(u8, _)> = runtime()
         .block_on(
-            early_supplies::<Local, u64, UnderRoot, _>(
+            early_supplies::<Local, u64, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
-                Prefix::new(),
+                Prefix::new().erase(),
                 stream::iter(frames),
             )
             .try_collect(),
@@ -240,11 +246,11 @@ fn second_opening_supply_reply_is_rejected() {
     let frames: Vec<Frame<u64>> = vec![Frame::End(End::Reply), Frame::End(End::Reply)];
     let error = runtime()
         .block_on(async {
-            early_supplies::<Local, u64, UnderRoot, _>(
+            early_supplies::<Local, u64, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
-                Prefix::new(),
+                Prefix::new().erase(),
                 stream::iter(frames),
             )
             .try_collect::<Vec<_>>()
@@ -261,11 +267,11 @@ fn positional_reaction_in_opening_supplies_is_rejected() {
     let frames: Vec<Frame<u64>> = vec![Frame::Reaction(WireReaction::Match, Flow::End)];
     let error = runtime()
         .block_on(async {
-            early_supplies::<Local, u64, UnderRoot, _>(
+            early_supplies::<Local, u64, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
-                Prefix::new(),
+                Prefix::new().erase(),
                 stream::iter(frames),
             )
             .try_collect::<Vec<_>>()
@@ -282,29 +288,29 @@ fn positional_reaction_in_opening_supplies_is_rejected() {
 /// form or its exact typed rejection.
 #[test]
 fn opening_rejections_are_exhaustive() {
-    let empty = Reply::<Local, (), UnderRoot> {
+    let empty = Reply::<<Local as Backend<()>>::Erased> {
         replies: Vec::new(),
     };
     assert_eq!(opening_parts(empty).err(), Some(OpeningError::Empty));
 
     for count in 1..=3 {
-        let reply = Reply::<Local, (), UnderRoot> {
+        let reply = Reply::<<Local as Backend<()>>::Erased> {
             replies: (0..count).map(|_| Reaction::Match).collect(),
         };
         assert_eq!(opening_parts(reply).err(), Some(OpeningError::NotQuery));
     }
 
-    let supplied = Reply::<Local, (), UnderRoot> {
-        replies: vec![Reaction::Supply(0, UnderRoot::node())],
+    let supplied = Reply::<<Local as Backend<()>>::Erased> {
+        replies: vec![Reaction::Supply(0, erased(UnderRoot::node()))],
     };
     assert_eq!(opening_parts(supplied).err(), Some(OpeningError::NotQuery));
 
     // A non-supply reaction anywhere behind the question is rejected at
     // its whole-reply position.
-    let trailing = Reply::<Local, (), UnderRoot> {
+    let trailing = Reply::<<Local as Backend<()>>::Erased> {
         replies: vec![
             Reaction::Query(vec![(3, hash(1))]),
-            Reaction::Supply(5, UnderRoot::node()),
+            Reaction::Supply(5, erased(UnderRoot::node())),
             Reaction::Match,
         ],
     };
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/parking.rs b/src/tree/mirror/streaming/remote/adapter/tests/parking.rs
index f79f58290..798a6b5ee 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/parking.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/parking.rs
@@ -28,15 +28,12 @@ use crate::{
     tree::{
         Action, Tree,
         mirror::streaming::{
-            Local,
-            message::{Reaction, Reply},
+            Backend, Local,
+            erased::{Reaction, Reply},
             remote::codec::{self, RunBudget, Speaker, Stream},
             window::FAN,
         },
-        typed::{
-            self, Hash,
-            height::{UnderRoot, UnderUnderRoot},
-        },
+        typed::{self, Hash, height::UnderRoot},
     },
 };
 
@@ -106,14 +103,14 @@ fn parked_supply_reply_holds_handles_not_subtrees() {
         "the fan partitions every committed leaf",
     );
 
-    let reply = Reply::<Local, u64, UnderRoot> {
+    let reply = Reply {
         replies: children
             .into_iter()
-            .map(|(radix, node)| Reaction::Supply(radix, node))
+            .map(|(radix, node)| Reaction::Supply(radix, <Local as Backend<u64>>::erase(node)))
             .collect(),
     };
     let runtime = runtime();
-    let scope = Scope::<UnderRoot>::opening(&[]);
+    let scope = Scope::opening(&[]);
     let frames = runtime.block_on(async {
         encode_reply(Local, RunBudget::default(), scope.clone(), reply)
             .map_ok(|encoded| encoded.into_parts().0)
@@ -124,7 +121,7 @@ fn parked_supply_reply_holds_handles_not_subtrees() {
 
     let mut frames = stream::iter(frames);
     let decoded = runtime
-        .block_on(decode_reply::<Local, u64, UnderUnderRoot, _>(
+        .block_on(decode_reply::<Local, u64, _>(
             Local,
             u64::MAX,
             unbounded(),
@@ -166,12 +163,12 @@ fn maximally_disputed_reply_parks_bounded_skeleton() {
     let listing: Vec<(u8, Hash)> = (0..FAN)
         .map(|radix| (radix as u8, hash(radix as u8)))
         .collect();
-    let reply = Reply::<Local, u64, UnderRoot> {
+    let reply = Reply::<<Local as Backend<u64>>::Erased> {
         replies: (0..FAN).map(|_| Reaction::Query(listing.clone())).collect(),
     };
 
     let runtime = runtime();
-    let scope = Scope::<UnderRoot>::opening(&listing);
+    let scope = Scope::opening(&listing);
     let frames = runtime.block_on(async {
         encode_reply(Local, RunBudget::default(), scope.clone(), reply)
             .map_ok(|encoded| encoded.into_parts().0)
@@ -211,11 +208,11 @@ fn maximally_disputed_reply_parks_bounded_skeleton() {
 
     let mut frames = stream::iter(frames);
     let decoded = runtime
-        .block_on(decode_reply::<Local, u64, UnderUnderRoot, _>(
+        .block_on(decode_reply::<Local, u64, _>(
             Local,
             u64::MAX,
             unbounded(),
-            Scope::<UnderRoot>::opening(&listing),
+            Scope::opening(&listing),
             &mut frames,
         ))
         .expect("a canonical maximally disputed reply decodes");
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/properties.rs b/src/tree/mirror/streaming/remote/adapter/tests/properties.rs
index 11d793353..512034fad 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/properties.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/properties.rs
@@ -9,7 +9,7 @@ use crate::tree::{
     mirror::streaming::{
         Backend, Local,
         convert::Convert,
-        message::{Reaction, Reply},
+        erased::{Reaction, Reply},
     },
     typed::{
         self, Hash, Prefix,
@@ -17,6 +17,10 @@ use crate::tree::{
     },
 };
 
+/// The in-memory backend's erased node representations, per payload.
+type ErasedUnit = <Local as Backend<()>>::Erased;
+type ErasedU64 = <Local as Backend<u64>>::Erased;
+
 use super::{
     super::{DecodeError, Scope, decode_leaf_reply, decode_reply, encode_leaf_reply, encode_reply},
     LeafCase, hash, leaf_run, runtime, unbounded,
@@ -100,7 +104,7 @@ impl AdapterHeight for Z {
         runtime: &tokio::runtime::Runtime,
     ) -> TestCaseResult {
         let (parent, radix) = Prefix::<Z>::containing(&leaf.path()).pop();
-        let scope = Scope::new(parent, &[]);
+        let scope = Scope::new(parent.erase(), &[]);
         let frame = supplied_frame(leaf, Flow::End);
         let mut frames = stream::iter([frame.clone()]);
         let decoded = runtime
@@ -132,8 +136,8 @@ impl AdapterHeight for Z {
         runtime: &tokio::runtime::Runtime,
     ) -> TestCaseResult {
         let parent = Prefix::<S<Z>>::containing(&leaf.path());
-        let scope = Scope::new(parent, &listing(radixes));
-        let reply = Reply::<Local, (), Z> {
+        let scope = Scope::new(parent.erase(), &listing(radixes));
+        let reply = Reply::<ErasedUnit> {
             replies: radixes.iter().map(|_| Reaction::Match).collect(),
         };
         let encoded = runtime.block_on(async {
@@ -173,10 +177,10 @@ impl AdapterHeight for Z {
         runtime: &tokio::runtime::Runtime,
     ) -> TestCaseResult {
         let parent = Prefix::<S<Z>>::containing(&leaf.path());
-        let scope = Scope::new(parent, &case.listing());
+        let scope = Scope::new(parent.erase(), &case.listing());
         let mut leaf_case = case.clone();
         leaf_case.nested.clear();
-        let reply = Reply::<Local, (), Z> {
+        let reply = Reply::<ErasedUnit> {
             replies: (0..leaf_case.radixes.len())
                 .map(|position| {
                     if leaf_case.is_query(position) {
@@ -193,7 +197,7 @@ impl AdapterHeight for Z {
             .iter()
             .enumerate()
             .filter(|(position, _)| leaf_case.is_query(*position))
-            .map(|(_, &radix)| Scope::leaf(parent.push(radix)))
+            .map(|(_, &radix)| Scope::leaf(parent.push(radix).erase()))
             .collect::<Vec<_>>();
         let expected_publications = if leaf_case.radixes.is_empty() {
             vec![None]
@@ -205,7 +209,7 @@ impl AdapterHeight for Z {
                 .map(|(position, &radix)| {
                     leaf_case
                         .is_query(position)
-                        .then(|| Scope::leaf(parent.push(radix)))
+                        .then(|| Scope::leaf(parent.push(radix).erase()))
                 })
                 .collect::<Vec<_>>()
         };
@@ -249,11 +253,12 @@ impl AdapterHeight for Z {
     ) -> TestCaseResult {
         let (parent, supply_radix) = Prefix::<Z>::containing(&leaf.path()).pop();
         let (case, supply_at) = case.with_supply(supply_radix);
-        let scope = Scope::new(parent, &case.listing());
+        let scope = Scope::new(parent.erase(), &case.listing());
         let reply = mixed_reply(&case, &[], supply_at, supply_radix, Self::node(leaf));
         let expected_frames = expected_mixed_frames(&case, &[], supply_at, leaf);
-        let expected_publications =
-            mixed_publications(&case, supply_at, |radix| Scope::leaf(parent.push(radix)));
+        let expected_publications = mixed_publications(&case, supply_at, |radix| {
+            Scope::leaf(parent.push(radix).erase())
+        });
         let expected_questions = expected_publications
             .iter()
             .filter_map(Clone::clone)
@@ -289,7 +294,7 @@ impl AdapterHeight for Z {
             ))
             .expect("canonical mixed leaf reactions decode");
         prop_assert_eq!(&decoded.questions, &expected_questions, "height 0");
-        assert_mixed_reply(
+        assert_mixed_reply::<Z>(
             &decoded.reply,
             &case,
             &[],
@@ -313,7 +318,7 @@ impl AdapterHeight for Z {
                 Local,
                 u64::MAX,
                 unbounded(),
-                Scope::new(parent, &[]),
+                Scope::new(parent.erase(), &[]),
                 &mut frames,
             ))
             .err()
@@ -333,7 +338,7 @@ impl AdapterHeight for Z {
                 Local,
                 u64::MAX,
                 unbounded(),
-                Scope::new(foreign, &[]),
+                Scope::new(foreign.erase(), &[]),
                 &mut frames,
             ))
             .err()
@@ -358,11 +363,11 @@ where
         runtime: &tokio::runtime::Runtime,
     ) -> TestCaseResult {
         let (parent, radix) = Prefix::<S<H>>::containing(&leaf.path()).pop();
-        let scope = Scope::new(parent, &[]);
+        let scope = Scope::new(parent.erase(), &[]);
         let frame = supplied_frame(leaf, Flow::End);
         let mut frames = stream::iter([frame.clone()]);
         let decoded = runtime
-            .block_on(decode_reply::<Local, u64, H, _>(
+            .block_on(decode_reply::<Local, u64, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
@@ -390,8 +395,8 @@ where
         runtime: &tokio::runtime::Runtime,
     ) -> TestCaseResult {
         let parent = Prefix::<S<S<H>>>::containing(&leaf.path());
-        let scope = Scope::new(parent, &listing(radixes));
-        let reply = Reply::<Local, (), Self> {
+        let scope = Scope::new(parent.erase(), &listing(radixes));
+        let reply = Reply::<ErasedUnit> {
             replies: radixes.iter().map(|_| Reaction::Match).collect(),
         };
         let encoded = runtime.block_on(async {
@@ -411,7 +416,7 @@ where
                 .chain([sentinel.clone()]),
         );
         let decoded = runtime
-            .block_on(decode_reply::<Local, (), H, _>(
+            .block_on(decode_reply::<Local, (), _>(
                 Local,
                 u64::MAX,
                 unbounded(),
@@ -436,8 +441,8 @@ where
         runtime: &tokio::runtime::Runtime,
     ) -> TestCaseResult {
         let parent = Prefix::<S<S<H>>>::containing(&leaf.path());
-        let scope = Scope::new(parent, &case.listing());
-        let reply = Reply::<Local, (), Self> {
+        let scope = Scope::new(parent.erase(), &case.listing());
+        let reply = Reply::<ErasedUnit> {
             replies: (0..case.radixes.len())
                 .map(|position| {
                     if case.is_query(position) {
@@ -453,8 +458,8 @@ where
             .iter()
             .enumerate()
             .filter(|(position, _)| case.is_query(*position))
-            .map(|(_, &radix)| Scope::new(parent.push(radix), &case.nested))
-            .collect::<Vec<Scope<H>>>();
+            .map(|(_, &radix)| Scope::new(parent.push(radix).erase(), &case.nested))
+            .collect::<Vec<Scope>>();
         let expected_frames = expected_positional_frames(case);
         let expected_publications = if case.radixes.is_empty() {
             vec![None]
@@ -464,7 +469,7 @@ where
                 .enumerate()
                 .map(|(position, &radix)| {
                     case.is_query(position)
-                        .then(|| Scope::new(parent.push(radix), &case.nested))
+                        .then(|| Scope::new(parent.push(radix).erase(), &case.nested))
                 })
                 .collect::<Vec<_>>()
         };
@@ -494,7 +499,7 @@ where
 
         let mut frames = stream::iter(actual_frames);
         let decoded = runtime
-            .block_on(decode_reply::<Local, (), H, _>(
+            .block_on(decode_reply::<Local, (), _>(
                 Local,
                 u64::MAX,
                 unbounded(),
@@ -518,7 +523,7 @@ where
     ) -> TestCaseResult {
         let (parent, supply_radix) = Prefix::<Self>::containing(&leaf.path()).pop();
         let (case, supply_at) = case.with_supply(supply_radix);
-        let scope = Scope::new(parent, &case.listing());
+        let scope = Scope::new(parent.erase(), &case.listing());
         let reply = mixed_reply(
             &case,
             &case.nested,
@@ -528,7 +533,7 @@ where
         );
         let expected_frames = expected_mixed_frames(&case, &case.nested, supply_at, leaf);
         let expected_publications = mixed_publications(&case, supply_at, |radix| {
-            Scope::new(parent.push(radix), &case.nested)
+            Scope::new(parent.push(radix).erase(), &case.nested)
         });
         let expected_questions = expected_publications
             .iter()
@@ -561,7 +566,7 @@ where
         let sentinel = Frame::End(End::Reply);
         let mut frames = stream::iter(actual_frames.into_iter().chain([sentinel.clone()]));
         let decoded = runtime
-            .block_on(decode_reply::<Local, u64, H, _>(
+            .block_on(decode_reply::<Local, u64, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
@@ -575,7 +580,7 @@ where
             "height {}",
             Self::HEIGHT
         );
-        assert_mixed_reply(
+        assert_mixed_reply::<Self>(
             &decoded.reply,
             &case,
             &case.nested,
@@ -600,11 +605,11 @@ where
         let parent = Prefix::<Self>::containing(&leaf.path()).pop().0;
         let mut frames = stream::iter(duplicate_frames(leaf));
         let error = runtime
-            .block_on(decode_reply::<Local, u64, H, _>(
+            .block_on(decode_reply::<Local, u64, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
-                Scope::new(parent, &[]),
+                Scope::new(parent.erase(), &[]),
                 &mut frames,
             ))
             .err()
@@ -626,11 +631,11 @@ where
         let foreign = foreign_parent::<Self>(leaf, actual);
         let mut frames = stream::iter([supplied_frame(leaf, Flow::End)]);
         let error = runtime
-            .block_on(decode_reply::<Local, u64, H, _>(
+            .block_on(decode_reply::<Local, u64, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
-                Scope::new(foreign, &[]),
+                Scope::new(foreign.erase(), &[]),
                 &mut frames,
             ))
             .err()
@@ -663,8 +668,8 @@ fn mixed_reply<H: Height>(
     supply_at: usize,
     supply_radix: u8,
     supply: typed::Node<u64, H>,
-) -> Reply<Local, u64, H> {
-    let mut supply = Some(supply);
+) -> Reply<ErasedU64> {
+    let mut supply = Some(<Local as Backend<u64>>::erase(supply));
     let mut replies = Vec::with_capacity(case.radixes.len() + 1);
     for position in 0..=case.radixes.len() {
         if position == supply_at {
@@ -742,7 +747,7 @@ fn mixed_publications<Q>(
 }
 
 fn assert_mixed_reply<H: Convert>(
-    reply: &Reply<Local, u64, H>,
+    reply: &Reply<ErasedU64>,
     case: &PositionalCase,
     query_listing: &[(u8, Hash)],
     supply_at: usize,
@@ -787,7 +792,7 @@ where
 }
 
 fn assert_decoded_supply<H: Convert>(
-    reply: &Reply<Local, u64, H>,
+    reply: &Reply<ErasedU64>,
     expected_radix: u8,
     expected_leaf: &LeafCase,
     runtime: &tokio::runtime::Runtime,
@@ -806,7 +811,7 @@ where
 }
 
 fn assert_node_leaf<H: Convert>(
-    node: &typed::Node<u64, H>,
+    node: &ErasedU64,
     expected_leaf: &LeafCase,
     runtime: &tokio::runtime::Runtime,
 ) -> TestCaseResult
@@ -816,7 +821,7 @@ where
     let prefix = Prefix::<H>::containing(&expected_leaf.path());
     let leaves = runtime.block_on(async {
         Local
-            .leaves(prefix, node.clone())
+            .leaves(prefix, <Local as Backend<u64>>::assume::<H>(node.clone()))
             .try_collect::<Vec<_>>()
             .await
             .expect("the local backend is infallible")
@@ -866,11 +871,7 @@ fn assert_match_encoding<Q>(
     Ok(())
 }
 
-fn assert_matches<H: Height>(
-    reply: &Reply<Local, (), H>,
-    count: usize,
-    height: usize,
-) -> TestCaseResult {
+fn assert_matches(reply: &Reply<ErasedUnit>, count: usize, height: usize) -> TestCaseResult {
     prop_assert_eq!(reply.replies.len(), count, "height {}", height);
     prop_assert!(
         reply
@@ -903,8 +904,8 @@ fn expected_positional_frames(case: &PositionalCase) -> Vec<Frame<()>> {
         .collect()
 }
 
-fn assert_positional_reply<H: Height>(
-    reply: &Reply<Local, (), H>,
+fn assert_positional_reply(
+    reply: &Reply<ErasedUnit>,
     case: &PositionalCase,
     height: usize,
 ) -> TestCaseResult {
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/runs.rs b/src/tree/mirror/streaming/remote/adapter/tests/runs.rs
index e86d49233..f07359fdd 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/runs.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/runs.rs
@@ -20,16 +20,13 @@ use crate::{
     tree::{
         mirror::streaming::{
             Backend, Local,
-            message::Reaction,
+            erased::Reaction,
             remote::codec::{
                 DEFAULT_TARGET_MESSAGE_SIZE, Flow, Frame, LeafRun, Reaction as WireReaction,
                 RunBudget, SUPPLY_FRAME_OVERHEAD,
             },
         },
-        typed::{
-            Prefix,
-            height::{UnderRoot, UnderUnderRoot},
-        },
+        typed::{Prefix, height::UnderRoot},
     },
 };
 
@@ -111,11 +108,11 @@ fn recode(frames: Vec<Frame<u64>>, budget: RunBudget) -> Vec<Frame<u64>> {
     let runtime = runtime();
     runtime.block_on(async {
         let mut input = stream::iter(frames);
-        let decoded = decode_reply::<Local, u64, UnderUnderRoot, _>(
+        let decoded = decode_reply::<Local, u64, _>(
             Local,
             u64::MAX,
             unbounded(),
-            Scope::<UnderRoot>::opening(&[]),
+            Scope::opening(&[]),
             &mut input,
         )
         .await
@@ -267,11 +264,11 @@ fn a_batched_run_round_trips_the_reply() {
     let runtime = runtime();
     let reply = runtime.block_on(async {
         let mut input = stream::iter(frames);
-        decode_reply::<Local, u64, UnderUnderRoot, _>(
+        decode_reply::<Local, u64, _>(
             Local,
             u64::MAX,
             unbounded(),
-            Scope::<UnderRoot>::opening(&[]),
+            Scope::opening(&[]),
             &mut input,
         )
         .await
@@ -284,7 +281,10 @@ fn a_batched_run_round_trips_the_reply() {
     let prefix = Prefix::<UnderRoot>::containing(&leaves[0].path());
     let rebuilt = runtime.block_on(async {
         Local
-            .leaves(prefix, node.clone())
+            .leaves(
+                prefix,
+                <Local as Backend<u64>>::assume::<UnderRoot>(node.clone()),
+            )
             .try_collect::<Vec<_>>()
             .await
             .expect("the local backend is infallible")
diff --git a/src/tree/mirror/streaming/remote/proxy.rs b/src/tree/mirror/streaming/remote/proxy.rs
index 96f1b0463..79f7a52a6 100644
--- a/src/tree/mirror/streaming/remote/proxy.rs
+++ b/src/tree/mirror/streaming/remote/proxy.rs
@@ -24,14 +24,14 @@ async fn send_or_cancel<T>(sender: &Sender<T>, value: T) {
 /// proxy analogue of the materialized implementation's `yield_resolve_query!`.
 macro_rules! yield_reply_scopes {
     (
-        $progress:expr, $height:ty, $count:expr;
+        $progress:expr, $height:expr, $count:expr;
         $yielded:expr;
         $scopes:expr => $next_scopes:expr;
     ) => {{
-        $progress.decoded_reply::<$height>($count);
+        $progress.decoded_reply($height, $count);
         $yielded;
         for scope in $next_scopes {
-            $progress.next_scope::<$height>();
+            $progress.next_scope($height);
             $crate::tree::mirror::streaming::remote::proxy::send_or_cancel(&$scopes, scope).await;
         }
     }};
diff --git a/src/tree/mirror/streaming/remote/proxy/state.rs b/src/tree/mirror/streaming/remote/proxy/state.rs
index 04eab96dd..39554ef92 100644
--- a/src/tree/mirror/streaming/remote/proxy/state.rs
+++ b/src/tree/mirror/streaming/remote/proxy/state.rs
@@ -7,12 +7,13 @@
 //! stage yield its reply before publishing the lower scopes derived from it,
 //! so one-slot backpressure cannot withhold the reply which releases it.
 
+use std::marker::PhantomData;
+
 use crate::link::{Acceptor, Connector};
 use crate::tree::{
     mirror::streaming::{
         Backend, Leaf,
         channel::Receiver,
-        convert::Convert,
         protocol::{self, BoxResponses, Requests},
         remote::{
             adapter::Scope,
@@ -180,13 +181,19 @@ where
     A: Acceptor,
 {
     session: Session<B, T, R, W, C, A>,
-    scopes: Receiver<Scope<H>>,
+    /// The next local reply's scopes, erased: the typestate's `H` is what
+    /// pins this queue to the stage that consumes it at the right height,
+    /// and every scope's parent prefix carries the runtime witness.
+    scopes: Receiver<Scope>,
     /// The remote initiator's opening-supply stream (`None` below the
     /// stage right after the opening, the one whose scopes are root-level).
     ///
     /// The receiver claims its transport stream on first read, so a
     /// session without early supplies never touches it.
     early: Option<StreamReceiver<A::Rx, T>>,
+    /// The stage's height, phantom (`fn() -> H` for the auto-trait
+    /// shortcut; see [`typed::Node`](crate::tree::typed::Node)).
+    height: PhantomData<fn() -> H>,
 }
 
 /// The initiator proxy's leaf terminal and accumulated transport work.
@@ -197,7 +204,7 @@ where
     A: Acceptor,
 {
     session: Session<B, T, R, W, C, A>,
-    scopes: Receiver<Scope<Z>>,
+    scopes: Receiver<Scope>,
 }
 
 impl<B, T, H, R, W, C, A> protocol::Protocol for Descending<B, T, H, R, W, C, A>
@@ -275,6 +282,7 @@ where
             session,
             scopes,
             early: Some(early),
+            height: PhantomData,
         };
         (responses, next)
     }
@@ -288,7 +296,6 @@ where
     W: Send,
     C: Connector,
     A: Acceptor,
-    UnderRoot: crate::tree::mirror::streaming::convert::Convert,
 {
     type Next = Descending<B, T, UnderUnderRoot, R, W, C, A>;
 
@@ -314,6 +321,7 @@ where
             session,
             scopes: next_scopes,
             early: None,
+            height: PhantomData,
         };
         (responses, next)
     }
@@ -328,8 +336,8 @@ where
     C: Connector,
     A: Acceptor,
     H: Height,
-    S<H>: Convert,
-    S<S<H>>: Convert,
+    S<H>: Height,
+    S<S<H>>: Height,
     S<S<S<H>>>: Height,
 {
     type Next = Descending<B, T, H, R, W, C, A>;
@@ -350,6 +358,7 @@ where
             session: self.session,
             scopes: next_scopes,
             early: None,
+            height: PhantomData,
         };
         (responses, next)
     }
diff --git a/src/tree/mirror/streaming/remote/proxy/work.rs b/src/tree/mirror/streaming/remote/proxy/work.rs
index 9b7e63ccb..fe9a35f78 100644
--- a/src/tree/mirror/streaming/remote/proxy/work.rs
+++ b/src/tree/mirror/streaming/remote/proxy/work.rs
@@ -5,16 +5,18 @@
 //! protocol operation concurrently drives the stored pumps, its own terminal
 //! work, the session's accept driver, and the incoming-stream error route.
 
-use std::pin::pin;
+use std::pin::{Pin, pin};
 
-use futures::{StreamExt, future::BoxFuture};
+use futures::{Stream, StreamExt, future::BoxFuture};
 
 use crate::link::Acceptor;
 use crate::tree::{
     mirror::streaming::{
         Backend, Leaf,
+        channel::{QueueKind, QueueRole, Sender},
+        erased,
         materialized::SupplyLedger,
-        protocol::{BoxResponses, Responses},
+        protocol::BoxResponses,
         remote::{
             adapter::{DecodeError, EncodeError},
             codec::{Origin, RunBudget, Speaker},
@@ -125,34 +127,26 @@ where
         self.tasks.push(Box::pin(task));
     }
 
-    /// Add a task which actively drives a response stream.
-    ///
-    /// One buffered response is sufficient: whenever the task blocks, that
-    /// response is already available to advance the counterparty and release
-    /// the slot. Buffering a fan would retain whole protocol messages without
-    /// breaking any additional dependency.
+    /// Add a task which actively drives a response stream, and return the
+    /// stream's typed exit: the one point where the proxy's decoded erased
+    /// replies re-tag at their stage's height.
     fn respond<H>(
         &mut self,
-        messages: impl Responses<B, T, H, Error<B::Error>>,
+        messages: impl Stream<Item = Result<erased::Reply<B::Erased>, Error<B::Error>>> + Send + 'static,
     ) -> BoxResponses<B, T, H, Error<B::Error>>
     where
         H: Height,
     {
-        let (send, receive) = self::queues::responses::<_, H>();
-        self.spawn(async move {
-            let mut messages = pin!(messages);
-            while let Some(message) = messages.next().await {
-                let failed = message.is_err();
-                send_or_cancel(&send, message).await;
-                park_after_published_error(failed).await;
-            }
-            Ok(())
-        });
-        #[cfg(test)]
-        let responses = Box::pin(receive);
-        #[cfg(not(test))]
-        let responses = Box::pin(tokio_stream::wrappers::ReceiverStream::new(receive));
-        responses
+        // One buffered response is sufficient: whenever the pump blocks,
+        // that response is already available to advance the counterparty
+        // and release the slot. Buffering a fan would retain whole
+        // protocol messages without breaking any additional dependency.
+        let (send, responses) = erased::reply_channel::<B, T, H, Error<B::Error>>(
+            QueueRole::new(QueueKind::ProxyResponses, H::HEIGHT),
+            1,
+        );
+        self.spawn(pump(Box::pin(messages), send));
+        Box::pin(responses)
     }
 
     /// Drive all accumulated pumps, the terminal operation, and the session's
@@ -267,5 +261,18 @@ where
     }
 }
 
+/// Drive one decoded response stream into its outgoing relay edge.
+async fn pump<E: Send, Err: Send + 'static>(
+    mut messages: Pin<Box<dyn Stream<Item = Result<erased::Reply<E>, Error<Err>>> + Send>>,
+    send: Sender<Result<erased::Reply<E>, Error<Err>>>,
+) -> Result<(), Error<Err>> {
+    while let Some(message) = messages.next().await {
+        let failed = message.is_err();
+        send_or_cancel(&send, message).await;
+        park_after_published_error(failed).await;
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests;
diff --git a/src/tree/mirror/streaming/remote/proxy/work/encode.rs b/src/tree/mirror/streaming/remote/proxy/work/encode.rs
index 0f1f4f59a..2ad2ebf88 100644
--- a/src/tree/mirror/streaming/remote/proxy/work/encode.rs
+++ b/src/tree/mirror/streaming/remote/proxy/work/encode.rs
@@ -3,8 +3,13 @@
 //! Questions are retained until every frame of their containing reply has
 //! flushed. Publishing them any earlier could block the encoder before the
 //! reply end reaches the remote peer which must answer them.
+//!
+//! Every encoder here consumes the erased vocabulary — its typed request
+//! stream is erased and boxed by the proxy state that spawns it — so each
+//! encoder body instantiates once per backend; the stage's height arrives
+//! as the runtime label the progress trace records.
 
-use std::pin::{Pin, pin};
+use std::pin::Pin;
 
 use futures::{Stream, StreamExt};
 
@@ -13,9 +18,7 @@ use crate::tree::{
     mirror::streaming::{
         Backend, Leaf,
         channel::{Receiver, Sender},
-        convert::Convert,
-        message::Reply,
-        protocol::Requests,
+        erased::Reply,
         remote::{
             adapter::{self, Encoded, Scope, encode_reply, opening_parts},
             codec::RunBudget,
@@ -25,20 +28,23 @@ use crate::tree::{
     },
     typed::{
         Hash,
-        height::{Height, S, UnderRoot, UnderUnderRoot, Z},
+        height::{Height, UnderRoot, Z},
     },
 };
 
 use super::progress::Progress;
 
+/// A local reply stream already erased and boxed at the proxy boundary.
+pub type Replies<E> = Pin<Box<dyn Stream<Item = Reply<E>> + Send>>;
+
 /// Encode local leaf replies, optionally publishing the leaf questions they ask.
 pub async fn terminal<B, T, C>(
     backend: B,
     budget: RunBudget,
-    requests: impl Requests<B, T, Z>,
-    mut scopes: Receiver<Scope<Z>>,
+    requests: Replies<B::Erased>,
+    mut scopes: Receiver<Scope>,
     mut outgoing: StreamSender<C, T>,
-    questions: Option<Sender<Scope<Z>>>,
+    questions: Option<Sender<Scope>>,
     progress: Progress,
 ) -> Result<(), Error<B::Error>>
 where
@@ -46,7 +52,7 @@ where
     T: Send + Sync + 'static,
     C: Connector,
 {
-    let mut requests = pin!(requests);
+    let mut requests = requests;
     // Scope-first pairing: dequeuing the scope before awaiting the local
     // reply frees its channel slot one reply earlier, so a K-slot edge
     // admits K truly in-flight scopes (the walk's stage loops make the
@@ -55,9 +61,9 @@ where
         let request = requests.next().await.ok_or(Error::UnansweredRemoteQuery)?;
         let mut encoded = adapter::encode_leaf_reply(backend.clone(), budget, scope, request);
         let batch = write_reply(&mut outgoing, &mut encoded).await?;
-        progress.wire_reply::<Z>(batch.len());
+        progress.wire_reply(Z::HEIGHT, batch.len());
         if let Some(questions) = &questions {
-            publish::<_, Z>(questions, batch, progress).await;
+            publish(questions, batch, progress, Z::HEIGHT).await;
         } else if !batch.is_empty() {
             return Err(Error::TerminalQuery);
         }
@@ -66,30 +72,34 @@ where
 }
 
 /// Encode non-leaf replies and publish each complete question batch.
-pub async fn replies<B, T, C, H>(
+///
+/// `question_height` is the derived questions' height, one under the
+/// replies this encoder renders.
+// The argument list is the stage's dataflow, one edge per argument;
+// bundling edges into a struct would only rename the arity.
+#[allow(clippy::too_many_arguments)]
+pub async fn replies<B, T, C>(
     backend: B,
     budget: RunBudget,
-    requests: impl Requests<B, T, S<H>>,
-    mut scopes: Receiver<Scope<S<H>>>,
+    requests: Replies<B::Erased>,
+    mut scopes: Receiver<Scope>,
     mut outgoing: StreamSender<C, T>,
-    questions: Sender<Scope<H>>,
+    questions: Sender<Scope>,
     progress: Progress,
+    question_height: usize,
 ) -> Result<(), Error<B::Error>>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
     C: Connector,
-    H: Height,
-    S<H>: Convert,
-    S<S<H>>: Height,
 {
-    let mut requests = pin!(requests);
+    let mut requests = requests;
     while let Some(scope) = scopes.recv().await {
         let request = requests.next().await.ok_or(Error::UnansweredRemoteQuery)?;
         let mut encoded = encode_reply(backend.clone(), budget, scope, request);
         let batch = write_reply(&mut outgoing, &mut encoded).await?;
-        progress.wire_reply::<H>(batch.len());
-        publish::<_, H>(&questions, batch, progress).await;
+        progress.wire_reply(question_height, batch.len());
+        publish(&questions, batch, progress, question_height).await;
     }
     finish(requests, outgoing).await
 }
@@ -117,8 +127,8 @@ where
 pub async fn opening<B, T, C>(
     backend: B,
     budget: RunBudget,
-    requests: impl Requests<B, T, UnderRoot>,
-    questions: Sender<Scope<UnderRoot>>,
+    requests: Replies<B::Erased>,
+    questions: Sender<Scope>,
     mut outgoing: StreamSender<C, T>,
     peer_listing: Vec<(u8, Hash)>,
     progress: Progress,
@@ -128,12 +138,12 @@ where
     T: Send + Sync + 'static,
     C: Connector,
 {
-    let mut requests = pin!(requests);
+    let mut requests = requests;
     let request = requests.next().await.ok_or(Error::MissingOpening)?;
     let (listing, supplies) = opening_parts(request).map_err(Error::OpeningEncode)?;
     let question = Scope::opening(&listing);
-    progress.wire_reply::<UnderRoot>(1);
-    progress.local_question::<UnderRoot>();
+    progress.wire_reply(UnderRoot::HEIGHT, 1);
+    progress.local_question(UnderRoot::HEIGHT);
     send_or_cancel(&questions, question).await;
 
     let early = {
@@ -150,7 +160,7 @@ where
             Scope::opening(&[]),
             Reply { replies: supplies },
         );
-        let batch: Vec<Scope<UnderUnderRoot>> = write_reply(&mut outgoing, &mut encoded).await?;
+        let batch: Vec<Scope> = write_reply(&mut outgoing, &mut encoded).await?;
         debug_assert!(batch.is_empty(), "opening supplies ask no question");
     } else {
         debug_assert!(
@@ -183,16 +193,16 @@ where
 }
 
 /// Publish one complete reply's questions in their wire order.
-async fn publish<Q, H: Height>(questions: &Sender<Q>, batch: Vec<Q>, progress: Progress) {
+async fn publish(questions: &Sender<Scope>, batch: Vec<Scope>, progress: Progress, height: usize) {
     for question in batch {
-        progress.local_question::<H>();
+        progress.local_question(height);
         send_or_cancel(questions, question).await;
     }
 }
 
 /// Reject unclaimed local replies, then close the outgoing logical stream.
 async fn finish<T, C, R, E>(
-    mut requests: Pin<&mut R>,
+    mut requests: Pin<Box<R>>,
     outgoing: StreamSender<C, T>,
 ) -> Result<(), Error<E>>
 where
diff --git a/src/tree/mirror/streaming/remote/proxy/work/progress.rs b/src/tree/mirror/streaming/remote/proxy/work/progress.rs
index 1d78d1d86..0f5325f85 100644
--- a/src/tree/mirror/streaming/remote/proxy/work/progress.rs
+++ b/src/tree/mirror/streaming/remote/proxy/work/progress.rs
@@ -1,7 +1,5 @@
 //! Ordering trace for the proxy's progress-critical publications.
 
-use crate::tree::typed::height::Height;
-
 /// One endpoint-local progress identity.
 #[derive(Clone, Copy)]
 pub struct Progress {
@@ -18,38 +16,39 @@ impl Progress {
         }
     }
 
-    /// Record one complete outgoing wire reply and its question count.
-    pub fn wire_reply<H: Height>(self, _questions: usize) {
+    /// Record one complete outgoing wire reply and its question count,
+    /// at the reply's height.
+    pub fn wire_reply(self, _height: usize, _questions: usize) {
         #[cfg(test)]
         trace::record(
             self.work,
             trace::Kind::WireReply {
                 questions: _questions,
             },
-            H::HEIGHT,
+            _height,
         );
     }
 
     /// Record one question published after its wire reply.
-    pub fn local_question<H: Height>(self) {
+    pub fn local_question(self, _height: usize) {
         #[cfg(test)]
-        trace::record(self.work, trace::Kind::LocalQuestion, H::HEIGHT);
+        trace::record(self.work, trace::Kind::LocalQuestion, _height);
     }
 
     /// Record one decoded reply and its dependent-scope count.
-    pub fn decoded_reply<H: Height>(self, _scopes: usize) {
+    pub fn decoded_reply(self, _height: usize, _scopes: usize) {
         #[cfg(test)]
         trace::record(
             self.work,
             trace::Kind::DecodedReply { scopes: _scopes },
-            H::HEIGHT,
+            _height,
         );
     }
 
     /// Record one dependent scope published after its decoded reply.
-    pub fn next_scope<H: Height>(self) {
+    pub fn next_scope(self, _height: usize) {
         #[cfg(test)]
-        trace::record(self.work, trace::Kind::NextScope, H::HEIGHT);
+        trace::record(self.work, trace::Kind::NextScope, _height);
     }
 }
 
diff --git a/src/tree/mirror/streaming/remote/proxy/work/pump.rs b/src/tree/mirror/streaming/remote/proxy/work/pump.rs
index 0e028cf5c..59d86bc68 100644
--- a/src/tree/mirror/streaming/remote/proxy/work/pump.rs
+++ b/src/tree/mirror/streaming/remote/proxy/work/pump.rs
@@ -5,6 +5,11 @@
 //! receiver-side stream or next-phase scope queue fed by that task. No state
 //! outside this module handles an internal sender.
 //!
+//! Like the walk, the decode loops run on the erased vocabulary — one
+//! instantiation per backend and transport — behind thin typed methods
+//! that erase the stage's local reply stream on the way in and re-tag the
+//! decoded responses at the typed exit (`Work::respond`).
+//!
 //! Three channels carry the dataflow:
 //!
 //! - flushed local questions flow into decoding, sized by the session
@@ -30,9 +35,8 @@ use crate::tree::{
     mirror::streaming::{
         Backend, Leaf,
         channel::Receiver,
-        convert::Convert,
-        materialized::{SupplyLedger, children_of},
-        message::{Reaction, Reply},
+        erased::{self, Reaction, Reply, ops},
+        materialized::SupplyLedger,
         protocol::{BoxResponses, Requests},
         remote::{
             adapter::{
@@ -44,7 +48,7 @@ use crate::tree::{
         },
     },
     typed::{
-        Prefix,
+        ErasedPrefix,
         height::{Height, S, UnderRoot, UnderUnderRoot, Z},
     },
 };
@@ -73,36 +77,37 @@ where
         &mut self,
     ) -> (
         BoxResponses<B, T, UnderRoot, Error<B::Error>>,
-        Receiver<Scope<UnderRoot>>,
+        Receiver<Scope>,
     ) {
         let (next_scopes, scopes) =
-            queues::next_scopes::<_, UnderRoot>(self.window.capacity(UnderRoot::HEIGHT));
+            queues::next_scopes(UnderRoot::HEIGHT, self.window.capacity(UnderRoot::HEIGHT));
         let progress = self.progress;
         let listing = std::mem::take(&mut self.peer_listing);
         let responses = try_stream! {
-            let (reply, scope) = opening_reply(listing);
+            let (reply, scope) = opening_reply::<B::Erased>(listing);
             yield_reply_scopes!(
-                progress, UnderRoot, 1;
+                progress, UnderRoot::HEIGHT, 1;
                 yield reply;
                 next_scopes => [scope];
             );
         };
-        (self.respond(responses), scopes)
+        (self.respond::<UnderRoot>(responses), scopes)
     }
 
     /// Proxy the responder opening and return its lower scope queue.
     pub fn opening_responder<C: Connector>(
         &mut self,
         requests: impl Requests<B, T, UnderRoot>,
-        mut incoming: StreamReceiver<A::Rx, T>,
+        incoming: StreamReceiver<A::Rx, T>,
         outgoing: StreamSender<C, T>,
     ) -> (
         BoxResponses<B, T, UnderRoot, Error<B::Error>>,
-        Receiver<Scope<UnderUnderRoot>>,
+        Receiver<Scope>,
     ) {
-        let progress = self.progress;
-        let (local_questions, mut questions) =
-            queues::local_questions::<_, UnderRoot>(self.window.capacity(UnderRoot::HEIGHT));
+        let requests: encode::Replies<B::Erased> =
+            Box::pin(requests.map(erased::erase_reply::<B, T, UnderRoot>));
+        let (local_questions, questions) =
+            queues::local_questions(UnderRoot::HEIGHT, self.window.capacity(UnderRoot::HEIGHT));
         let peer_listing = std::mem::take(&mut self.peer_listing);
         self.spawn(encode::opening(
             self.backend(),
@@ -111,28 +116,20 @@ where
             local_questions,
             outgoing,
             peer_listing,
-            progress,
+            self.progress,
         ));
-        let (next_scopes, scopes) =
-            queues::next_scopes::<_, UnderUnderRoot>(self.window.capacity(UnderUnderRoot::HEIGHT));
-        let backend = self.backend();
-        let version_bytes = self.peer_version_bytes;
-        let ledger = self.peer_supplies.clone();
-        let responses = try_stream! {
-            while let Some(scope) = questions.recv().await {
-                let Decoded { reply, questions } =
-                    decode_reply::<B, T, UnderUnderRoot, _>(
-                        backend.clone(), version_bytes, ledger.clone(), scope, &mut incoming,
-                    ).await?;
-                yield_reply_scopes!(
-                    progress, UnderUnderRoot, questions.len();
-                    yield reply;
-                    next_scopes => questions;
-                );
-            }
-            reject_extra(&mut incoming).await?;
-        };
-        (self.respond(responses), scopes)
+        let (next_scopes, scopes) = queues::next_scopes(
+            UnderUnderRoot::HEIGHT,
+            self.window.capacity(UnderUnderRoot::HEIGHT),
+        );
+        let responses = self.decode_pump(
+            questions,
+            incoming,
+            next_scopes,
+            None,
+            UnderUnderRoot::HEIGHT,
+        );
+        (self.respond::<UnderRoot>(responses), scopes)
     }
 
     /// Proxy one ordinary two-height transition and return its lower scopes.
@@ -146,23 +143,20 @@ where
     pub fn internal_replies<C: Connector, H>(
         &mut self,
         requests: impl Requests<B, T, S<S<H>>>,
-        scopes: Receiver<Scope<S<S<H>>>>,
-        mut incoming: StreamReceiver<A::Rx, T>,
+        scopes: Receiver<Scope>,
+        incoming: StreamReceiver<A::Rx, T>,
         outgoing: StreamSender<C, T>,
         early: Option<StreamReceiver<A::Rx, T>>,
-    ) -> (
-        BoxResponses<B, T, S<H>, Error<B::Error>>,
-        Receiver<Scope<H>>,
-    )
+    ) -> (BoxResponses<B, T, S<H>, Error<B::Error>>, Receiver<Scope>)
     where
         H: Height,
-        S<H>: Convert,
-        S<S<H>>: Convert,
-        S<S<S<H>>>: Height,
+        S<H>: Height,
+        S<S<H>>: Height,
     {
-        let progress = self.progress;
-        let (local_questions, mut questions) =
-            queues::local_questions::<_, S<H>>(self.window.capacity(<S<H>>::HEIGHT));
+        let requests: encode::Replies<B::Erased> =
+            Box::pin(requests.map(erased::erase_reply::<B, T, S<S<H>>>));
+        let (local_questions, questions) =
+            queues::local_questions(<S<H>>::HEIGHT, self.window.capacity(<S<H>>::HEIGHT));
         self.spawn(encode::replies(
             self.backend(),
             self.budget,
@@ -170,14 +164,39 @@ where
             scopes,
             outgoing,
             local_questions,
-            progress,
+            self.progress,
+            <S<H>>::HEIGHT,
         ));
-        let (next_scopes, scopes) = queues::next_scopes::<_, H>(self.window.capacity(H::HEIGHT));
+        let (next_scopes, scopes) = queues::next_scopes(H::HEIGHT, self.window.capacity(H::HEIGHT));
+        let responses = self.decode_pump(questions, incoming, next_scopes, early, H::HEIGHT);
+        (self.respond::<S<H>>(responses), scopes)
+    }
+
+    /// The decode loop shared by the responder opening and every internal
+    /// transition: pair each flushed local question with its decoded wire
+    /// reply, publishing the reply before the lower scopes derived from it.
+    ///
+    /// `height` is the derived scopes' height. `early` arms the
+    /// opening-supply pairing (see
+    /// [`internal_replies`](Self::internal_replies)); the opening
+    /// responder and every deeper stage pass `None`.
+    fn decode_pump(
+        &mut self,
+        mut questions: Receiver<Scope>,
+        mut incoming: StreamReceiver<A::Rx, T>,
+        next_scopes: crate::tree::mirror::streaming::channel::Sender<Scope>,
+        early: Option<StreamReceiver<A::Rx, T>>,
+        height: usize,
+    ) -> impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>>
+    + Send
+    + 'static
+    + use<B, T, R, W, A> {
+        let progress = self.progress;
         let backend = self.backend();
         let version_bytes = self.peer_version_bytes;
         let ledger = self.peer_supplies.clone();
-        let responses = try_stream! {
-            let mut early = Early::<B, T, S<S<H>>, A::Rx>::new(version_bytes, ledger.clone(), early);
+        try_stream! {
+            let mut early = Early::<B, T, A::Rx>::new(version_bytes, ledger.clone(), early);
             while let Some(scope) = questions.recv().await {
                 if early.armed() && scope.is_request() {
                     // A root-level request: its content crossed at the
@@ -185,14 +204,14 @@ where
                     // the early stream carries the node — or neither does,
                     // when pruning removed the whole subtree.
                     let parent = scope.parent();
-                    let Decoded { reply, questions: asked } = decode_reply::<B, T, H, _>(
+                    let Decoded { reply, questions: asked } = decode_reply::<B, T, _>(
                         backend.clone(), version_bytes, ledger.clone(), scope, &mut incoming,
                     ).await?;
                     debug_assert!(asked.is_empty(), "an empty request opens no lower scope");
                     let (root, radix) = parent.pop();
                     let mut replies = reply.replies;
                     if let Some(node) = early.advance_to(&backend, root, radix).await? {
-                        let children = children_of(&backend, parent, node)
+                        let children = ops::children_of(&backend, parent, node)
                             .await
                             .map_err(|error| Error::Decode(DecodeError::Backend(error)))?;
                         replies.extend(
@@ -202,38 +221,38 @@ where
                         );
                     }
                     yield_reply_scopes!(
-                        progress, H, 0;
+                        progress, height, 0;
                         yield Reply { replies };
-                        next_scopes => Vec::<Scope<H>>::new();
+                        next_scopes => Vec::<Scope>::new();
                     );
                     continue;
                 }
-                let Decoded { reply, questions } = decode_reply::<B, T, H, _>(
+                let Decoded { reply, questions } = decode_reply::<B, T, _>(
                     backend.clone(), version_bytes, ledger.clone(), scope, &mut incoming,
                 ).await?;
                 yield_reply_scopes!(
-                    progress, H, questions.len();
+                    progress, height, questions.len();
                     yield reply;
                     next_scopes => questions;
                 );
             }
             early.finish().await?;
             reject_extra(&mut incoming).await?;
-        };
-        (self.respond(responses), scopes)
+        }
     }
 
     /// Proxy the leaf-parent transition and return its terminal leaf scopes.
     pub fn leaf_replies<C: Connector>(
         &mut self,
         requests: impl Requests<B, T, S<Z>>,
-        scopes: Receiver<Scope<S<Z>>>,
-        mut incoming: StreamReceiver<A::Rx, T>,
+        scopes: Receiver<Scope>,
+        incoming: StreamReceiver<A::Rx, T>,
         outgoing: StreamSender<C, T>,
-    ) -> (BoxResponses<B, T, Z, Error<B::Error>>, Receiver<Scope<Z>>) {
-        let progress = self.progress;
-        let (local_questions, mut questions) =
-            queues::local_questions::<_, Z>(self.window.capacity(Z::HEIGHT));
+    ) -> (BoxResponses<B, T, Z, Error<B::Error>>, Receiver<Scope>) {
+        let requests: encode::Replies<B::Erased> =
+            Box::pin(requests.map(erased::erase_reply::<B, T, S<Z>>));
+        let (local_questions, questions) =
+            queues::local_questions(Z::HEIGHT, self.window.capacity(Z::HEIGHT));
         self.spawn(encode::replies(
             self.backend(),
             self.budget,
@@ -241,36 +260,53 @@ where
             scopes,
             outgoing,
             local_questions,
-            progress,
+            self.progress,
+            Z::HEIGHT,
         ));
-        let (next_scopes, scopes) = queues::next_scopes::<_, Z>(self.window.capacity(Z::HEIGHT));
+        let (next_scopes, scopes) = queues::next_scopes(Z::HEIGHT, self.window.capacity(Z::HEIGHT));
+        let responses = self.leaf_decode_pump(questions, incoming, next_scopes);
+        (self.respond::<Z>(responses), scopes)
+    }
+
+    /// The leaf-height decode loop: like [`decode_pump`](Self::decode_pump),
+    /// but every question is a terminal leaf request.
+    fn leaf_decode_pump(
+        &mut self,
+        mut questions: Receiver<Scope>,
+        mut incoming: StreamReceiver<A::Rx, T>,
+        next_scopes: crate::tree::mirror::streaming::channel::Sender<Scope>,
+    ) -> impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>>
+    + Send
+    + 'static
+    + use<B, T, R, W, A> {
+        let progress = self.progress;
         let backend = self.backend();
         let version_bytes = self.peer_version_bytes;
         let ledger = self.peer_supplies.clone();
-        let responses = try_stream! {
+        try_stream! {
             while let Some(scope) = questions.recv().await {
                 let Decoded { reply, questions } = decode_leaf_reply(
                     backend.clone(), version_bytes, ledger.clone(), scope, &mut incoming,
                 ).await?;
                 yield_reply_scopes!(
-                    progress, Z, questions.len();
+                    progress, Z::HEIGHT, questions.len();
                     yield reply;
                     next_scopes => questions;
                 );
             }
             reject_extra(&mut incoming).await?;
-        };
-        (self.respond(responses), scopes)
+        }
     }
 
     /// Drive the final local answers for a remote initiator to completion.
     pub async fn complete_initiator<C: Connector>(
         self,
         requests: impl Requests<B, T, Z>,
-        scopes: Receiver<Scope<Z>>,
+        scopes: Receiver<Scope>,
         outgoing: StreamSender<C, T>,
     ) -> Result<(R, W), Error<B::Error>> {
-        let progress = self.progress;
+        let requests: encode::Replies<B::Erased> =
+            Box::pin(requests.map(erased::erase_reply::<B, T, Z>));
         let finish = encode::terminal(
             self.backend(),
             self.budget,
@@ -278,7 +314,7 @@ where
             scopes,
             outgoing,
             None,
-            progress,
+            self.progress,
         );
         let ((), read, write) = self.execute(finish).await?;
         Ok((read, write))
@@ -288,8 +324,8 @@ where
     pub fn complete_responder<C: Connector>(
         mut self,
         requests: impl Requests<B, T, Z>,
-        scopes: Receiver<Scope<Z>>,
-        mut incoming: StreamReceiver<A::Rx, T>,
+        scopes: Receiver<Scope>,
+        incoming: StreamReceiver<A::Rx, T>,
         outgoing: StreamSender<C, T>,
     ) -> (
         BoxResponses<B, T, Z, Error<B::Error>>,
@@ -300,9 +336,10 @@ where
         W: Send,
         A: Send,
     {
-        let progress = self.progress;
-        let (local_questions, mut questions) =
-            queues::local_questions::<_, Z>(self.window.capacity(Z::HEIGHT));
+        let requests: encode::Replies<B::Erased> =
+            Box::pin(requests.map(erased::erase_reply::<B, T, Z>));
+        let (local_questions, questions) =
+            queues::local_questions(Z::HEIGHT, self.window.capacity(Z::HEIGHT));
         self.spawn(encode::terminal(
             self.backend(),
             self.budget,
@@ -310,12 +347,32 @@ where
             scopes,
             outgoing,
             Some(local_questions),
-            progress,
+            self.progress,
         ));
+        let responses = self.terminal_decode_pump(questions, incoming);
+        let responses = self.respond::<Z>(responses);
+        let completion = async move {
+            let ((), read, write) = self.execute(async { Ok(()) }).await?;
+            Ok((read, write))
+        };
+        (responses, completion)
+    }
+
+    /// The responder terminal's decode loop: leaf replies that may open no
+    /// further scope.
+    fn terminal_decode_pump(
+        &mut self,
+        mut questions: Receiver<Scope>,
+        mut incoming: StreamReceiver<A::Rx, T>,
+    ) -> impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>>
+    + Send
+    + 'static
+    + use<B, T, R, W, A> {
+        let progress = self.progress;
         let backend = self.backend();
         let version_bytes = self.peer_version_bytes;
         let ledger = self.peer_supplies.clone();
-        let responses = try_stream! {
+        try_stream! {
             while let Some(scope) = questions.recv().await {
                 let Decoded { reply, questions } = decode_leaf_reply(
                     backend.clone(), version_bytes, ledger.clone(), scope, &mut incoming,
@@ -323,17 +380,11 @@ where
                 if !questions.is_empty() {
                     Err(Error::TerminalQuery)?;
                 }
-                progress.decoded_reply::<Z>(0);
+                progress.decoded_reply(Z::HEIGHT, 0);
                 yield reply;
             }
             reject_extra(&mut incoming).await?;
-        };
-        let responses = self.respond(responses);
-        let completion = async move {
-            let ((), read, write) = self.execute(async { Ok(()) }).await?;
-            Ok((read, write))
-        };
-        (responses, completion)
+        }
     }
 }
 
@@ -346,11 +397,10 @@ where
 /// session. An armed cursor whose stage sees no request never polls the
 /// receiver, so the transport stream is never claimed — the lazy-claim
 /// discipline every level follows.
-struct Early<B, T, G, Rx>
+struct Early<B, T, Rx>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: Send + Sync + 'static,
-    G: Height,
 {
     /// The peer's greeting-declared `max_version_bytes`, enforced on
     /// every supplied version the opening stream decodes.
@@ -360,17 +410,15 @@ where
     ledger: SupplyLedger,
     receiver: Option<StreamReceiver<Rx, T>>,
     supplies:
-        Option<Pin<Box<dyn Stream<Item = Result<(u8, B::Node<G>), DecodeError<B::Error>>> + Send>>>,
-    lookahead: Option<(u8, B::Node<G>)>,
+        Option<Pin<Box<dyn Stream<Item = Result<(u8, B::Erased), DecodeError<B::Error>>> + Send>>>,
+    lookahead: Option<(u8, B::Erased)>,
     exhausted: bool,
 }
 
-impl<B, T, G, Rx> Early<B, T, G, Rx>
+impl<B, T, Rx> Early<B, T, Rx>
 where
     B: Backend<T, Node<Z>: Leaf<T>>,
     T: DeserializeOwned + Send + Sync + 'static,
-    G: Convert,
-    S<G>: Height,
     Rx: tokio::io::AsyncRead + Unpin + Send + 'static,
 {
     /// Arm the cursor with the opening-supply stream's receiver, if this
@@ -400,9 +448,9 @@ where
     async fn advance_to(
         &mut self,
         backend: &B,
-        root: Prefix<S<G>>,
+        root: ErasedPrefix,
         radix: u8,
-    ) -> Result<Option<B::Node<G>>, Error<B::Error>> {
+    ) -> Result<Option<B::Erased>, Error<B::Error>> {
         loop {
             if let Some((next, node)) = self.lookahead.take() {
                 if next == radix {
@@ -427,7 +475,7 @@ where
                         .take()
                         .expect("an unarmed cursor resolves no request");
                     self.supplies
-                        .get_or_insert(Box::pin(early_supplies::<B, T, G, _>(
+                        .get_or_insert(Box::pin(early_supplies::<B, T, _>(
                             backend.clone(),
                             self.version_bytes,
                             self.ledger.clone(),
diff --git a/src/tree/mirror/streaming/remote/proxy/work/queues.rs b/src/tree/mirror/streaming/remote/proxy/work/queues.rs
index 640a167f1..58927b71d 100644
--- a/src/tree/mirror/streaming/remote/proxy/work/queues.rs
+++ b/src/tree/mirror/streaming/remote/proxy/work/queues.rs
@@ -1,8 +1,13 @@
-//! Typed channel constructors for the remote proxy's three dataflow edges.
+//! Channel constructors for the remote proxy's scope-carrying edges.
 //!
 //! A response is published before the scopes it releases, and a complete
 //! outgoing wire reply is flushed before its local question scopes are
 //! published. Those orderings make one slot per edge the liveness floor.
+//! Both edges carry the erased [`Scope`] — one channel-machinery
+//! instantiation for the whole proxy — with each edge's height kept as
+//! its runtime [`QueueRole`] label. (The third proxy edge, the one-slot
+//! decoded-response relay, is minted by the response pump itself: see
+//! `Work::respond`.)
 //!
 //! - [`local_questions`] is the wire-facing question window itself, sized
 //!   by the session
@@ -10,22 +15,15 @@
 //!   there re-serializes the descent no matter how wide the walk's own
 //!   channels are;
 //! - [`next_scopes`] is the decode-side register, also window-sized, whose
-//!   items are small enough to widen defensively;
-//! - [`responses`] stays at one slot: it is an in-order relay pump, so a
-//!   full slot only stalls when its consumer is itself stalled, and the
-//!   single slot is what bounds decoded replies in flight per stage.
+//!   items are small enough to widen defensively.
 
-use crate::tree::{
-    mirror::streaming::channel::{QueueKind, QueueRole, Receiver, Sender, channel},
-    typed::height::Height,
+use crate::tree::mirror::streaming::{
+    channel::{QueueKind, QueueRole, Receiver, Sender, channel},
+    remote::adapter::Scope,
 };
 
-/// Buffer one decoded response on its way to the local protocol participant.
-pub fn responses<T, H: Height>() -> (Sender<T>, Receiver<T>) {
-    channel(QueueRole::new(QueueKind::ProxyResponses, H::HEIGHT), 1)
-}
-
-/// Carry flushed-but-unanswered questions, window-wide.
+/// Carry flushed-but-unanswered questions, window-wide, labeled at the
+/// questions' height.
 ///
 /// This queue's occupancy tracks the questions in flight on the wire at
 /// this height: the encoder publishes each question once its complete
@@ -36,18 +34,15 @@ pub fn responses<T, H: Height>() -> (Sender<T>, Receiver<T>) {
 /// decodes). The canonical derivation — the occupancy bound, its
 /// reachability, and the slack — is in the
 /// [`window`](crate::tree::mirror::streaming::window) module docs.
-pub fn local_questions<T, H: Height>(capacity: usize) -> (Sender<T>, Receiver<T>) {
+pub fn local_questions(height: usize, capacity: usize) -> (Sender<Scope>, Receiver<Scope>) {
     channel(
-        QueueRole::new(QueueKind::ProxyLocalQuestions, H::HEIGHT),
+        QueueRole::new(QueueKind::ProxyLocalQuestions, height),
         capacity,
     )
 }
 
 /// Carry scopes derived from a response already published locally,
-/// window-wide.
-pub fn next_scopes<T, H: Height>(capacity: usize) -> (Sender<T>, Receiver<T>) {
-    channel(
-        QueueRole::new(QueueKind::ProxyNextScopes, H::HEIGHT),
-        capacity,
-    )
+/// window-wide, labeled at the scopes' height.
+pub fn next_scopes(height: usize, capacity: usize) -> (Sender<Scope>, Receiver<Scope>) {
+    channel(QueueRole::new(QueueKind::ProxyNextScopes, height), capacity)
 }
diff --git a/src/tree/typed/prefix.rs b/src/tree/typed/prefix.rs
index ff08226a9..e591af5cd 100644
--- a/src/tree/typed/prefix.rs
+++ b/src/tree/typed/prefix.rs
@@ -81,6 +81,20 @@ impl ErasedPrefix {
         self.hash.push(byte);
         self
     }
+
+    /// Pop one hash byte off the end of the prefix, ascending one height:
+    /// the remainder and the byte ([`Prefix::pop`]).
+    ///
+    /// # Panics
+    ///
+    /// If the prefix is empty (the root has no parent).
+    pub fn pop(mut self) -> (ErasedPrefix, u8) {
+        let byte = self
+            .hash
+            .pop()
+            .expect("a prefix below the root has at least one byte to pop");
+        (self, byte)
+    }
 }
 
 impl Debug for ErasedPrefix {

From d52a633ad20455250818e1f3985f8657ec08abb1 Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Wed, 19 Aug 2026 18:45:57 -0400
Subject: [PATCH 05/18] height erasure: record the results; sketch item-type
 erasure

The design doc graduates to .agent-notes as the decision and measurement
record: per-step IR readings (2,884,887 -> 1,039,534 lines, -64%, on
--test pairwise), the runtime pin (gossip_fixed_bidir_insertions/V2/5000
on ox-east-1 reserved cores: 54.51 ms -> 54.10 ms, no movement), the
compile-cost A/B (non-incremental fleet rebuild: 7,819 -> 3,093
CPU-seconds, -60%), the declined step-5 Tagged collapse with its
rationale, and the resolutions of the sketch's open questions. The
streaming module's layer map gains the erased seam.

design/item-erasure.md is the phase-2 sketch (item-type erasure at the
leaf boundary), status sketch, awaiting review: the measured residue
shows the tree layers now dominate what every downstream binary re-buys,
so the sketch weighs erasing the session boundary alone against erasing
the tree's stored payload too.
---
 .../2026-08-19-height-erasure/README.md       | 132 ++++++++++
 design/height-erasure.md                      | 248 ------------------
 design/item-erasure.md                        | 111 ++++++++
 src/tree/mirror/streaming.rs                  |   3 +
 4 files changed, 246 insertions(+), 248 deletions(-)
 create mode 100644 .agent-notes/2026-08-19-height-erasure/README.md
 delete mode 100644 design/height-erasure.md
 create mode 100644 design/item-erasure.md

diff --git a/.agent-notes/2026-08-19-height-erasure/README.md b/.agent-notes/2026-08-19-height-erasure/README.md
new file mode 100644
index 000000000..8438b1118
--- /dev/null
+++ b/.agent-notes/2026-08-19-height-erasure/README.md
@@ -0,0 +1,132 @@
+# Height erasure for the streaming mirror's plumbing: the record
+
+Status: implemented (the four migration steps below); this note is the
+decision and measurement record. The mechanism's documentation of record
+is the rustdoc — start at `streaming::erased` and the `materialized` and
+`remote` module docs.
+
+## What was built
+
+The streaming (V2) mirror builds its executor-free runtime out of the
+type system, and before this work it built it once per trie height: the
+height-indexed vocabulary flowed through height-indexed channels,
+generators, pumps, and adapters, so each of ~31 heights instantiated the
+whole tokio mpsc stack, two async_stream state machines, and per-height
+encode/decode adapters — all re-monomorphized per payload type per
+downstream binary.
+
+The height parameter was phantom at every layer that matters (one Arc'd
+node representation for every height; prefix length as runtime data; a
+wire that never sees H), so erasure was re-tagging, not
+re-representation: no unsafe, no transmutes, no copies, zero wire-format
+change. The byte-pinned snapshots were the acceptance test for every
+step and never moved.
+
+What landed, by commit:
+
+1. **The seam** (`streaming: add the height-erasure seam on Backend`):
+   `Backend::{Erased, erase, assume}`, the `ErasedNode` observation
+   trait, `ErasedPrefix` (length = height witness), implementations for
+   `Local` and the three test/conformance wrapper backends.
+2. **Channels** (`streaming: erase the materialized channels' payloads`):
+   erased channel payloads behind per-edge typed facades.
+   Measured: 2,884,887 → 2,609,789 IR lines on `--test pairwise`
+   (debug, default features); rows naming tokio's mpsc 632k → 235k.
+3. **The walk** (`streaming: erase the materialized walk's workers`):
+   the vocabulary itself went erased (`Query<E>`/`Resolution<E>`/
+   `Resolve<E>` over `Backend::Erased`), the level loops, answerer,
+   resolver, assembler, and deletion filter became shared bodies behind
+   thin typed shells, and step 2's facades dissolved into them. Erased
+   code reaches the typed `Backend` GATs through the 33-arm
+   runtime-to-type dispatch in `erased::ops`, keyed on prefix length.
+   Measured: → 1,717,836 lines; materialized-labeled rows 662k → 274k.
+4. **The proxy** (`streaming: erase the remote proxy's scopes, adapter,
+   and pumps`): `Scope` erased to one type, the adapter's encode/decode
+   and the pump/encode workers shared, with `ops::{leaves, assemble}`
+   dispatching the two stream-shaped backend ops.
+   Measured: → 1,039,534 lines / 41,172 copies.
+
+Cumulative: **2,884,887 → 1,039,534 IR lines (−64%), 109,613 → 41,172
+copies** on the `pairwise` binary. (The design's original baseline of
+2.04M had drifted to 2.88M before this work began; the drift is
+pre-existing growth, not part of this attribution.)
+
+Runtime pin: `gossip_fixed_bidir_insertions/V2/5000`, parent vs.
+result, measured back-to-back on ox-east-1 under `pset-run -n 8`
+(scheduler-quiet reserved cores; local attempts were discarded as
+contended by concurrent builds and are not comparable):
+
+- parent: 54.461–54.553 ms (point estimate 54.506 ms)
+- erased: 54.031–54.182 ms (point estimate 54.095 ms)
+
+A −0.75% point delta with nearly touching confidence intervals: no
+runtime movement.
+
+Compile cost, measured on the same box (stable 1.96.1, no build cache,
+dependencies warm, then `cargo clean -p rumors` and a non-incremental
+`cargo build --locked --tests` — the fleet-wide cost of compiling the
+crate's own code into every test binary):
+
+- parent: 7,819 CPU-seconds (7,426 user + 392 sys), 423 s wall
+- erased: 3,093 CPU-seconds (2,906 user + 186 sys), 271 s wall
+
+−60% CPU, −36% wall. CPU-seconds are the load-tolerant figure; wall
+clock is bounded below by the dependency graph's critical path.
+
+## Step 5: the `Tagged<B::Erased, H>` collapse — declined
+
+The optional fifth step (flipping `Backend::Node<H>` to a mirror-layer
+`Tagged<B::Erased, H>` wrapper so the GAT and the seam collapse) was
+conditioned on the typed facades feeling heavy after 1–4 settled. They
+do not: the surviving typed surface is the protocol typestates (which
+must stay typed — they are the compile-time schedule proof), one
+request-erasure map and one reply re-tag per stage, and the fixed-height
+root re-tags. Collapsing the GAT would reshape a public-ish trait to
+remove code that no longer shows up in the measurements. Revisit only if
+a future backend's `Node<H>` stops being phantom-convertible.
+
+## What the types stopped proving, and what catches it instead
+
+Cross-height pairing inside the walk and proxy is now a
+runtime-witnessed property rather than a compile error: every
+`ErasedPrefix::assume` debug-asserts its byte length against the claimed
+height, `erased::ops` derives its dispatch height from that same length
+(coordinate and witness cannot drift), every channel keeps its
+`QueueRole` height label, and the behavioral pins (alternating oracle,
+violation/capacity suites, byte-pinned wire snapshots) exercise exactly
+these pairings. The schedule itself — phase order, role alternation,
+bottoming at `Z` — stays compile-time. Peer input cannot reach a
+mispairing: wire prefixes decode through height-typed readers.
+
+## Resolutions of the sketch's open questions
+
+- **Coherence tricks on distinct `Node<H>` types**: nothing relied on
+  them; the `Leaf` bound at `Z` survives at the typed shells.
+- **`future_size.rs`**: verified in a release run after step 4 — all
+  three pins pass unchanged. The public futures were already
+  type-erased, and the budget is a generous order-of-magnitude
+  tripwire.
+- **The fused `mirror!`/`seq!` drivers**: still linear-in-height inside
+  one function; after erasure they are no longer among the largest
+  functions (~5k lines/copy, one copy per peer pairing), so the boxing
+  follow-up stays unneeded.
+
+## Incident log
+
+(Retained from the design sketch, as history.)
+
+- **2026-07-17: the lib test binary crossed the memwatch limit.** The
+  link axis, not the height axis: every distinct `Link` type driven into
+  `remote::Handshaking::start` instantiates the whole proxy tower, and
+  the in-crate tests had accumulated fixture-wrapped link types. One
+  additional tower instantiation cost +137k IR lines but +0.7 GiB of
+  rustc peak memory; the tripwire's default was raised from 8 to 12 GiB.
+  The durable fix named then was this height erasure, which shrank every
+  tower from the inside.
+
+## What remains: the T axis
+
+Height erasure deliberately kept the payload axis. The follow-on design
+(`design/item-erasure.md`) sketches erasing `T` at the leaf conversion
+boundary so the subsystem compiles once into the rlib; height erasure
+shrank what that phase must move.
diff --git a/design/height-erasure.md b/design/height-erasure.md
deleted file mode 100644
index f4a954d52..000000000
--- a/design/height-erasure.md
+++ /dev/null
@@ -1,248 +0,0 @@
-# Height erasure for the streaming mirror's plumbing
-
-Status: sketch, not implemented. Companion to the compile-time work of
-2026-07-16 (transport erasure at the session boundary; `protocol-v1`
-feature gate). Numbers below are *measured* with `cargo llvm-lines` on
-`--test pairwise` (debug profile, default features) unless marked
-*derived*.
-
-## The problem, precisely
-
-The streaming (V2) mirror gets fixed memory and pipelining without an
-executor: every logical stream keeps moving under plain polling, with no
-`tokio::spawn`. It builds that runtime out of the type system — and it
-builds it **once per trie height**. The height-indexed vocabulary
-(`message::Reply<B, T, H>`, `Query<B, T, H>`, `Resolution<B, T, H>`)
-flows through height-indexed channels, generators, pumps, and adapters,
-so each of the ~31 heights instantiates:
-
-- ~6 typed mpsc channels (`materialized/work/queues.rs`), each dragging
-  tokio's whole mpsc stack (~1k IR lines per payload type);
-- two `async_stream` generator state machines (`work/levels.rs`,
-  the proxy pumps), each with its own drop glue;
-- per-height encode/decode adapters and reply pumps on the proxy side.
-
-Measured, in one test binary after V1 gating: **2.04M lines of LLVM IR
-total**, of which ~696k is streaming-marked symbols, ~446k is
-`tokio::sync::mpsc` + `async_stream` machinery instantiated on the
-height axis, and a large share of the remaining `core`/`alloc` glue and
-12k+ `drop_in_place` symbols is induced by the same height-indexed
-types. All of it re-monomorphizes per payload type `T`, per downstream
-binary (24 test binaries exercise sessions).
-
-Boxing cannot fix this: `BoxResponses` already caps how deeply the
-stream *types nest* (the one genuinely exponential hazard, long since
-fixed), but boxing does not reduce the instantiation *count* — every
-boxed stream still has a height-indexed item type.
-
-## The load-bearing observation: the runtime is already erased
-
-The height parameter is phantom at every layer that matters:
-
-- `typed::Node<T, H>` wraps `untyped::Node<T>` (one `Arc`'d
-  representation for every height; the prefix length is runtime data) —
-  `src/tree/typed/node.rs`, `src/tree/typed/untyped.rs`.
-- `Prefix<H>` is `PhantomData<fn() -> H>` over an
-  `ArrayVec<[u8; 32]>` whose length (`32 - H::HEIGHT`) is runtime data —
-  `src/tree/typed/prefix.rs`.
-- The wire never sees `H`: the V2 codec's runtime signal byte
-  (`state * 17 + stream`) names the logical stream on every frame —
-  under the Link transport nothing multiplexes, so it is no longer a
-  demux key but per-stream redundancy, validated to exact equality
-  against the claimed label (`streaming-wire-deadlock.md` §8.6) — and
-  the channel layer already threads `H::HEIGHT` as a runtime `u8` for
-  diagnostics (`QueueRole::new(kind, H::HEIGHT)` in
-  `streaming/materialized/work/queues.rs`).
-
-So height erasure is **re-tagging, not re-representation**: every
-conversion is a `PhantomData` swap over the value the program already
-holds. No `unsafe`, no transmutes, no copies, and — because the encoder
-never consumed `H` — **zero wire-format change**. The byte-pinned
-snapshots must not move; that is the acceptance test for every step.
-
-## The design
-
-Keep the typed phase schedule as the interface; erase everything that
-flows *through* it.
-
-### What stays typed (the guarantees we keep)
-
-`protocol.rs`'s traits (`Initiator`, `Responder`, `Reply`,
-`CompleteResponder`, `CompleteInitiator`, `ReplyHeight`), the
-`Descending<B, T, H, R, W>` typestates, and the `mirror!` driver
-schedule. These are what prove, at compile time, that phases run in
-order, each side speaks when it must, and the descent bottoms out at
-`Z` instead of trusting a depth counter. They are also *cheap*: each
-state is a small struct and a thin method once the workers beneath them
-are shared.
-
-### The erased seam on `Backend`
-
-```rust
-pub trait Backend<T: ...>: ... {
-    type Node<H: Height>: ...;            // unchanged
-    /// One runtime representation shared by every height's `Node<H>`.
-    type Erased: Clone + Send + 'static;
-    /// Forget a node's height tag. Free for `Local` (a field move).
-    fn erase<H: Height>(node: Self::Node<H>) -> Self::Erased;
-    /// Re-tag an erased node at height `H`.
-    ///
-    /// Contract: `assume::<H>(erase::<H>(n)) == n`. Debug builds check
-    /// the runtime height (prefix length) and panic on a cross-level
-    /// value; release builds trust the erased module's internal
-    /// invariant (see "What the types stop proving").
-    fn assume<H: Height>(erased: Self::Erased) -> Self::Node<H>;
-}
-```
-
-For `Local`: `Erased = untyped::Node<T>`, and both conversions are the
-existing phantom wrap/unwrap. A hypothetical backend with genuinely
-different per-height representations supplies an enum. (`Backend` is
-public; adding an associated type is a breaking change — acceptable
-pre-1.0, and the crate docs already reserve API reshaping.)
-
-`Prefix<H>` gets the same pair (`Prefix::erase() -> ErasedPrefix`,
-`ErasedPrefix::assume::<H>()` with a `debug_assert_eq!(len,
-32 - H::HEIGHT)`), where `ErasedPrefix` is the `ArrayVec` it already
-is.
-
-### The erased vocabulary and channels
-
-One module (say `streaming/erased.rs`) defines the height-free frames:
-
-```rust
-struct Reply<B, T>      { replies: Vec<Reaction<B, T>> }
-enum   Reaction<B, T>   { Supply(u8, B::Erased), Match, Query(Vec<(u8, Hash)>) }
-struct Query<B, T>      { prefix: ErasedPrefix, ours: Vec<(u8, B::Erased)> }
-struct Resolution<B, T> { prefix: ErasedPrefix, resolved: ... }
-```
-
-`queues.rs` mints channels of *these* — one mpsc instantiation per
-`(B, T)` instead of per `(B, T, H)`. The typed facade is a pair of
-one-line wrappers:
-
-```rust
-struct TypedSender<M, H>(Sender<Erased>, PhantomData<fn() -> H>);
-```
-
-whose `send` erases and whose `recv` re-tags. The per-height residue is
-these adapters and the `BoxResponses<H>` map-streams at the schedule
-boundary — one small map per height instead of the full machinery.
-
-### The erased workers
-
-`internal_level<H>` (and `leaf_parent_level`, `leaf_level`,
-`answer::internal`, `Resolver`, `children_of`, `assemble`, the
-`unknown` walk, the `convert` folds, and the proxy's
-`encode`/`decode`/`internal_replies` pumps) each become a thin typed
-shell — capture `H::HEIGHT` as a `u8`, erase the inputs, delegate,
-re-tag the outputs — over one shared worker. Two workers keep a runtime
-branch the types used to make static:
-
-- the leaf boundary: leaves carry `Message<T>` and content-addressing;
-  the erased worker branches where `untyped::Children::Leaf` already
-  discriminates, and `height == 0` must agree with that discriminant
-  (debug-asserted);
-- the `unknown` recursion: a loop over runtime height replaces 31
-  `BoxFuture` instantiations (that module already boxes each level, so
-  this is strictly less machinery).
-
-### What the types stop proving, and what catches it instead
-
-Today, sending a level-5 resolution into a level-6 queue is a compile
-error. After erasure it is a bug class again — confined as follows:
-
-1. **Locality.** The typed facade is the only entry to the erased
-   module; a mispairing can only be authored inside it. The audit
-   surface is one module, not the codebase.
-2. **Runtime witnesses.** Every `assume` debug-asserts the prefix
-   length; `QueueRole` already labels every channel with its height, so
-   a violation names itself.
-3. **The oracle and the violation suite.** The alternating oracle tests
-   (`streaming/tests`), the adversarial-schedule backend, and
-   `work/tests/violations.rs` exercise exactly these pairings; the
-   byte-pinned wire snapshots pin the external behavior.
-4. **Unchanged threat model.** Peer-controlled input was always
-   validated at runtime (the typed layer never protected the wire);
-   the schedule itself — phase order, role alternation, bottoming at
-   `Z` — stays compile-time.
-
-### What it buys (derived)
-
-- mpsc/`async_stream` machinery: ~446k lines ÷ ~31 heights → ~15–30k.
-- Streaming-marked symbols: the per-height workers dominate the ~696k;
-  shared workers leave roughly 150–250k (schedule shells + one worker
-  set + leaf specifics).
-- Drop glue and `core`/`alloc` glue shrink proportionally (they are
-  per-type artifacts of the erased population).
-
-Estimate: `pairwise` drops from ~2.04M to roughly **0.7–1.0M lines**,
-and — more important for the fleet — each *additional* payload type or
-test binary re-buys only the residue, not the tower. The axis this does
-NOT remove is `T` itself: compiling the whole subsystem once, inside
-`rumors`, additionally requires content erasure at the leaf (the
-conversion boundary already named in the streaming module docs — leaves
-cross the wire as canonical borsh bytes today). That is phase 2,
-orthogonal, and composes: height erasure shrinks what phase 2 would
-move.
-
-## Migration plan (each step lands gate-clean, snapshots byte-identical)
-
-1. **Seam.** Add `Backend::Erased` + `erase`/`assume`, `ErasedPrefix`,
-   and the `Local` impl. No caller changes; pure addition.
-2. **Channels.** Erase `queues.rs`/`channel.rs` payloads behind
-   `TypedSender`/`TypedReceiver`. Measure (expect the mpsc block to
-   collapse).
-3. **Materialized workers.** One erased worker behind
-   `internal_level`/`leaf_parent_level`/`leaf_level`;
-   erase `answer`/`Resolver`/`assemble`/`unknown`. The oracle suite is
-   the behavioral pin. Measure.
-4. **Proxy workers.** Erase the adapter encode/decode and reply pumps
-   (the codec beneath them is already runtime-indexed). Wire snapshots
-   are the pin. Measure.
-5. **Optional cleanup.** If the facades feel heavy, consider flipping
-   `Backend::Node<H>` to a mirror-layer `Tagged<B::Erased, H>` wrapper
-   so the GAT and the seam collapse into one shape. Bigger surface
-   change; only worth it once 1–4 have settled.
-
-## Incident log
-
-- **2026-07-17: the lib test binary crossed the memwatch limit.** The
-  link axis, not the height axis: every distinct `Link` type driven into
-  `remote::Handshaking::start` instantiates the whole proxy tower, and
-  the in-crate tests had accumulated fixture-wrapped link types (memory,
-  adversarial, scripted; a reordering acceptor tipped it over).
-
-  Measured on the lib test target (stable 1.96.1, all features): one
-  additional tower instantiation cost +137k IR lines but **+0.7 GiB of
-  rustc peak memory** — the cost is type-tree and collector state, not
-  codegen volume — and under incremental CGU partitioning (every tower
-  lands in the proxy module's CGU) the same delta took the compile from
-  ~7.3 GB to the 9.4 GB memwatch kill.
-
-  Resolution: the tripwire's default was raised from 8 to 12 GiB
-  (`tools/memwatch`). The guard exists to catch runaway exponential type
-  growth (its motivating incident was 25+ GiB); this was measured
-  *linear* growth in an intentional axis — each fixture link type is one
-  more tower at a bounded, known cost. A test-only `Link::into_erased`
-  funnel was tried and worked (7 → 4 towers, peak back to 7.7 GB) but
-  was rejected as contorting test code to an arbitrary threshold. If the
-  tower count keeps growing, that owned erased carrier is the shape to
-  revive — and it must be *owning*: a borrowed carrier leaves the
-  concrete connector alive in the caller, so the peer's supply never
-  closes and every supply-closure test stalls. The durable fix remains
-  this document's height erasure, which shrinks every tower from the
-  inside.
-
-## Open questions
-
-- Does any code rely on `B::Node<H>` being *distinct types* per height
-  for coherence tricks (blanket impls keyed on `Node<Z>: Leaf<T>`)? The
-  `Leaf` bound at `Z` survives (the typed shells still see `Node<Z>`),
-  but step 5 would need care here.
-- `future_size.rs` pins session-future sizes; the erased state machines
-  are smaller, so the pins move once (deliberately).
-- The fused `mirror!`/`seq!` drivers stay linear-in-height inside one
-  function (~5k IR lines/copy). If they remain the largest single
-  functions after erasure, box each phase step — a small, independent
-  follow-up.
diff --git a/design/item-erasure.md b/design/item-erasure.md
new file mode 100644
index 000000000..a9615217a
--- /dev/null
+++ b/design/item-erasure.md
@@ -0,0 +1,111 @@
+# Item-type erasure at the leaf boundary (part II sketch)
+
+Status: sketch, not implemented — the "phase 2" the height-erasure work
+names. Written after height erasure landed; numbers marked *measured*
+come from `cargo llvm-lines --test pairwise` (debug, default features)
+on the height-erased tree.
+
+## The problem, precisely
+
+Height erasure removed the per-height axis: the streaming session's
+channels, walks, and proxy pumps instantiate once per backend. The axis
+it deliberately kept is the payload type `T`. Everything the session
+touches is still generic over `T`:
+
+- `Backend<T>::Erased = untyped::Node<T>`: nodes hold `Message<T>` at
+  their leaves, so every erased worker, channel, and dispatch arm
+  re-monomorphizes per `T`;
+- the codec's `Frame<T>` / `LeafRun<T>` and the leaf conversion boundary
+  (`Leaf::leaf(Version, Message<T>)`, `Node::message() -> &Message<T>`);
+- the tree itself (`untyped::Node<T>`, the traversals, the CRDT ops).
+
+Because this code is generic, none of it is compiled into the `rumors`
+rlib: every downstream binary re-instantiates it. Measured: the
+`pairwise` test binary carries ~1.04M IR lines after height erasure, and
+essentially all of it is generic re-instantiation — the marginal cost of
+each additional payload type *or* additional binary. The fleet effect is
+the 24 session-exercising test binaries each re-buying the subsystem.
+
+"Compiles only once" means: the session subsystem (and ideally the tree)
+becomes non-generic code, codegen'd once into the rlib, with a thin
+typed facade per `T`.
+
+## The load-bearing observation: the wire is already erased
+
+On the wire a leaf is `(Version, payload bytes)`: the codec serializes
+`Message<T>` to canonical CBOR at encode and deserializes at decode —
+`T` exists on the wire only as bytes. Likewise the tree's identity
+layer: a leaf's path derives from its version, and its hash commits to
+canonical bytes, not to `T`'s shape. The only operations that genuinely
+need `T` are the user-facing reads (`Rumors::iter`, `get`) and
+insertion.
+
+## Design options
+
+The decision is where `Message<T> ⇄ canonical bytes` conversion lives.
+
+### Option A: erase at the session boundary only
+
+The tree keeps storing `Message<T>`; sessions convert each supplied leaf
+to bytes at encode and construct `Message<T>` at decode (what the codec
+already does). The session core becomes generic over an opaque
+`Payload = raw canonical bytes` instead of `T`.
+
+- Buys: the streaming subsystem compiles once. The tree stays generic.
+- Costs: nothing new at runtime (the encode/decode conversions already
+  happen at exactly these points).
+- Residue: the tree + CRDT ops still re-instantiate per `T` per binary.
+  Measured share (rows naming the tree layers in the height-erased
+  `pairwise` binary, overlapping): `tree::typed` 728k of the 1.04M
+  total, `typed::untyped` 318k, `tree::traverse` 186k — the tree, not
+  the session, is now the larger half of the re-bought code, which
+  argues for option B (or C's second phase) rather than stopping at A.
+
+### Option B: erase the tree's storage too
+
+`untyped::Node` stores `Message<Raw>` (canonical bytes); the typed
+facade decodes on read (`iter`/`get` return decoded values or a lazy
+view) and encodes on insert.
+
+- Buys: tree + session compile once; the whole gossip stack becomes
+  rlib code. The `T`-facade shrinks to (de)serialization at the public
+  API.
+- Costs: decode-on-read for iteration (each read pays a CBOR decode;
+  today reads are free); or cache decoded values (memory). Insertion
+  already pays one encode (for hashing) — verify: if hashing already
+  encodes, insertion cost is unchanged.
+- This is the full "compiles only once".
+
+### Option C: A now, B later
+
+A is strictly smaller and proves the seam; B builds on it. The
+measurement after A decides whether B's read-path trade is worth it.
+
+## What the types stop proving
+
+`T`'s type safety at the session boundary is today only the guarantee
+that both ends of an in-process session speak the same `T`; on the wire
+it was never checked beyond CBOR well-formedness. Erasure moves nothing
+security-relevant: payload validation stays exactly where it is
+(deserialization at the read boundary).
+
+## Acceptance
+
+- Wire snapshots byte-identical (the wire never sees the change).
+- The oracle and violation suites as behavioral pins.
+- `cargo llvm-lines` per step, plus the new headline number: IR lines of
+  a *minimal downstream binary* (one `gossip` call), before and after —
+  the "what does the next consumer pay" meter.
+- The `gossip_fixed_bidir_insertions/5000` bench as the runtime pin.
+
+## Open questions for review
+
+1. Is `Message<T>`'s canonical encoding stable enough to be the stored
+   representation (option B), or is decode-on-read unacceptable for the
+   read path's contract?
+2. Should the erased payload be a newtype (`Payload(Bytes)`) with the
+   canonicality invariant documented, or the existing
+   `Message<RawValue>`-style vehicle if one exists?
+3. Facade shape: seal the session core behind non-generic functions in
+   the rlib (taking `&mut dyn` link objects — the transport is already
+   dyn-erased), or keep generic entry points that immediately erase?
diff --git a/src/tree/mirror/streaming.rs b/src/tree/mirror/streaming.rs
index a55534ff9..275ca3e2e 100644
--- a/src/tree/mirror/streaming.rs
+++ b/src/tree/mirror/streaming.rs
@@ -16,6 +16,9 @@
 //!   binding.
 //! - [`window`]: how one byte budget becomes per-height channel capacities.
 //! - [`message`]: the wire vocabulary, the greeting included.
+//! - [`erased`]: the height-erased seam both implementors run on — the
+//!   wire vocabulary's erased twin, its typed exits, and the dispatch
+//!   back into the height-typed backend surface.
 //! - [`convert`]: the leaf conversion boundary between backends.
 //! - [`driver`], [`channel`], [`tasks`]: plumbing — phase scheduling and
 //!   error routing, named bounded edges, task completion.

From b499ca9b2d810564a740cdf6f9232f3a5c1257a8 Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Wed, 19 Aug 2026 18:58:16 -0400
Subject: [PATCH 06/18] item-erasure sketch: adopt the Arc<dyn Any> payload
 shape
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Message already pairs its Arc'd value with the canonical serialized
bytes, and the tree and session consume only the bytes outside the
typed reads — so erasing the value is an unsizing coercion of the
existing Arc, read back by checked downcast, with a per-T deserialize
witness at wire ingress as the only other per-T residue. This replaces
the decode-on-read variant, which charged every read a CBOR decode to
save a fat pointer.
---
 design/item-erasure.md | 68 ++++++++++++++++++++++++++++++------------
 1 file changed, 49 insertions(+), 19 deletions(-)

diff --git a/design/item-erasure.md b/design/item-erasure.md
index a9615217a..f1685a85d 100644
--- a/design/item-erasure.md
+++ b/design/item-erasure.md
@@ -61,25 +61,56 @@ already does). The session core becomes generic over an opaque
   the session, is now the larger half of the re-bought code, which
   argues for option B (or C's second phase) rather than stopping at A.
 
-### Option B: erase the tree's storage too
-
-`untyped::Node` stores `Message<Raw>` (canonical bytes); the typed
-facade decodes on read (`iter`/`get` return decoded values or a lazy
-view) and encodes on insert.
-
-- Buys: tree + session compile once; the whole gossip stack becomes
-  rlib code. The `T`-facade shrinks to (de)serialization at the public
-  API.
-- Costs: decode-on-read for iteration (each read pays a CBOR decode;
-  today reads are free); or cache decoded values (memory). Insertion
-  already pays one encode (for hashing) — verify: if hashing already
-  encodes, insertion cost is unchanged.
-- This is the full "compiles only once".
+### Option B (recommended; Finch's shape): erase the stored value
+behind `Arc<dyn Any>`
+
+`Message<T>` already stores `{ message: Arc<T>, serialized: Bytes }`,
+and everything the tree and session do with a payload other than the
+typed reads — the hash preimage, wire encode, size accounting — reads
+the cached canonical bytes, never the value. So the erased message is
+simply
+
+```rust
+struct Message /* erased */ {
+    message: Arc<dyn Any + Send + Sync>,  // the same allocation,
+                                          // unsized: +8 B fat pointer
+    serialized: Bytes,                    // unchanged, and already
+                                          // everything the erased
+                                          // core consumes
+}
+```
+
+with the typed boundary reading by checked downcast (a `TypeId`
+compare; a failed downcast is a *caught* mispairing — stronger
+witnessing than the height seam's debug-only prefix asserts). The one
+per-`T` residue beyond the facade is a deserialize witness
+(`fn(&[u8]) -> Result<Arc<dyn Any + Send + Sync>, _>`) threaded from
+peer construction to the wire-decode boundary, which keeps malformed
+payloads failing at ingress as `DecodeError::Record` exactly as today.
+
+- Buys: tree + session compile once — the full "compiles only once" —
+  with today's runtime behavior preserved at every point: reads free,
+  ingress single-decode, hash/encode off the cached bytes.
+- Costs: a fat pointer per `Message` handle and a `TypeId` compare per
+  typed read; the `gossip_fixed` bench pin guards the claim that this
+  is nothing.
+- Public API consequence, the part to shape deliberately: `iter`/`get`
+  and `Leaf::message` return `&Message<T>` today, which cannot survive
+  as-is once the payload inside is erased — the API becomes a typed
+  accessor (`message.get::<T>() -> &T`) or a `MessageView<'_, T>`.
+  `T: Serialize` migrates to the insert boundary and
+  `DeserializeOwned` to witness minting; nothing new is demanded of
+  `T`.
+
+A decode-on-read variant (store the bytes only, decode at the typed
+boundary) loses to this on every axis: it saves the fat pointer but
+charges every read a CBOR decode that today is free.
 
 ### Option C: A now, B later
 
-A is strictly smaller and proves the seam; B builds on it. The
-measurement after A decides whether B's read-path trade is worth it.
+A is strictly smaller and proves the session seam; B builds on it. But
+the measured residue above says the tree is the larger half, so
+stopping at A forfeits most of the prize.
 
 ## What the types stop proving
 
@@ -103,9 +134,8 @@ security-relevant: payload validation stays exactly where it is
 1. Is `Message<T>`'s canonical encoding stable enough to be the stored
    representation (option B), or is decode-on-read unacceptable for the
    read path's contract?
-2. Should the erased payload be a newtype (`Payload(Bytes)`) with the
-   canonicality invariant documented, or the existing
-   `Message<RawValue>`-style vehicle if one exists?
+2. The `&Message<T>` return type's replacement: typed accessor on an
+   erased `Message`, or a borrowed `MessageView<'_, T>`?
 3. Facade shape: seal the session core behind non-generic functions in
    the rlib (taking `&mut dyn` link objects — the transport is already
    dyn-erased), or keep generic entry points that immediately erase?

From b500889b1997679a036f8e9784c2088525313e0d Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Wed, 19 Aug 2026 19:05:30 -0400
Subject: [PATCH 07/18] item-erasure sketch: Message is crate-internal; no
 public API movement

The public observers speak (Version, Arc<T>) and nothing re-exports
Message (verified against the public rustdoc surface), so the erased
payload reshapes only crate internals; the observers' retained
most-recent-leaf slot becomes the per-yield downcast point. The open
questions shrink to witness minting, facade sealing, and whether the
tree erases in the same stroke.
---
 design/item-erasure.md | 33 ++++++++++++++++++++-------------
 1 file changed, 20 insertions(+), 13 deletions(-)

diff --git a/design/item-erasure.md b/design/item-erasure.md
index f1685a85d..6830bd4ad 100644
--- a/design/item-erasure.md
+++ b/design/item-erasure.md
@@ -94,13 +94,17 @@ payloads failing at ingress as `DecodeError::Record` exactly as today.
 - Costs: a fat pointer per `Message` handle and a `TypeId` compare per
   typed read; the `gossip_fixed` bench pin guards the claim that this
   is nothing.
-- Public API consequence, the part to shape deliberately: `iter`/`get`
-  and `Leaf::message` return `&Message<T>` today, which cannot survive
-  as-is once the payload inside is erased — the API becomes a typed
-  accessor (`message.get::<T>() -> &T`) or a `MessageView<'_, T>`.
-  `T: Serialize` migrates to the insert boundary and
-  `DeserializeOwned` to witness minting; nothing new is demanded of
-  `T`.
+- No public API movement: `Message` is crate-internal (nothing
+  re-exports it; verified against the public rustdoc surface), and the
+  public observers already speak `(Version, Arc<T>)`. The one
+  mechanical seam is the observers' lending contract —
+  `borrow_next() -> (&Version, &Arc<T>)` lends from a retained
+  most-recent-leaf slot, so that slot becomes the downcast point: one
+  `Arc::downcast::<T>()` (a refcount bump plus the `TypeId` check) per
+  yielded message, a cost the owned `(Version, Arc<T>)` item already
+  pays. `T: Serialize` migrates to the insert boundary and
+  `DeserializeOwned` to witness minting; the public bounds stay
+  equivalent.
 
 A decode-on-read variant (store the bytes only, decode at the typed
 boundary) loses to this on every axis: it saves the fat pointer but
@@ -131,11 +135,14 @@ security-relevant: payload validation stays exactly where it is
 
 ## Open questions for review
 
-1. Is `Message<T>`'s canonical encoding stable enough to be the stored
-   representation (option B), or is decode-on-read unacceptable for the
-   read path's contract?
-2. The `&Message<T>` return type's replacement: typed accessor on an
-   erased `Message`, or a borrowed `MessageView<'_, T>`?
-3. Facade shape: seal the session core behind non-generic functions in
+1. Witness minting site: at `Peer<T>` construction (one witness for the
+   peer's lifetime, threaded through sessions), or per gossip call?
+   Construction seems right — it is also where `DeserializeOwned`
+   naturally lives.
+2. Facade shape: seal the session core behind non-generic functions in
    the rlib (taking `&mut dyn` link objects — the transport is already
    dyn-erased), or keep generic entry points that immediately erase?
+3. Does the tree erase in the same stroke (it must for the full win —
+   `untyped::Node<T>`'s only `T` is the stored `Message`), or does a
+   first landing keep a typed tree and erase at the session boundary
+   (option A) to de-risk?

From cd7c09db3345535b4af29acaca8f27009bab89c7 Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Wed, 19 Aug 2026 20:34:24 -0400
Subject: [PATCH 08/18] observers: dissolve the lending forms

borrow_next and the lending TryNext existed to avoid cloning a Version
whose clone once materialized ITC structure; with Version CoW over
shared bytes, a clone is a refcount bump and the lending forms' whole
value collapsed to two atomic increments per message. The Stream face
becomes the observers' one engine: try_next keeps its non-blocking
Message/Quiet/Ended trichotomy but yields the owned (Version, Arc<T>)
pair (TryNext loses its lifetime parameter), and the retained
most-recent-leaf lending slots dissolve with the borrowing entry
points.

This also removes the one observer seam the item-erasure sketch had to
thread a downcast through (design/item-erasure.md).
---
 benches/in_memory.rs           |   6 +-
 examples/swarm.rs              |   4 +-
 src/rumors/causal.rs           | 107 ++++++--------------------------
 src/rumors/unordered.rs        | 109 ++++++++-------------------------
 src/tree/typed/untyped/iter.rs |   4 +-
 tests/api_send_bounds.rs       |  11 +---
 tests/causal.rs                |  22 +++----
 tests/common/sim.rs            |  10 +--
 tests/listen.rs                |  33 +++++-----
 9 files changed, 85 insertions(+), 221 deletions(-)

diff --git a/benches/in_memory.rs b/benches/in_memory.rs
index c84c33483..fb4e2ccfa 100644
--- a/benches/in_memory.rs
+++ b/benches/in_memory.rs
@@ -41,7 +41,7 @@
 use std::hint::black_box;
 
 use criterion::{BatchSize, BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
-use futures::FutureExt;
+use futures::{FutureExt, StreamExt};
 use rumors::{CausalMessages, Peer, Rumors, UnorderedMessages, Version, causally};
 
 // The shared grid module exposes a superset of helpers; each bench binary uses
@@ -76,7 +76,7 @@ fn build(n: usize) -> (Rumors<()>, Vec<Version>) {
 /// many messages were yielded.
 fn drain(observer: &mut UnorderedMessages<()>) -> usize {
     let mut count = 0usize;
-    while let Some(Some(item)) = observer.borrow_next().now_or_never() {
+    while let Some(Some(item)) = observer.next().now_or_never() {
         black_box(item);
         count += 1;
     }
@@ -259,7 +259,7 @@ fn bench_observer_delta(c: &mut Criterion) {
 /// many messages were yielded: [`drain`]'s twin for the causal face.
 fn drain_causal(observer: &mut CausalMessages<()>) -> usize {
     let mut count = 0usize;
-    while let Some(Some(item)) = observer.borrow_next().now_or_never() {
+    while let Some(Some(item)) = observer.next().now_or_never() {
         black_box(item);
         count += 1;
     }
diff --git a/examples/swarm.rs b/examples/swarm.rs
index 331a455b2..15f619975 100644
--- a/examples/swarm.rs
+++ b/examples/swarm.rs
@@ -134,7 +134,7 @@ use std::time::{Duration, Instant};
 
 use arc_swap::ArcSwap;
 use clap::Parser;
-use futures::FutureExt;
+use futures::{FutureExt, StreamExt};
 use rand::rngs::SmallRng;
 use rand::{Rng, RngCore, SeedableRng};
 use ratatui::Terminal;
@@ -618,7 +618,7 @@ fn run_party(
 /// its version into the pool. Each message is yielded exactly once across
 /// the party's lifetime, so the pool never holds duplicates.
 fn drain_versions(observer: &mut UnorderedMessages<Payload>, pool: &mut Vec<Version>) {
-    while let Some(Some((version, _))) = observer.borrow_next().now_or_never() {
+    while let Some(Some((version, _))) = observer.next().now_or_never() {
         pool.push(version.clone());
     }
 }
diff --git a/src/rumors/causal.rs b/src/rumors/causal.rs
index caac9c337..7a7cfe1be 100644
--- a/src/rumors/causal.rs
+++ b/src/rumors/causal.rs
@@ -20,6 +20,11 @@ use super::unordered::{Channel, TryNext};
 /// order, which may differ between [`gossip`](crate::Rumors::gossip)ing
 /// replicas of the same [`Rumors`](crate::Rumors).
 ///
+/// Each message arrives as an owned `(Version, Arc<T>)` — both handles are
+/// cheap reference bumps into shared storage — through the [`Stream`] impl
+/// or [`try_next`](Self::try_next), exactly as for
+/// [`UnorderedMessages`](super::UnorderedMessages).
+///
 /// Unlike [`UnorderedMessages`](super::UnorderedMessages), this costs an
 /// extra amortized factor, logarithmic in the number of messages the set
 /// holds, in memory and in the time to retrieve each message, and both
@@ -56,9 +61,6 @@ pub struct CausalMessages<T> {
     /// opens only once this empties), whose range start was `checkpoint`
     /// and whose ceiling is `ingested`.
     staged: BTreeMap<(Rank, Vec<u8>), Leaf<T>>,
-    /// The most recently delivered leaf, kept alive so its version and
-    /// value can be lent to the caller until the next call.
-    current: Option<Leaf<T>>,
 }
 
 impl<T> CausalMessages<T> {
@@ -68,7 +70,6 @@ impl<T> CausalMessages<T> {
             ingested: since.clone(),
             checkpoint: since,
             staged: BTreeMap::new(),
-            current: None,
         }
     }
 
@@ -102,66 +103,6 @@ impl<T> CausalMessages<T> {
         *ingested |= &ceiling;
     }
 
-    /// Pop the causally least staged message, parking it in `current` so
-    /// its borrows survive the return.
-    ///
-    /// Never moves the resume point, even when this empties the backlog:
-    /// the popped message is still unhandled in the caller's hands, so the
-    /// catch-up is deferred to the next call, exactly as
-    /// [`UnorderedMessages`](super::UnorderedMessages) defers a drained
-    /// pass's ceiling.
-    fn pop(&mut self) -> Option<(&Version, &Arc<T>)> {
-        let (_, leaf) = self.staged.pop_first()?;
-        let leaf = self.current.insert(leaf);
-        Some((leaf.version(), leaf.value()))
-    }
-
-    /// Advance to the next message in causal order and lend it.
-    pub(crate) async fn borrow_next_inner(&mut self) -> Option<(&Version, &Arc<T>)>
-    where
-        T: Send + Sync,
-    {
-        loop {
-            // Deliver the staged backlog before consulting the channel:
-            // everything staged became deliverable when its pass finished
-            // ingesting. (Polonius limitation: returning `self.pop()` here
-            // would hold the borrow across the loop, so flag-and-break.)
-            if !self.staged.is_empty() {
-                break;
-            }
-            match self.channel.as_mut().expect("channel state present") {
-                // Finish a wait the `Stream` face left in flight.
-                Channel::Waiting(wait) => {
-                    let (closed, rx) = wait.as_mut().await;
-                    self.channel = Some(Channel::Ready(rx));
-                    if closed {
-                        return None;
-                    }
-                }
-                Channel::Ready(rx) => {
-                    // The backlog is empty here (the loop head breaks
-                    // otherwise), so the previous pass is fully delivered
-                    // and its last message is back out of the caller's
-                    // hands: the deferred catch-up runs now, before the
-                    // next pass opens against the caught-up boundary.
-                    self.checkpoint = self.ingested.clone();
-                    Self::ingest(&mut self.staged, &mut self.ingested, rx);
-                    if self.staged.is_empty() {
-                        // Nothing new: the resume point covers the pass's
-                        // content-free ceiling advance too; await the next
-                        // change. `Err` means every sender is gone and the
-                        // ingest above saw the final state.
-                        self.checkpoint = self.ingested.clone();
-                        if rx.changed().await.is_err() {
-                            return None;
-                        }
-                    }
-                }
-            }
-        }
-        self.pop()
-    }
-
     /// The sound resume point: the causal frontier *behind* any internally
     /// staged backlog, suitable for persisting across processes or handing to
     /// another replica of the same network.
@@ -184,29 +125,17 @@ impl<T> CausalMessages<T> {
     }
 }
 
-impl<T> CausalMessages<T> {
-    /// Advance to the next message in causal order, lending its version and
-    /// value until the following call.
-    ///
-    /// Awaits quietly while the set is unchanged; resolves [`None`] once no
-    /// further change is possible and the backlog has drained.
-    pub async fn borrow_next(&mut self) -> Option<(&Version, &Arc<T>)>
-    where
-        T: Send + Sync,
-    {
-        self.borrow_next_inner().await
-    }
+impl<T: Send + Sync + 'static> CausalMessages<T> {
     /// Take one non-blocking step: a message if one is ready, [`Quiet`] (ask
     /// again later) if not, [`Ended`] if no further message is possible.
     ///
+    /// One [`Stream`] poll with a no-op waker, rendered as the trichotomy.
+    ///
     /// [`Quiet`]: TryNext::Quiet
     /// [`Ended`]: TryNext::Ended
-    pub fn try_next(&mut self) -> TryNext<'_, T>
-    where
-        T: Send + Sync,
-    {
-        use futures::FutureExt;
-        match self.borrow_next_inner().now_or_never() {
+    pub fn try_next(&mut self) -> TryNext<T> {
+        use futures::{FutureExt, StreamExt};
+        match self.next().now_or_never() {
             None => TryNext::Quiet,
             Some(None) => TryNext::Ended,
             Some(Some(message)) => TryNext::Message(message),
@@ -214,9 +143,8 @@ impl<T> CausalMessages<T> {
     }
 }
 
-/// The owned-item face: `(Version, Arc<T>)` per item, popped from the
-/// same staged backlog [`borrow_next`](CausalMessages::borrow_next) lends
-/// from.
+/// Yields owned `(Version, Arc<T>)` pairs popped from the staged backlog
+/// in causal order: cheap handles into the shared storage.
 ///
 /// `T: 'static` because the quiet-period wait is materialized as an
 /// owned future, exactly as in [`UnorderedMessages`](super::UnorderedMessages).
@@ -226,10 +154,11 @@ impl<T: Send + Sync + 'static> Stream for CausalMessages<T> {
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         let this = self.get_mut();
         loop {
-            // As in `pop`, the resume point stays put even when this pop
-            // empties the backlog: the yielded message is unhandled until
-            // the stream is polled again, so the catch-up defers to the
-            // next poll's ingest.
+            // The resume point stays put even when this pop empties the
+            // backlog: the yielded message is unhandled until the stream
+            // is polled again, so the catch-up defers to the next poll's
+            // ingest, exactly as UnorderedMessages defers a drained pass's
+            // ceiling.
             if let Some((_, leaf)) = this.staged.pop_first() {
                 return Poll::Ready(Some((leaf.version().clone(), leaf.value().clone())));
             }
diff --git a/src/rumors/unordered.rs b/src/rumors/unordered.rs
index e67b54a57..97ca874b2 100644
--- a/src/rumors/unordered.rs
+++ b/src/rumors/unordered.rs
@@ -1,4 +1,4 @@
-use crate::tree::{Leaf, RangeOwned};
+use crate::tree::RangeOwned;
 use crate::{Version, causally};
 use futures::Stream;
 use std::pin::Pin;
@@ -16,12 +16,11 @@ use tokio::sync::watch;
 /// and no further change is possible, it yields whatever remains and ends
 /// with `None`.
 ///
-/// There are two ways to use it:
+/// Each message arrives as an owned `(Version, Arc<T>)` — both handles are
+/// cheap reference bumps into shared storage — through either face:
 ///
-/// - [`borrow_next`](Self::borrow_next) lends each message as
-///   `(&Version, &Arc<T>)`, the borrows living until the next call.
-/// - The [`Stream`] impl (for `T: 'static`) yields owned
-///   `(Version, Arc<T>)`.
+/// - the [`Stream`] impl, awaiting quietly while the set is unchanged;
+/// - [`try_next`](Self::try_next), one non-blocking step at a time.
 ///
 /// Order is unspecified and does *not* follow the causal order: a message may
 /// be yielded before another that causally precedes it; use
@@ -34,17 +33,13 @@ use tokio::sync::watch;
 pub struct UnorderedMessages<T> {
     /// The watch channel, or the in-flight wait for it to change.
     ///
-    /// The wait future owns the receiver and hands it back: the `Stream`
-    /// face cannot hold a borrowing `changed()` future across polls
-    /// (recreating one per poll would drop its waker registration and lose
-    /// the wakeup), so the wait is materialized; `borrow_next` enters it
-    /// only to finish what a `Stream` poll started.
+    /// The wait future owns the receiver and hands it back: a `Stream`
+    /// cannot hold a borrowing `changed()` future across polls (recreating
+    /// one per poll would drop its waker registration and lose the
+    /// wakeup), so the wait is materialized.
     channel: Option<Channel<T>>,
     checkpoint: Version,
     pass: Option<Pass<T>>,
-    /// The most recently yielded leaf, kept alive so its version and value
-    /// can be lent to the caller until the next call.
-    current: Option<Leaf<T>>,
 }
 
 /// The outcome of [`UnorderedMessages::try_next`] or [`CausalMessages::try_next`].
@@ -53,10 +48,10 @@ pub struct UnorderedMessages<T> {
 ///
 /// [`CausalMessages::try_next`]: super::CausalMessages::try_next
 #[derive(Debug)]
-pub enum TryNext<'a, T> {
-    /// A message was ready, lent until the next call (as
-    /// [`borrow_next`](UnorderedMessages::borrow_next) lends it).
-    Message((&'a Version, &'a Arc<T>)),
+pub enum TryNext<T> {
+    /// A message was ready: the same owned `(Version, Arc<T>)` pair the
+    /// [`Stream`] face yields.
+    Message((Version, Arc<T>)),
     /// No message is ready yet, but handles are still live: ask again later.
     Quiet,
     /// Every handle is gone and no further message is possible.
@@ -69,7 +64,7 @@ type WaitForChange<T> =
     Pin<Box<dyn Future<Output = (bool, watch::Receiver<crate::Inner<T>>)> + Send>>;
 
 /// An observer's hold on the watch channel: either the receiver itself, or
-/// the materialized owned wait the `Stream` face left in flight (see the
+/// the materialized owned wait a quiet poll left in flight (see the
 /// [`UnorderedMessages::channel`] field docs for why the wait must be owned).
 pub(super) enum Channel<T> {
     /// The channel is in hand.
@@ -91,7 +86,6 @@ impl<T> UnorderedMessages<T> {
             channel: Some(Channel::Ready(inner.subscribe())),
             checkpoint: since,
             pass: None,
-            current: None,
         }
     }
 
@@ -114,46 +108,6 @@ impl<T> UnorderedMessages<T> {
         }
     }
 
-    /// Advance to the next message and lend it until the following call.
-    pub(crate) async fn borrow_next_inner(&mut self) -> Option<(&Version, &Arc<T>)>
-    where
-        T: Send + Sync,
-    {
-        loop {
-            match self.channel.as_mut().expect("channel state present") {
-                // Finish a wait the `Stream` face left in flight.
-                Channel::Waiting(wait) => {
-                    let (closed, rx) = wait.as_mut().await;
-                    self.channel = Some(Channel::Ready(rx));
-                    if closed {
-                        return None;
-                    }
-                }
-                Channel::Ready(rx) => {
-                    Self::open_pass(&mut self.pass, rx, &self.checkpoint);
-
-                    // Lend the next leaf out of the walk, parking it in
-                    // `current` so the borrows survive the return.
-                    let pass = self.pass.as_mut().expect("opened above");
-                    if let Some((_, leaf)) = pass.walk.next() {
-                        let leaf = self.current.insert(leaf);
-                        return Some((leaf.version(), leaf.value()));
-                    }
-
-                    // The pass drained: absorb its ceiling as completed,
-                    // then await the next change; `Err` means every sender
-                    // is gone and the drain above already saw the final
-                    // state.
-                    let Pass { ceiling, .. } = self.pass.take().expect("opened above");
-                    self.checkpoint |= &ceiling;
-                    if rx.changed().await.is_err() {
-                        return None;
-                    }
-                }
-            }
-        }
-    }
-
     /// The sound resume point: the causal frontier of the last *completed*
     /// pass, suitable for persisting across processes or handing to another
     /// replica of the same network.
@@ -174,7 +128,7 @@ impl<T> UnorderedMessages<T> {
     /// # Examples
     ///
     /// ```
-    /// use futures::FutureExt;
+    /// use futures::{FutureExt, StreamExt};
     /// use rumors::{Peer, Version};
     ///
     /// # tokio::runtime::Builder::new_current_thread()
@@ -185,7 +139,7 @@ impl<T> UnorderedMessages<T> {
     /// rumors.send("one".to_string());
     ///
     /// let mut observer = rumors.unordered_messages();
-    /// let (_version, m) = observer.borrow_next().await.expect("one message");
+    /// let (_version, m) = observer.next().await.expect("one message");
     /// assert_eq!(m.as_str(), "one");
     ///
     /// // Mid-pass, the checkpoint has not moved: resuming here would
@@ -194,14 +148,14 @@ impl<T> UnorderedMessages<T> {
     ///
     /// // One more step finds nothing ready, completing the pass and
     /// // absorbing its frontier into the checkpoint.
-    /// assert!(observer.borrow_next().now_or_never().is_none());
+    /// assert!(observer.next().now_or_never().is_none());
     /// let checkpoint = observer.checkpoint().clone();
     ///
     /// // A resume from it re-observes nothing from the completed pass and
     /// // everything not yet delivered.
     /// rumors.send("two".to_string());
     /// let mut resumed = rumors.unordered_messages_since(checkpoint);
-    /// let (_version, m) = resumed.borrow_next().await.expect("only the new message");
+    /// let (_version, m) = resumed.next().await.expect("only the new message");
     /// assert_eq!(m.as_str(), "two");
     /// # });
     /// ```
@@ -210,27 +164,17 @@ impl<T> UnorderedMessages<T> {
     }
 }
 
-impl<T> UnorderedMessages<T> {
-    /// Advance to the next message, lending its version and value until the
-    /// following call. Awaits quietly while the set is unchanged; resolves
-    /// [`None`] once no further change is possible.
-    pub async fn borrow_next(&mut self) -> Option<(&Version, &Arc<T>)>
-    where
-        T: Send + Sync,
-    {
-        self.borrow_next_inner().await
-    }
+impl<T: Send + Sync + 'static> UnorderedMessages<T> {
     /// Take one non-blocking step: a message if one is ready, [`Quiet`] (ask
     /// again later) if not, [`Ended`] if no further message is possible.
     ///
+    /// One [`Stream`] poll with a no-op waker, rendered as the trichotomy.
+    ///
     /// [`Quiet`]: TryNext::Quiet
     /// [`Ended`]: TryNext::Ended
-    pub fn try_next(&mut self) -> TryNext<'_, T>
-    where
-        T: Send + Sync,
-    {
-        use futures::FutureExt;
-        match self.borrow_next_inner().now_or_never() {
+    pub fn try_next(&mut self) -> TryNext<T> {
+        use futures::{FutureExt, StreamExt};
+        match self.next().now_or_never() {
             None => TryNext::Quiet,
             Some(None) => TryNext::Ended,
             Some(Some(message)) => TryNext::Message(message),
@@ -238,8 +182,9 @@ impl<T> UnorderedMessages<T> {
     }
 }
 
-/// The owned-item face: `(Version, Arc<T>)` per item, cloned out of
-/// the same engine [`borrow_next`](UnorderedMessages::borrow_next) lends from.
+/// Yields owned `(Version, Arc<T>)` pairs: cheap handles into the shared
+/// storage (the version's buffer and the message's allocation are shared,
+/// not copied).
 ///
 /// `T: 'static` because the quiet-period wait is materialized as an owned
 /// future.
diff --git a/src/tree/typed/untyped/iter.rs b/src/tree/typed/untyped/iter.rs
index 35e0e40c3..c5f57ddd2 100644
--- a/src/tree/typed/untyped/iter.rs
+++ b/src/tree/typed/untyped/iter.rs
@@ -286,8 +286,8 @@ impl<'a, T, P: Polarity> DoubleEndedIterator for Range<'a, T, P> {
 /// borrowing walk (see [`Range`]); forward-only, since its consumers are
 /// subscription drains.
 /// Yields each passing leaf as an owned [`Leaf`] handle alongside its
-/// reconstructed 32-byte path, which is what lets a caller
-/// lend `&Version` / `&Arc<T>` out of a leaf it keeps.
+/// reconstructed 32-byte path; the version and value read out of the
+/// handle as shared, clone-cheap references into the tree's storage.
 pub struct RangeOwned<T, P: Polarity> {
     /// The not-yet-visited root, consumed by the first advance.
     start: Option<Node<T>>,
diff --git a/tests/api_send_bounds.rs b/tests/api_send_bounds.rs
index 78ee8cba5..f5910cfa2 100644
--- a/tests/api_send_bounds.rs
+++ b/tests/api_send_bounds.rs
@@ -78,18 +78,13 @@ fn try_into_peer_future_is_send() {
     drop(fut);
 }
 
-/// Both observer faces — `borrow_next`'s future and the `Stream`'s item
-/// future — are `Send`, for spawned and `select!`-driven consumers.
+/// The observer's item future is `Send`, for spawned and
+/// `select!`-driven consumers.
 #[test]
 fn observer_futures_are_send() {
     let alice = Peer::<String>::seed().sync_window_floor().into_rumors();
     let mut messages = alice.unordered_messages();
-    {
-        let fut = messages.borrow_next();
-        require_send(&fut);
-        drop(fut);
-    }
-    // The `Stream` face's item future must be `Send` too, for
+    // The `Stream` face's item future must be `Send`, for
     // `tokio::spawn`d `select!` consumers.
     let fut = messages.next();
     require_send(&fut);
diff --git a/tests/causal.rs b/tests/causal.rs
index c7741c691..b68c9f566 100644
--- a/tests/causal.rs
+++ b/tests/causal.rs
@@ -15,7 +15,7 @@ mod common;
 
 use std::collections::{BTreeMap, BTreeSet};
 
-use futures::FutureExt;
+use futures::{FutureExt, StreamExt};
 use proptest::collection::vec;
 use proptest::prelude::*;
 use rumors::{CausalMessages, Peer, Rumors, Version};
@@ -35,12 +35,12 @@ enum Step {
     Ended,
 }
 
-/// Poll `borrow_next` exactly once without an executor.
+/// Poll the observer exactly once without an executor.
 fn step(obs: &mut CausalMessages<u64>) -> Step {
-    match obs.borrow_next().now_or_never() {
+    match obs.next().now_or_never() {
         None => Step::Quiet,
         Some(None) => Step::Ended,
-        Some(Some((v, m))) => Step::Item((v.clone(), **m)),
+        Some(Some((v, m))) => Step::Item((v, *m)),
     }
 }
 
@@ -92,9 +92,7 @@ fn drain_unordered(obs: &mut rumors::UnorderedMessages<u64>) -> Vec<(Version, u6
     let mut items = Vec::new();
     loop {
         match obs.try_next() {
-            rumors::TryNext::Message((version, message)) => {
-                items.push((version.clone(), **message))
-            }
+            rumors::TryNext::Message((version, message)) => items.push((version, *message)),
             rumors::TryNext::Quiet | rumors::TryNext::Ended => return items,
         }
     }
@@ -328,12 +326,10 @@ fn observer_drains_the_final_state_causally_then_ends() {
     assert_eq!(step(&mut obs), Step::Ended, "ended is terminal");
 }
 
-/// The owned-item face delivers the same causal order as `borrow_next` and
-/// terminates with `None` once the set closes.
+/// The `Stream` face delivers in causal order and terminates with `None`
+/// once the set closes.
 #[test]
 fn stream_face_is_causal_and_terminates() {
-    use futures::StreamExt;
-
     let known = Peer::<u64>::seed().sync_window_floor().into_rumors();
     for v in 0..6u64 {
         known.send(v);
@@ -576,7 +572,7 @@ proptest! {
         for _ in 0..taken {
             match unordered.try_next() {
                 rumors::TryNext::Message((version, message)) => {
-                    unordered_delivered.push((version.clone(), **message));
+                    unordered_delivered.push((version, *message));
                 }
                 other => panic!("the pass has more items, got {other:?}"),
             }
@@ -660,7 +656,7 @@ fn final_pop_checkpoint_still_replays_the_last_message() {
     // message, persist the checkpoint, crash, resume — replays the message.
     let mut unordered = known.unordered_messages();
     assert!(
-        unordered.borrow_next().now_or_never().flatten().is_some(),
+        unordered.next().now_or_never().flatten().is_some(),
         "a populated set delivers an item"
     );
     let persisted = unordered.checkpoint().clone();
diff --git a/tests/common/sim.rs b/tests/common/sim.rs
index 90a6cafb3..4ec6573fe 100644
--- a/tests/common/sim.rs
+++ b/tests/common/sim.rs
@@ -558,7 +558,7 @@ async fn run_activity(handle: Rumors<u64>, script: Vec<Activity>) -> Vec<(Versio
 /// path (`send_if_modified` racing `borrow_and_update`) outside
 /// single-threaded tests.
 async fn run_observers(handle: Rumors<u64>, done: Arc<AtomicBool>) {
-    use futures::FutureExt;
+    use futures::{FutureExt, StreamExt};
 
     let mut plain = handle.unordered_messages();
     let mut causal = handle.causal_messages();
@@ -572,15 +572,15 @@ async fn run_observers(handle: Rumors<u64>, done: Arc<AtomicBool>) {
         // races nothing.
         let finished = done.load(Ordering::Acquire);
 
-        while let Some(Some((version, _))) = plain.borrow_next().now_or_never() {
+        while let Some(Some((version, _))) = plain.next().now_or_never() {
             assert!(
-                plain_seen.insert(version_key(version)),
+                plain_seen.insert(version_key(&version)),
                 "Messages delivered version {version:?} twice"
             );
         }
-        while let Some(Some((version, _))) = causal.borrow_next().now_or_never() {
+        while let Some(Some((version, _))) = causal.next().now_or_never() {
             assert!(
-                causal_seen.insert(version_key(version)),
+                causal_seen.insert(version_key(&version)),
                 "CausalMessages delivered version {version:?} twice"
             );
             // `Version` is a partial order: `!(version < earlier)` also
diff --git a/tests/listen.rs b/tests/listen.rs
index 9fc88636a..83286bd62 100644
--- a/tests/listen.rs
+++ b/tests/listen.rs
@@ -15,7 +15,7 @@ mod common;
 
 use std::collections::{BTreeMap, BTreeSet};
 
-use futures::FutureExt;
+use futures::{FutureExt, StreamExt};
 use proptest::collection::vec;
 use proptest::prelude::*;
 use rand::SeedableRng;
@@ -37,12 +37,12 @@ enum Step {
     Ended,
 }
 
-/// Poll `borrow_next` exactly once without an executor.
+/// Poll the observer exactly once without an executor.
 fn step(obs: &mut UnorderedMessages<u64>) -> Step {
-    match obs.borrow_next().now_or_never() {
+    match obs.next().now_or_never() {
         None => Step::Quiet,
         Some(None) => Step::Ended,
-        Some(Some((v, m))) => Step::Item((v.clone(), **m)),
+        Some(Some((v, m))) => Step::Item((v, *m)),
     }
 }
 
@@ -339,11 +339,11 @@ fn lent_borrows_do_not_block_senders() {
     rumors.batch().send(1).send(2);
 
     let mut obs = rumors.unordered_messages();
-    let lent = block_on(obs.borrow_next()).expect("first item of the pass");
-    let lent_value = *lent.1.clone();
+    let lent = block_on(obs.next()).expect("first item of the pass");
+    let lent_value = *lent.1;
 
-    // With the borrow conceptually outstanding (the observer is mid-pass),
-    // a send must not deadlock.
+    // With the yielded item outstanding (the observer is mid-pass), a
+    // send must not deadlock.
     rumors.send(3);
 
     let (rest, _) = drain(&mut obs);
@@ -405,9 +405,10 @@ fn checkpoint_is_portable_across_replicas() {
     assert_eq!(items[0].1, 2, "A-observed messages are skipped at B");
 }
 
-/// The observer's non-blocking step lends exactly as
-/// `borrow_next` does, and distinguishes a *quiet* observer (nothing new,
-/// actors live — where `borrow_next` would block) from an *ended* one.
+/// The observer's non-blocking step yields the same owned items as the
+/// `Stream` face, and distinguishes a *quiet* observer (nothing new,
+/// actors live — where an awaited `next` would block) from an *ended*
+/// one.
 #[test]
 fn try_next_distinguishes_quiet_from_ended() {
     use rumors::TryNext;
@@ -418,7 +419,7 @@ fn try_next_distinguishes_quiet_from_ended() {
     let mut obs = rumors.unordered_messages();
     let mut seen = BTreeSet::new();
     while let TryNext::Message((_, m)) = obs.try_next() {
-        seen.insert(**m);
+        seen.insert(*m);
     }
     assert_eq!(seen, BTreeSet::from([1, 2]), "the pending pass drains");
     assert!(
@@ -430,7 +431,7 @@ fn try_next_distinguishes_quiet_from_ended() {
     let TryNext::Message((_, m)) = obs.try_next() else {
         panic!("the new send is immediately available");
     };
-    assert_eq!(**m, 3);
+    assert_eq!(*m, 3);
 
     drop(rumors);
     assert!(matches!(obs.try_next(), TryNext::Ended));
@@ -440,12 +441,10 @@ fn try_next_distinguishes_quiet_from_ended() {
     );
 }
 
-/// The owned-item face: the `Stream` impl yields the same messages as
-/// `borrow_next`, owned, and terminates with `None` once the set closes.
+/// The `Stream` impl yields every message, owned, and terminates with
+/// `None` once the set closes.
 #[test]
 fn stream_face_matches_and_terminates() {
-    use futures::StreamExt;
-
     let rumors = Peer::<u64>::seed().sync_window_floor().into_rumors();
     rumors.batch().send(1).send(2);
     let expected = live_map(&rumors);

From ec67f1bf895a7501cbb84ba62a29d29abe95a7af Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Wed, 19 Aug 2026 20:34:53 -0400
Subject: [PATCH 09/18] item-erasure sketch: the observers' typed boundary
 after lending dissolved

---
 design/item-erasure.md | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/design/item-erasure.md b/design/item-erasure.md
index 6830bd4ad..ad1c756d4 100644
--- a/design/item-erasure.md
+++ b/design/item-erasure.md
@@ -96,12 +96,10 @@ payloads failing at ingress as `DecodeError::Record` exactly as today.
   is nothing.
 - No public API movement: `Message` is crate-internal (nothing
   re-exports it; verified against the public rustdoc surface), and the
-  public observers already speak `(Version, Arc<T>)`. The one
-  mechanical seam is the observers' lending contract —
-  `borrow_next() -> (&Version, &Arc<T>)` lends from a retained
-  most-recent-leaf slot, so that slot becomes the downcast point: one
-  `Arc::downcast::<T>()` (a refcount bump plus the `TypeId` check) per
-  yielded message, a cost the owned `(Version, Arc<T>)` item already
+  public observers speak owned `(Version, Arc<T>)` on every face (the
+  former lending forms dissolved when `Version` went CoW), so the
+  typed boundary is one `Arc::downcast::<T>()` — a refcount bump plus
+  the `TypeId` check — folded into the clone each yielded item already
   pays. `T: Serialize` migrates to the insert boundary and
   `DeserializeOwned` to witness minting; the public bounds stay
   equivalent.

From ee1869574a0ba209a87d948626bd94218555ed0b Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Wed, 19 Aug 2026 20:49:36 -0400
Subject: [PATCH 10/18] item-erasure: record the owner rulings and the staged
 plan

Witness at peer construction; non-generic core sealing with the public
API unchanged (fall back to erasing generic shells if it turns hairy;
legibility outranks purity); tree and session in one stroke; landing on
the height-erasure branch.
---
 design/item-erasure.md | 56 +++++++++++++++++++++++++++++-------------
 1 file changed, 39 insertions(+), 17 deletions(-)

diff --git a/design/item-erasure.md b/design/item-erasure.md
index ad1c756d4..9e910d924 100644
--- a/design/item-erasure.md
+++ b/design/item-erasure.md
@@ -1,9 +1,9 @@
 # Item-type erasure at the leaf boundary (part II sketch)
 
-Status: sketch, not implemented — the "phase 2" the height-erasure work
-names. Written after height erasure landed; numbers marked *measured*
-come from `cargo llvm-lines --test pairwise` (debug, default features)
-on the height-erased tree.
+Status: accepted (option B, with the rulings below); implementation in
+progress on the `height-erasure` branch. Numbers marked *measured* come
+from `cargo llvm-lines --test pairwise` (debug, default features) on
+the height-erased tree.
 
 ## The problem, precisely
 
@@ -131,16 +131,38 @@ security-relevant: payload validation stays exactly where it is
   the "what does the next consumer pay" meter.
 - The `gossip_fixed_bidir_insertions/5000` bench as the runtime pin.
 
-## Open questions for review
-
-1. Witness minting site: at `Peer<T>` construction (one witness for the
-   peer's lifetime, threaded through sessions), or per gossip call?
-   Construction seems right — it is also where `DeserializeOwned`
-   naturally lives.
-2. Facade shape: seal the session core behind non-generic functions in
-   the rlib (taking `&mut dyn` link objects — the transport is already
-   dyn-erased), or keep generic entry points that immediately erase?
-3. Does the tree erase in the same stroke (it must for the full win —
-   `untyped::Node<T>`'s only `T` is the stored `Message`), or does a
-   first landing keep a typed tree and erase at the session boundary
-   (option A) to de-risk?
+## Rulings (owner-resolved)
+
+1. **Witness minting**: at `Peer<T>` construction — one witness per
+   peer lifetime, stored alongside the erased tree in the shared inner
+   state and threaded to every session. `DeserializeOwned` lives at
+   construction; the gossip entry points carry no serde bounds.
+2. **Sealing**: non-generic core functions in the rlib, with the
+   public API unchanged — byte-for-byte the same signatures. If the
+   non-generic sealing turns structurally hairy, back it out and fall
+   back to generic shells that erase immediately: legibility outranks
+   structural purity here.
+3. **Scope**: one stroke — tree and session erase together, staged as
+   gate-clean commits (the part I pattern); no transient
+   typed-tree/erased-session seam.
+4. **Branch**: continues on `height-erasure`, stacking on part I.
+
+## Implementation plan (staged, each commit gate-clean)
+
+1. **The erased `Message`**: the crate-internal `Message<T>` becomes
+   non-generic — `{ message: Arc<dyn Any + Send + Sync>, serialized:
+   Bytes }` — with typed constructors at the insert boundary and
+   checked typed accessors (downcast) at the read boundary. Measure.
+2. **The erased tree**: `untyped::Node<T>` and the typed veneer drop
+   `T` (the stored `Message` was its only occurrence); iterators and
+   walks yield erased leaves; `Rumors`/`Snapshot`/observer facades
+   downcast at the door. The V1 oracle and the wire codecs sweep along.
+   Measure.
+3. **The erased session**: `Backend<T>` drops `T`; the codec's record
+   decode keeps the wire bytes and builds payloads through the witness;
+   sessions receive the witness from the peer. Measure.
+4. **Sealing**: the session core's entry points go non-generic over
+   the erased tree, witness, and dyn-erased link (public API
+   unchanged). The new meter lands here: IR lines of a minimal
+   downstream binary (one `gossip` call) — the "what the next consumer
+   pays" number. Measure; bench pin at the end.

From 00c007c706736f137232bafe02680fbac27ff337 Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Wed, 19 Aug 2026 22:17:35 -0400
Subject: [PATCH 11/18] message: erase the payload type behind Arc<dyn Any>
 (part II stage 1)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Message becomes non-generic: { message: Arc<dyn Any + Send + Sync>,
serialized: Bytes } — the caller's own Arc<T> allocation, unsized in
place. Typed constructors sit at the insert boundary; the read boundary
downcasts (message::<T>/arc::<T>), and a payload-type mismatch panics as
a crate-bug tripwire (every message reachable from a typed facade was
constructed with that facade's type).

Owner-ruled public API movement (rulings 5 and 6 in
design/item-erasure.md): Snapshot::get returns Option<Arc<T>> — the
echoed version was always the queried one, since a leaf's path derives
from its version — and iter/range/IntoIterator yield (&Version, Arc<T>)
owned, because a coerced fat pointer has no Arc<T> object to lend.
T: 'static joins the insert-path bounds (safe erasure is TypeId-based,
and Any requires it; gossip already demanded it).

Message equality and hashing now compare the cached serialization; the
Ord and serde-Deserialize forms dissolved (no consumers outside the
type's own tests), and the V1 wire decode routes through the typed
Message::from_reader. The tree stores erased Messages with T phantom on
NodeInner until stage 2 dissolves it; Action de-genericized; the Leaf
seam and the streaming codec's leaf records speak erased Message.

Measured (cargo llvm-lines --test pairwise, debug, default features):
1,039,827 lines / 41,186 copies vs 1,039,534 / 41,172 at the parent —
flat, as this stage predicts: the payload type left storage, but every
instantiation still exists while tree and session stay generic over the
phantom T. The dedup is stage 2's and 3's to collect.
---
 design/item-erasure.md                        |  39 ++-
 src/batch.rs                                  |   6 +-
 src/conformance/backend.rs                    |   4 +-
 src/conformance/backend/tests.rs              |   7 +-
 src/message.rs                                | 255 ++++++++----------
 src/message/tests.rs                          |  69 +++--
 src/peer.rs                                   |   2 +-
 src/rumors.rs                                 |   2 +-
 src/rumors/causal.rs                          |   2 +-
 src/rumors/unordered.rs                       |   2 +-
 src/snapshot.rs                               |  26 +-
 src/tree.rs                                   |  57 ++--
 src/tree/arb.rs                               |   2 +-
 src/tree/mirror/alternating/backend/remote.rs |  14 +-
 src/tree/mirror/alternating/message.rs        |  10 +-
 src/tree/mirror/alternating/tests.rs          |   6 +-
 src/tree/mirror/streaming/backend.rs          |   4 +-
 src/tree/mirror/streaming/backend/local.rs    |   4 +-
 .../streaming/materialized/unknown/tests.rs   |   2 +-
 src/tree/mirror/streaming/remote.rs           |   2 +-
 src/tree/mirror/streaming/remote/adapter.rs   |   2 +-
 .../mirror/streaming/remote/adapter/encode.rs |   2 +-
 .../mirror/streaming/remote/adapter/tests.rs  |   4 +-
 .../remote/adapter/tests/fan_occupancy.rs     |   8 +-
 .../remote/adapter/tests/malformed.rs         |   8 +-
 .../streaming/remote/adapter/tests/runs.rs    |   4 +-
 src/tree/mirror/streaming/remote/codec.rs     |   2 +-
 .../streaming/remote/codec/capture/tests.rs   |   2 +-
 .../streaming/remote/codec/decode/tests.rs    |   2 +-
 .../streaming/remote/codec/encode/tests.rs    |   2 +-
 .../mirror/streaming/remote/codec/frame.rs    |  16 +-
 .../streaming/remote/codec/frame/tests.rs     |   2 +-
 .../mirror/streaming/remote/codec/tests.rs    |   2 +-
 .../remote/codec/tests/error_atlas.rs         |   2 +-
 .../mirror/streaming/remote/proxy/tests.rs    |   8 +-
 src/tree/mirror/streaming/testing/failing.rs  |   4 +-
 src/tree/mirror/streaming/tests/fixtures.rs   |   4 +-
 src/tree/tests.rs                             |  74 ++---
 src/tree/traverse/act.rs                      |  12 +-
 src/tree/traverse/unknown/tests.rs            |   2 +-
 src/tree/typed/node.rs                        |  14 +-
 src/tree/typed/untyped.rs                     |  20 +-
 src/tree/typed/untyped/iter.rs                |  20 +-
 src/tree/typed/untyped/tests.rs               |   6 +-
 src/tree/wire.rs                              |  17 +-
 tests/bookmark_causality.rs                   |   4 +-
 tests/bookmark_transmit_window.rs             |   2 +-
 tests/bookmark_when.rs                        |   2 +-
 tests/bootstrap.rs                            |   6 +-
 tests/causal.rs                               |   2 +-
 tests/cbor_evolution.rs                       |   2 +-
 tests/changes.rs                              |   2 +-
 tests/common/action.rs                        |   2 +-
 tests/common/oracle.rs                        |   2 +-
 tests/common/peer.rs                          |   2 +-
 tests/common/shape.rs                         |   2 +-
 tests/common/sim.rs                           |   2 +-
 tests/gossip_snapshot.rs                      |  10 +-
 tests/gossip_when.rs                          |   6 +-
 tests/hop_trace.rs                            |   4 +-
 tests/listen.rs                               |   4 +-
 tests/opening_supply.rs                       |   2 +-
 tests/retire.rs                               |   8 +-
 tests/session_stats.rs                        |   2 +-
 tests/single_peer.rs                          |   2 +-
 tests/stale_floor.rs                          |   4 +-
 66 files changed, 424 insertions(+), 402 deletions(-)

diff --git a/design/item-erasure.md b/design/item-erasure.md
index 9e910d924..90b4a2370 100644
--- a/design/item-erasure.md
+++ b/design/item-erasure.md
@@ -94,15 +94,16 @@ payloads failing at ingress as `DecodeError::Record` exactly as today.
 - Costs: a fat pointer per `Message` handle and a `TypeId` compare per
   typed read; the `gossip_fixed` bench pin guards the claim that this
   is nothing.
-- No public API movement: `Message` is crate-internal (nothing
-  re-exports it; verified against the public rustdoc surface), and the
-  public observers speak owned `(Version, Arc<T>)` on every face (the
-  former lending forms dissolved when `Version` went CoW), so the
-  typed boundary is one `Arc::downcast::<T>()` — a refcount bump plus
-  the `TypeId` check — folded into the clone each yielded item already
-  pays. `T: Serialize` migrates to the insert boundary and
-  `DeserializeOwned` to witness minting; the public bounds stay
-  equivalent.
+- Public API movement, owner-ruled (see the rulings): `Message` itself
+  is crate-internal (nothing re-exports it; verified against the
+  public rustdoc surface), but two of the crate's faces move. The
+  observers already speak owned `(Version, Arc<T>)`, and the
+  `Snapshot` faces join them: a coerced `Arc<dyn Any>` is a fat
+  pointer sharing the `T` allocation, with no `Arc<T>` object anywhere
+  to lend, so the former `&Arc<T>`-lending faces become owned — each
+  yielded item one `Arc::downcast::<T>()`, a refcount bump plus the
+  `TypeId` check, exactly what a keeper paid before. And `Any` demands
+  `T: 'static`, which the insert paths previously did not.
 
 A decode-on-read variant (store the bytes only, decode at the typed
 boundary) loses to this on every axis: it saves the fat pointer but
@@ -146,6 +147,21 @@ security-relevant: payload validation stays exactly where it is
    gate-clean commits (the part I pattern); no transient
    typed-tree/erased-session seam.
 4. **Branch**: continues on `height-erasure`, stacking on part I.
+5. **Holder shape and the payload faces**: the single coerced
+   `Arc<dyn Any + Send + Sync>` (the same allocation, unsized in
+   place), with the `Snapshot` faces going owned: `iter`/`range` yield
+   `(&Version, Arc<T>)` and `get` returns `Option<Arc<T>>` — `get` no
+   longer echoes a version at all, because a leaf's path derives from
+   its version, so the hit's version is always the queried one. The
+   alternative (an extra box holding a concrete `Arc<T>`, to keep
+   lending `&Arc<T>`) was rejected: it charges the gossip path a
+   malloc per message at insert and wire ingress to subsidize
+   look-only application scans, and the box is pure plumbing whose
+   only justification is preserving a signature.
+6. **`T: 'static` at the insert paths**: added. Safe type erasure is
+   `TypeId`-based and `Any` requires `'static`; gossip already
+   demanded it, and the local-only borrowed-payload usage that
+   previously compiled (verified by probe) was unintended surface.
 
 ## Implementation plan (staged, each commit gate-clean)
 
@@ -153,6 +169,11 @@ security-relevant: payload validation stays exactly where it is
    non-generic — `{ message: Arc<dyn Any + Send + Sync>, serialized:
    Bytes }` — with typed constructors at the insert boundary and
    checked typed accessors (downcast) at the read boundary. Measure.
+   *Measured*: `pairwise` at 1,039,827 lines / 41,186 copies — flat
+   against the 1,039,534 / 41,172 baseline, as this stage predicts:
+   the payload type leaves storage, but every instantiation still
+   exists because the tree and session stay generic over the now-
+   phantom `T`. The dedup is stage 2's and 3's to collect.
 2. **The erased tree**: `untyped::Node<T>` and the typed veneer drop
    `T` (the stored `Message` was its only occurrence); iterators and
    walks yield erased leaves; `Rumors`/`Snapshot`/observer facades
diff --git a/src/batch.rs b/src/batch.rs
index d56f0b7dc..8c648e7ff 100644
--- a/src/batch.rs
+++ b/src/batch.rs
@@ -44,7 +44,7 @@ use serde::Serialize;
 /// synchronizes them itself.
 pub struct Batch<'a, T: Send + Sync> {
     inner: &'a watch::Sender<Inner<T>>,
-    actions: Vec<Action<T>>,
+    actions: Vec<Action>,
 }
 
 impl<'a, T: Send + Sync> Batch<'a, T> {
@@ -63,9 +63,9 @@ impl<'a, T: Send + Sync> Batch<'a, T> {
     /// commit: the failure surfaces at the offending call.
     pub fn send(&mut self, message: T) -> &mut Self
     where
-        T: Serialize,
+        T: Serialize + 'static,
     {
-        self.actions.push(Action::Insert(Message::from(message)));
+        self.actions.push(Action::Insert(Message::new(message)));
         self
     }
 
diff --git a/src/conformance/backend.rs b/src/conformance/backend.rs
index 8dae0603e..527fb9067 100644
--- a/src/conformance/backend.rs
+++ b/src/conformance/backend.rs
@@ -242,13 +242,13 @@ where
     N: Leaf<T> + Clone + Send + 'static,
     N::Backend: Measure<T>,
 {
-    fn message(&self) -> &Message<T> {
+    fn message(&self) -> &Message {
         self.inner().message()
     }
 
     async fn leaf(
         version: Version,
-        message: Message<T>,
+        message: Message,
     ) -> Result<Self, <N::Backend as Backend<T>>::Error> {
         let node = N::leaf(version, message).await?;
         let measured = <N::Backend as Measure<T>>::measure::<N::Height>(&node);
diff --git a/src/conformance/backend/tests.rs b/src/conformance/backend/tests.rs
index a14550d62..3c4688bf8 100644
--- a/src/conformance/backend/tests.rs
+++ b/src/conformance/backend/tests.rs
@@ -246,11 +246,11 @@ impl<T> Leaf<T> for MaterializedNode<typed::Node<T, Z>>
 where
     T: Send + Sync + 'static,
 {
-    fn message(&self) -> &Message<T> {
+    fn message(&self) -> &Message {
         self.inner.message()
     }
 
-    async fn leaf(version: Version, message: Message<T>) -> Result<Self, Infallible> {
+    async fn leaf(version: Version, message: Message) -> Result<Self, Infallible> {
         // Eager persistence at the conversion boundary: the payload is
         // written to the store here, so the resident row keeps only the
         // header and bounds — the thin-handle shape the leaf seam prices
@@ -583,7 +583,8 @@ fn ledger_settles_over_clone_and_drop() {
     drop(leaf);
     drop(clone);
 
-    let node = typed::Node::leaf(Version::new(), Message::new(7));
+    let node: typed::Node<i32, crate::tree::typed::height::Z> =
+        typed::Node::leaf(Version::new(), Message::new(7));
     let charged = Charged::<Local>::new(Local);
     let _ = &charged;
     let wrapped = super::ChargedNode::wrap(node, 100);
diff --git a/src/message.rs b/src/message.rs
index dd8779615..a847abf79 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -1,4 +1,4 @@
-use std::cmp::Ordering;
+use std::any::Any;
 use std::fmt;
 use std::hash::{Hash, Hasher};
 use std::io;
@@ -6,49 +6,54 @@ use std::sync::Arc;
 
 use bytes::Bytes;
 
-use serde::Deserialize;
-use serde::Deserializer;
 use serde::Serialize;
 use serde::Serializer;
 use serde::de::DeserializeOwned;
-/// A message of type `T` paired with its cached serialization.
+/// A stored message: a type-erased payload paired with its cached
+/// serialization.
 ///
-/// The cache avoids repeated roundtrips through serialization: a `Message<T>`
-/// always carries the exact CBOR bytes its `T` was encoded to or decoded
-/// from. Cloning is cheap, because the serialized bytes are shared and the
-/// message is enclosed in an `Arc<T>`.
+/// The payload is held as `Arc<dyn Any + Send + Sync>` — the caller's own
+/// `Arc<T>` allocation, unsized in place — so the tree and the gossip
+/// sessions handle messages without being generic over the payload type:
+/// they compile once, and only the thin typed facades at the crate's API
+/// boundary name `T`. Construction goes through the typed constructors
+/// ([`new`](Self::new), [`from_slice`](Self::from_slice), ...); reads at
+/// the typed boundary go through the checked downcasts
+/// ([`message`](Self::message), [`arc`](Self::arc)).
+///
+/// The cache avoids repeated roundtrips through serialization: a `Message`
+/// always carries the exact CBOR bytes its payload was encoded to or
+/// decoded from, and every identity-blind consumer — the wire encoders,
+/// size accounting — reads the cached bytes, never the payload. Cloning is
+/// cheap: both fields are shared handles.
 ///
 /// The payload encoding is CBOR (via [`ciborium`]): self-describing, so
 /// field and variant *names* are the wire contract — a decoder pairs fields
 /// by name, tolerating reordering — and no canonical encoding is required
-/// of `T`, because payload bytes carry no identity (a leaf's identity is
-/// its version).
+/// of the payload type, because payload bytes carry no identity (a leaf's
+/// identity is its version).
 ///
 /// # Panics
 ///
-/// Every value of `T` must serialize: methods that serialize (`new`,
-/// `from_arc`, `From<T>`) panic if `T`'s [`serde::Serialize`]
-/// implementation reports an error. Encoding runs into an in-memory
-/// buffer and CBOR imposes no format-driven failures (any map key, any
-/// nesting), so the only trigger is the implementation itself declining a
-/// value — which this crate treats as a bug in `T`, exactly as `Ord`'s
-/// totality is trusted. Types whose `Serialize` is data-dependently
-/// fallible (for example `std::path::PathBuf`, which errors on non-UTF-8
-/// paths) violate that obligation and must not be used as message types.
-pub struct Message<T> {
-    message: Arc<T>,
+/// Every payload value must serialize: methods that serialize
+/// ([`new`](Self::new), [`from_arc`](Self::from_arc)) panic if the
+/// payload's [`serde::Serialize`] implementation reports an error.
+/// Encoding runs into an in-memory buffer and CBOR imposes no
+/// format-driven failures (any map key, any nesting), so the only trigger
+/// is the implementation itself declining a value — which this crate
+/// treats as a bug in the payload type, exactly as `Ord`'s totality is
+/// trusted. Types whose `Serialize` is data-dependently fallible (for
+/// example `std::path::PathBuf`, which errors on non-UTF-8 paths) violate
+/// that obligation and must not be used as message types.
+///
+/// The typed reads panic on a payload type mismatch; see
+/// [`message`](Self::message).
+#[derive(Clone)]
+pub struct Message {
+    message: Arc<dyn Any + Send + Sync>,
     serialized: Bytes,
 }
 
-impl<T> Clone for Message<T> {
-    fn clone(&self) -> Self {
-        Self {
-            message: self.message.clone(),
-            serialized: self.serialized.clone(),
-        }
-    }
-}
-
 /// Map a ciborium deserialization failure into `io::Error`, keeping the
 /// truncation/corruption split callers classify by: a reader's own error
 /// passes through, everything else is invalid data.
@@ -73,16 +78,16 @@ fn to_vec<T: Serialize>(value: &T) -> Vec<u8> {
     buf
 }
 
-impl<T> Message<T> {
+impl Message {
     /// Creates a `Message` pairing the given object with its cached
     /// serialization.
     ///
     /// # Panics
     ///
     /// If the message cannot be serialized (see [`Message`]).
-    pub fn new(message: T) -> Self
+    pub fn new<T>(message: T) -> Self
     where
-        T: Serialize,
+        T: Serialize + Send + Sync + 'static,
     {
         Message {
             serialized: Bytes::from(to_vec(&message)),
@@ -91,14 +96,14 @@ impl<T> Message<T> {
     }
 
     /// Creates a `Message` pairing the given serialized bytes with the
-    /// object derived by deserializing them.
+    /// object derived by deserializing them as a `T`.
     ///
     /// The bytes must be exactly one CBOR value: trailing bytes are
     /// rejected as invalid data, so the cache is always the value's exact
     /// encoding.
-    pub fn from_slice(bytes: &[u8]) -> io::Result<Self>
+    pub fn from_slice<T>(bytes: &[u8]) -> io::Result<Self>
     where
-        T: DeserializeOwned,
+        T: DeserializeOwned + Send + Sync + 'static,
     {
         let mut input = bytes;
         let message: T = ciborium::de::from_reader(&mut input).map_err(de_error)?;
@@ -121,7 +126,10 @@ impl<T> Message<T> {
     /// CBOR encoding `message` was parsed out of (the wire codec's record
     /// parser upholds this — it hands over precisely the bytes its parse
     /// consumed).
-    pub(crate) fn from_decoded(message: T, serialized: Bytes) -> Self {
+    pub(crate) fn from_decoded<T>(message: T, serialized: Bytes) -> Self
+    where
+        T: Send + Sync + 'static,
+    {
         Message {
             message: Arc::new(message),
             serialized,
@@ -131,11 +139,11 @@ impl<T> Message<T> {
     /// Creates a `Message` from already-shared serialized bytes, without
     /// copying.
     ///
-    /// The bytes are deserialized to produce the paired object, under
-    /// [`from_slice`](Self::from_slice)'s exactly-one-value contract.
-    pub fn from_bytes(bytes: Bytes) -> io::Result<Self>
+    /// The bytes are deserialized as a `T` to produce the paired object,
+    /// under [`from_slice`](Self::from_slice)'s exactly-one-value contract.
+    pub fn from_bytes<T>(bytes: Bytes) -> io::Result<Self>
     where
-        T: DeserializeOwned,
+        T: DeserializeOwned + Send + Sync + 'static,
     {
         let mut input = bytes.as_ref();
         let message: T = ciborium::de::from_reader(&mut input).map_err(de_error)?;
@@ -151,14 +159,15 @@ impl<T> Message<T> {
         })
     }
 
-    /// Creates a `Message` from an existing [`Arc`], without copying.
+    /// Creates a `Message` from an existing [`Arc`], without copying: the
+    /// same allocation, unsized in place.
     ///
     /// # Panics
     ///
     /// If the message cannot be serialized (see [`Message`]).
-    pub fn from_arc(arc: Arc<T>) -> Self
+    pub fn from_arc<T>(arc: Arc<T>) -> Self
     where
-        T: Serialize,
+        T: Serialize + Send + Sync + 'static,
     {
         Message {
             serialized: Bytes::from(to_vec(&*arc)),
@@ -166,135 +175,105 @@ impl<T> Message<T> {
         }
     }
 
-    /// Returns a reference to the object represented by this message.
-    pub fn message(&self) -> &T {
-        &self.message
-    }
-
-    /// Returns a reference to the shared [`Arc`] holding this message's
-    /// object, without cloning it.
+    /// Reads one `Message` off a byte stream, consuming exactly its bytes.
     ///
-    /// Used by enumeration paths (e.g. [`Tree::iter`]) that hand out
-    /// borrowed `&Arc<T>` exactly as the public observers do.
+    /// The shape is one CBOR byte string wrapping the payload's own CBOR
+    /// encoding (the same shape [`Serialize`] writes), decoded as a `T`
+    /// under [`from_slice`](Self::from_slice)'s exactly-one-value
+    /// contract.
     ///
-    /// [`Tree::iter`]: crate::tree::Tree::iter
-    pub fn as_arc(&self) -> &Arc<T> {
-        &self.message
-    }
-
-    /// Returns the serialized bytes corresponding to this message.
-    pub fn as_slice(&self) -> &[u8] {
-        self.serialized.as_ref()
-    }
-
-    /// Returns a cheaply-clonable handle to the shared serialized bytes.
-    pub fn bytes(&self) -> &Bytes {
-        &self.serialized
-    }
-
-    /// Consumes the message and returns the inner object, dropping the cached
-    /// serialization.
-    pub fn into_inner(self) -> Arc<T> {
-        self.message
-    }
-
-    /// Consumes the message and returns the inner object, dropping the cached
-    /// serialization and cloning the inner object if necessary.
-    pub fn clone_into_inner(self) -> T
+    /// Trailing data after the byte string survives for the next field:
+    /// the property the wire codec's mid-stream decodes rest on. Gated to
+    /// the alternating protocol's codec, its only production consumer.
+    #[cfg(any(test, feature = "protocol-v1"))]
+    pub(crate) fn from_reader<T, R>(reader: R) -> io::Result<Self>
     where
-        T: Clone,
+        T: DeserializeOwned + Send + Sync + 'static,
+        R: io::Read,
     {
-        Arc::unwrap_or_clone(self.message)
+        let bytes: Vec<u8> = ciborium::de::from_reader(reader).map_err(de_error)?;
+        Self::from_slice::<T>(&bytes)
     }
 
-    /// Consumes the message and returns the inner object along with the
-    /// shared serialized bytes.
-    pub fn into_parts(self) -> (Arc<T>, Bytes)
-    where
-        T: Clone,
-    {
-        (self.message, self.serialized)
+    /// Borrows the payload as its concrete type.
+    ///
+    /// # Panics
+    ///
+    /// If the payload is not a `T`. A mismatch is always a crate bug,
+    /// never an input: every message reachable from a typed facade was
+    /// constructed with that facade's payload type — local sends through
+    /// the same `Peer`'s type, wire ingress through its typed decode —
+    /// so no gossip input can place a differently-typed payload here.
+    pub fn message<T: 'static>(&self) -> &T {
+        self.message
+            .downcast_ref::<T>()
+            .expect("a message's payload type matches its tree's")
     }
-}
 
-impl<T: Serialize> From<T> for Message<T> {
-    /// Creates a `Message` pairing the given object with its cached
-    /// serialization.
+    /// Clones out an owned handle to the payload: a reference bump on the
+    /// same shared allocation.
     ///
     /// # Panics
     ///
-    /// If the message cannot be serialized (see [`Message`]).
-    fn from(message: T) -> Self {
-        Self::new(message)
+    /// If the payload is not a `T` (see [`message`](Self::message)).
+    pub fn arc<T: Send + Sync + 'static>(&self) -> Arc<T> {
+        self.message
+            .clone()
+            .downcast::<T>()
+            .unwrap_or_else(|_| panic!("a message's payload type matches its tree's"))
     }
-}
 
-impl<T> AsRef<T> for Message<T> {
-    fn as_ref(&self) -> &T {
-        &self.message
+    /// Returns the serialized bytes corresponding to this message.
+    pub fn as_slice(&self) -> &[u8] {
+        self.serialized.as_ref()
     }
-}
 
-impl<T> AsRef<Arc<T>> for Message<T> {
-    fn as_ref(&self) -> &Arc<T> {
-        &self.message
+    /// Returns a cheaply-clonable handle to the shared serialized bytes.
+    pub fn bytes(&self) -> &Bytes {
+        &self.serialized
     }
 }
 
-// Manual trait implementations that treat `Message<T>` as a transparent wrapper
-// around `T`, ignoring the cached serialized bytes. Two messages holding equal
-// `T` values compare equal even if their cached bytes differ (e.g. produced by
-// different serializer versions).
-
-impl<T: fmt::Debug> fmt::Debug for Message<T> {
+/// Shows the cached serialization, not the payload: the payload's type is
+/// erased here, so its own `Debug` is out of reach.
+impl fmt::Debug for Message {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.message.fmt(f)
+        f.debug_struct("Message")
+            .field("serialized", &hex::encode(&self.serialized))
+            .finish_non_exhaustive()
     }
 }
 
-impl<T: PartialEq> PartialEq for Message<T> {
-    fn eq(&self, other: &Self) -> bool {
-        self.message == other.message
-    }
-}
-
-impl<T: Eq> Eq for Message<T> {}
+// Equality, and the `Hash` that must agree with it, compare the cached
+// serialization: with the payload's type erased, its bytes are the whole
+// observable content. Two messages built from the same value by the same
+// constructor always carry equal bytes.
 
-impl<T: PartialOrd> PartialOrd for Message<T> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.message.partial_cmp(&other.message)
+impl PartialEq for Message {
+    fn eq(&self, other: &Self) -> bool {
+        self.serialized == other.serialized
     }
 }
 
-impl<T: Ord> Ord for Message<T> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.message.cmp(&other.message)
-    }
-}
+impl Eq for Message {}
 
-impl<T: Hash> Hash for Message<T> {
+impl Hash for Message {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.message.hash(state);
+        self.serialized.hash(state);
     }
 }
 
-// The serde form lets `Message<T>` nest inside larger CBOR values without
-// re-encoding: one byte string wrapping the cached CBOR payload. The
-// wrapper is what makes a nested message self-delimiting wherever the
-// container does not delimit it.
-
-impl<T> Serialize for Message<T> {
+/// One CBOR byte string wrapping the cached CBOR payload, so a message
+/// nests inside larger CBOR values without re-encoding.
+///
+/// The wrapper is what makes a nested message self-delimiting wherever
+/// the container does not delimit it; [`from_reader`](Message::from_reader)
+/// is the typed decoder of the same shape.
+impl Serialize for Message {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         serializer.serialize_bytes(&self.serialized)
     }
 }
 
-impl<'de, T: DeserializeOwned> Deserialize<'de> for Message<T> {
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        let bytes = <Vec<u8>>::deserialize(deserializer)?;
-        Message::from_slice(&bytes).map_err(serde::de::Error::custom)
-    }
-}
-
 #[cfg(test)]
 mod tests;
diff --git a/src/message/tests.rs b/src/message/tests.rs
index 5d8451960..146eee7bf 100644
--- a/src/message/tests.rs
+++ b/src/message/tests.rs
@@ -41,13 +41,14 @@ fn cbor_vec<T: Serialize>(value: &T) -> Vec<u8> {
 
 proptest! {
     /// After construction via `new`, the cached serialized bytes are exactly
-    /// the value's CBOR encoding.
+    /// the value's CBOR encoding, and the typed reads recover the value.
     #[test]
     fn new_caches_cbor_serialization(p in payload()) {
         let m = Message::new(p.clone());
         let direct = cbor_vec(&p);
         prop_assert_eq!(m.bytes(), direct.as_slice());
-        prop_assert_eq!(m.message(), &p);
+        prop_assert_eq!(m.message::<Payload>(), &p);
+        prop_assert_eq!(&*m.arc::<Payload>(), &p);
     }
 
     /// `from_slice` reconstructs the inner value and stores exactly the input
@@ -55,8 +56,8 @@ proptest! {
     #[test]
     fn from_slice_roundtrips(p in payload()) {
         let bytes = cbor_vec(&p);
-        let m = Message::<Payload>::from_slice(&bytes).unwrap();
-        prop_assert_eq!(m.message(), &p);
+        let m = Message::from_slice::<Payload>(&bytes).unwrap();
+        prop_assert_eq!(m.message::<Payload>(), &p);
         prop_assert_eq!(m.bytes(), bytes.as_slice());
     }
 
@@ -65,8 +66,8 @@ proptest! {
     #[test]
     fn from_bytes_matches_from_slice(p in payload()) {
         let bytes = cbor_vec(&p);
-        let a = Message::<Payload>::from_slice(&bytes).unwrap();
-        let b = Message::<Payload>::from_bytes(Bytes::from(bytes.clone())).unwrap();
+        let a = Message::from_slice::<Payload>(&bytes).unwrap();
+        let b = Message::from_bytes::<Payload>(Bytes::from(bytes.clone())).unwrap();
         prop_assert_eq!(&a, &b);
         prop_assert_eq!(a.bytes(), b.bytes());
     }
@@ -77,13 +78,13 @@ proptest! {
     fn trailing_bytes_are_rejected(p in payload(), trailer in proptest::collection::vec(any::<u8>(), 1..8)) {
         let mut bytes = cbor_vec(&p);
         bytes.extend_from_slice(&trailer);
-        prop_assert!(Message::<Payload>::from_slice(&bytes).is_err());
-        prop_assert!(Message::<Payload>::from_bytes(Bytes::from(bytes)).is_err());
+        prop_assert!(Message::from_slice::<Payload>(&bytes).is_err());
+        prop_assert!(Message::from_bytes::<Payload>(Bytes::from(bytes)).is_err());
     }
 
-    /// The serde form of a `Message<T>` is one CBOR byte string wrapping
-    /// the cached payload bytes — never a re-encoding of `T` — so nesting
-    /// a message in a larger CBOR value costs one length header.
+    /// The serde form of a `Message` is one CBOR byte string wrapping
+    /// the cached payload bytes — never a re-encoding of the payload — so
+    /// nesting a message in a larger CBOR value costs one length header.
     #[test]
     fn serde_form_wraps_cached_bytes(p in payload()) {
         struct Bstr<'a>(&'a [u8]);
@@ -98,32 +99,17 @@ proptest! {
         prop_assert_eq!(wrapped, direct);
     }
 
-    /// A `Message<T>` roundtrips through its serde form: deserializing a
+    /// A `Message` roundtrips through its serde form: `from_reader` on a
     /// serialized message yields an equal message with equal cached bytes.
     #[test]
     fn serde_roundtrip(p in payload()) {
         let m = Message::new(p);
         let bytes = cbor_vec(&m);
-        let back: Message<Payload> = ciborium::de::from_reader(bytes.as_slice()).unwrap();
+        let back = Message::from_reader::<Payload, _>(bytes.as_slice()).unwrap();
         prop_assert_eq!(&m, &back);
         prop_assert_eq!(m.bytes(), back.bytes());
     }
 
-    /// `Message<T>` nests correctly inside other CBOR containers: a
-    /// `Vec<Message<T>>` roundtrips and preserves each element's cached
-    /// bytes.
-    #[test]
-    fn nested_in_vec_roundtrips(ps in proptest::collection::vec(payload(), 0..8)) {
-        let msgs: Vec<Message<Payload>> =
-            ps.into_iter().map(Message::new).collect();
-        let bytes = cbor_vec(&msgs);
-        let back: Vec<Message<Payload>> = ciborium::de::from_reader(bytes.as_slice()).unwrap();
-        prop_assert_eq!(&msgs, &back);
-        for (a, b) in msgs.iter().zip(back.iter()) {
-            prop_assert_eq!(a.bytes(), b.bytes());
-        }
-    }
-
     /// Reading a message off a stream consumes exactly the message's own
     /// bytes: trailing data after the CBOR value survives for the next
     /// field (the property the wire codec's mid-stream decodes rest on).
@@ -135,13 +121,13 @@ proptest! {
         combined.extend_from_slice(&trailer);
 
         let mut slice: &[u8] = &combined;
-        let back: Message<Payload> = ciborium::de::from_reader(&mut slice).unwrap();
+        let back = Message::from_reader::<Payload, _>(&mut slice).unwrap();
         prop_assert_eq!(back.bytes(), m.bytes());
         prop_assert_eq!(slice, trailer.as_slice());
         prop_assert_eq!(combined.len() - slice.len(), expected.len());
     }
 
-    /// Equal `Message<T>` values hash identically, so `Hash` agrees with
+    /// Equal `Message`s hash identically, so `Hash` agrees with
     /// `PartialEq` as required by the standard library contract.
     #[test]
     fn eq_implies_hash_eq(p in payload()) {
@@ -151,14 +137,21 @@ proptest! {
         prop_assert_eq!(hash_of(&a), hash_of(&b));
     }
 
-    /// `into_parts` returns exactly the inner value and cached bytes, matching
-    /// what `message()` and `bytes()` would have returned.
+    /// `arc` hands out the same shared allocation `new` stored, not a
+    /// copy: unsizing erased the type, never the identity.
     #[test]
-    fn into_parts_matches_accessors(p in payload()) {
-        let m = Message::new(p.clone());
-        let expected_bytes = m.bytes().to_vec();
-        let (inner, bytes) = m.into_parts();
-        prop_assert_eq!(&*inner, &p);
-        prop_assert_eq!(bytes.as_ref(), expected_bytes.as_slice());
+    fn arc_shares_the_stored_allocation(p in payload()) {
+        let stored = std::sync::Arc::new(p);
+        let m = Message::from_arc(stored.clone());
+        prop_assert!(std::sync::Arc::ptr_eq(&stored, &m.arc::<Payload>()));
     }
 }
+
+/// A typed read with the wrong payload type panics: the mispairing is a
+/// crate bug, and the downcast is the tripwire that catches it.
+#[test]
+#[should_panic(expected = "payload type matches")]
+fn mismatched_downcast_panics() {
+    let m = Message::new(0u64);
+    let _ = m.message::<String>();
+}
diff --git a/src/peer.rs b/src/peer.rs
index ed0e2b2ab..64b9728fe 100644
--- a/src/peer.rs
+++ b/src/peer.rs
@@ -544,7 +544,7 @@ impl<T, B: BookmarkError> Peer<T, B> {
 
     pub(crate) fn send(&self, message: T) -> Batch<'_, T>
     where
-        T: Serialize + Send + Sync,
+        T: Serialize + Send + Sync + 'static,
     {
         let mut batch = self.batch();
         batch.send(message);
diff --git a/src/rumors.rs b/src/rumors.rs
index a2a4fabea..80d9a858e 100644
--- a/src/rumors.rs
+++ b/src/rumors.rs
@@ -162,7 +162,7 @@ impl<T, B: BookmarkError> Rumors<T, B> {
     /// If `message` fails to serialize (see [`Batch::send`]).
     pub fn send(&self, message: T) -> Batch<'_, T>
     where
-        T: Serialize + Send + Sync,
+        T: Serialize + Send + Sync + 'static,
     {
         self.peer.send(message)
     }
diff --git a/src/rumors/causal.rs b/src/rumors/causal.rs
index 7a7cfe1be..a7bfbbf49 100644
--- a/src/rumors/causal.rs
+++ b/src/rumors/causal.rs
@@ -160,7 +160,7 @@ impl<T: Send + Sync + 'static> Stream for CausalMessages<T> {
             // ingest, exactly as UnorderedMessages defers a drained pass's
             // ceiling.
             if let Some((_, leaf)) = this.staged.pop_first() {
-                return Poll::Ready(Some((leaf.version().clone(), leaf.value().clone())));
+                return Poll::Ready(Some((leaf.version().clone(), leaf.value())));
             }
             match this.channel.as_mut().expect("channel state present") {
                 Channel::Waiting(wait) => match wait.as_mut().poll(cx) {
diff --git a/src/rumors/unordered.rs b/src/rumors/unordered.rs
index 97ca874b2..ef5267ff3 100644
--- a/src/rumors/unordered.rs
+++ b/src/rumors/unordered.rs
@@ -209,7 +209,7 @@ impl<T: Send + Sync + 'static> Stream for UnorderedMessages<T> {
 
                     let pass = this.pass.as_mut().expect("opened above");
                     if let Some((_, leaf)) = pass.walk.next() {
-                        return Poll::Ready(Some((leaf.version().clone(), leaf.value().clone())));
+                        return Poll::Ready(Some((leaf.version().clone(), leaf.value())));
                     }
 
                     // The pass drained: absorb its ceiling, then enter the
diff --git a/src/snapshot.rs b/src/snapshot.rs
index 2f72bcd37..aecb37264 100644
--- a/src/snapshot.rs
+++ b/src/snapshot.rs
@@ -2,7 +2,7 @@ use crate::{Network, Version, causally, tree::Tree};
 use std::sync::Arc;
 
 /// The iterator of [`Snapshot::iter`], re-exported from the tree internals:
-/// every live message as `(&Version, &Arc<T>)`, unspecified order,
+/// every live message as `(&Version, Arc<T>)`, unspecified order,
 /// exact-size and double-ended.
 pub use crate::tree::Iter;
 
@@ -84,11 +84,19 @@ impl<T> Snapshot<T> {
     /// Looks up the live message stamped with `version` (for example, a
     /// version an observer yielded earlier). Returns `None` when no live
     /// message carries it — never sent here, or since redacted.
-    pub fn get(&self, version: &Version) -> Option<(&Version, &Arc<T>)> {
+    ///
+    /// The yielded handle is an owned reference bump into the shared
+    /// storage: cheap to take, and it keeps the message alive on its own.
+    pub fn get(&self, version: &Version) -> Option<Arc<T>>
+    where
+        T: Send + Sync + 'static,
+    {
         self.tree.get(version)
     }
 
-    /// Iterates every live message as `(&Version, &Arc<T>)`.
+    /// Iterates every live message as `(&Version, Arc<T>)` — the version
+    /// borrowed from the snapshot, the payload an owned handle into the
+    /// shared storage.
     ///
     /// Order is unspecified, and in particular does *not* follow the causal
     /// order: a message may be yielded before another that causally precedes
@@ -96,9 +104,9 @@ impl<T> Snapshot<T> {
     /// ordering consistent with causality.
     pub fn iter(
         &self,
-    ) -> impl DoubleEndedIterator<Item = (&Version, &Arc<T>)> + ExactSizeIterator + Send + Sync
+    ) -> impl DoubleEndedIterator<Item = (&Version, Arc<T>)> + ExactSizeIterator + Send + Sync
     where
-        T: Send + Sync,
+        T: Send + Sync + 'static,
     {
         self.tree.iter()
     }
@@ -145,9 +153,9 @@ impl<T> Snapshot<T> {
     pub fn range<'q, P: causally::Polarity>(
         &'q self,
         query: impl Into<causally::Query<'q, P>>,
-    ) -> impl DoubleEndedIterator<Item = (&'q Version, &'q Arc<T>)> + Send + Sync
+    ) -> impl DoubleEndedIterator<Item = (&'q Version, Arc<T>)> + Send + Sync
     where
-        T: Send + Sync,
+        T: Send + Sync + 'static,
     {
         self.tree.range(query)
     }
@@ -161,8 +169,8 @@ impl<T> Snapshot<T> {
     }
 }
 
-impl<'a, T: Send + Sync> IntoIterator for &'a Snapshot<T> {
-    type Item = (&'a Version, &'a Arc<T>);
+impl<'a, T: Send + Sync + 'static> IntoIterator for &'a Snapshot<T> {
+    type Item = (&'a Version, Arc<T>);
     type IntoIter = Iter<'a, T>;
 
     fn into_iter(self) -> Self::IntoIter {
diff --git a/src/tree.rs b/src/tree.rs
index 4dacb3349..70490b0b2 100644
--- a/src/tree.rs
+++ b/src/tree.rs
@@ -81,7 +81,7 @@ pub mod mirror;
 pub use typed::{Leaf, RangeOwned};
 
 /// A sparse Merkle radix trie with transparent path compression, whose
-/// leaves store versioned [`Message<T>`]s.
+/// leaves store versioned [`Message`]s.
 ///
 /// The tree has a branching factor of 256 and a depth of 32, so a leaf's
 /// 32-byte path is the full-width hash of its version (see
@@ -162,26 +162,29 @@ impl<T> Default for Tree<T> {
 
 /// An action to perform on the tree, locally.
 #[derive(Clone, Debug)]
-pub enum Action<T> {
+pub enum Action {
     /// Insert some value, tagged at the current version by your own party.
-    Insert(Message<T>),
+    Insert(Message),
     /// Forget the leaf at a version-derived path.
     Forget(typed::Path),
 }
 
-/// The iterator of [`Snapshot::iter`](crate::Snapshot::iter):
-/// a lazy depth-first walk over every live message as
-/// `(&Version, &Arc<T>)`, in unspecified order.
+/// The iterator of [`Snapshot::iter`](crate::Snapshot::iter): a lazy
+/// depth-first walk over every live message as `(&Version, Arc<T>)`, in
+/// unspecified order.
+///
+/// The version is borrowed from the tree; the payload is an owned handle
+/// into the shared storage.
 ///
 /// An [`ExactSizeIterator`] (the live-message count is known up front) and a
 /// [`DoubleEndedIterator`].
 pub struct Iter<'a, T>(typed::Iter<'a, T>);
 
-impl<'a, T> Iterator for Iter<'a, T> {
-    type Item = (&'a Version, &'a Arc<T>);
+impl<'a, T: Send + Sync + 'static> Iterator for Iter<'a, T> {
+    type Item = (&'a Version, Arc<T>);
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.0.next().map(|(v, m)| (v, m.as_arc()))
+        self.0.next().map(|(v, m)| (v, m.arc::<T>()))
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
@@ -189,13 +192,13 @@ impl<'a, T> Iterator for Iter<'a, T> {
     }
 }
 
-impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
+impl<'a, T: Send + Sync + 'static> DoubleEndedIterator for Iter<'a, T> {
     fn next_back(&mut self) -> Option<Self::Item> {
-        self.0.next_back().map(|(v, m)| (v, m.as_arc()))
+        self.0.next_back().map(|(v, m)| (v, m.arc::<T>()))
     }
 }
 
-impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
+impl<'a, T: Send + Sync + 'static> ExactSizeIterator for Iter<'a, T> {}
 
 impl<T> Tree<T> {
     /// Creates a new, empty tree carrying the empty [`Version`].
@@ -277,13 +280,19 @@ impl<T> Tree<T> {
 
     /// Looks up the live message stamped with `version`, by its
     /// version-derived path.
-    pub fn get(&self, version: &Version) -> Option<(&Version, &Arc<T>)> {
+    ///
+    /// The stored version is not echoed back: a leaf's path derives from
+    /// its version, so the hit's version is the queried one.
+    pub fn get(&self, version: &Version) -> Option<Arc<T>>
+    where
+        T: Send + Sync + 'static,
+    {
         let path = <[u8; 32]>::from(typed::Path::for_leaf(version));
         self.root
             .root
             .as_ref()?
             .get(&path)
-            .map(|(version, message)| (version, message.as_arc()))
+            .map(|(_, message)| message.arc::<T>())
     }
 
     /// Forces every lazily-memoized structural value — the observable hash
@@ -305,10 +314,10 @@ impl<T> Tree<T> {
     }
 
     /// Lazily iterates every live leaf currently in the tree as
-    /// `(&Version, &Arc<T>)`, in unspecified order.
+    /// `(&Version, Arc<T>)`, in unspecified order.
     pub fn iter(&self) -> Iter<'_, T>
     where
-        T: Send + Sync,
+        T: Send + Sync + 'static,
     {
         Iter(
             self.root
@@ -347,15 +356,15 @@ impl<T> Tree<T> {
     pub fn range<'q, P: causally::Polarity>(
         &'q self,
         query: impl Into<causally::Query<'q, P>>,
-    ) -> impl DoubleEndedIterator<Item = (&'q Version, &'q Arc<T>)> + Send + Sync
+    ) -> impl DoubleEndedIterator<Item = (&'q Version, Arc<T>)> + Send + Sync
     where
-        T: Send + Sync,
+        T: Send + Sync + 'static,
     {
         typed::node::Root::range(self.root.root.as_ref(), query.into())
-            // The shared walk yields the full `&Message<T>`; the public
-            // contract hands out only the `&Arc<T>` value, a cheap projection
-            // of it.
-            .map(|(v, m)| (v, m.as_arc()))
+            // The shared walk yields the full `&Message`; the public
+            // contract hands out the owned payload handle, one reference
+            // bump on the shared allocation.
+            .map(|(v, m)| (v, m.arc::<T>()))
     }
 
     /// Applies the specified actions as a batch to the tree, advancing its
@@ -407,7 +416,7 @@ impl<T> Tree<T> {
     pub fn act<I>(&mut self, party: &before::Party, actions: I) -> bool
     where
         T: Send + Sync,
-        I: IntoIterator<Item = Action<T>>,
+        I: IntoIterator<Item = Action>,
     {
         // Track the running version across the batch, ticking the owning party
         // once per action so that (a) content-identical messages occupy
@@ -466,7 +475,7 @@ impl<T> Tree<T> {
     fn react<M, I>(&mut self, reactions: I) -> bool
     where
         T: Send + Sync,
-        M: Into<Option<Message<T>>>,
+        M: Into<Option<Message>>,
         I: IntoIterator<Item = (typed::Path, Version, M)>,
     {
         // Materialize the caller's action stream before the commit section
diff --git a/src/tree/arb.rs b/src/tree/arb.rs
index 0d15b0d19..1ff979a1a 100644
--- a/src/tree/arb.rs
+++ b/src/tree/arb.rs
@@ -534,7 +534,7 @@ fn root_with_ceiling<T>(node: Option<Node<T, Root>>, ceiling: Version) -> crate:
 pub fn poisoned_root<T: Send + Sync>(
     party: &Party,
     base: &Version,
-    message: Message<T>,
+    message: Message,
 ) -> (crate::tree::Root<T>, Path, Version) {
     /// How far the escaped version outruns `base`: an upper bound on the
     /// honest ticks a test performs after the root is planted.
diff --git a/src/tree/mirror/alternating/backend/remote.rs b/src/tree/mirror/alternating/backend/remote.rs
index a54219cb2..4c604b3a6 100644
--- a/src/tree/mirror/alternating/backend/remote.rs
+++ b/src/tree/mirror/alternating/backend/remote.rs
@@ -172,7 +172,7 @@ impl<T, R, W> protocol::Accept<T> for Exchange<T, R, W, Start, Root>
 where
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
-    T: Serialize + DeserializeOwned + Send + Sync,
+    T: Serialize + DeserializeOwned + Send + Sync + 'static,
 {
     type Next = Exchange<T, R, W, Connected, Root>;
 
@@ -210,7 +210,7 @@ where
 
 impl<T, R, W> protocol::Initiator<T> for Exchange<T, R, W, Connected, Root>
 where
-    T: DeserializeOwned + Send + Sync,
+    T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
     Node<T, UnderRoot>: wire::Decode,
@@ -232,7 +232,7 @@ where
 
 impl<T, R, W> protocol::Responder<T> for Exchange<T, R, W, Connected, Root>
 where
-    T: DeserializeOwned + Send + Sync,
+    T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
     Node<T, UnderRoot>: wire::Decode,
@@ -260,7 +260,7 @@ where
 
 impl<T, R, W> protocol::OpenInitiator<T> for Exchange<T, R, W, Connected, Root>
 where
-    T: DeserializeOwned + Send + Sync,
+    T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
     Node<T, UnderRoot>: wire::Decode,
@@ -294,7 +294,7 @@ where
 
 impl<T, R, W, H> protocol::Exchange<T> for Exchange<T, R, W, Connected, S<S<H>>>
 where
-    T: DeserializeOwned + Send + Sync,
+    T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
     H: Height,
@@ -343,7 +343,7 @@ where
 
 impl<T, R, W> protocol::CloseResponder<T> for Exchange<T, R, W, Connected, S<Z>>
 where
-    T: DeserializeOwned + Send + Sync,
+    T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
 {
@@ -384,7 +384,7 @@ where
 
 impl<T, R, W> protocol::CompleteInitiator<T> for Exchange<T, R, W, Connected, Z>
 where
-    T: DeserializeOwned + Send + Sync,
+    T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
 {
diff --git a/src/tree/mirror/alternating/message.rs b/src/tree/mirror/alternating/message.rs
index 8b05e3fe0..9ac65b0ae 100644
--- a/src/tree/mirror/alternating/message.rs
+++ b/src/tree/mirror/alternating/message.rs
@@ -12,7 +12,7 @@
 //!   no length prefix.
 //! - [`typed::Prefix<H>`](crate::tree::typed::Prefix): exactly `32 −
 //!   H::HEIGHT` raw bytes, no length prefix (the type pins the byte count).
-//! - [`Version`] and [`Message<T>`](crate::message::Message): one CBOR
+//! - [`Version`] and [`Message`](crate::message::Message): one CBOR
 //!   value each — a byte string wrapping the version's canonical encoding,
 //!   and a byte string wrapping the message's cached CBOR payload —
 //!   self-delimiting by CBOR's own length headers.
@@ -32,7 +32,7 @@
 //!     prefix_len: u8                  // path-compressed prefix byte count
 //!     [u8; prefix_len]                // head bytes, shallowest first
 //!     body                            // dispatched on `children`:
-//!         Children::Leaf:   version: Version, message: Message<T>
+//!         Children::Leaf:   version: Version, message: Message
 //!         Children::Branch: count_minus_two: u8, [(radix: u8, NodeWire); count]
 //! ```
 //!
@@ -226,7 +226,7 @@ where
 // discharges it.
 impl<T, H> Decode for Exchange<T, H>
 where
-    T: DeserializeOwned,
+    T: DeserializeOwned + Send + Sync + 'static,
     S<H>: Height,
     H: Height,
     Node<T, S<H>>: Decode,
@@ -310,7 +310,7 @@ impl<T> Encode for Closing<T> {
 
 impl<T> Decode for Closing<T>
 where
-    T: DeserializeOwned,
+    T: DeserializeOwned + Send + Sync + 'static,
 {
     fn read_wire<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
         let providing: Providing<T, Z> = Decode::read_wire(reader)?;
@@ -356,7 +356,7 @@ impl<T> Encode for Complete<T> {
 
 impl<T> Decode for Complete<T>
 where
-    T: DeserializeOwned,
+    T: DeserializeOwned + Send + Sync + 'static,
 {
     fn read_wire<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
         let providing: Providing<T, Z> = Decode::read_wire(reader)?;
diff --git a/src/tree/mirror/alternating/tests.rs b/src/tree/mirror/alternating/tests.rs
index bc4fe2cd9..d86e84883 100644
--- a/src/tree/mirror/alternating/tests.rs
+++ b/src/tree/mirror/alternating/tests.rs
@@ -84,7 +84,7 @@ fn mirror_via<T>(
     scenario: Scenario,
 ) -> crate::tree::Root<T>
 where
-    T: PartialEq + std::fmt::Debug + Serialize + DeserializeOwned + Send + Sync,
+    T: PartialEq + std::fmt::Debug + Serialize + DeserializeOwned + Send + Sync + 'static,
 {
     block_on(async move {
         match scenario {
@@ -233,7 +233,7 @@ proptest! {
         let make_actions = |party_index: usize, forgets: &[bool]| -> Vec<_> {
             let p = nth_party(party_index);
             let mut version = Version::new();
-            let mut actions: Vec<(Path, Version, Action<()>)> = Vec::new();
+            let mut actions: Vec<(Path, Version, Action)> = Vec::new();
             let mut paths: Vec<Path> = Vec::new();
             for _ in forgets {
                 version.tick(&p);
@@ -257,7 +257,7 @@ proptest! {
         // The wrapper version must be a causal upper bound on every action
         // we apply — `Tree::react` maintains the same invariant by `|=`-ing
         // each action's version into the tree's version vector.
-        let wrap = |actions: &[(Path, Version, Action<()>)]| crate::tree::Root {
+        let wrap = |actions: &[(Path, Version, Action)]| crate::tree::Root::<()> {
             ceiling: actions
                 .iter()
                 .fold(Version::default(), |acc, (_, v, _)| acc | v.clone()),
diff --git a/src/tree/mirror/streaming/backend.rs b/src/tree/mirror/streaming/backend.rs
index d133b0d45..6e8e30926 100644
--- a/src/tree/mirror/streaming/backend.rs
+++ b/src/tree/mirror/streaming/backend.rs
@@ -306,7 +306,7 @@ pub trait ErasedNode {
 /// shape every backend must represent faithfully.
 pub trait Leaf<T: Send + Sync + 'static>: Node<T> {
     /// The message stored at this leaf node.
-    fn message(&self) -> &Message<T>;
+    fn message(&self) -> &Message;
 
     /// Construct a leaf node from one decoded wire record, taking custody
     /// of its payload.
@@ -338,7 +338,7 @@ pub trait Leaf<T: Send + Sync + 'static>: Node<T> {
     /// (the reclaimable-garbage case).
     fn leaf(
         version: Version,
-        message: Message<T>,
+        message: Message,
     ) -> impl Future<Output = Result<Self, <Self::Backend as Backend<T>>::Error>> + Send
     where
         Self: Sized;
diff --git a/src/tree/mirror/streaming/backend/local.rs b/src/tree/mirror/streaming/backend/local.rs
index 557952fba..8bac7f470 100644
--- a/src/tree/mirror/streaming/backend/local.rs
+++ b/src/tree/mirror/streaming/backend/local.rs
@@ -73,13 +73,13 @@ impl<T: Send + Sync + 'static> ErasedNode for typed::untyped::Node<T> {
 }
 
 impl<T: Send + Sync + 'static> Leaf<T> for typed::Node<T, Z> {
-    fn message(&self) -> &Message<T> {
+    fn message(&self) -> &Message {
         self.message()
     }
 
     // Custody is free: the handle owns the payload and the tree it will
     // join is resident regardless, so construction completes immediately.
-    async fn leaf(version: Version, message: Message<T>) -> Result<Self, Infallible> {
+    async fn leaf(version: Version, message: Message) -> Result<Self, Infallible> {
         Ok(Self::leaf(version, message))
     }
 }
diff --git a/src/tree/mirror/streaming/materialized/unknown/tests.rs b/src/tree/mirror/streaming/materialized/unknown/tests.rs
index cc5151143..8d5857cf3 100644
--- a/src/tree/mirror/streaming/materialized/unknown/tests.rs
+++ b/src/tree/mirror/streaming/materialized/unknown/tests.rs
@@ -27,7 +27,7 @@ use crate::{
 /// the "floor concurrent, keep whole subtree" fast path is exercised alongside
 /// the drop path.
 fn tree_and_known(flags_a: &[bool], flags_b: &[bool]) -> (Option<typed::node::Root<()>>, Version) {
-    let mut actions: Vec<(Path, Version, Action<()>)> = Vec::new();
+    let mut actions: Vec<(Path, Version, Action)> = Vec::new();
     let mut known = Version::new();
 
     for (party_index, flags) in [(0, flags_a), (1, flags_b)] {
diff --git a/src/tree/mirror/streaming/remote.rs b/src/tree/mirror/streaming/remote.rs
index 9d9b6b92d..aaf6470ce 100644
--- a/src/tree/mirror/streaming/remote.rs
+++ b/src/tree/mirror/streaming/remote.rs
@@ -33,7 +33,7 @@
 //! Supplied leaves ship in *runs*: one exact-length-delimited body carrying
 //! one or more leaf records, each itself exact-length-delimited — a CBOR
 //! byte string wrapping the [`Version`](crate::Version)'s canonical bytes,
-//! then the [`Message<T>`](crate::message::Message)'s CBOR payload. The
+//! then the [`Message`](crate::message::Message)'s CBOR payload. The
 //! encoder chunks a supplied subtree's leaves into runs by a byte budget
 //! ([`RunBudget`]); once a run's whole body arrives, the frame codec
 //! validates its record framing and the incoming adapter decodes each
diff --git a/src/tree/mirror/streaming/remote/adapter.rs b/src/tree/mirror/streaming/remote/adapter.rs
index 911ba3c30..98297f47f 100644
--- a/src/tree/mirror/streaming/remote/adapter.rs
+++ b/src/tree/mirror/streaming/remote/adapter.rs
@@ -4,7 +4,7 @@
 //! levels. In memory, one [`Reply`](super::super::message::Reply) contains
 //! backend node handles and omits its prefix because the receiver already knows
 //! which earlier question it answers. On the wire, a supplied node is flattened
-//! into runs of backend-neutral `(Version, Message<T>)` leaf records which
+//! into runs of backend-neutral `(Version, Message)` leaf records which
 //! still carry neither prefix nor radix. This module is the lossless boundary
 //! between them:
 //!
diff --git a/src/tree/mirror/streaming/remote/adapter/encode.rs b/src/tree/mirror/streaming/remote/adapter/encode.rs
index a2231a9c6..f966c1520 100644
--- a/src/tree/mirror/streaming/remote/adapter/encode.rs
+++ b/src/tree/mirror/streaming/remote/adapter/encode.rs
@@ -210,7 +210,7 @@ where
                         let message = leaf.message();
                         if !run.is_empty()
                             && !budget
-                                .admits(run.encoded_len(), LeafRun::record_len(version, message))
+                                .admits(run.encoded_len(), LeafRun::<T>::record_len(version, message))
                         {
                             let full = mem::take(&mut run);
                             if let Some((ready, question)) =
diff --git a/src/tree/mirror/streaming/remote/adapter/tests.rs b/src/tree/mirror/streaming/remote/adapter/tests.rs
index f94c3296b..0e9251e8b 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests.rs
@@ -39,7 +39,7 @@ fn unbounded() -> SupplyLedger {
 }
 
 /// Build a supply run from borrowed leaf records, in the given order.
-fn leaf_run<T>(records: &[(&Version, &Message<T>)]) -> LeafRun<T> {
+fn leaf_run<T>(records: &[(&Version, &Message)]) -> LeafRun<T> {
     let mut run = LeafRun::new();
     for (version, message) in records {
         run.push(version, message)
@@ -58,7 +58,7 @@ fn runtime() -> tokio::runtime::Runtime {
 struct LeafCase {
     value: u64,
     version: Version,
-    message: Message<u64>,
+    message: Message,
 }
 
 impl LeafCase {
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/fan_occupancy.rs b/src/tree/mirror/streaming/remote/adapter/tests/fan_occupancy.rs
index 5a3d67f5a..f641abad5 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/fan_occupancy.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/fan_occupancy.rs
@@ -39,8 +39,8 @@ const PER_FRAME: usize = 16;
 
 /// `count` unique `u64` leaves, in ascending path order (the wire order
 /// the decoder validates).
-fn leaves(count: u64) -> Vec<(Version, Message<u64>)> {
-    let mut leaves: Vec<(Version, Message<u64>)> = (0..count)
+fn leaves(count: u64) -> Vec<(Version, Message)> {
+    let mut leaves: Vec<(Version, Message)> = (0..count)
         .map(|index| {
             let version = Version::try_from(index + 1).expect("small linear versions are valid");
             (version, Message::new(index))
@@ -51,8 +51,8 @@ fn leaves(count: u64) -> Vec<(Version, Message<u64>)> {
 }
 
 /// Chunk leaves into supply frames of [`PER_FRAME`] records each.
-fn frames(leaves: &[(Version, Message<u64>)]) -> Vec<Frame<u64>> {
-    let chunks: Vec<&[(Version, Message<u64>)]> = leaves.chunks(PER_FRAME).collect();
+fn frames(leaves: &[(Version, Message)]) -> Vec<Frame<u64>> {
+    let chunks: Vec<&[(Version, Message)]> = leaves.chunks(PER_FRAME).collect();
     let count = chunks.len();
     chunks
         .into_iter()
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs b/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs
index 54cd4c4f4..edd93886a 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs
@@ -311,8 +311,8 @@ fn decode_scope_error(error: DecodeError<Infallible>) -> ScopeError {
     }
 }
 
-fn under_root_pair() -> [(Version, Message<u64>, Path); 2] {
-    let mut by_radix: BTreeMap<u8, Vec<(Version, Message<u64>, Path)>> = BTreeMap::new();
+fn under_root_pair() -> [(Version, Message, Path); 2] {
+    let mut by_radix: BTreeMap<u8, Vec<(Version, Message, Path)>> = BTreeMap::new();
     for value in 0..u64::MAX {
         let leaf = LeafCase::new(value, value as u8 % 4);
         let path = leaf.path();
@@ -433,7 +433,7 @@ fn leaf_scope_is_enforced_within_one_run() {
         .find(|candidate| Prefix::<Z>::containing(&candidate.path()).pop().0 != parent)
         .expect("content paths do not all share one leaf parent");
     let frames = vec![Frame::Reaction(
-        WireReaction::Supply(leaf_run(&[
+        WireReaction::Supply(leaf_run::<u64>(&[
             (&inside.version, &inside.message),
             (&outside.version, &outside.message),
         ])),
@@ -508,7 +508,7 @@ fn a_version_over_the_declared_bound_is_rejected() {
     let declared = leaf.version.as_bytes().len() as u64;
     let frames = || {
         vec![Frame::Reaction(
-            WireReaction::Supply(leaf_run(&[(&leaf.version, &leaf.message)])),
+            WireReaction::Supply(leaf_run::<u64>(&[(&leaf.version, &leaf.message)])),
             Flow::End,
         )]
     };
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/runs.rs b/src/tree/mirror/streaming/remote/adapter/tests/runs.rs
index f07359fdd..9c5bfb60d 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/runs.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/runs.rs
@@ -137,7 +137,7 @@ fn runs_of(frames: &[Frame<u64>]) -> Vec<&LeafRun<u64>> {
 }
 
 /// The decoded records of `runs`, flattened in wire order.
-fn records_of(runs: &[&LeafRun<u64>]) -> Vec<(Version, Message<u64>)> {
+fn records_of(runs: &[&LeafRun<u64>]) -> Vec<(Version, Message)> {
     runs.iter()
         .flat_map(|run| {
             run.records()
@@ -197,7 +197,7 @@ proptest! {
                 prop_assert!(
                     SUPPLY_FRAME_OVERHEAD
                         + run.encoded_len()
-                        + LeafRun::record_len(&version, &message)
+                        + LeafRun::<u64>::record_len(&version, &message)
                         > budget,
                     "run {position} flushed although the next record fit"
                 );
diff --git a/src/tree/mirror/streaming/remote/codec.rs b/src/tree/mirror/streaming/remote/codec.rs
index 154c2f4db..0ebd53460 100644
--- a/src/tree/mirror/streaming/remote/codec.rs
+++ b/src/tree/mirror/streaming/remote/codec.rs
@@ -19,7 +19,7 @@
 //! An empty query is wholly represented by its signal. A nonempty query carries
 //! `count - 1` in one byte, covering 1 through 256. A supply body is a
 //! [`LeafRun`] behind an exact `u32` body length: one or more
-//! backend-neutral `(Version, Message<T>)` leaf records, each behind its own
+//! backend-neutral `(Version, Message)` leaf records, each behind its own
 //! exact `u32` record length. The codec validates the run's record framing
 //! once its whole body arrives but leaves the records encoded; the adapter
 //! decodes them one at a time, constructs its backend-specific leaves, and
diff --git a/src/tree/mirror/streaming/remote/codec/capture/tests.rs b/src/tree/mirror/streaming/remote/codec/capture/tests.rs
index 35b2fb32b..2cf597d2c 100644
--- a/src/tree/mirror/streaming/remote/codec/capture/tests.rs
+++ b/src/tree/mirror/streaming/remote/codec/capture/tests.rs
@@ -38,7 +38,7 @@ fn supply_decode_names_the_field_that_moved() {
     high.tick(&party);
 
     let render = |version: &Version| {
-        let mut run = LeafRun::new();
+        let mut run = LeafRun::<u64>::new();
         run.push(version, &Message::new(7_u64))
             .expect("one small record fits any run");
         supply_lines(run.as_bytes().to_vec())
diff --git a/src/tree/mirror/streaming/remote/codec/decode/tests.rs b/src/tree/mirror/streaming/remote/codec/decode/tests.rs
index 72289053f..b2bdb3e52 100644
--- a/src/tree/mirror/streaming/remote/codec/decode/tests.rs
+++ b/src/tree/mirror/streaming/remote/codec/decode/tests.rs
@@ -36,7 +36,7 @@ fn supply(stream: Stream, flow: Flow, body: &[u8]) -> Vec<u8> {
 
 /// One length-prefixed leaf record as it appears inside a run body: the
 /// version as one CBOR value, then the payload's CBOR bytes bare.
-fn record(version: &Version, message: &Message<u64>) -> Vec<u8> {
+fn record(version: &Version, message: &Message) -> Vec<u8> {
     let mut body = Vec::new();
     ciborium::ser::into_writer(version, &mut body).unwrap();
     body.extend_from_slice(message.as_slice());
diff --git a/src/tree/mirror/streaming/remote/codec/encode/tests.rs b/src/tree/mirror/streaming/remote/codec/encode/tests.rs
index 8a3bd85cc..848f62baa 100644
--- a/src/tree/mirror/streaming/remote/codec/encode/tests.rs
+++ b/src/tree/mirror/streaming/remote/codec/encode/tests.rs
@@ -118,7 +118,7 @@ proptest! {
         records in proptest::collection::vec((arb_version(), any::<u64>()), 1..=4),
     ) {
         let stream = stream(index);
-        let mut run = super::LeafRun::new();
+        let mut run = super::LeafRun::<u64>::new();
         let mut body = Vec::new();
         for (version, value) in &records {
             let message = Message::new(*value);
diff --git a/src/tree/mirror/streaming/remote/codec/frame.rs b/src/tree/mirror/streaming/remote/codec/frame.rs
index 712f6c46c..dcbb3fc2f 100644
--- a/src/tree/mirror/streaming/remote/codec/frame.rs
+++ b/src/tree/mirror/streaming/remote/codec/frame.rs
@@ -52,7 +52,7 @@ pub type WireFrame<T> = (Stream, Frame<T>);
 
 /// One supply frame's run of leaf records, held in encoded form.
 ///
-/// A run is a delimited sequence of one or more `(Version, Message<T>)`
+/// A run is a delimited sequence of one or more `(Version, Message)`
 /// records: each record is a [`LENGTH_HEADER_LEN`]-byte big-endian length
 /// followed by one CBOR value (a byte string wrapping the version's
 /// canonical encoding) and then the message's CBOR payload, back to back —
@@ -142,7 +142,7 @@ impl<T> LeafRun<T> {
     /// `record_len_matches_an_actual_push`. Saturating: a sum past
     /// `usize::MAX` cannot occur for in-memory slices, and an over-large
     /// record is rejected by [`push`](Self::push) regardless.
-    pub fn record_len(version: &Version, message: &Message<T>) -> usize {
+    pub fn record_len(version: &Version, message: &Message) -> usize {
         let version = version.as_bytes().len();
         LENGTH_HEADER_LEN
             .saturating_add(cbor_bytes_header_len(version))
@@ -157,7 +157,7 @@ impl<T> LeafRun<T> {
     /// Rejects a record no run can carry — one whose combined encoding plus
     /// its own record header exceeds the `u32` run-body limit — leaving the
     /// run untouched.
-    pub fn push(&mut self, version: &Version, message: &Message<T>) -> Result<(), LengthOverflow> {
+    pub fn push(&mut self, version: &Version, message: &Message) -> Result<(), LengthOverflow> {
         let version = version.as_bytes();
         let message = message.as_slice();
         let len = cbor_bytes_header_len(version.len())
@@ -206,11 +206,11 @@ impl<T> LeafRun<T> {
     }
 
     /// Iterate the run's records, decoding each into its canonical pair.
-    pub fn records(&self) -> impl Iterator<Item = Result<(Version, Message<T>), DecodeLeafError>>
+    pub fn records(&self) -> impl Iterator<Item = Result<(Version, Message), DecodeLeafError>>
     where
-        T: DeserializeOwned,
+        T: DeserializeOwned + Send + Sync + 'static,
     {
-        self.record_slices().map(parse_record)
+        self.record_slices().map(parse_record::<T>)
     }
 
     /// Split the validated run back into its exact record slices.
@@ -263,9 +263,9 @@ fn record_header(header: &[u8]) -> usize {
 }
 
 /// Decode one exact record body into its canonical pair.
-fn parse_record<T: DeserializeOwned>(
+fn parse_record<T: DeserializeOwned + Send + Sync + 'static>(
     record: &[u8],
-) -> Result<(Version, Message<T>), DecodeLeafError> {
+) -> Result<(Version, Message), DecodeLeafError> {
     // Both fields are self-delimiting CBOR values, so the exact record
     // body parses without retrying, and whatever the payload's parse does
     // not consume is trailing.
diff --git a/src/tree/mirror/streaming/remote/codec/frame/tests.rs b/src/tree/mirror/streaming/remote/codec/frame/tests.rs
index 3f2acdb0c..4394f4900 100644
--- a/src/tree/mirror/streaming/remote/codec/frame/tests.rs
+++ b/src/tree/mirror/streaming/remote/codec/frame/tests.rs
@@ -63,7 +63,7 @@ fn record_len_matches_an_actual_push() {
             run.push(&version, &message).expect("test records fit");
             assert_eq!(
                 run.encoded_len(),
-                LeafRun::record_len(&version, &message),
+                LeafRun::<u64>::record_len(&version, &message),
                 "record_len must price exactly one pushed record",
             );
             // The version atom `push` writes is byte-identical to the
diff --git a/src/tree/mirror/streaming/remote/codec/tests.rs b/src/tree/mirror/streaming/remote/codec/tests.rs
index 8b7890835..7adb6b03f 100644
--- a/src/tree/mirror/streaming/remote/codec/tests.rs
+++ b/src/tree/mirror/streaming/remote/codec/tests.rs
@@ -67,7 +67,7 @@ const MAX_ARBITRARY_SUFFIX_LEN: usize = 32;
 const MAX_ARBITRARY_RUN_RECORDS: usize = 4;
 
 /// Build a supply run from decoded leaf records.
-fn leaf_run<T: Serialize + Clone>(records: &[(Version, T)]) -> LeafRun<T> {
+fn leaf_run<T: Serialize + Clone + Send + Sync + 'static>(records: &[(Version, T)]) -> LeafRun<T> {
     let mut run = LeafRun::new();
     for (version, value) in records {
         run.push(version, &Message::new(value.clone()))
diff --git a/src/tree/mirror/streaming/remote/codec/tests/error_atlas.rs b/src/tree/mirror/streaming/remote/codec/tests/error_atlas.rs
index 2929a65c0..a8b261f60 100644
--- a/src/tree/mirror/streaming/remote/codec/tests/error_atlas.rs
+++ b/src/tree/mirror/streaming/remote/codec/tests/error_atlas.rs
@@ -82,7 +82,7 @@ const INTERIOR_STREAM: u8 = 8;
 const FIRST_RESERVED_SIGNAL: u8 = WireSignal::BYTE_COUNT;
 
 /// Build a supply run holding one leaf record.
-fn one_record_run<T: Serialize>(version: Version, value: T) -> LeafRun<T> {
+fn one_record_run<T: Serialize + Send + Sync + 'static>(version: Version, value: T) -> LeafRun<T> {
     let mut run = LeafRun::new();
     run.push(&version, &Message::new(value))
         .expect("an atlas record fits the run framing");
diff --git a/src/tree/mirror/streaming/remote/proxy/tests.rs b/src/tree/mirror/streaming/remote/proxy/tests.rs
index 9c02da448..a845eb1b8 100644
--- a/src/tree/mirror/streaming/remote/proxy/tests.rs
+++ b/src/tree/mirror/streaming/remote/proxy/tests.rs
@@ -290,9 +290,9 @@ async fn divergent_leaves_converge() {
 /// live under deterministic closed-world polling.
 #[test]
 fn symmetric_accept_handshakes_are_live() {
-    let mut a = Tree::new();
+    let mut a = Tree::<()>::new();
     a.act(&nth_party(0), [Action::Insert(Message::new(()))]);
-    let mut b = Tree::new();
+    let mut b = Tree::<()>::new();
     b.act(&nth_party(1), [Action::Insert(Message::new(()))]);
 
     let (a, b) = run_to_quiescence(reconcile_symmetric_accepts(a.root, b.root, 1))
@@ -306,9 +306,9 @@ fn symmetric_accept_handshakes_are_live() {
 fn symmetric_accepts_with_distinct_payloads_are_live() {
     let mut a_party = before::Party::seed();
     let b_party = a_party.fork();
-    let mut a = Tree::new();
+    let mut a = Tree::<u64>::new();
     a.act(&a_party, [Action::Insert(Message::new(1_u64))]);
-    let mut b = Tree::new();
+    let mut b = Tree::<u64>::new();
     b.act(&b_party, [Action::Insert(Message::new(2_u64))]);
 
     let (a, b) = run_to_quiescence(reconcile_after_preamble(a.root, b.root))
diff --git a/src/tree/mirror/streaming/testing/failing.rs b/src/tree/mirror/streaming/testing/failing.rs
index 1ab69ff99..36a6f5dec 100644
--- a/src/tree/mirror/streaming/testing/failing.rs
+++ b/src/tree/mirror/streaming/testing/failing.rs
@@ -180,7 +180,7 @@ where
     T: Send + Sync + 'static,
     N: Leaf<T> + Clone + Send + 'static,
 {
-    fn message(&self) -> &Message<T> {
+    fn message(&self) -> &Message {
         self.0.message()
     }
 
@@ -188,7 +188,7 @@ where
     // traversal operations, not construction.
     async fn leaf(
         version: Version,
-        message: Message<T>,
+        message: Message,
     ) -> Result<Self, Failure<<N::Backend as Backend<T>>::Error>> {
         N::leaf(version, message)
             .await
diff --git a/src/tree/mirror/streaming/tests/fixtures.rs b/src/tree/mirror/streaming/tests/fixtures.rs
index d81c6ef31..aec6f689e 100644
--- a/src/tree/mirror/streaming/tests/fixtures.rs
+++ b/src/tree/mirror/streaming/tests/fixtures.rs
@@ -39,7 +39,7 @@ pub(super) fn grown<T>(
     paths: &[Path],
 ) -> Option<TreeNode<T, height::Root>>
 where
-    T: Serialize + Clone + Send + Sync,
+    T: Serialize + Clone + Send + Sync + 'static,
 {
     assert!(stride > 0, "each leaf needs a fresh version");
     let party = nth_party(party);
@@ -238,7 +238,7 @@ impl Divergence {
     /// in both.
     pub fn trees<T>(&self, value: &T) -> (Root<T>, Root<T>, Root<T>)
     where
-        T: Serialize + Clone + Send + Sync,
+        T: Serialize + Clone + Send + Sync + 'static,
     {
         let as_paths =
             |bytes: Vec<[u8; 32]>| -> Vec<Path> { bytes.into_iter().map(Path::from).collect() };
diff --git a/src/tree/tests.rs b/src/tree/tests.rs
index 60b7491ac..1e0cc7e2b 100644
--- a/src/tree/tests.rs
+++ b/src/tree/tests.rs
@@ -13,16 +13,16 @@ fn arb_path() -> impl Strategy<Value = Path> {
     any::<[u8; 32]>().prop_map(Path::from)
 }
 
-/// Wrap a `Bytes` value as a `Message<Bytes>` with its cached serialization.
+/// Wrap a `Bytes` value as a `Message` with its cached serialization.
 /// Tests speak in terms of raw `Bytes`, but the tree's API takes
-/// `Message<T>`, so every insert goes through this one-liner.
-fn msg(b: Bytes) -> Message<Bytes> {
+/// `Message`, so every insert goes through this one-liner.
+fn msg(b: Bytes) -> Message {
     Message::new(b)
 }
 
 /// Wrap a value as the insert action the tree accepts, with its cached
 /// serialization.
-fn insert_action(b: Bytes) -> Action<Bytes> {
+fn insert_action(b: Bytes) -> Action {
     Action::Insert(msg(b))
 }
 
@@ -100,7 +100,7 @@ fn insert_at(
     party: impl AsRef<[u8]>,
     scalar: u64,
     value: Bytes,
-) -> (Path, Version, Message<Bytes>) {
+) -> (Path, Version, Message) {
     (leaf_path(party, scalar), version, msg(value))
 }
 
@@ -218,7 +218,7 @@ proptest! {
         values in proptest::collection::vec(any::<Vec<u8>>(), 0..16)
             .prop_map(|v| v.into_iter().map(Bytes::from).collect::<Vec<_>>()),
     ) {
-        let mut tree = Tree::new();
+        let mut tree = Tree::<Bytes>::new();
         tree.act(&party_of("P"), values.iter().cloned().map(insert_action));
         let reference_input: Vec<_> = values
             .into_iter()
@@ -254,7 +254,7 @@ proptest! {
     ) {
         // One tick of the leaf's own disjoint party; kept leaf indices come
         // from base order, extras continue the numbering beyond them.
-        let event = |index: usize, b: &Bytes| -> (Path, Version, Message<Bytes>) {
+        let event = |index: usize, b: &Bytes| -> (Path, Version, Message) {
             let mut version = Version::new();
             version.tick(&crate::tree::arb::nth_party(index));
             let message = msg(b.clone());
@@ -276,7 +276,7 @@ proptest! {
 
         // Route B: shuffled order, split into two batches, with the extra
         // leaves inserted in between and redacted again afterwards.
-        let extra_events: Vec<(Path, Version, Message<Bytes>)> = extras
+        let extra_events: Vec<(Path, Version, Message)> = extras
             .iter()
             .enumerate()
             .map(|(i, b)| event(kept.len() + i, b))
@@ -317,7 +317,7 @@ proptest! {
                     <[u8; 32]>::from(Path::for_leaf(version)),
                     Some(untyped::Node::leaf(
                         version.clone(),
-                        Message::new((**value).clone()),
+                        Message::new((*value).clone()),
                     )),
                 )
             })
@@ -356,11 +356,11 @@ proptest! {
             insert_at(version_for(&party, scalar), &party, scalar, b)
         };
 
-        let mut all_in_one = Tree::new();
+        let mut all_in_one = Tree::<Bytes>::new();
         all_in_one
             .react(bytes.iter().cloned().enumerate().map(event));
 
-        let mut partitioned = Tree::new();
+        let mut partitioned = Tree::<Bytes>::new();
         let mut chunk: Vec<(usize, Bytes)> = Vec::new();
         for (i, b) in bytes.iter().cloned().enumerate() {
             chunk.push((i, b));
@@ -389,7 +389,7 @@ proptest! {
     fn act_sequence_equals_react_with_explicit_versions(
         bytes in distinct_bytes(16),
     ) {
-        let mut t_act = Tree::new();
+        let mut t_act = Tree::<Bytes>::new();
         for b in &bytes {
             t_act.act(&party_of("P"), [insert_action(b.clone())]);
         }
@@ -399,7 +399,7 @@ proptest! {
             .map(|i| version_for(&party, i as u64))
             .collect();
 
-        let mut t_react = Tree::new();
+        let mut t_react = Tree::<Bytes>::new();
         t_react.react(
             versions
                 .into_iter()
@@ -514,7 +514,7 @@ proptest! {
         let value = Bytes::from(value);
         let path = leaf_path(&party, 1);
 
-        let mut tree = Tree::new();
+        let mut tree = Tree::<Bytes>::new();
         tree.act(&party_of("P"), [insert_action(value)]);
         tree.act(&party_of("P"), [Action::Forget(path)]);
 
@@ -532,7 +532,7 @@ proptest! {
         let value = Bytes::from(value);
         let path = leaf_path(&party, 1);
 
-        let mut tree = Tree::new();
+        let mut tree = Tree::<Bytes>::new();
         tree.act(&party_of("P"), [insert_action(value), Action::Forget(path)]);
 
         prop_assert_eq!(tree.hash(), *reference_hash(&[]).as_bytes());
@@ -553,7 +553,7 @@ proptest! {
             .collect();
         prop_assume!(!present.contains(&nuke));
 
-        let mut t_before = Tree::new();
+        let mut t_before = Tree::<Bytes>::new();
         t_before.act(&party_of("P"), bytes.into_iter().map(insert_action));
         let mut t_after = t_before.clone();
         t_after.act(&party_of("P"), [Action::Forget(nuke)]);
@@ -577,14 +577,14 @@ proptest! {
         batch_size in 1usize..8,
     ) {
         let party = "P".to_string();
-        let mut tree = Tree::new();
+        let mut tree = Tree::<Bytes>::new();
         for i in 0..prior_inserts {
             tree.act(&party_of(&party), [insert_action(Bytes::from(
                 format!("prior-{i}").into_bytes(),
             ))]);
         }
 
-        let actions: Vec<Action<Bytes>> = (0..batch_size)
+        let actions: Vec<Action> = (0..batch_size)
             .map(|i| {
                 insert_action(Bytes::from(format!("batch-{i}").into_bytes()))
             })
@@ -602,14 +602,14 @@ proptest! {
     /// An empty `act` batch leaves the version vector completely unchanged.
     #[test]
     fn empty_act_is_a_version_noop(prior_batches in 0usize..4) {
-        let mut tree = Tree::new();
+        let mut tree = Tree::<Bytes>::new();
         for i in 0..prior_batches {
             tree.act(&party_of("P"), [insert_action(Bytes::from(
                 format!("prior-{i}").into_bytes(),
             ))]);
         }
         let before = tree.latest().clone();
-        tree.act(&party_of("P"), std::iter::empty::<Action<Bytes>>());
+        tree.act(&party_of("P"), std::iter::empty::<Action>());
         prop_assert_eq!(tree.latest(), before);
     }
 
@@ -644,7 +644,7 @@ proptest! {
             })
             .collect();
 
-        let mut t_ab = Tree::new();
+        let mut t_ab = Tree::<Bytes>::new();
         t_ab.react(batch_a.clone());
         t_ab.react(batch_b.clone());
 
@@ -675,7 +675,7 @@ proptest! {
             })
             .collect();
 
-        let mut t_once = Tree::new();
+        let mut t_once = Tree::<Bytes>::new();
         t_once.react(batch.clone());
 
         let mut t_twice = Tree::new();
@@ -709,7 +709,7 @@ proptest! {
             .zip(versions.iter().cloned().enumerate().map(|(i, v)| (v, (i + 1) as u64)))
             .collect();
 
-        let mut t_base = Tree::new();
+        let mut t_base = Tree::<Bytes>::new();
         t_base.react(base.iter().cloned().map(|b| {
             let (v, scalar) = meta_by_value.get(&b).unwrap();
             insert_at(v.clone(), &party, *scalar, b)
@@ -742,7 +742,7 @@ proptest! {
         // replay the event. This is the information a real synchronization
         // protocol would put on the wire.
         let mut tree_a: Tree<Bytes> = Tree::new();
-        let mut a_events: Vec<(Path, Version, Message<Bytes>)> = Vec::new();
+        let mut a_events: Vec<(Path, Version, Message)> = Vec::new();
         for (i, value) in a_inserts.iter().enumerate() {
             let scalar = (i + 1) as u64;
             let mut recorded = tree_a.latest().clone();
@@ -752,7 +752,7 @@ proptest! {
         }
 
         let mut tree_b: Tree<Bytes> = Tree::new();
-        let mut b_events: Vec<(Path, Version, Message<Bytes>)> = Vec::new();
+        let mut b_events: Vec<(Path, Version, Message)> = Vec::new();
         for (i, value) in b_inserts.iter().enumerate() {
             let scalar = (i + 1) as u64;
             let mut recorded = tree_b.latest().clone();
@@ -773,7 +773,7 @@ proptest! {
     /// semantic operation.
     #[test]
     fn clone_preserves_all_observables(acts in distinct_bytes(8)) {
-        let mut tree = Tree::new();
+        let mut tree = Tree::<Bytes>::new();
         tree.act(&party_of("P"), acts.into_iter().map(insert_action));
         let cloned = tree.clone();
 
@@ -791,7 +791,7 @@ proptest! {
     /// equal, so the implication is exercised on its non-vacuous branch.
     #[test]
     fn eq_implies_same_hash(acts in distinct_bytes(8)) {
-        let mut t1 = Tree::new();
+        let mut t1 = Tree::<Bytes>::new();
         t1.act(&party_of("P"), acts.iter().cloned().map(insert_action));
         let mut t2 = Tree::new();
         t2.act(&party_of("P"), acts.into_iter().map(insert_action));
@@ -810,8 +810,8 @@ proptest! {
     #[test]
     fn same_value_different_parties_differ(value in any::<Vec<u8>>()) {
         let value = Bytes::from(value);
-        let mut t_a = Tree::new();
-        let mut t_b = Tree::new();
+        let mut t_a = Tree::<Bytes>::new();
+        let mut t_b = Tree::<Bytes>::new();
         t_a.act(&party_of("A"), [insert_action(value.clone())]);
         t_b.act(&party_of("B"), [insert_action(value)]);
 
@@ -836,11 +836,11 @@ proptest! {
         let path_v2 = leaf_path(&party, 2);
 
         prop_assert_ne!(path_v1, path_v2);
-        let got = [
+        let got: [Arc<Bytes>; 2] = [
             tree.get(&version_for(&party, 1)).unwrap(),
             tree.get(&version_for(&party, 2)).unwrap(),
         ];
-        prop_assert!(got.iter().all(|b| b.1[..] == *value));
+        prop_assert!(got.iter().all(|b| **b == value));
     }
 }
 
@@ -856,8 +856,8 @@ fn delete_nonexistent_key() {
 
 /// Project a borrowed leaf pair to an owned one, for collecting and
 /// comparing walk outputs.
-fn owned<T>((version, value): (&Version, &Arc<T>)) -> (Version, Arc<T>) {
-    (version.clone(), value.clone())
+fn owned<T>((version, value): (&Version, Arc<T>)) -> (Version, Arc<T>) {
+    (version.clone(), value)
 }
 
 proptest! {
@@ -975,7 +975,7 @@ proptest! {
         for (version, value) in &forward {
             prop_assert_eq!(
                 tree.get(version),
-                Some((version, value)),
+                Some(value.clone()),
                 "get resolves every iterated version",
             );
         }
@@ -1141,7 +1141,7 @@ proptest! {
         );
         let live: Vec<Path> = tree.iter().map(|(v, _)| Path::for_leaf(v)).collect();
 
-        let mut actions: Vec<Action<Bytes>> =
+        let mut actions: Vec<Action> =
             batch_values.iter().cloned().map(insert_action).collect();
         for index in forget_live {
             if !live.is_empty() {
@@ -1509,7 +1509,7 @@ fn act_unwind_leaves_tree_byte_identical() {
     // section touches the tree.
     let panicking_actions = [insert_action(Bytes::from_static(b"casualty"))]
         .into_iter()
-        .chain(std::iter::once_with(|| -> Action<Bytes> {
+        .chain(std::iter::once_with(|| -> Action {
             panic!("injected: actions iterator panics mid-drain")
         }));
     let unwound = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
@@ -1588,7 +1588,7 @@ fn join_unwind_leaves_tree_byte_identical() {
 
 /// A test payload whose destructor panics while armed.
 ///
-/// [`Message<T>`] clones share one `Arc<T>`, so `T`'s destructor runs only
+/// [`Message`] clones share one payload allocation, so `T`'s destructor runs only
 /// when the *last* handle drops: arming the flag turns that drop —
 /// wherever the tree performs it — into the commit sections' one
 /// caller-reachable mid-walk unwind source. Construction and serialization
diff --git a/src/tree/traverse/act.rs b/src/tree/traverse/act.rs
index bfa665770..af8af9692 100644
--- a/src/tree/traverse/act.rs
+++ b/src/tree/traverse/act.rs
@@ -7,9 +7,9 @@ use height::{Height, Root, S, Z};
 
 /// An action to perform at a particular [`Path`].
 #[derive(Debug, Clone)]
-pub enum Action<T> {
+pub enum Action {
     /// Insert a value tagged by a version at a party.
-    Insert(Message<T>),
+    Insert(Message),
     /// Delete a value at this path.
     Forget,
 }
@@ -41,7 +41,7 @@ pub fn act<T, F, I>(
 where
     T: Send + Sync,
     F: FnMut(&Version),
-    I: IntoIterator<Item = (Path, Version, Action<T>)>,
+    I: IntoIterator<Item = (Path, Version, Action)>,
 {
     // Test-only unwind source for the panic-atomicity pins: this walk is
     // the unwind-source region of `Tree::react`'s commit section, and its entry
@@ -69,7 +69,7 @@ pub trait Act: Height {
     where
         T: Send + Sync,
         F: FnMut(&Version),
-        I: IntoIterator<Item = (Path<Self>, Version, Action<T>)>;
+        I: IntoIterator<Item = (Path<Self>, Version, Action)>;
 }
 
 impl<H: Act> Act for S<H>
@@ -84,7 +84,7 @@ where
     where
         T: Send + Sync,
         F: FnMut(&Version),
-        I: IntoIterator<Item = (Path<Self>, Version, Action<T>)>,
+        I: IntoIterator<Item = (Path<Self>, Version, Action)>,
     {
         // Test-only unwind source, continued: every branch-level apply step
         // burns one fuse step, so a fuse armed past the entry unwinds only
@@ -156,7 +156,7 @@ impl Act for Z {
     where
         T: Send + Sync,
         F: FnMut(&Version),
-        I: IntoIterator<Item = (Path<Self>, Version, Action<T>)>,
+        I: IntoIterator<Item = (Path<Self>, Version, Action)>,
     {
         let existed_before = node.is_some();
         let mut greatest_version = Version::default();
diff --git a/src/tree/traverse/unknown/tests.rs b/src/tree/traverse/unknown/tests.rs
index 476d466bf..1f816e8d6 100644
--- a/src/tree/traverse/unknown/tests.rs
+++ b/src/tree/traverse/unknown/tests.rs
@@ -94,7 +94,7 @@ fn wide_divergence(
     known_leaves: usize,
     divergent_leaves: usize,
 ) -> (Option<typed::node::Root<()>>, Version) {
-    let mut actions: Vec<(Path, Version, Action<()>)> = Vec::new();
+    let mut actions: Vec<(Path, Version, Action)> = Vec::new();
     let mut known = Version::new();
 
     for (party_index, count, flagged) in [(0, known_leaves, true), (1, divergent_leaves, false)] {
diff --git a/src/tree/typed/node.rs b/src/tree/typed/node.rs
index d76d88a51..4cfdbe470 100644
--- a/src/tree/typed/node.rs
+++ b/src/tree/typed/node.rs
@@ -363,7 +363,7 @@ where
 
 impl<T> Node<T, Z> {
     /// Construct a new leaf node from a versioned message.
-    pub fn leaf(version: Version, message: Message<T>) -> Self {
+    pub fn leaf(version: Version, message: Message) -> Self {
         Self {
             height: PhantomData,
             inner: untyped::Node::leaf(version, message),
@@ -371,7 +371,7 @@ impl<T> Node<T, Z> {
     }
 
     /// Get a reference to the message at this leaf node.
-    pub fn message(&self) -> &Message<T> {
+    pub fn message(&self) -> &Message {
         self.inner
             .as_leaf()
             .expect("typed leaf failed to be a leaf")
@@ -389,12 +389,12 @@ impl<T> Node<T, height::Root> {
 
     /// Look up the live leaf whose full 32-byte path is `path`, by a single
     /// `O(depth)` descent.
-    pub fn get(&self, path: &[u8]) -> Option<(&Version, &Message<T>)> {
+    pub fn get(&self, path: &[u8]) -> Option<(&Version, &Message)> {
         self.inner.get(path)
     }
 
     /// Lazily iterate every live leaf in this root subtree as
-    /// `([u8; 32], &Version, &Message<T>)`.
+    /// `([u8; 32], &Version, &Message)`.
     ///
     /// Delegates to the height-agnostic untyped walk; because this is a
     /// height-32 root, every yielded path is a full 32-byte array.
@@ -484,7 +484,7 @@ where
 #[cfg(any(test, feature = "protocol-v1"))]
 impl<T> wire::Decode for Node<T, Z>
 where
-    T: DeserializeOwned,
+    T: DeserializeOwned + Send + Sync + 'static,
 {
     fn read_wire<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
         let prefix_len = u8::read_wire(reader)?;
@@ -492,7 +492,7 @@ where
             return Err(wire::invalid("leaf height cannot carry a prefix"));
         }
         let version = Version::read_wire(reader)?;
-        let message = Message::<T>::read_wire(reader)?;
+        let message = Message::from_reader::<T, _>(reader)?;
         Ok(Node::leaf(version, message))
     }
 }
@@ -500,7 +500,7 @@ where
 #[cfg(any(test, feature = "protocol-v1"))]
 impl<T, H> wire::Decode for Node<T, S<H>>
 where
-    T: DeserializeOwned,
+    T: DeserializeOwned + Send + Sync + 'static,
     H: Height,
     S<H>: Height,
     Node<T, H>: wire::Decode,
diff --git a/src/tree/typed/untyped.rs b/src/tree/typed/untyped.rs
index 1d7b62ed6..e224d4d16 100644
--- a/src/tree/typed/untyped.rs
+++ b/src/tree/typed/untyped.rs
@@ -7,6 +7,7 @@ use tinyvec::ArrayVec;
 use before::{Dominance, Span};
 
 use crate::{Version, message::Message, tree::typed::Hash};
+use std::marker::PhantomData;
 
 pub mod fan;
 mod iter;
@@ -77,6 +78,13 @@ pub(crate) mod census {
 }
 
 struct NodeInner<T> {
+    /// The payload type the containing tree's facade reads its leaves at.
+    ///
+    /// Stored messages are type-erased ([`Message`] holds `dyn Any`), so
+    /// nothing structural consumes `T` here: the marker keeps the veneer's
+    /// parameter anchored (as `fn() -> T`, so auto-traits never descend
+    /// into `T`) until the typed boundary downcasts at the crate's API.
+    marker: PhantomData<fn() -> T>,
     /// Compressed path above this node's own branching level, stored with the
     /// deepest byte at index 0 and the shallowest byte at the last index. An
     /// empty prefix means the node is not path-compressed above its level.
@@ -104,6 +112,7 @@ struct NodeInner<T> {
 impl<T> Clone for NodeInner<T> {
     fn clone(&self) -> Self {
         Self {
+            marker: PhantomData,
             prefix: self.prefix.clone(),
             hash: self.hash.clone(),
             children: self.children.clone(),
@@ -128,7 +137,7 @@ enum Children<T> {
         /// The version of this leaf.
         version: Version,
         /// The payload of this leaf.
-        message: Message<T>,
+        message: Message,
     },
     /// A materialized branch point, with the invariant that there are always >=
     /// 2 branches (or else they should be path-compressed away).
@@ -211,6 +220,7 @@ impl<T> Node<T> {
                 Some(node.beneath(index))
             }
             _ => Some(Node::from_inner(Arc::new(NodeInner {
+                marker: PhantomData,
                 prefix: Vec::new(),
                 hash: OnceLock::new(),
                 children: Children::Branch {
@@ -329,6 +339,7 @@ impl<T> Node<T> {
         debug_assert!(children.len() >= 2, "a branch point separates >= 2 runs");
 
         Node::from_inner(Arc::new(NodeInner {
+            marker: PhantomData,
             prefix: first[depth..branch_at].iter().rev().copied().collect(),
             hash: OnceLock::new(),
             children: Children::Branch {
@@ -341,8 +352,9 @@ impl<T> Node<T> {
     }
 
     /// Construct a new leaf node.
-    pub fn leaf(version: Version, value: Message<T>) -> Self {
+    pub fn leaf(version: Version, value: Message) -> Self {
         Node::from_inner(Arc::new(NodeInner {
+            marker: PhantomData,
             prefix: Vec::new(),
             hash: OnceLock::new(),
             children: Children::Leaf {
@@ -353,7 +365,7 @@ impl<T> Node<T> {
     }
 
     /// Get a reference to the leaf at this node, if it is a leaf.
-    pub fn as_leaf(&self) -> Option<&Message<T>> {
+    pub fn as_leaf(&self) -> Option<&Message> {
         match &self.inner.children {
             Children::Leaf { message, .. } => Some(message),
             _ => None,
@@ -363,7 +375,7 @@ impl<T> Node<T> {
     /// Look up the leaf at `path` beneath this node: a single root-to-leaf
     /// descent costing `O(depth)`, never a scan. `None` when no live leaf
     /// sits at that path.
-    pub fn get(&self, mut path: &[u8]) -> Option<(&Version, &Message<T>)> {
+    pub fn get(&self, mut path: &[u8]) -> Option<(&Version, &Message)> {
         let mut node = self;
         loop {
             // Consume the compressed prefix, shallowest byte first (it is
diff --git a/src/tree/typed/untyped/iter.rs b/src/tree/typed/untyped/iter.rs
index c5f57ddd2..ed01632a9 100644
--- a/src/tree/typed/untyped/iter.rs
+++ b/src/tree/typed/untyped/iter.rs
@@ -100,7 +100,7 @@ impl<'a, T, P: Polarity> Walk<'a, T, P> {
     /// ordered so the frontier stays ascending front-to-back; the two ends
     /// therefore never yield the same leaf and meet cleanly when the frontier
     /// empties.
-    fn step(&mut self, back: bool) -> Option<(&'a Version, &'a Message<T>)> {
+    fn step(&mut self, back: bool) -> Option<(&'a Version, &'a Message)> {
         'frontier: while let Some(Frame { node, passes }) = if back {
             self.frames.pop_back()
         } else {
@@ -159,8 +159,8 @@ impl<'a, T, P: Polarity> Walk<'a, T, P> {
 /// For the same walk filtered to a causal range, see [`Range`].
 ///
 /// The [`Message`] is the richest leaf payload (it carries the cached
-/// serialization alongside the `Arc<T>`); callers that only want the value
-/// project it cheaply with [`Message::as_arc`].
+/// serialization alongside the shared payload handle); callers that only
+/// want the value project it with [`Message::arc`].
 ///
 /// [`next`](Iterator::next) yields leaves in ascending order of their
 /// version-derived paths; the iterator is also a [`DoubleEndedIterator`],
@@ -196,7 +196,7 @@ impl<'a, T> Iter<'a, T> {
 }
 
 impl<'a, T> Iterator for Iter<'a, T> {
-    type Item = (&'a Version, &'a Message<T>);
+    type Item = (&'a Version, &'a Message);
 
     fn next(&mut self) -> Option<Self::Item> {
         self.walk.step(false)
@@ -248,7 +248,7 @@ impl<'a, T, P: Polarity> Range<'a, T, P> {
 }
 
 impl<'a, T, P: Polarity> Iterator for Range<'a, T, P> {
-    type Item = (&'a Version, &'a Message<T>);
+    type Item = (&'a Version, &'a Message);
 
     fn next(&mut self) -> Option<Self::Item> {
         self.walk.step(false)
@@ -329,12 +329,16 @@ impl<T> Leaf<T> {
         self.0.ceiling()
     }
 
-    /// The message's value.
-    pub fn value(&self) -> &std::sync::Arc<T> {
+    /// The message's value: an owned handle, one reference bump on the
+    /// shared allocation.
+    pub fn value(&self) -> std::sync::Arc<T>
+    where
+        T: Send + Sync + 'static,
+    {
         self.0
             .as_leaf()
             .expect("a Leaf wraps a leaf node, by construction")
-            .as_arc()
+            .arc::<T>()
     }
 
     /// Unwrap into a bare height-zero leaf node.
diff --git a/src/tree/typed/untyped/tests.rs b/src/tree/typed/untyped/tests.rs
index 0afdc8571..352ad4d6e 100644
--- a/src/tree/typed/untyped/tests.rs
+++ b/src/tree/typed/untyped/tests.rs
@@ -94,7 +94,7 @@ fn arb_tree(depth: usize, budget: usize) -> BoxedStrategy<Node<()>> {
 /// yields them. The version is the leaf's own version as recorded by
 /// `Node::leaf`, and is preserved across path compression because
 /// `into_children` never mutates `version` — only `prefix`.
-fn enumerate_leaves(node: Node<()>, path: Vec<u8>) -> Vec<(Vec<u8>, Version, Message<()>)> {
+fn enumerate_leaves(node: Node<()>, path: Vec<u8>) -> Vec<(Vec<u8>, Version, Message)> {
     match node.into_children() {
         Ok(children) => children
             .into_iter()
@@ -127,7 +127,7 @@ fn enumerate_leaves(node: Node<()>, path: Vec<u8>) -> Vec<(Vec<u8>, Version, Mes
 /// versions we started with.
 fn rebuild_with<F>(node: Node<()>, f: &F) -> Node<()>
 where
-    F: Fn(&Message<()>) -> Message<()>,
+    F: Fn(&Message) -> Message,
 {
     let version = node.ceiling().clone();
     match node.into_children() {
@@ -593,7 +593,7 @@ fn check_virtual_levels(
 #[test]
 fn node_hash_preimage_is_in_path_order() {
     const LEAF_TAG: u8 = 0;
-    let leaf = Node::leaf(Version::new(), Message::new(()));
+    let leaf = Node::<()>::leaf(Version::new(), Message::new(()));
     let wrapped = leaf.beneath(0xAA).beneath(0xBB);
     assert_eq!(wrapped.hash(), super::Hash::of(&[LEAF_TAG, 2, 0xBB, 0xAA]));
 }
diff --git a/src/tree/wire.rs b/src/tree/wire.rs
index 4a420690f..5fedbe644 100644
--- a/src/tree/wire.rs
+++ b/src/tree/wire.rs
@@ -8,7 +8,7 @@
 //! Container shapes (counts, radix records, fixed-width prefixes and
 //! hashes) are protocol framing, written and validated by hand exactly
 //! like the streaming codec's signal and length headers. The two atoms a
-//! frame cannot delimit itself — a [`Version`] and a [`Message<T>`] — ride
+//! frame cannot delimit itself — a [`Version`] and a [`Message`] — ride
 //! as single CBOR values, self-delimiting by CBOR's own length headers:
 //! the version as a byte string wrapping its canonical encoding (the
 //! `before` serde form), the message as a byte string wrapping its cached
@@ -21,7 +21,6 @@ use crate::Version;
 use crate::message::Message;
 use crate::tree::typed::Hash;
 
-use serde::de::DeserializeOwned;
 /// Encode `self` onto a byte stream.
 ///
 /// The method is `write_wire`, not `encode_to`: `before`'s types carry
@@ -207,19 +206,15 @@ impl Decode for Version {
     }
 }
 
-/// One CBOR value: a byte string wrapping the cached CBOR payload.
-impl<T> Encode for Message<T> {
+/// One CBOR value: a byte string wrapping the cached CBOR payload. The
+/// decode direction is typed ([`Message::from_reader`]): the payload's
+/// type is erased in storage, so decoding names it explicitly.
+impl Encode for Message {
     fn write_wire<W: Write>(&self, writer: &mut W) -> std::io::Result<()> {
         ciborium::ser::into_writer(self, writer).map_err(ser_error)
     }
 }
 
-impl<T: DeserializeOwned> Decode for Message<T> {
-    fn read_wire<R: Read>(reader: &mut R) -> std::io::Result<Self> {
-        ciborium::de::from_reader(reader).map_err(de_error)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -247,7 +242,7 @@ mod tests {
 
         let m = Message::new(());
         let enc = to_vec(&m).unwrap();
-        let back: Message<()> = from_slice(&enc).unwrap();
+        let back = Message::from_reader::<(), _>(&mut enc.as_slice()).unwrap();
         assert_eq!(back.as_slice(), m.as_slice());
 
         let leaf: Node<(), Z> = Node::leaf(version.clone(), Message::new(()));
diff --git a/tests/bookmark_causality.rs b/tests/bookmark_causality.rs
index 036155ebc..9f5608ca3 100644
--- a/tests/bookmark_causality.rs
+++ b/tests/bookmark_causality.rs
@@ -395,7 +395,7 @@ impl World {
         let snapshot = rumors.snapshot();
         let mut version = None;
         for (leaf_version, value) in snapshot.iter() {
-            if **value == id {
+            if *value == id {
                 version = Some(leaf_version.clone());
                 break;
             }
@@ -872,7 +872,7 @@ impl World {
             let snapshot = rumors.snapshot();
             for (leaf_version, value) in snapshot.iter() {
                 live_leaves += 1;
-                let seq = **value;
+                let seq = *value;
                 assert!(
                     self.emissions.contains_exact(network, seq, leaf_version),
                     "live message #{seq} at version {leaf_version:?} in network {network:?} \
diff --git a/tests/bookmark_transmit_window.rs b/tests/bookmark_transmit_window.rs
index e7b59f397..798c8dccf 100644
--- a/tests/bookmark_transmit_window.rs
+++ b/tests/bookmark_transmit_window.rs
@@ -193,7 +193,7 @@ fn leaf_version(rumors: &Rumors<Msg, GatedBookmark>, payload: Msg) -> Option<Ver
     rumors
         .snapshot()
         .iter()
-        .find(|(_, value)| ***value == payload)
+        .find(|(_, value)| **value == payload)
         .map(|(version, _)| version.clone())
 }
 
diff --git a/tests/bookmark_when.rs b/tests/bookmark_when.rs
index d38737081..4022440c2 100644
--- a/tests/bookmark_when.rs
+++ b/tests/bookmark_when.rs
@@ -505,7 +505,7 @@ fn incorporating_remote_content_writes_nothing() {
         "incorporating remote content must drive no bookmark I/O",
     );
     assert!(
-        probe.subject.snapshot().iter().any(|(_, m)| **m == 2),
+        probe.subject.snapshot().iter().any(|(_, m)| *m == 2),
         "the remote content was nonetheless incorporated",
     );
 }
diff --git a/tests/bootstrap.rs b/tests/bootstrap.rs
index 5757456db..0672eadc1 100644
--- a/tests/bootstrap.rs
+++ b/tests/bootstrap.rs
@@ -84,7 +84,7 @@ proptest! {
         bootstrapped.send(u64::MAX);
         wire_gossip(&provider, &bootstrapped);
         prop_assert!(
-            provider.snapshot().iter().any(|(_, m)| **m == u64::MAX),
+            provider.snapshot().iter().any(|(_, m)| *m == u64::MAX),
             "the newcomer's origination must survive gossip into the provider",
         );
     }
@@ -114,7 +114,7 @@ proptest! {
         bootstrapped.send("newcomer's own".to_string());
         wire_gossip(&provider, &bootstrapped);
         prop_assert!(
-            provider.snapshot().iter().any(|(_, m)| **m == "newcomer's own"),
+            provider.snapshot().iter().any(|(_, m)| *m == "newcomer's own"),
             "the newcomer's origination must survive gossip into the provider",
         );
     }
@@ -192,7 +192,7 @@ fn zero_budget_bootstrap_converges() {
     bootstrapped.send(u64::MAX);
     wire_gossip(&provider, &bootstrapped);
     assert!(
-        provider.snapshot().iter().any(|(_, m)| **m == u64::MAX),
+        provider.snapshot().iter().any(|(_, m)| *m == u64::MAX),
         "the newcomer's origination must survive its zero-budget gossip",
     );
 }
diff --git a/tests/causal.rs b/tests/causal.rs
index b68c9f566..4a6277964 100644
--- a/tests/causal.rs
+++ b/tests/causal.rs
@@ -82,7 +82,7 @@ fn live_map(rumors: &Rumors<u64>) -> BTreeMap<Vec<u8>, u64> {
     rumors
         .snapshot()
         .iter()
-        .map(|(v, m)| (v.as_bytes().to_vec(), **m))
+        .map(|(v, m)| (v.as_bytes().to_vec(), *m))
         .collect()
 }
 
diff --git a/tests/cbor_evolution.rs b/tests/cbor_evolution.rs
index 90a4daa28..82cbadf42 100644
--- a/tests/cbor_evolution.rs
+++ b/tests/cbor_evolution.rs
@@ -75,7 +75,7 @@ where
 
     let snapshot = receiver.snapshot();
     let (_, message) = snapshot.iter().next().expect("one live message");
-    (**message).clone()
+    (*message).clone()
 }
 
 /// Struct fields decode by name: a payload encoded with one field order
diff --git a/tests/changes.rs b/tests/changes.rs
index 603c46c7c..1c982b5c5 100644
--- a/tests/changes.rs
+++ b/tests/changes.rs
@@ -46,7 +46,7 @@ async fn one_tick_per_observed_commit() {
     let version = rumors
         .snapshot()
         .iter()
-        .find_map(|(v, m)| (**m == 1).then_some(v.clone()))
+        .find_map(|(v, m)| (*m == 1).then_some(v.clone()))
         .expect("message 1 is live");
     rumors.redact(&version);
     assert_eq!(changes.next().now_or_never(), Some(Some(())));
diff --git a/tests/common/action.rs b/tests/common/action.rs
index 63cabf7aa..88fd9f559 100644
--- a/tests/common/action.rs
+++ b/tests/common/action.rs
@@ -53,7 +53,7 @@ pub fn arb_string_actions() -> impl Strategy<Value = Vec<LocalAction<String>>> {
 /// # Panics
 ///
 /// Panics unless exactly one leaf qualifies.
-pub fn minted_version<T: Send + Sync>(snapshot: &Snapshot<T>, pre: &Version) -> Version {
+pub fn minted_version<T: Send + Sync + 'static>(snapshot: &Snapshot<T>, pre: &Version) -> Version {
     let mut fresh = snapshot.range(causally::since(pre)).map(|(v, _)| v);
     let version = fresh.next().expect("a send mints exactly one live leaf");
     assert!(
diff --git a/tests/common/oracle.rs b/tests/common/oracle.rs
index 507032e56..22e7c7ece 100644
--- a/tests/common/oracle.rs
+++ b/tests/common/oracle.rs
@@ -83,7 +83,7 @@ where
 {
     snapshot
         .iter()
-        .map(|(v, m)| (version_key(v), (**m).clone()))
+        .map(|(v, m)| (version_key(v), (*m).clone()))
         .collect()
 }
 
diff --git a/tests/common/peer.rs b/tests/common/peer.rs
index 47517c7a7..f265e51be 100644
--- a/tests/common/peer.rs
+++ b/tests/common/peer.rs
@@ -67,7 +67,7 @@ impl<T: Clone + Serialize + DeserializeOwned + Send + Sync + 'static> Peer<T> {
         let mut new = 0;
         for (version, message) in snapshot.range(causally::since(&self.checkpoint)) {
             self.observations
-                .push((version.clone(), (**message).clone()));
+                .push((version.clone(), (*message).clone()));
             new += 1;
         }
         self.checkpoint |= snapshot.latest();
diff --git a/tests/common/shape.rs b/tests/common/shape.rs
index a2dffafb5..de4e84437 100644
--- a/tests/common/shape.rs
+++ b/tests/common/shape.rs
@@ -39,7 +39,7 @@ pub fn pool(rumors: &Rumors<u64>, from: u64, count: u64) -> Vec<(u64, Version)>
         .snapshot()
         .iter()
         .filter(|(_, m)| (from..from + count).contains(m))
-        .map(|(v, m)| (**m, v.clone()))
+        .map(|(v, m)| (*m, v.clone()))
         .collect();
     pool.sort_by_key(|(value, _)| *value);
     pool
diff --git a/tests/common/sim.rs b/tests/common/sim.rs
index 4ec6573fe..7a3c8c036 100644
--- a/tests/common/sim.rs
+++ b/tests/common/sim.rs
@@ -529,7 +529,7 @@ async fn run_activity(handle: Rumors<u64>, script: Vec<Activity>) -> Vec<(Versio
                 let live: Vec<(Version, u64)> = handle
                     .snapshot()
                     .iter()
-                    .map(|(v, m)| (v.clone(), **m))
+                    .map(|(v, m)| (v.clone(), *m))
                     .collect();
                 if !live.is_empty() {
                     let (version, value) = live[index % live.len()].clone();
diff --git a/tests/gossip_snapshot.rs b/tests/gossip_snapshot.rs
index a0422dbb7..8ae731f0a 100644
--- a/tests/gossip_snapshot.rs
+++ b/tests/gossip_snapshot.rs
@@ -48,7 +48,7 @@ fn version_for(rumors: &Rumors<u64>, value: u64) -> Version {
     rumors
         .snapshot()
         .iter()
-        .find_map(|(v, m)| (**m == value).then_some(v.clone()))
+        .find_map(|(v, m)| (*m == value).then_some(v.clone()))
         .unwrap_or_else(|| panic!("no live message holds {value}"))
 }
 
@@ -349,19 +349,19 @@ fn early_supplies_honor_redactions() {
         "one pruned Supply run: the survivor, not the full subtree"
     );
     assert!(
-        !a.snapshot().iter().any(|(_, m)| **m == 1),
+        !a.snapshot().iter().any(|(_, m)| *m == 1),
         "the redaction is contagious: the initiator drops the message"
     );
     assert!(
-        !b.snapshot().iter().any(|(_, m)| **m == 1),
+        !b.snapshot().iter().any(|(_, m)| *m == 1),
         "the redacted message must not resurrect at the responder"
     );
     assert!(
-        a.snapshot().iter().any(|(_, m)| **m == sibling),
+        a.snapshot().iter().any(|(_, m)| *m == sibling),
         "the survivor converges to the initiator"
     );
     assert!(
-        b.snapshot().iter().any(|(_, m)| **m == sibling),
+        b.snapshot().iter().any(|(_, m)| *m == sibling),
         "the survivor converges to the responder"
     );
     insta::assert_snapshot!(capture);
diff --git a/tests/gossip_when.rs b/tests/gossip_when.rs
index 62689f566..f01f0b8a7 100644
--- a/tests/gossip_when.rs
+++ b/tests/gossip_when.rs
@@ -273,7 +273,7 @@ async fn changes_propagate_transitively_through_a_chain() {
         loop {
             c_changes.next().await.expect("set still open");
             let snapshot = c.snapshot();
-            if snapshot.iter().any(|(_, m)| **m == 42) {
+            if snapshot.iter().any(|(_, m)| *m == 42) {
                 return;
             }
         }
@@ -682,8 +682,8 @@ proptest! {
             // Atomicity: whatever happened, each side holds its own send,
             // nothing beyond the union, and never a torn intermediate.
             let (a_snapshot, b_snapshot) = (a.snapshot(), b.snapshot());
-            assert!(a_snapshot.iter().any(|(_, m)| **m == 1));
-            assert!(b_snapshot.iter().any(|(_, m)| **m == 2));
+            assert!(a_snapshot.iter().any(|(_, m)| *m == 1));
+            assert!(b_snapshot.iter().any(|(_, m)| *m == 2));
             assert!(a_snapshot.len() <= 2);
             assert!(b_snapshot.len() <= 2);
 
diff --git a/tests/hop_trace.rs b/tests/hop_trace.rs
index 6b498541d..4f25c3ef2 100644
--- a/tests/hop_trace.rs
+++ b/tests/hop_trace.rs
@@ -570,7 +570,7 @@ fn transfer_pair() -> (Rumors<u64>, Rumors<u64>) {
     let mut pool: Vec<(u64, u8)> = left
         .snapshot()
         .iter()
-        .map(|(v, m)| (**m, path_radix(v)))
+        .map(|(v, m)| (*m, path_radix(v)))
         .collect();
     pool.sort_unstable();
     let (first, second) = pool
@@ -597,7 +597,7 @@ fn transfer_pair() -> (Rumors<u64>, Rumors<u64>) {
         .iter()
         .filter(|(v, _)| path_radix(v) != radix)
         .take(3)
-        .map(|(_, m)| **m)
+        .map(|(_, m)| *m)
         .collect();
     assert_eq!(ballast.len(), 3, "the ballast pool cannot fill its quota");
     keep_only(&right, &ballast);
diff --git a/tests/listen.rs b/tests/listen.rs
index 83286bd62..e62af9eb2 100644
--- a/tests/listen.rs
+++ b/tests/listen.rs
@@ -66,7 +66,7 @@ fn live_map(rumors: &Rumors<u64>) -> BTreeMap<Vec<u8>, u64> {
     rumors
         .snapshot()
         .iter()
-        .map(|(v, m)| (v.as_bytes().to_vec(), **m))
+        .map(|(v, m)| (v.as_bytes().to_vec(), *m))
         .collect()
 }
 
@@ -491,7 +491,7 @@ fn folding_delivered_versions_can_lose_a_message() {
             rumors.send(later_value);
             let snapshot = rumors.snapshot();
             let first_yielded = snapshot.iter().next().expect("two live messages");
-            let later_first = **first_yielded.1 == later_value;
+            let later_first = *first_yielded.1 == later_value;
             drop(snapshot);
             later_first.then_some(rumors)
         })
diff --git a/tests/opening_supply.rs b/tests/opening_supply.rs
index 90b81d0c5..ac8b4261e 100644
--- a/tests/opening_supply.rs
+++ b/tests/opening_supply.rs
@@ -75,7 +75,7 @@ fn divergent_root_child_has_one_question_owner() {
     let radix = path_radix(
         &a.snapshot()
             .iter()
-            .find_map(|(v, m)| (**m == 1).then_some(v.clone()))
+            .find_map(|(v, m)| (*m == 1).then_some(v.clone()))
             .expect("message 1 is live"),
     );
     send_pool(&a, 2, RADIX_POOL);
diff --git a/tests/retire.rs b/tests/retire.rs
index 85a17698c..5d5775d73 100644
--- a/tests/retire.rs
+++ b/tests/retire.rs
@@ -172,7 +172,7 @@ fn divergent_retiree_reconciles_then_retires() {
         matches!(outcome, Retire::Retired),
         "the in-session gossip round brings the peer to dominance, got {outcome:?}"
     );
-    let mut live: Vec<u64> = b.snapshot().iter().map(|(_, m)| **m).collect();
+    let mut live: Vec<u64> = b.snapshot().iter().map(|(_, m)| *m).collect();
     live.sort_unstable();
     assert_eq!(
         live,
@@ -194,7 +194,7 @@ fn retiree_redaction_propagates_through_retire() {
     let version_of_1 = seed
         .snapshot()
         .iter()
-        .find_map(|(v, m)| (**m == 1).then_some(v.clone()))
+        .find_map(|(v, m)| (*m == 1).then_some(v.clone()))
         .expect("version recorded for 1");
 
     let a = bootstrap_fork(&seed);
@@ -207,7 +207,7 @@ fn retiree_redaction_propagates_through_retire() {
         matches!(outcome, Retire::Retired),
         "the reconciled peer absorbs the retiree, got {outcome:?}"
     );
-    let mut live: Vec<u64> = b.snapshot().iter().map(|(_, m)| **m).collect();
+    let mut live: Vec<u64> = b.snapshot().iter().map(|(_, m)| *m).collect();
     live.sort_unstable();
     assert_eq!(
         live,
@@ -288,7 +288,7 @@ fn retire_into_bootstrapper_hands_off_the_identity() {
     successor.send(99);
     wire_gossip(&successor, &seed);
     assert!(
-        seed.snapshot().iter().any(|(_, m)| **m == 99),
+        seed.snapshot().iter().any(|(_, m)| *m == 99),
         "the successor's origination survives gossip"
     );
 }
diff --git a/tests/session_stats.rs b/tests/session_stats.rs
index d7b7530cd..d9e0d721f 100644
--- a/tests/session_stats.rs
+++ b/tests/session_stats.rs
@@ -100,7 +100,7 @@ fn honored_redaction_counts_as_shed() {
         let version = a
             .snapshot()
             .iter()
-            .find(|(_, value)| ***value == 10)
+            .find(|(_, value)| **value == 10)
             .map(|(version, _)| version.clone())
             .expect("the sent message is live");
         a.redact(&version);
diff --git a/tests/single_peer.rs b/tests/single_peer.rs
index cee4af3a4..45220466d 100644
--- a/tests/single_peer.rs
+++ b/tests/single_peer.rs
@@ -138,7 +138,7 @@ proptest! {
             batch_send(&peer, values);
             let mut out = BTreeMap::new();
             for (_, v) in peer.snapshot().iter() {
-                *out.entry(**v).or_insert(0) += 1;
+                *out.entry(*v).or_insert(0) += 1;
             }
             out
         };
diff --git a/tests/stale_floor.rs b/tests/stale_floor.rs
index d896e8cc4..55e982bc6 100644
--- a/tests/stale_floor.rs
+++ b/tests/stale_floor.rs
@@ -49,8 +49,8 @@ fn message_minted_after_bootstrap_survives_gossip() {
         // forgotten" and evict the fresh message from both sides.
         wire_gossip_async(&f, &b).await;
 
-        let f_has = f.snapshot().iter().any(|(_, m)| **m == 100);
-        let b_has = b.snapshot().iter().any(|(_, m)| **m == 100);
+        let f_has = f.snapshot().iter().any(|(_, m)| *m == 100);
+        let b_has = b.snapshot().iter().any(|(_, m)| *m == 100);
         assert!(
             f_has && b_has,
             "message 100 must survive the sync: f_has={f_has} b_has={b_has}"

From b524e40613b516b6cf26cb6827a14041e3aae347 Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Wed, 19 Aug 2026 23:27:36 -0400
Subject: [PATCH 12/18] tree: erase the payload type from storage; seal the
 walk towers (part II stage 2)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The tree's layers drop their payload parameter: the untyped storage
node, the radix fan, the borrowing and owned walks, the typed height
veneer, the traversal trio, and the V1 zipper are all payload-free —
the stored Message was the parameter's only remaining occurrence.
Tree<T> stays as the phantom-typed facade whose faces downcast (stage
1's boundary), and tree::Root goes bare. The V1 protocol messages keep
T as decode context only (a phantom field); their node decode reworks
from a wire::Decode impl tower into the DecodeNode height trait
(read_node::<T>), the typed analog of the streaming codec's
parse_record::<T>.

Sealing, and the measured argument for it: dropping T alone moved
little. cargo llvm-lines counts the named target's crate, so a
binary's total IS its marginal cost, and it fell only 1,039,827 →
971,148 until the batch-apply entry went monomorphic (a Vec of
actions in, a &mut dyn FnMut observer): the generic entry had been
re-instantiating the entire per-height apply tower — radix grouping
included, ~155k lines — in every consumer crate. With act sealed the
way join's shape already was (both towers verify as present in the
lib's codegen and absent from the binary's):

  pairwise: 1,039,827 lines / 41,186 copies -> 719,899 / 30,285
            (-30.8% per consumer binary, from stage 1)
  lib:      32,262 / 1,691 -> ~102k / ~4.5k (paid once, in the rlib)

The residue is the streaming session, still generic over (B, T):
stage 3's scope, and where the erasure's cost/benefit verdict lands.
---
 design/item-erasure.md                        |  16 ++
 src/conformance/backend/tests.rs              |  34 ++---
 src/peer/gossip.rs                            |  21 +--
 src/peer/gossip/tests.rs                      |  23 ++-
 src/rumors/causal.rs                          |   6 +-
 src/rumors/unordered.rs                       |  10 +-
 src/tests.rs                                  |   8 +-
 src/tree.rs                                   |  52 ++++---
 src/tree/arb.rs                               |  66 ++++----
 src/tree/mirror/alternating/backend/local.rs  |  41 +++--
 .../alternating/backend/local/partition.rs    |  66 +++-----
 src/tree/mirror/alternating/backend/remote.rs |  10 +-
 src/tree/mirror/alternating/message.rs        |  67 +++++---
 src/tree/mirror/alternating/message/tests.rs  |  38 +++--
 src/tree/mirror/alternating/tests.rs          |  39 ++---
 src/tree/mirror/alternating/wire_snapshot.rs  |  45 +++---
 src/tree/mirror/streaming/backend.rs          |   3 +-
 src/tree/mirror/streaming/backend/local.rs    |  23 ++-
 .../mirror/streaming/backend/local/tests.rs   |  14 +-
 src/tree/mirror/streaming/convert/tests.rs    |  28 ++--
 .../mirror/streaming/materialized/tests.rs    |   2 +-
 .../streaming/materialized/unknown/tests.rs   |   9 +-
 .../streaming/materialized/work/tests.rs      |  20 ++-
 .../materialized/work/tests/violations.rs     |   6 +-
 .../remote/adapter/tests/backend_errors.rs    |   8 +-
 .../remote/adapter/tests/malformed.rs         |  24 +--
 .../streaming/remote/adapter/tests/opening.rs |   8 +-
 .../streaming/remote/adapter/tests/parking.rs |   7 +-
 .../remote/adapter/tests/properties.rs        |  21 +--
 .../streaming/remote/adapter/tests/runs.rs    |  16 +-
 .../mirror/streaming/remote/proxy/tests.rs    |  75 ++++-----
 .../remote/proxy/tests/containment.rs         |  13 +-
 .../remote/proxy/tests/declarations.rs        |  28 ++--
 .../streaming/remote/proxy/tests/failures.rs  |   6 +-
 .../streaming/remote/proxy/tests/greeting.rs  |  48 +++---
 .../streaming/remote/proxy/tests/harness.rs   |  43 +++---
 .../streaming/remote/proxy/tests/malformed.rs |   6 +-
 .../streaming/remote/proxy/tests/transport.rs |   4 +-
 src/tree/mirror/streaming/testing/faulting.rs |   8 +-
 src/tree/mirror/streaming/tests.rs            |  38 +++--
 src/tree/mirror/streaming/tests/announced.rs  |   2 +-
 src/tree/mirror/streaming/tests/capacity.rs   |   8 +-
 src/tree/mirror/streaming/tests/faults.rs     |   4 +-
 src/tree/mirror/streaming/tests/fixtures.rs   |  40 +++--
 src/tree/mirror/streaming/tests/local_eq.rs   |  18 +--
 src/tree/mirror/streaming/tests/skeleton.rs   |   4 +-
 src/tree/mirror/streaming/tests/stats.rs      |  18 +--
 src/tree/mirror/streaming/tests/wedge.rs      |   4 +-
 src/tree/mirror/streaming/window.rs           |   8 +-
 src/tree/tests.rs                             |  38 ++---
 src/tree/traverse/act.rs                      |  58 +++----
 src/tree/traverse/join.rs                     |  43 ++----
 src/tree/traverse/join/tests.rs               |  10 +-
 src/tree/traverse/unknown.rs                  |  14 +-
 src/tree/traverse/unknown/tests.rs            |  18 +--
 src/tree/typed.rs                             |   2 +-
 src/tree/typed/levels.rs                      |  67 +++-----
 src/tree/typed/levels/level.rs                |  32 ++--
 src/tree/typed/levels/tests.rs                |  13 +-
 src/tree/typed/node.rs                        | 143 ++++++++++--------
 src/tree/typed/untyped.rs                     |  51 +++----
 src/tree/typed/untyped/fan.rs                 |  69 +++++----
 src/tree/typed/untyped/fan/tests.rs           |  22 +--
 src/tree/typed/untyped/iter.rs                |  79 +++++-----
 src/tree/typed/untyped/tests.rs               |  44 +++---
 src/tree/wire.rs                              |  23 ++-
 66 files changed, 879 insertions(+), 953 deletions(-)

diff --git a/design/item-erasure.md b/design/item-erasure.md
index 90b4a2370..646072b77 100644
--- a/design/item-erasure.md
+++ b/design/item-erasure.md
@@ -179,6 +179,22 @@ security-relevant: payload validation stays exactly where it is
    walks yield erased leaves; `Rumors`/`Snapshot`/observer facades
    downcast at the door. The V1 oracle and the wire codecs sweep along.
    Measure.
+   *Measured*: `pairwise` at 719,899 lines / 30,285 copies, from
+   1,039,827 / 41,186 — −30.8% per consumer binary — after two moves:
+   the tree layers going non-generic (the `join`/`unknown` towers then
+   codegen once in the rlib: present in the lib's own measurement,
+   absent from the binary's), and the batch-apply entry going
+   *monomorphic* (`Vec` in, `&mut dyn FnMut` observer), because a
+   generic entry re-instantiated the whole per-height apply tower —
+   radix grouping included, ~155k lines — in every consumer despite
+   the payload erasure. The lib's own codegen grows 32,262 → ~102k:
+   the once-paid residence of what consumers stopped re-buying.
+   Measurement lens, corrected en route: `cargo llvm-lines` counts
+   only the named target's crate, so the per-binary number IS the
+   marginal cost, and substring attribution overcounts (session
+   workers' signatures mention tree type names). The residue is the
+   streaming session, still generic over `(B, T)` — stage 3's scope,
+   and where the trade's verdict lands.
 3. **The erased session**: `Backend<T>` drops `T`; the codec's record
    decode keeps the wire bytes and builds payloads through the witness;
    sessions receive the witness from the peer. Measure.
diff --git a/src/conformance/backend/tests.rs b/src/conformance/backend/tests.rs
index 3c4688bf8..3fbe9c975 100644
--- a/src/conformance/backend/tests.rs
+++ b/src/conformance/backend/tests.rs
@@ -206,7 +206,7 @@ impl<N> MaterializedNode<N> {
     }
 }
 
-impl<T, H> Node<T> for MaterializedNode<typed::Node<T, H>>
+impl<T, H> Node<T> for MaterializedNode<typed::Node<H>>
 where
     T: Send + Sync + 'static,
     H: Height,
@@ -242,7 +242,7 @@ where
     }
 }
 
-impl<T> Leaf<T> for MaterializedNode<typed::Node<T, Z>>
+impl<T> Leaf<T> for MaterializedNode<typed::Node<Z>>
 where
     T: Send + Sync + 'static,
 {
@@ -262,7 +262,7 @@ where
 }
 
 /// The two encoded bounds of a freshly built node, in bytes.
-fn bounds_of<T: Send + Sync + 'static, H: Height>(node: &typed::Node<T, H>) -> usize {
+fn bounds_of<H: Height>(node: &typed::Node<H>) -> usize {
     node.ceiling().as_bytes().len() + node.floor().as_bytes().len()
 }
 
@@ -286,8 +286,8 @@ impl<T> Backend<T> for Materializing
 where
     T: Send + Sync + 'static,
 {
-    type Node<H: Height> = MaterializedNode<typed::Node<T, H>>;
-    type Erased = MaterializedNode<typed::untyped::Node<T>>;
+    type Node<H: Height> = MaterializedNode<typed::Node<H>>;
+    type Erased = MaterializedNode<typed::untyped::Node>;
     type Error = Infallible;
 
     // Erasure re-tags the store's handle; the resident row rides along
@@ -310,7 +310,7 @@ where
     }
 
     fn node_bytes(children: usize, version_bound: usize) -> usize {
-        let priced = std::mem::size_of::<MaterializedNode<typed::Node<T, Z>>>()
+        let priced = std::mem::size_of::<MaterializedNode<typed::Node<Z>>>()
             + PRICED_HEADER.get()
             + ROW_ENTRY * children
             + version_bound;
@@ -337,7 +337,7 @@ where
             .into_iter()
             .map(|(radix, child)| (radix, child.map(|child| child.inner)))
             .collect();
-        let parent = Local.parent(prefix, children).await?;
+        let parent = <Local as Backend<T>>::parent(Local, prefix, children).await?;
         Ok(parent.map(|node| {
             let row = ROW_HEADER + ROW_ENTRY * fan + bounds_of(&node);
             MaterializedNode::wrap(node, row)
@@ -354,7 +354,7 @@ where
         S<H>: Height,
     {
         stream! {
-            let mut children = pin!(Local.children(prefix, parent.inner));
+            let mut children = pin!(<Local as Backend<T>>::children(Local, prefix, parent.inner));
             while let Some(child) = children.next().await {
                 yield child.map(|(prefix, node)| {
                     // A lazily loaded row: header and bounds, its child
@@ -375,7 +375,7 @@ where
         // that drop leaves ([`WALK_SKIPS`]) and inflate the yielded rows
         // ([`WALK_SLACK`]) — honest at rest, the negative controls'
         // subject when set.
-        H::explode(
+        H::explode::<Self, T>(
             self,
             Box::pin(futures_stream::once(async move { Ok((prefix, node)) })),
         )
@@ -539,7 +539,7 @@ fn dipping_node_bytes_fails_the_monotonicity_sweep() {
 fn leaf_underpricing_fails_at_construction() {
     let _dishonest = PRICED_HEADER.set(0);
     let leaf = pollster::block_on(
-        <super::ChargedNode<MaterializedNode<typed::Node<u64, Z>>> as Leaf<u64>>::leaf(
+        <super::ChargedNode<MaterializedNode<typed::Node<Z>>> as Leaf<u64>>::leaf(
             Version::new(),
             Message::new(7),
         ),
@@ -566,14 +566,12 @@ fn ledger_settles_over_clone_and_drop() {
         ledger::reset_peak();
         ledger::peak()
     };
-    let leaf = pollster::block_on(
-        <super::ChargedNode<typed::Node<u64, Z>> as Leaf<u64>>::leaf(
-            Version::new(),
-            Message::new(7),
-        ),
-    )
+    let leaf = pollster::block_on(<super::ChargedNode<typed::Node<Z>> as Leaf<u64>>::leaf(
+        Version::new(),
+        Message::new(7),
+    ))
     .expect("a local leaf constructs infallibly");
-    let handle = std::mem::size_of::<typed::Node<u64, Z>>();
+    let handle = std::mem::size_of::<typed::Node<Z>>();
     let clone = leaf.clone();
     assert_eq!(
         ledger::peak(),
@@ -583,7 +581,7 @@ fn ledger_settles_over_clone_and_drop() {
     drop(leaf);
     drop(clone);
 
-    let node: typed::Node<i32, crate::tree::typed::height::Z> =
+    let node: typed::Node<crate::tree::typed::height::Z> =
         typed::Node::leaf(Version::new(), Message::new(7));
     let charged = Charged::<Local>::new(Local);
     let _ = &charged;
diff --git a/src/peer/gossip.rs b/src/peer/gossip.rs
index 6ec7c3c98..e20f57af2 100644
--- a/src/peer/gossip.rs
+++ b/src/peer/gossip.rs
@@ -269,7 +269,7 @@ impl<T> Peer<T, NoBookmark> {
             #[allow(clippy::type_complexity)]
             let reconcile: BoxFuture<
                 '_,
-                Result<Option<(tree::Root<T>, DynRead<'a>, DynWrite<'a>)>, Error>,
+                Result<Option<(tree::Root, DynRead<'a>, DynWrite<'a>)>, Error>,
             > = match config.protocol {
                 Protocol::V2 => Box::pin(async move {
                     let local_root: streaming::Root<Local, T> = tree::Root::default().into();
@@ -312,7 +312,7 @@ impl<T> Peer<T, NoBookmark> {
                 #[cfg(any(test, feature = "protocol-v1"))]
                 Protocol::V1 => Box::pin(async move {
                     let local = alternating_local::Exchange::start(tree::Root::default());
-                    let proxy = alternating_remote::Exchange::start(
+                    let proxy = alternating_remote::Exchange::<T, _, _, _, _>::start(
                         FrameRead::new(read),
                         FrameWrite::new(write),
                     );
@@ -351,7 +351,7 @@ impl<T> Peer<T, NoBookmark> {
                 run_budget: config.run_budget,
                 inner: watch::Sender::new(Inner {
                     party: Some(party),
-                    tree: Tree { root },
+                    tree: Tree::from_root(root),
                 }),
                 bookmark: Arc::new(Mutex::new(Bookmarked::new(NoBookmark))),
             };
@@ -741,13 +741,14 @@ impl<T, B: Persist> Peer<T, B> {
         #[allow(clippy::type_complexity)]
         let reconcile: BoxFuture<
             '_,
-            Result<(tree::Root<T>, DynRead<'a>, DynWrite<'a>), Error>,
+            Result<(tree::Root, DynRead<'a>, DynWrite<'a>), Error>,
         > = match self.protocol {
             Protocol::V2 => Box::pin(async move {
-                let local = materialized::Handshaking::start(Local, prior_tree.root.into())
-                    .window(window)
-                    .target_message_size(run_budget.bytes() as u64)
-                    .stats(session_stats.clone());
+                let local =
+                    materialized::Handshaking::<_, T, _>::start(Local, prior_tree.root.into())
+                        .window(window)
+                        .target_message_size(run_budget.bytes() as u64)
+                        .stats(session_stats.clone());
                 let carrier = Link::for_session(read, write, connector, acceptor, epoch);
                 let proxy = streaming_remote::Handshaking::start(Local, carrier)
                     .window(window)
@@ -771,7 +772,7 @@ impl<T, B: Persist> Peer<T, B> {
             #[cfg(any(test, feature = "protocol-v1"))]
             Protocol::V1 => Box::pin(async move {
                 let local = alternating_local::Exchange::start(prior_tree.root);
-                let proxy = alternating_remote::Exchange::start(
+                let proxy = alternating_remote::Exchange::<T, _, _, _, _>::start(
                     FrameRead::new(read),
                     FrameWrite::new(write),
                 );
@@ -861,7 +862,7 @@ impl<T, B: Persist> Peer<T, B> {
         // The reconciled tree's frontier is the converged version: what both
         // replicas hold the instant this commits, *before* the join below
         // mixes in any commits that ran concurrently with the session.
-        let merged = Tree { root };
+        let merged = Tree::from_root(root);
         let converged = merged.latest().clone();
         let mut party_overlap = false;
         self.inner.send_if_modified(|inner| {
diff --git a/src/peer/gossip/tests.rs b/src/peer/gossip/tests.rs
index 9d9b6dc08..95814157c 100644
--- a/src/peer/gossip/tests.rs
+++ b/src/peer/gossip/tests.rs
@@ -143,7 +143,7 @@ fn bytes_after_the_marker_stay_untouched() {
 /// the ceiling and leaves no tombstone, so committing and then redacting
 /// `events` messages leaves an empty root carrying a genuine `events`-tick
 /// version.
-fn redacted_history_root(events: u64) -> tree::Root<u64> {
+fn redacted_history_root(events: u64) -> tree::Root {
     let donor = Peer::<u64>::seed();
     {
         let mut batch = donor.batch();
@@ -180,7 +180,7 @@ fn redacted_history_root(events: u64) -> tree::Root<u64> {
 /// tree if the counterparty serves the session to completion.
 async fn claim_bootstrap_v2(
     link: &mut MemoryLink,
-    root: tree::Root<u64>,
+    root: tree::Root,
 ) -> Result<(Party, Tree<u64>), Error> {
     let (read, write, connector, acceptor, epoch) = erase(link)?;
     let mut staged = handshake::Staged::new();
@@ -205,7 +205,7 @@ async fn claim_bootstrap_v2(
     let (root, (mut read, mut write)) = descent.await.map_err(streaming_error)?;
     let party = party::receive(&mut read).await?;
     epilogue(&mut read, &mut write).await?;
-    Ok((party, Tree { root: root.into() }))
+    Ok((party, Tree::from_root(root.into())))
 }
 
 /// Drive one V1 session as a bootstrap claimant whose greeting version comes
@@ -215,7 +215,7 @@ async fn claim_bootstrap_v2(
 /// no epilogue.
 async fn claim_bootstrap_v1(
     link: &mut MemoryLink,
-    root: tree::Root<u64>,
+    root: tree::Root,
 ) -> Result<(Party, Tree<u64>), Error> {
     let (read, write, _connector, _acceptor, _epoch) = erase(link)?;
     let mut staged = handshake::Staged::new();
@@ -230,7 +230,10 @@ async fn claim_bootstrap_v1(
     .await
     .map_err(Error::from)?;
     let local = alternating_local::Exchange::start(root);
-    let proxy = alternating_remote::Exchange::start(FrameRead::new(read), FrameWrite::new(write));
+    let proxy = alternating_remote::Exchange::<u64, _, _, _, _>::start(
+        FrameRead::new(read),
+        FrameWrite::new(write),
+    );
     let handshaken = alternating::handshake(local, proxy)
         .await
         .map_err(alternating_error)?;
@@ -238,7 +241,7 @@ async fn claim_bootstrap_v1(
     let (root, (read, _write)) = descent.await.map_err(alternating_error)?;
     let mut read = read.into_inner();
     let party = party::receive(&mut read).await?;
-    Ok((party, Tree { root }))
+    Ok((party, Tree::from_root(root)))
 }
 
 /// A provider holding `values`, plus its pre-session root hash.
@@ -282,9 +285,7 @@ fn v2_bootstrap_claimant_declaring_history_is_rejected() {
     let provider = provider_with(&[1, 2, 3]);
     let hash_before = provider.snapshot().hash();
     let party_before = party_of(&provider);
-    let claimant_tree = Tree {
-        root: redacted_history_root(8),
-    };
+    let claimant_tree = Tree::<()>::from_root(redacted_history_root(8));
     let claimed_min_events = claimant_tree.latest().min_ticks();
     assert!(
         provider.snapshot().latest() < claimant_tree.latest(),
@@ -347,9 +348,7 @@ fn v1_bootstrap_claimant_declaring_history_is_rejected() {
     let provider = provider_with(&[1, 2, 3]).protocol(Protocol::V1);
     let hash_before = provider.snapshot().hash();
     let party_before = party_of(&provider);
-    let claimant_tree = Tree {
-        root: redacted_history_root(8),
-    };
+    let claimant_tree = Tree::<()>::from_root(redacted_history_root(8));
     let claimed_min_events = claimant_tree.latest().min_ticks();
 
     let provider_ref = &provider;
diff --git a/src/rumors/causal.rs b/src/rumors/causal.rs
index a7bfbbf49..bc2942947 100644
--- a/src/rumors/causal.rs
+++ b/src/rumors/causal.rs
@@ -60,7 +60,7 @@ pub struct CausalMessages<T> {
     /// deterministic. Always the residue of a *single* ingest (a new pass
     /// opens only once this empties), whose range start was `checkpoint`
     /// and whose ceiling is `ingested`.
-    staged: BTreeMap<(Rank, Vec<u8>), Leaf<T>>,
+    staged: BTreeMap<(Rank, Vec<u8>), Leaf>,
 }
 
 impl<T> CausalMessages<T> {
@@ -83,7 +83,7 @@ impl<T> CausalMessages<T> {
     /// complete. The watch read guard lives only long enough to freeze the
     /// walk and capture the ceiling; the walk itself runs unlocked.
     fn ingest(
-        staged: &mut BTreeMap<(Rank, Vec<u8>), Leaf<T>>,
+        staged: &mut BTreeMap<(Rank, Vec<u8>), Leaf>,
         ingested: &mut Version,
         rx: &mut watch::Receiver<crate::Inner<T>>,
     ) where
@@ -160,7 +160,7 @@ impl<T: Send + Sync + 'static> Stream for CausalMessages<T> {
             // ingest, exactly as UnorderedMessages defers a drained pass's
             // ceiling.
             if let Some((_, leaf)) = this.staged.pop_first() {
-                return Poll::Ready(Some((leaf.version().clone(), leaf.value())));
+                return Poll::Ready(Some((leaf.version().clone(), leaf.value::<T>())));
             }
             match this.channel.as_mut().expect("channel state present") {
                 Channel::Waiting(wait) => match wait.as_mut().poll(cx) {
diff --git a/src/rumors/unordered.rs b/src/rumors/unordered.rs
index ef5267ff3..9cab13eb3 100644
--- a/src/rumors/unordered.rs
+++ b/src/rumors/unordered.rs
@@ -39,7 +39,7 @@ pub struct UnorderedMessages<T> {
     /// wakeup), so the wait is materialized.
     channel: Option<Channel<T>>,
     checkpoint: Version,
-    pass: Option<Pass<T>>,
+    pass: Option<Pass>,
 }
 
 /// The outcome of [`UnorderedMessages::try_next`] or [`CausalMessages::try_next`].
@@ -75,8 +75,8 @@ pub(super) enum Channel<T> {
 
 /// One in-progress pass: the frozen walk over its snapshot, and the
 /// snapshot's ceiling to absorb into the checkpoint when the walk drains.
-struct Pass<T> {
-    walk: RangeOwned<T, causally::Down>,
+struct Pass {
+    walk: RangeOwned<causally::Down>,
     ceiling: Version,
 }
 
@@ -93,7 +93,7 @@ impl<T> UnorderedMessages<T> {
     /// watch read guard lives only long enough to freeze the walk (a root
     /// handle clone) and capture the ceiling.
     fn open_pass(
-        pass: &mut Option<Pass<T>>,
+        pass: &mut Option<Pass>,
         rx: &mut watch::Receiver<crate::Inner<T>>,
         checkpoint: &Version,
     ) where
@@ -209,7 +209,7 @@ impl<T: Send + Sync + 'static> Stream for UnorderedMessages<T> {
 
                     let pass = this.pass.as_mut().expect("opened above");
                     if let Some((_, leaf)) = pass.walk.next() {
-                        return Poll::Ready(Some((leaf.version().clone(), leaf.value())));
+                        return Poll::Ready(Some((leaf.version().clone(), leaf.value::<T>())));
                     }
 
                     // The pass drained: absorb its ceiling, then enter the
diff --git a/src/tests.rs b/src/tests.rs
index 1ba9f5ac2..1b622354a 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -101,9 +101,7 @@ fn overlapping_retiree_party_is_rejected() {
         run_budget: survivor.run_budget,
         inner: watch::Sender::new(Inner {
             party: Some(party_of(&survivor)),
-            tree: Tree {
-                root: Root::default(),
-            },
+            tree: Tree::from_root(Root::default()),
         }),
         bookmark: Arc::new(Mutex::new(Bookmarked::new(NoBookmark))),
     };
@@ -268,7 +266,7 @@ fn greeting_frame_len(retiree: &Peer<u64>) -> usize {
     use crate::tree::mirror::streaming::{self, Local, materialized};
 
     let root: streaming::Root<Local, u64> = retiree.inner.borrow().tree.clone().root.into();
-    let fan = pollster::block_on(materialized::greeting_fan(&Local, root.root))
+    let fan = pollster::block_on(materialized::greeting_fan::<_, u64>(&Local, root.root))
         .unwrap_or_else(|never| match never {});
     // The listing frame is raw radix-hash records: one byte plus a Merkle
     // hash per child, the frame length carrying the count.
@@ -564,7 +562,7 @@ fn uncontained_supply_fails_gossip_and_poisons_the_link() {
     let (escaped_root, _, escaped) =
         crate::tree::arb::poisoned_root(&party_of(&poisoned), &base, Message::new(0u64));
     poisoned.inner.send_modify(|inner| {
-        inner.tree.join(Tree { root: escaped_root });
+        inner.tree.join(Tree::from_root(escaped_root));
     });
     assert!(
         !crate::tree::mirror::contained(&escaped, poisoned.inner.borrow().tree.latest()),
diff --git a/src/tree.rs b/src/tree.rs
index 70490b0b2..64f044e80 100644
--- a/src/tree.rs
+++ b/src/tree.rs
@@ -60,6 +60,7 @@
 //! filter — so every convergence property can be tested in-memory and
 //! trusted on the wire.
 
+use std::marker::PhantomData;
 use std::sync::Arc;
 
 pub(crate) mod traverse;
@@ -92,7 +93,13 @@ pub use typed::{Leaf, RangeOwned};
 /// which conforming peers cannot do.
 #[derive(Debug, Eq)]
 pub struct Tree<T> {
-    pub(crate) root: Root<T>,
+    pub(crate) root: Root,
+    /// The payload type this tree's typed faces read leaves at.
+    ///
+    /// Storage is erased ([`Message`] holds `dyn Any`); the facade's `T`
+    /// names the type its faces downcast to (as `fn() -> T`, so
+    /// auto-traits never descend into `T`).
+    payload: PhantomData<fn() -> T>,
 }
 
 /// A tree's root pair: the node structure (absent when empty) and the
@@ -101,31 +108,22 @@ pub struct Tree<T> {
 /// The ceiling outlives the nodes — it advances on effectual redactions and
 /// survives a tree emptying out — which is exactly what deletion honoring
 /// compares against.
-#[derive(Debug, Eq)]
-pub struct Root<T> {
+#[derive(Clone, Debug, Eq)]
+pub struct Root {
     ceiling: Version,
-    root: Option<typed::node::Root<T>>,
+    root: Option<typed::node::Root>,
 }
 
-impl<T> From<Root<T>> for Option<typed::node::Root<T>> {
-    fn from(value: Root<T>) -> Self {
+impl From<Root> for Option<typed::node::Root> {
+    fn from(value: Root) -> Self {
         value.root
     }
 }
 
-impl<T> Clone for Root<T> {
-    fn clone(&self) -> Self {
-        Self {
-            ceiling: self.ceiling.clone(),
-            root: self.root.clone(),
-        }
-    }
-}
-
 /// The empty root: the empty [`Version`] over no nodes. The state a mirror
 /// exchange starts from when the local side holds nothing yet: a
 /// bootstrapping peer mirrors the provider's tree into it.
-impl<T> Default for Root<T> {
+impl Default for Root {
     fn default() -> Self {
         Root {
             ceiling: Version::new(),
@@ -134,7 +132,7 @@ impl<T> Default for Root<T> {
     }
 }
 
-impl<T> PartialEq for Root<T> {
+impl PartialEq for Root {
     fn eq(&self, other: &Self) -> bool {
         self.ceiling == other.ceiling && self.root == other.root
     }
@@ -144,6 +142,7 @@ impl<T> Clone for Tree<T> {
     fn clone(&self) -> Self {
         Self {
             root: self.root.clone(),
+            payload: PhantomData,
         }
     }
 }
@@ -178,7 +177,7 @@ pub enum Action {
 ///
 /// An [`ExactSizeIterator`] (the live-message count is known up front) and a
 /// [`DoubleEndedIterator`].
-pub struct Iter<'a, T>(typed::Iter<'a, T>);
+pub struct Iter<'a, T>(typed::Iter<'a>, PhantomData<fn() -> T>);
 
 impl<'a, T: Send + Sync + 'static> Iterator for Iter<'a, T> {
     type Item = (&'a Version, Arc<T>);
@@ -209,11 +208,15 @@ impl<T> Tree<T> {
     /// plain [`clone`](Clone); any party split happens on the owning
     /// [`Peer`](crate::Peer).
     pub fn new() -> Self {
+        Self::from_root(Root::default())
+    }
+
+    /// Wrap an already-built root pair as a typed tree facade: the caller
+    /// asserts the payload type its leaves were constructed with.
+    pub(crate) fn from_root(root: Root) -> Self {
         Tree {
-            root: Root {
-                ceiling: Version::new(),
-                root: None,
-            },
+            root,
+            payload: PhantomData,
         }
     }
 
@@ -325,6 +328,7 @@ impl<T> Tree<T> {
                 .as_ref()
                 .map(typed::node::Root::iter)
                 .unwrap_or_else(typed::Iter::empty),
+            PhantomData,
         )
     }
 
@@ -339,7 +343,7 @@ impl<T> Tree<T> {
     pub fn range_owned<'q, P: causally::Polarity>(
         &self,
         query: impl Into<causally::Query<'q, P>>,
-    ) -> RangeOwned<T, P> {
+    ) -> RangeOwned<P> {
         typed::node::Root::range_owned(self.root.root.as_ref(), query.into().into_owned())
     }
 
@@ -521,7 +525,7 @@ impl<T> Tree<T> {
         // internal unwind via the injected fuse.
         let mut changed = false;
         let mut new_ceiling = self.root.ceiling.clone();
-        let new_root = traverse::act(self.root.root.clone(), actions, |v: &Version| {
+        let new_root = traverse::act(self.root.root.clone(), actions, &mut |v: &Version| {
             new_ceiling |= v;
             changed = true;
         });
diff --git a/src/tree/arb.rs b/src/tree/arb.rs
index 1ff979a1a..ac27d5a2d 100644
--- a/src/tree/arb.rs
+++ b/src/tree/arb.rs
@@ -59,7 +59,7 @@ pub fn arb_version() -> BoxedStrategy<Version> {
 pub fn arb_root_node(
     party: usize,
     leaves: impl Into<proptest::collection::SizeRange>,
-) -> BoxedStrategy<Option<Node<(), Root>>> {
+) -> BoxedStrategy<Option<Node<Root>>> {
     vec(any::<()>(), leaves)
         .prop_map(move |draws| {
             // Tick this tree's party once per leaf, so the leaves carry a
@@ -79,7 +79,7 @@ pub fn arb_root_node(
                     (path, version.clone(), Action::Insert(message))
                 })
                 .collect();
-            act(None, actions, |_| ())
+            act(None, actions, &mut |_| ())
         })
         .boxed()
 }
@@ -92,7 +92,7 @@ pub fn arb_root_node(
 pub fn arb_tree_root(
     party: usize,
     leaves: impl Into<proptest::collection::SizeRange>,
-) -> BoxedStrategy<crate::tree::Root<()>> {
+) -> BoxedStrategy<crate::tree::Root> {
     (arb_root_node(party, leaves), 0u64..8)
         .prop_map(move |(node, extra_ticks)| {
             // The wrapper version must be a causal upper bound on every version
@@ -129,7 +129,7 @@ pub fn arb_tree_root(
 /// while the other still holds them (which the merge must drop by version
 /// dominance, the entire deletion mechanism). With zero shared inserts the two
 /// sides are fully disjoint, so this one generator also covers that case.
-pub fn arb_divergent_pair() -> BoxedStrategy<(crate::tree::Root<()>, crate::tree::Root<()>)> {
+pub fn arb_divergent_pair() -> BoxedStrategy<(crate::tree::Root, crate::tree::Root)> {
     use crate::tree::{Action, Tree};
 
     (
@@ -147,7 +147,7 @@ pub fn arb_divergent_pair() -> BoxedStrategy<(crate::tree::Root<()>, crate::tree
             // Common base; at this point the tree holds exactly the shared
             // inserts, so its live keys are the shared keys each side may
             // redact.
-            let mut base = Tree::new();
+            let mut base = Tree::<()>::new();
             base.act(
                 &p_s,
                 (0..n_shared).map(|_| Action::Insert(Message::new(()))),
@@ -190,7 +190,7 @@ pub fn arb_divergent_pair() -> BoxedStrategy<(crate::tree::Root<()>, crate::tree
 /// is instead the deterministic [`early_first_child_dispute_pair`] fixture,
 /// which performs that search once; this strategy provides breadth around
 /// it.
-pub fn arb_wide_divergent_pair() -> BoxedStrategy<(crate::tree::Root<()>, crate::tree::Root<()>)> {
+pub fn arb_wide_divergent_pair() -> BoxedStrategy<(crate::tree::Root, crate::tree::Root)> {
     use crate::tree::{Action, Tree};
 
     (
@@ -205,7 +205,7 @@ pub fn arb_wide_divergent_pair() -> BoxedStrategy<(crate::tree::Root<()>, crate:
             let p_a = nth_party(1);
             let p_b = nth_party(2);
 
-            let mut base = Tree::new();
+            let mut base = Tree::<()>::new();
             base.act(
                 &p_s,
                 (0..n_shared).map(|_| Action::Insert(Message::new(()))),
@@ -241,7 +241,7 @@ pub fn arb_wide_divergent_pair() -> BoxedStrategy<(crate::tree::Root<()>, crate:
 /// widths draw zero too, so subset, identical, and ceiling-only merges —
 /// a changed flag's `false` arm — are sampled at depth alongside the
 /// gains.
-pub fn arb_deep_divergent_pair() -> BoxedStrategy<(crate::tree::Root<()>, crate::tree::Root<()>)> {
+pub fn arb_deep_divergent_pair() -> BoxedStrategy<(crate::tree::Root, crate::tree::Root)> {
     (0usize..32, 0u8..5, 0u8..5)
         .prop_map(|(depth, a_width, b_width)| {
             let path_at = |branch: u8| {
@@ -259,7 +259,7 @@ pub fn arb_deep_divergent_pair() -> BoxedStrategy<(crate::tree::Root<()>, crate:
                     shared_version.clone(),
                     Action::Insert(Message::new(())),
                 )],
-                |_| (),
+                &mut |_| (),
             );
 
             // One side: `width` sibling leaves diverging at `depth`, all on
@@ -280,7 +280,7 @@ pub fn arb_deep_divergent_pair() -> BoxedStrategy<(crate::tree::Root<()>, crate:
                 let node = if leaves.is_empty() {
                     base.clone()
                 } else {
-                    act(base.clone(), leaves, |_| ())
+                    act(base.clone(), leaves, &mut |_| ())
                 };
                 root_with_ceiling(node, shared_version.clone() | version)
             };
@@ -303,7 +303,7 @@ pub fn arb_deep_divergent_pair() -> BoxedStrategy<(crate::tree::Root<()>, crate:
 /// counts vary per attempt, each attempt's honestly-built pair is checked
 /// against the geometry, and the first satisfying pair wins. Hashing is
 /// deterministic, so the search — and therefore the fixture — is too.
-pub fn early_first_child_dispute_pair() -> (crate::tree::Root<()>, crate::tree::Root<()>) {
+pub fn early_first_child_dispute_pair() -> (crate::tree::Root, crate::tree::Root) {
     use crate::tree::{Action, Tree};
 
     /// Leaves per side: enough on the left for wide roots with collisions,
@@ -385,7 +385,7 @@ pub fn early_first_child_dispute_pair() -> (crate::tree::Root<()>, crate::tree::
         };
         if left_under.min(right_under) >= 1 && left_under.max(right_under) >= 2 && provisions >= 6 {
             let build = |party: &Party, base: Version, live: usize| {
-                let mut tree = Tree::new();
+                let mut tree = Tree::<()>::new();
                 tree.root.ceiling = base;
                 tree.act(party, (0..live).map(|_| Action::Insert(Message::new(()))));
                 tree
@@ -424,7 +424,7 @@ pub fn early_first_child_dispute_pair() -> (crate::tree::Root<()>, crate::tree::
 /// receiver adopts, or the receiver's own later redact ticks — ever
 /// contains it. Returns the two roots plus the escaped leaf's
 /// version-derived path and its version.
-pub fn uncontained_supply_pair() -> (crate::tree::Root<()>, crate::tree::Root<()>, Path, Version) {
+pub fn uncontained_supply_pair() -> (crate::tree::Root, crate::tree::Root, Path, Version) {
     /// How far the escaped version outruns both declared ceilings, per
     /// party: an upper bound on the honest ticks a test performs after
     /// the pair is built.
@@ -470,7 +470,7 @@ pub fn uncontained_supply_pair() -> (crate::tree::Root<()>, crate::tree::Root<()
                 receiver_version.clone(),
                 Action::Insert(receiver_message),
             )],
-            |_| (),
+            &mut |_| (),
         ),
         receiver_version.clone(),
     );
@@ -493,7 +493,7 @@ pub fn uncontained_supply_pair() -> (crate::tree::Root<()>, crate::tree::Root<()
         act(
             None,
             vec![(path, escaped.clone(), Action::Insert(message))],
-            |_| (),
+            &mut |_| (),
         ),
         declared,
     );
@@ -514,7 +514,7 @@ fn leaf_sibling_path(last: u8) -> Path {
 
 /// Wrap an optional root node in a [`tree::Root`](crate::tree::Root) with the
 /// given ceiling.
-fn root_with_ceiling<T>(node: Option<Node<T, Root>>, ceiling: Version) -> crate::tree::Root<T> {
+fn root_with_ceiling(node: Option<Node<Root>>, ceiling: Version) -> crate::tree::Root {
     crate::tree::Root {
         ceiling,
         root: node,
@@ -531,11 +531,11 @@ fn root_with_ceiling<T>(node: Option<Node<T, Root>>, ceiling: Version) -> crate:
 /// honest ticks a test may perform afterward without containing the
 /// escape. Returns the root plus the escaped leaf's version-derived path
 /// and its version.
-pub fn poisoned_root<T: Send + Sync>(
+pub fn poisoned_root(
     party: &Party,
     base: &Version,
     message: Message,
-) -> (crate::tree::Root<T>, Path, Version) {
+) -> (crate::tree::Root, Path, Version) {
     /// How far the escaped version outruns `base`: an upper bound on the
     /// honest ticks a test performs after the root is planted.
     const ESCAPE_MARGIN: usize = 64;
@@ -549,7 +549,7 @@ pub fn poisoned_root<T: Send + Sync>(
         act(
             None,
             vec![(path, escaped.clone(), Action::Insert(message))],
-            |_| (),
+            &mut |_| (),
         ),
         Version::new(),
     );
@@ -564,11 +564,7 @@ pub fn poisoned_root<T: Send + Sync>(
 /// down to `S<Z>` holds exactly one child on each side and disputes at every
 /// height: the difference survives to the closing rounds, where each side
 /// must provide its own extra and absorb the other's.
-pub fn leaf_parent_dispute_pair() -> (
-    crate::tree::Root<()>,
-    crate::tree::Root<()>,
-    crate::tree::Root<()>,
-) {
+pub fn leaf_parent_dispute_pair() -> (crate::tree::Root, crate::tree::Root, crate::tree::Root) {
     // The shared leaf: one tick on party 0, literally the same node in both
     // trees (each side is built on top of `base`).
     let mut shared_version = Version::new();
@@ -580,7 +576,7 @@ pub fn leaf_parent_dispute_pair() -> (
             shared_version.clone(),
             Action::Insert(Message::new(())),
         )],
-        |_| (),
+        &mut |_| (),
     );
 
     // Each side's extra rides its own disjoint party, so both extras are
@@ -594,7 +590,7 @@ pub fn leaf_parent_dispute_pair() -> (
             a_version.clone(),
             Action::Insert(Message::new(())),
         )],
-        |_| (),
+        &mut |_| (),
     );
 
     let mut b_version = Version::new();
@@ -604,9 +600,9 @@ pub fn leaf_parent_dispute_pair() -> (
         b_version.clone(),
         Action::Insert(Message::new(())),
     );
-    let b_node = act(base, vec![b_extra.clone()], |_| ());
+    let b_node = act(base, vec![b_extra.clone()], &mut |_| ());
 
-    let union = act(a_node.clone(), vec![b_extra], |_| ());
+    let union = act(a_node.clone(), vec![b_extra], &mut |_| ());
 
     let a_ceiling = shared_version.clone() | a_version;
     let b_ceiling = shared_version | b_version;
@@ -626,11 +622,7 @@ pub fn leaf_parent_dispute_pair() -> (
 /// `b` lacks the leaf, so reconciliation must delete it from `a` too — with
 /// no tombstone to say so, only the version bounds. The surviving tree is
 /// `b`'s: the concurrent insert alone.
-pub fn leaf_parent_redaction_pair() -> (
-    crate::tree::Root<()>,
-    crate::tree::Root<()>,
-    crate::tree::Root<()>,
-) {
+pub fn leaf_parent_redaction_pair() -> (crate::tree::Root, crate::tree::Root, crate::tree::Root) {
     // a's only leaf, on party 0.
     let mut a_version = Version::new();
     a_version.tick(&nth_party(0));
@@ -641,7 +633,7 @@ pub fn leaf_parent_redaction_pair() -> (
             a_version.clone(),
             Action::Insert(Message::new(())),
         )],
-        |_| (),
+        &mut |_| (),
     );
 
     // b: built on a's history, inserts a concurrent sibling, then forgets
@@ -657,16 +649,16 @@ pub fn leaf_parent_redaction_pair() -> (
     let mut forget_version = b_version.clone();
     forget_version.tick(&nth_party(1));
     let b_node = act(
-        act(a_node.clone(), vec![b_insert.clone()], |_| ()),
+        act(a_node.clone(), vec![b_insert.clone()], &mut |_| ()),
         vec![(
             leaf_sibling_path(0x00),
             forget_version.clone(),
             Action::Forget,
         )],
-        |_| (),
+        &mut |_| (),
     );
 
-    let survivor = act(None, vec![b_insert], |_| ());
+    let survivor = act(None, vec![b_insert], &mut |_| ());
 
     let b_ceiling = a_version.clone() | forget_version;
     let expected = root_with_ceiling(survivor, a_version.clone() | b_ceiling.clone());
diff --git a/src/tree/mirror/alternating/backend/local.rs b/src/tree/mirror/alternating/backend/local.rs
index 0095ce493..9edfd6afa 100644
--- a/src/tree/mirror/alternating/backend/local.rs
+++ b/src/tree/mirror/alternating/backend/local.rs
@@ -167,14 +167,11 @@ pub struct Exchange<V, L> {
     expected_parents: std::collections::BTreeSet<Box<[u8]>>,
 }
 
-impl<T> Exchange<Start, Top<T>>
-where
-    T: Send + Sync,
-{
+impl Exchange<Start, Top> {
     /// Open a local exchange over `node`, ready for the connect phase: the
     /// zipper at the top, the handshake version captured from the root's
     /// ceiling.
-    pub fn start(node: tree::Root<T>) -> Self {
+    pub fn start(node: tree::Root) -> Self {
         Self {
             versions: Start {
                 our_version: node.ceiling.clone(),
@@ -191,20 +188,19 @@ where
 impl<V: Send, L> protocol::Stage for Exchange<V, L>
 where
     L: Levels + Send,
-    L::Message: Send,
 {
     type Height = L::Height;
-    type Output = tree::Root<L::Message>;
+    type Output = tree::Root;
     /// Absorbing peer content can diagnose a semantic violation
     /// ([`Exchange::absorb_providing`]); nothing else here fails.
     type Error = Violation;
 }
 
-impl<T> protocol::Connect<T> for Exchange<Start, Top<T>>
+impl<T> protocol::Connect<T> for Exchange<Start, Top>
 where
     T: Send + Sync,
 {
-    type Next = Exchange<Connecting, Top<T>>;
+    type Next = Exchange<Connecting, Top>;
 
     async fn connect(
         self,
@@ -229,11 +225,11 @@ where
     }
 }
 
-impl<T> protocol::CompleteConnect<T> for Exchange<Connecting, Top<T>>
+impl<T> protocol::CompleteConnect<T> for Exchange<Connecting, Top>
 where
     T: Send + Sync,
 {
-    type Next = Exchange<Connected, Top<T>>;
+    type Next = Exchange<Connected, Top>;
 
     async fn complete_connect(
         self,
@@ -266,11 +262,11 @@ where
     }
 }
 
-impl<T> protocol::Accept<T> for Exchange<Start, Top<T>>
+impl<T> protocol::Accept<T> for Exchange<Start, Top>
 where
     T: Send + Sync,
 {
-    type Next = Exchange<Connected, Top<T>>;
+    type Next = Exchange<Connected, Top>;
 
     async fn accept(
         self,
@@ -311,11 +307,11 @@ where
     }
 }
 
-impl<T> protocol::Initiator<T> for Exchange<Connected, Top<T>>
+impl<T> protocol::Initiator<T> for Exchange<Connected, Top>
 where
     T: Send + Sync,
 {
-    type Next = Exchange<Connected, Top<T>>;
+    type Next = Exchange<Connected, Top>;
 
     async fn initiator(
         self,
@@ -333,11 +329,11 @@ where
     }
 }
 
-impl<T> protocol::Responder<T> for Exchange<Connected, Top<T>>
+impl<T> protocol::Responder<T> for Exchange<Connected, Top>
 where
     T: Send + Sync,
 {
-    type Next = Exchange<Connected, Below<UnderRoot, Top<T>>>;
+    type Next = Exchange<Connected, Below<UnderRoot, Top>>;
 
     async fn responder(
         mut self,
@@ -389,7 +385,7 @@ where
 impl<T, L> protocol::OpenInitiator<T> for Exchange<Connected, L>
 where
     T: Send + Sync,
-    L: Levels<Message = T, Height = Root> + Send,
+    L: Levels<Height = Root> + Send,
 {
     type Next = Exchange<Connected, Below<UnderUnderRoot, Below<UnderRoot, L>>>;
 
@@ -407,7 +403,7 @@ where
 impl<T, H, L> protocol::Exchange<T> for Exchange<Connected, L>
 where
     T: Send + Sync,
-    L: Levels<Message = T, Height = S<S<H>>> + Send,
+    L: Levels<Height = S<S<H>>> + Send,
     S<S<H>>: Height,
     S<H>: Height,
     H: Height + Unknown,
@@ -430,7 +426,7 @@ where
 impl<T, L> protocol::CloseResponder<T> for Exchange<Connected, L>
 where
     T: Send + Sync,
-    L: Levels<Message = T, Height = S<Z>> + Send,
+    L: Levels<Height = S<Z>> + Send,
 {
     type Next = Exchange<Connected, Below<Z, L>>;
 
@@ -445,7 +441,7 @@ where
 impl<T, L> protocol::CompleteInitiator<T> for Exchange<Connected, L>
 where
     T: Send + Sync,
-    L: Levels<Message = T, Height = Z> + Send,
+    L: Levels<Height = Z> + Send,
 {
     async fn complete_initiator(
         mut self,
@@ -456,6 +452,7 @@ where
         Ok(protocol::Step::Done {
             msg: message::Complete {
                 providing: providing.into_iter().collect(),
+                payload: std::marker::PhantomData,
             },
             output: tree::Root {
                 ceiling: self.versions.our_version | self.versions.their_version,
@@ -468,7 +465,7 @@ where
 impl<T, L> protocol::CompleteResponder<T> for Exchange<Connected, L>
 where
     T: Send + Sync,
-    L: Levels<Message = T, Height = Z> + Send,
+    L: Levels<Height = Z> + Send,
 {
     async fn complete_responder(
         mut self,
diff --git a/src/tree/mirror/alternating/backend/local/partition.rs b/src/tree/mirror/alternating/backend/local/partition.rs
index 4b85680ba..cb423a113 100644
--- a/src/tree/mirror/alternating/backend/local/partition.rs
+++ b/src/tree/mirror/alternating/backend/local/partition.rs
@@ -25,7 +25,7 @@ use super::{Connected, Exchange, message, protocol};
 
 /// The output of [`Exchange::partition_uncertain`], one field per outgoing
 /// channel in the asymmetry matrix.
-struct Partition<T, H>
+struct Partition<H>
 where
     S<H>: Height,
     H: Height,
@@ -33,26 +33,26 @@ where
     /// Left-case subtrees (we have them, the counterparty does not). The caller
     /// will combine these with `answer_requested`'s output to form the final
     /// outgoing `providing`.
-    providing: Level<T, S<H>>,
+    providing: Level<S<H>>,
     /// Right-case prefixes (the counterparty has them, we do not): the outgoing
     /// `requested`. Built in strictly ascending order (see
     /// [`Exchange::partition_uncertain`]).
     requested: Vec<Prefix<S<H>>>,
     /// `Both`-case children whose hashes agreed, plus Left-case children we
     /// kept locally. Become the new level immediately above the bottom.
-    matched: Level<T, S<H>>,
+    matched: Level<S<H>>,
     /// `Both`-case grandchildren of children whose hashes disagreed. Become the
     /// new bottom of the zipper, and next round's outgoing `uncertain`.
-    exploded: Level<T, H>,
+    exploded: Level<H>,
 }
 
 /// The output of [`Exchange::partition_leaf_uncertain`]: the leaf-height
 /// [`Partition`], with the dispute cell gone (a leaf never recurses) and the
 /// matched-and-kept leaves named `kept`.
-struct LeafPartition<T> {
+struct LeafPartition {
     /// Leaves only we hold that the counterparty has not deleted: joins the
     /// outgoing `providing`.
-    providing: Level<T, Z>,
+    providing: Level<Z>,
     /// Leaves only the counterparty holds: the outgoing `requested`. Built in
     /// strictly ascending order.
     requested: Vec<Prefix<Z>>,
@@ -61,13 +61,12 @@ struct LeafPartition<T> {
     ///
     /// Becomes the zipper's new bottom, where the counterparty's answers to
     /// `requested` join it before `collapse` reassembles the union parents.
-    kept: Level<T, Z>,
+    kept: Level<Z>,
 }
 
 impl<L> Exchange<Connected, L>
 where
     L: Levels,
-    L::Message: Send + Sync,
 {
     /// Insert nodes the counterparty has just sent us (because we requested
     /// them last round, or because they unilaterally knew we lacked them) into
@@ -85,10 +84,9 @@ where
     /// subtree: O(nodes received). Rejection leaves the zipper untouched.
     pub(super) fn absorb_providing<H>(
         &mut self,
-        providing: message::Providing<L::Message, H>,
+        providing: message::Providing<H>,
     ) -> Result<(), Violation>
     where
-        L::Message: Send + Sync,
         L: Levels<Height = H>,
         H: Height,
     {
@@ -139,7 +137,7 @@ where
     fn answer_requested_surviving<H>(
         &mut self,
         requested: Vec<Prefix<H>>,
-        mut provide: impl FnMut(Prefix<H>, &tree::typed::Node<L::Message, H>),
+        mut provide: impl FnMut(Prefix<H>, &tree::typed::Node<H>),
     ) where
         L: Levels<Height = H>,
         H: Height + Unknown,
@@ -181,10 +179,7 @@ where
     /// that any subtrees they have deleted disappear locally too.
     ///
     /// Returns the outgoing `providing` map, one height below the frontier.
-    pub(super) fn answer_requested<H>(
-        &mut self,
-        requested: Vec<Prefix<S<H>>>,
-    ) -> Level<L::Message, H>
+    pub(super) fn answer_requested<H>(&mut self, requested: Vec<Prefix<S<H>>>) -> Level<H>
     where
         L: Levels<Height = S<H>>,
         S<H>: Unknown,
@@ -215,10 +210,7 @@ where
     /// constructed by Both-case matches in the previous round and therefore
     /// agree on every parent. The debug-assertions guard against a
     /// steady-state caller silently triggering either branch.
-    fn partition_uncertain<H>(
-        &mut self,
-        uncertain: Vec<(Prefix<S<H>>, Hash)>,
-    ) -> Partition<L::Message, H>
+    fn partition_uncertain<H>(&mut self, uncertain: Vec<(Prefix<S<H>>, Hash)>) -> Partition<H>
     where
         L: Levels<Height = S<S<H>>>,
         S<S<H>>: Height,
@@ -370,10 +362,7 @@ where
     /// the counterparty's version is one they deleted, so it is dropped
     /// locally instead of provided — deletion honored on both sides in one
     /// arm.
-    pub(super) fn answer_requested_leaves(
-        &mut self,
-        requested: Vec<Prefix<Z>>,
-    ) -> Level<L::Message, Z>
+    pub(super) fn answer_requested_leaves(&mut self, requested: Vec<Prefix<Z>>) -> Level<Z>
     where
         L: Levels<Height = Z>,
     {
@@ -394,10 +383,7 @@ where
     /// Each disputed parent leaves the frontier; its reconciled leaves land
     /// in the returned `kept` level, which the caller pushes down the zipper
     /// so `collapse` reassembles the union parent.
-    fn partition_leaf_uncertain(
-        &mut self,
-        uncertain: Vec<(Prefix<Z>, Hash)>,
-    ) -> LeafPartition<L::Message>
+    fn partition_leaf_uncertain(&mut self, uncertain: Vec<(Prefix<Z>, Hash)>) -> LeafPartition
     where
         L: Levels<Height = S<Z>>,
     {
@@ -501,15 +487,11 @@ where
     /// [`Step::Done`](protocol::Step::Done) when nothing was requested:
     /// the counterparty's [`message::Complete`] would carry nothing.
     #[allow(clippy::type_complexity)]
-    pub(super) fn close(
+    pub(super) fn close<T>(
         mut self,
-        request: message::Exchange<L::Message, Z>,
+        request: message::Exchange<T, Z>,
     ) -> Result<
-        protocol::Step<
-            message::Closing<L::Message>,
-            Exchange<Connected, Below<Z, L>>,
-            tree::Root<L::Message>,
-        >,
+        protocol::Step<message::Closing<T>, Exchange<Connected, Below<Z, L>>, tree::Root>,
         Violation,
     >
     where
@@ -519,6 +501,7 @@ where
             providing,
             requested,
             uncertain,
+            payload: _,
         } = request;
 
         self.absorb_providing(providing)?;
@@ -538,6 +521,7 @@ where
         let response = message::Closing {
             providing: providing.into_iter().collect(),
             requested: partition.requested,
+            payload: std::marker::PhantomData,
         };
 
         // The counterparty may only answer the leaves we just requested.
@@ -585,20 +569,16 @@ where
     /// [`close_responder`](protocol::CloseResponder::close_responder); they
     /// differ only in how they assemble the outgoing message.
     #[allow(clippy::type_complexity)]
-    pub(super) fn reply<Request, Response, H>(
+    pub(super) fn reply<Request, Response, H, T>(
         mut self,
         request: Request,
     ) -> Result<
-        protocol::Step<
-            Response,
-            Exchange<Connected, Below<H, Below<S<H>, L>>>,
-            tree::Root<L::Message>,
-        >,
+        protocol::Step<Response, Exchange<Connected, Below<H, Below<S<H>, L>>>, tree::Root>,
         Violation,
     >
     where
-        Request: Into<message::Exchange<L::Message, S<H>>>,
-        Response: From<message::Exchange<L::Message, H>>,
+        Request: Into<message::Exchange<T, S<H>>>,
+        Response: From<message::Exchange<T, H>>,
         L: Levels<Height = S<S<H>>>,
         S<S<H>>: Height,
         S<H>: Height,
@@ -608,6 +588,7 @@ where
             providing,
             requested,
             uncertain,
+            payload: _,
         } = request.into();
 
         // Phase 1: absorb the counterparty's `providing` into our frontier.
@@ -652,6 +633,7 @@ where
             providing: providing.into_iter().collect(),
             requested: partition.requested,
             uncertain,
+            payload: std::marker::PhantomData,
         };
 
         // Record which parents the counterparty may `provide` against in its
diff --git a/src/tree/mirror/alternating/backend/remote.rs b/src/tree/mirror/alternating/backend/remote.rs
index 4c604b3a6..92fddcfc7 100644
--- a/src/tree/mirror/alternating/backend/remote.rs
+++ b/src/tree/mirror/alternating/backend/remote.rs
@@ -55,8 +55,8 @@ use crate::tree::wire;
 use crate::Error;
 use crate::tree::mirror::framing::{FrameRead, FrameWrite};
 use crate::tree::typed::{
-    Node,
     height::{Height, Root, S, UnderRoot, UnderUnderRoot, Z},
+    node::DecodeNode,
 };
 
 use super::super::{
@@ -213,7 +213,7 @@ where
     T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
-    Node<T, UnderRoot>: wire::Decode,
+    UnderRoot: DecodeNode,
 {
     type Next = Exchange<T, R, W, Connected, Root>;
 
@@ -235,7 +235,7 @@ where
     T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
-    Node<T, UnderRoot>: wire::Decode,
+    UnderRoot: DecodeNode,
 {
     type Next = Exchange<T, R, W, Connected, UnderRoot>;
 
@@ -263,7 +263,7 @@ where
     T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
-    Node<T, UnderRoot>: wire::Decode,
+    UnderRoot: DecodeNode,
 {
     type Next = Exchange<T, R, W, Connected, UnderUnderRoot>;
 
@@ -300,7 +300,7 @@ where
     H: Height,
     S<H>: Height,
     S<S<H>>: Height,
-    Node<T, S<H>>: wire::Decode,
+    S<H>: DecodeNode,
     // Assumed at impl-validation time so we don't have to case-analyze `H`
     // here: at use sites `H` is concrete and one of the three blanket impls
     // in `super::protocol` discharges it.
diff --git a/src/tree/mirror/alternating/message.rs b/src/tree/mirror/alternating/message.rs
index 9ac65b0ae..c30a44763 100644
--- a/src/tree/mirror/alternating/message.rs
+++ b/src/tree/mirror/alternating/message.rs
@@ -21,7 +21,7 @@
 //!   frame whose entries are not strictly ascending order (which also
 //!   rejects duplicates).
 //!
-//! ## Typed [`Node<T, H>`](crate::tree::typed::Node)
+//! ## Typed [`Node<H>`](crate::tree::typed::Node)
 //!
 //! Encoded in its in-memory layout. The typed node's wire impl is a thin
 //! delegate over the untyped node's `serialize_to`, which is the canonical
@@ -52,7 +52,7 @@
 //!
 //! ## The three channels
 //!
-//! - **`providing`**: `Vec<(Prefix<_>, Node<T, _>)>` — the subtrees being
+//! - **`providing`**: `Vec<(Prefix<_>, Node<_>)>` — the subtrees being
 //!   provided, each paired with the prefix it lands at, in ascending prefix
 //!   order. Each node carries its full structure on the wire (path-compression
 //!   bytes, branch radices, child counts); the receiver inserts it directly at
@@ -78,16 +78,39 @@ use crate::Version;
 use crate::tree::typed::{
     Hash, Node, Prefix,
     height::{Height, Root, S, UnderRoot, Z},
+    node::DecodeNode,
 };
 
 use serde::de::DeserializeOwned;
+use std::marker::PhantomData;
 #[cfg(test)]
 mod tests;
 
 /// The `providing` channel's payload at height `H`: the subtrees being provided,
 /// each paired with the prefix it lands at, in ascending prefix order. The
 /// receiver inserts each node directly at its named prefix.
-pub type Providing<T, H> = Vec<(Prefix<H>, Node<T, H>)>;
+pub type Providing<H> = Vec<(Prefix<H>, Node<H>)>;
+
+/// Decode one `providing` channel: a `u32` count, then `(prefix, node)`
+/// pairs, the nodes' leaf payloads parsed as `T` (the protocol's typed
+/// ingress; see [`DecodeNode`]).
+fn read_providing<T, H, R>(reader: &mut R) -> std::io::Result<Providing<H>>
+where
+    T: DeserializeOwned + Send + Sync + 'static,
+    H: DecodeNode,
+    R: std::io::Read,
+{
+    let count = u32::read_wire(reader)? as usize;
+    // Grow as elements arrive rather than trusting the declared count for
+    // the allocation (the same discipline as the framing reader).
+    let mut items = Vec::new();
+    for _ in 0..count {
+        let prefix = Prefix::<H>::read_wire(reader)?;
+        let node = H::read_node::<T, R>(reader)?;
+        items.push((prefix, node));
+    }
+    Ok(items)
+}
 
 /// The opening message of every session, exchanged by the `connect`/`accept`
 /// steps. It carries the sender's causal [`Version`].
@@ -193,7 +216,7 @@ where
     /// On the wire each subtree travels as a whole `(prefix, node)` pair in
     /// ascending prefix order; the receiver inserts it directly at the named
     /// prefix. Strictly ascending by prefix; duplicates are rejected.
-    pub providing: Providing<T, S<H>>,
+    pub providing: Providing<S<H>>,
     /// Prefixes the counterparty listed in the previous round's `uncertain`
     /// that we lack entirely. We ask them to send the subtrees so we can insert
     /// them into our zipper. Strictly ascending; duplicates are rejected.
@@ -205,6 +228,10 @@ where
     /// [`super::local`] module docs) on the receiving side. Strictly ascending
     /// by prefix.
     pub uncertain: Vec<(Prefix<H>, Hash)>,
+    /// The payload type this message's leaves decode as: the nodes are
+    /// erased in memory, so the type rides the message as decode context
+    /// only (`fn() -> T` keeps auto-traits off the payload type).
+    pub payload: PhantomData<fn() -> T>,
 }
 
 impl<T, H> Encode for Exchange<T, H>
@@ -219,20 +246,14 @@ where
     }
 }
 
-// `Node<T, S<H>>: Decode` reduces inductively to `Node<T, H>: Decode`
-// and bottoms at `Z`, so with `H` left generic the proof obligation
-// doesn't terminate during inference. We thread `Node<T, S<H>>: Decode`
-// through as an explicit bound so the caller — who knows `H` concretely —
-// discharges it.
 impl<T, H> Decode for Exchange<T, H>
 where
     T: DeserializeOwned + Send + Sync + 'static,
-    S<H>: Height,
+    S<H>: DecodeNode,
     H: Height,
-    Node<T, S<H>>: Decode,
 {
     fn read_wire<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
-        let providing: Providing<T, S<H>> = Decode::read_wire(reader)?;
+        let providing: Providing<S<H>> = read_providing::<T, S<H>, R>(reader)?;
         verify_pairs_canonical(&providing, "Exchange.providing")?;
         let requested: Vec<Prefix<S<H>>> = Decode::read_wire(reader)?;
         verify_keys_canonical(&requested, "Exchange.requested")?;
@@ -242,6 +263,7 @@ where
             providing,
             requested,
             uncertain,
+            payload: PhantomData,
         })
     }
 }
@@ -265,6 +287,7 @@ where
             providing: Default::default(),
             requested: Default::default(),
             uncertain: Default::default(),
+            payload: PhantomData,
         }
     }
 }
@@ -291,7 +314,7 @@ pub struct Closing<T> {
     /// Leaves only the responder holds that the initiator has not deleted:
     /// answers to the initiator's final `requested`, plus leaves the
     /// initiator's `uncertain` listing proved it lacks.
-    pub providing: Providing<T, Z>,
+    pub providing: Providing<Z>,
     /// Leaves the initiator listed under disputed parents that the responder
     /// lacks entirely.
     ///
@@ -299,6 +322,8 @@ pub struct Closing<T> {
     /// leaf at or before the responder's version was deleted there, and
     /// drops on both sides instead of shipping.
     pub requested: Vec<Prefix<Z>>,
+    /// The leaves' payload type, as decode context (see [`Exchange::payload`]).
+    pub payload: PhantomData<fn() -> T>,
 }
 
 impl<T> Encode for Closing<T> {
@@ -313,13 +338,14 @@ where
     T: DeserializeOwned + Send + Sync + 'static,
 {
     fn read_wire<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
-        let providing: Providing<T, Z> = Decode::read_wire(reader)?;
+        let providing: Providing<Z> = read_providing::<T, Z, R>(reader)?;
         verify_pairs_canonical(&providing, "Closing.providing")?;
         let requested: Vec<Prefix<Z>> = Decode::read_wire(reader)?;
         verify_keys_canonical(&requested, "Closing.requested")?;
         Ok(Self {
             providing,
             requested,
+            payload: PhantomData,
         })
     }
 }
@@ -329,6 +355,7 @@ impl<T> Default for Closing<T> {
         Self {
             providing: Default::default(),
             requested: Default::default(),
+            payload: PhantomData,
         }
     }
 }
@@ -345,7 +372,9 @@ impl<T> Default for Closing<T> {
 /// (vacuous at leaf height, same reasoning as [`Closing`]).
 #[derive(Clone)]
 pub struct Complete<T> {
-    pub providing: Providing<T, Z>,
+    pub providing: Providing<Z>,
+    /// The leaves' payload type, as decode context (see [`Exchange::payload`]).
+    pub payload: PhantomData<fn() -> T>,
 }
 
 impl<T> Encode for Complete<T> {
@@ -359,9 +388,12 @@ where
     T: DeserializeOwned + Send + Sync + 'static,
 {
     fn read_wire<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
-        let providing: Providing<T, Z> = Decode::read_wire(reader)?;
+        let providing: Providing<Z> = read_providing::<T, Z, R>(reader)?;
         verify_pairs_canonical(&providing, "Complete.providing")?;
-        Ok(Self { providing })
+        Ok(Self {
+            providing,
+            payload: PhantomData,
+        })
     }
 }
 
@@ -369,6 +401,7 @@ impl<T> Default for Complete<T> {
     fn default() -> Self {
         Self {
             providing: Default::default(),
+            payload: PhantomData,
         }
     }
 }
diff --git a/src/tree/mirror/alternating/message/tests.rs b/src/tree/mirror/alternating/message/tests.rs
index fe214dba3..492904f0b 100644
--- a/src/tree/mirror/alternating/message/tests.rs
+++ b/src/tree/mirror/alternating/message/tests.rs
@@ -18,7 +18,7 @@ use crate::Version;
 use crate::message::Message;
 use crate::tree::arb::{arb_root_node, arb_version, nth_party};
 use crate::tree::typed::height::{Height, Root, S, Z};
-use crate::tree::typed::{Hash, Node, Prefix, hash::MERKLE_HASH_LEN};
+use crate::tree::typed::{Hash, Node, Prefix, hash::MERKLE_HASH_LEN, node::DecodeNode};
 use crate::tree::wire;
 
 use super as message;
@@ -39,7 +39,7 @@ fn arb_hash() -> BoxedStrategy<Hash> {
     any::<[u8; MERKLE_HASH_LEN]>().prop_map(Hash).boxed()
 }
 
-fn arb_leaf() -> BoxedStrategy<Node<(), Z>> {
+fn arb_leaf() -> BoxedStrategy<Node<Z>> {
     arb_version()
         .prop_map(|version| Node::leaf(version, Message::new(())))
         .boxed()
@@ -47,9 +47,7 @@ fn arb_leaf() -> BoxedStrategy<Node<(), Z>> {
 
 /// Sort and deduplicate `(prefix, node)` entries into the canonical ascending
 /// `Vec` the `providing` channel expects.
-fn canonical_providing<H: Height>(
-    entries: Vec<(Prefix<H>, Node<(), H>)>,
-) -> Vec<(Prefix<H>, Node<(), H>)> {
+fn canonical_providing<H: Height>(entries: Vec<(Prefix<H>, Node<H>)>) -> Vec<(Prefix<H>, Node<H>)> {
     entries
         .into_iter()
         .collect::<BTreeMap<_, _>>()
@@ -124,6 +122,7 @@ proptest! {
             providing: providing.clone(),
             requested: requested.clone(),
             uncertain: uncertain.clone(),
+            payload: std::marker::PhantomData,
         };
         let bytes = wire::to_vec(&m).unwrap();
         let decoded =
@@ -145,6 +144,7 @@ proptest! {
         let m: message::Closing<()> = message::Closing {
             providing: providing.clone(),
             requested: requested.clone(),
+            payload: std::marker::PhantomData,
         };
         let bytes = wire::to_vec(&m).unwrap();
         let decoded = wire::from_slice::<message::Closing<()>>(&bytes).unwrap();
@@ -159,7 +159,7 @@ proptest! {
         providing_entries in vec((arb_prefix::<Z>(), arb_leaf()), 0..=4),
     ) {
         let providing = canonical_providing(providing_entries);
-        let m: message::Complete<()> = message::Complete { providing: providing.clone() };
+        let m: message::Complete<()> = message::Complete { providing: providing.clone(), payload: std::marker::PhantomData };
         let bytes = wire::to_vec(&m).unwrap();
         let decoded = wire::from_slice::<message::Complete<()>>(&bytes).unwrap();
         prop_assert_eq!(decoded.providing, providing);
@@ -180,12 +180,26 @@ proptest! {
         let mut permuted = canonical.clone();
         permuted.rotate_left(rotate % canonical.len());
         prop_assume!(permuted != canonical);
-        let m = message::Complete::<()> { providing: permuted };
+        let m = message::Complete::<()> { providing: permuted, payload: std::marker::PhantomData };
         let bytes = wire::to_vec(&m).unwrap();
         prop_assert!(wire::from_slice::<message::Complete<()>>(&bytes).is_err());
     }
 }
 
+/// Decode one erased node at height `H` from an exact slice, rejecting
+/// trailing bytes: the test-side door to [`DecodeNode`], with unit payloads.
+fn node_from_slice<H: DecodeNode>(bytes: &[u8]) -> std::io::Result<Node<H>> {
+    let mut input = bytes;
+    let node = H::read_node::<(), _>(&mut input)?;
+    if !input.is_empty() {
+        return Err(std::io::Error::new(
+            std::io::ErrorKind::InvalidData,
+            format!("{} trailing bytes after the decoded node", input.len()),
+        ));
+    }
+    Ok(node)
+}
+
 /// A single version, ticked once on a fixed party — enough to place one leaf.
 fn one_version() -> Version {
     let p = nth_party(0);
@@ -202,6 +216,7 @@ fn providing_rejects_duplicate_prefix() {
     let leaf = Node::leaf(one_version(), Message::new(()));
     let m = message::Complete::<()> {
         providing: vec![(prefix, leaf.clone()), (prefix, leaf)],
+        payload: std::marker::PhantomData,
     };
     let bytes = wire::to_vec(&m).unwrap();
     assert!(wire::from_slice::<message::Complete<()>>(&bytes).is_err());
@@ -216,6 +231,7 @@ fn requested_rejects_descending_order() {
             prefix_from_bytes::<Z>(&[2u8; 32]),
             prefix_from_bytes::<Z>(&[1u8; 32]),
         ],
+        payload: std::marker::PhantomData,
     };
     let bytes = wire::to_vec(&m).unwrap();
     assert!(wire::from_slice::<message::Closing<()>>(&bytes).is_err());
@@ -248,7 +264,7 @@ fn uncertain_rejects_duplicate_prefix() {
 /// past the leaf floor.
 #[test]
 fn node_prefix_exceeding_height_is_rejected() {
-    let error = wire::from_slice::<Node<(), S<Z>>>(&[2]).unwrap_err();
+    let error = node_from_slice::<S<Z>>(&[2]).unwrap_err();
     assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
 }
 
@@ -260,7 +276,7 @@ fn node_prefix_exceeding_height_is_rejected() {
 /// cannot all be placed.
 #[test]
 fn node_child_count_overflow_is_rejected() {
-    let error = wire::from_slice::<Node<(), S<Z>>>(&[0, 255]).unwrap_err();
+    let error = node_from_slice::<S<Z>>(&[0, 255]).unwrap_err();
     assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
 }
 
@@ -271,7 +287,7 @@ fn node_child_count_overflow_is_rejected() {
 /// (`InvalidData`) rather than let one branch have two encodings.
 #[test]
 fn node_descending_radices_are_rejected() {
-    let leaf = wire::to_vec(&Node::<(), Z>::leaf(one_version(), Message::new(()))).unwrap();
+    let leaf = wire::to_vec(&Node::<Z>::leaf(one_version(), Message::new(()))).unwrap();
     // prefix_len 0, count_minus_two 0 (two children), radix 5, its leaf,
     // then a second radix that does not ascend.
     let mut bytes = vec![0, 0, 5];
@@ -279,6 +295,6 @@ fn node_descending_radices_are_rejected() {
     bytes.push(5);
     bytes.extend_from_slice(&leaf);
 
-    let error = wire::from_slice::<Node<(), S<Z>>>(&bytes).unwrap_err();
+    let error = node_from_slice::<S<Z>>(&bytes).unwrap_err();
     assert_eq!(error.kind(), std::io::ErrorKind::InvalidData);
 }
diff --git a/src/tree/mirror/alternating/tests.rs b/src/tree/mirror/alternating/tests.rs
index d86e84883..eb27d3a35 100644
--- a/src/tree/mirror/alternating/tests.rs
+++ b/src/tree/mirror/alternating/tests.rs
@@ -20,8 +20,6 @@ use crate::{Version, message::Message};
 use super::{local, mirror, remote};
 use crate::tree::mirror::handshake::{self, Intent};
 
-use serde::Serialize;
-use serde::de::DeserializeOwned;
 // clippy's `missing_const_for_thread_local` misreads `thread_local!`'s
 // fallback-TLS lowering (illumos among the gate's targets) and denies
 // initializers that already sit in `const` blocks; the allow keeps
@@ -78,20 +76,13 @@ const DUPLEX_BUF: usize = 8 * 1024;
 /// Drive the mirror protocol through the high-level [`super::mirror`]
 /// driver under the chosen [`Scenario`], and return the reconciled tree
 /// (which must be equal on both sides if the protocol converged).
-fn mirror_via<T>(
-    a: crate::tree::Root<T>,
-    b: crate::tree::Root<T>,
-    scenario: Scenario,
-) -> crate::tree::Root<T>
-where
-    T: PartialEq + std::fmt::Debug + Serialize + DeserializeOwned + Send + Sync + 'static,
-{
+fn mirror_via(a: crate::tree::Root, b: crate::tree::Root, scenario: Scenario) -> crate::tree::Root {
     block_on(async move {
         match scenario {
             Scenario::LocalLocal => {
                 let local_a = local::Exchange::start(a);
                 let local_b = local::Exchange::start(b);
-                match mirror(local_a, local_b).await {
+                match mirror::<_, _, ()>(local_a, local_b).await {
                     Err(e) => panic!("honest endpoints speak no violations: {e}"),
                     Ok((ours, theirs)) => {
                         assert_eq!(ours, theirs, "local-local endpoints should converge");
@@ -110,11 +101,17 @@ where
                 let (b_r, b_w) = tokio::io::split(b_side);
 
                 let local_a = local::Exchange::start(a);
-                let remote_b = remote::Exchange::start(FrameRead::new(a_r), FrameWrite::new(a_w));
+                let remote_b = remote::Exchange::<(), _, _, _, _>::start(
+                    FrameRead::new(a_r),
+                    FrameWrite::new(a_w),
+                );
                 let client = mirror(local_a, remote_b);
 
                 let local_b = local::Exchange::start(b);
-                let remote_a = remote::Exchange::start(FrameRead::new(b_r), FrameWrite::new(b_w));
+                let remote_a = remote::Exchange::<(), _, _, _, _>::start(
+                    FrameRead::new(b_r),
+                    FrameWrite::new(b_w),
+                );
                 let server = mirror(local_b, remote_a);
 
                 // Both sides poll on the same current-thread task; no
@@ -257,11 +254,11 @@ proptest! {
         // The wrapper version must be a causal upper bound on every action
         // we apply — `Tree::react` maintains the same invariant by `|=`-ing
         // each action's version into the tree's version vector.
-        let wrap = |actions: &[(Path, Version, Action)]| crate::tree::Root::<()> {
+        let wrap = |actions: &[(Path, Version, Action)]| crate::tree::Root {
             ceiling: actions
                 .iter()
                 .fold(Version::default(), |acc, (_, v, _)| acc | v.clone()),
-            root: act(None, actions.to_vec(), |_| ()),
+            root: act(None, actions.to_vec(), &mut |_| ()),
         };
 
         let tree_a = wrap(&actions_a);
@@ -297,7 +294,7 @@ fn uncontained_supply_is_rejected() {
     // violation.
     {
         let (receiver, poisoned, _, _) = uncontained_supply_pair();
-        let result = block_on(mirror(
+        let result = block_on(mirror::<_, _, ()>(
             local::Exchange::start(receiver),
             local::Exchange::start(poisoned),
         ));
@@ -317,11 +314,17 @@ fn uncontained_supply_is_rejected() {
             let (b_r, b_w) = tokio::io::split(b_side);
 
             let local_receiver = local::Exchange::start(receiver);
-            let remote_b = remote::Exchange::start(FrameRead::new(a_r), FrameWrite::new(a_w));
+            let remote_b = remote::Exchange::<(), _, _, _, _>::start(
+                FrameRead::new(a_r),
+                FrameWrite::new(a_w),
+            );
             let receiver_side = mirror(local_receiver, remote_b);
 
             let local_poisoned = local::Exchange::start(poisoned);
-            let remote_a = remote::Exchange::start(FrameRead::new(b_r), FrameWrite::new(b_w));
+            let remote_a = remote::Exchange::<(), _, _, _, _>::start(
+                FrameRead::new(b_r),
+                FrameWrite::new(b_w),
+            );
             let poisoned_side = mirror(local_poisoned, remote_a);
 
             let (receiver_result, poisoned_result) = tokio::join!(receiver_side, poisoned_side);
diff --git a/src/tree/mirror/alternating/wire_snapshot.rs b/src/tree/mirror/alternating/wire_snapshot.rs
index 4af0e03c1..30d209144 100644
--- a/src/tree/mirror/alternating/wire_snapshot.rs
+++ b/src/tree/mirror/alternating/wire_snapshot.rs
@@ -53,7 +53,7 @@ fn prefix_from_bytes<H: Height>(bytes: &[u8]) -> Prefix<H> {
     wire::from_slice(bytes).expect("known-valid prefix bytes")
 }
 
-fn leaf(party: &str, version: u64) -> Node<(), Z> {
+fn leaf(party: &str, version: u64) -> Node<Z> {
     Node::leaf(ticked(party, version), Message::new(()))
 }
 
@@ -118,7 +118,7 @@ fn prefix_z_full_32_bytes() {
     insta::assert_snapshot!(snap(&prefix_from_bytes::<Z>(&bytes)));
 }
 
-// ---------- Node<T, Z>: leaf ----------
+// ---------- Node<Z>: leaf ----------
 
 /// A bare leaf node: version then message payload.
 #[test]
@@ -129,17 +129,17 @@ fn node_z_leaf() {
 /// A leaf at the empty `Version`: the degenerate-timestamp encoding.
 #[test]
 fn node_z_leaf_empty_version() {
-    let l: Node<(), Z> = Node::leaf(Version::default(), Message::new(()));
+    let l: Node<Z> = Node::leaf(Version::default(), Message::new(()));
     insta::assert_snapshot!(snap(&l));
 }
 
-// ---------- Node<T, S<Z>> ----------
+// ---------- Node<S<Z>> ----------
 
 /// A path-compressed single child: the compressed prefix byte rides the
 /// node, not a materialized intermediate level.
 #[test]
 fn node_s_z_singleton_path_compressed_leaf() {
-    let n: Node<(), S<Z>> = Node::beneath(leaf("a", 1), 0xab);
+    let n: Node<S<Z>> = Node::beneath(leaf("a", 1), 0xab);
     insta::assert_snapshot!(snap(&n));
 }
 
@@ -147,29 +147,29 @@ fn node_s_z_singleton_path_compressed_leaf() {
 /// ascending-radix order.
 #[test]
 fn node_s_z_two_child_branch() {
-    let children: Children<(), Z> = [(0x00, leaf("a", 1)), (0xff, leaf("a", 2))]
+    let children: Children<Z> = [(0x00, leaf("a", 1)), (0xff, leaf("a", 2))]
         .into_iter()
         .collect();
-    let n = Node::<(), S<Z>>::branch(children).unwrap();
+    let n = Node::<S<Z>>::branch(children).unwrap();
     insta::assert_snapshot!(snap(&n));
 }
 
 /// The saturated 256-child branch: the maximum fan-out boundary.
 #[test]
 fn node_s_z_full_256_child_branch() {
-    let children: Children<(), Z> = (0u16..=255)
+    let children: Children<Z> = (0u16..=255)
         .map(|i| (i as u8, leaf("a", i as u64 + 1)))
         .collect();
-    let n = Node::<(), S<Z>>::branch(children).unwrap();
+    let n = Node::<S<Z>>::branch(children).unwrap();
     insta::assert_snapshot!(snap(&n));
 }
 
-// ---------- Node<T, Root> ----------
+// ---------- Node<Root> ----------
 
 /// The empty tree (`None` root): the smallest possible encoding.
 #[test]
 fn node_root_none() {
-    let n: Option<Node<(), Root>> = None;
+    let n: Option<Node<Root>> = None;
     insta::assert_snapshot!(snap(&n));
 }
 
@@ -181,7 +181,7 @@ fn node_root_single_leaf_full_compression() {
     seq_macro::seq!(I in 0..32 {
         let n = Node::beneath(n, I);
     });
-    let n: Node<(), Root> = n;
+    let n: Node<Root> = n;
     insta::assert_snapshot!(snap(&n));
 }
 
@@ -206,8 +206,8 @@ fn node_root_two_leaves_branched_at_root() {
             });
             n
         };
-        let children: Children<(), _> = [(0x01, n0), (0x02, n1)].into_iter().collect();
-        Node::<(), Root>::branch(children).unwrap()
+        let children: Children<_> = [(0x01, n0), (0x02, n1)].into_iter().collect();
+        Node::<Root>::branch(children).unwrap()
     };
     insta::assert_snapshot!(snap(&n));
 }
@@ -270,12 +270,12 @@ fn message_exchange_empty() {
 /// `requested`, and `uncertain` — the full steady-state round shape.
 #[test]
 fn message_exchange_populated() {
-    let leaf_z: Node<(), Z> = leaf("a", 1);
-    let inner: Node<(), S<Z>> = Node::beneath(leaf_z, 0xab);
-    let other_children: Children<(), S<Z>> =
+    let leaf_z: Node<Z> = leaf("a", 1);
+    let inner: Node<S<Z>> = Node::beneath(leaf_z, 0xab);
+    let other_children: Children<S<Z>> =
         [(0x01, inner.clone()), (0x02, inner)].into_iter().collect();
-    let s_s_z = Node::<(), S<S<Z>>>::branch(other_children).unwrap();
-    let n_root: Node<(), Root> = {
+    let s_s_z = Node::<S<S<Z>>>::branch(other_children).unwrap();
+    let n_root: Node<Root> = {
         let n = s_s_z;
         seq_macro::seq!(I in 0..30 {
             let n = Node::beneath(n, I);
@@ -296,6 +296,7 @@ fn message_exchange_populated() {
         providing,
         requested,
         uncertain,
+        payload: std::marker::PhantomData,
     };
     insta::assert_snapshot!(snap(&m));
 }
@@ -315,6 +316,7 @@ fn message_closing_populated() {
     let m: message::Closing<()> = message::Closing {
         providing,
         requested,
+        payload: std::marker::PhantomData,
     };
     insta::assert_snapshot!(snap(&m));
 }
@@ -330,6 +332,9 @@ fn message_complete_empty() {
 #[test]
 fn message_complete_populated() {
     let providing = vec![(prefix_from_bytes::<Z>(&[0u8; 32]), leaf("a", 1))];
-    let m: message::Complete<()> = message::Complete { providing };
+    let m: message::Complete<()> = message::Complete {
+        providing,
+        payload: std::marker::PhantomData,
+    };
     insta::assert_snapshot!(snap(&m));
 }
diff --git a/src/tree/mirror/streaming/backend.rs b/src/tree/mirror/streaming/backend.rs
index 6e8e30926..0f0505f78 100644
--- a/src/tree/mirror/streaming/backend.rs
+++ b/src/tree/mirror/streaming/backend.rs
@@ -47,7 +47,8 @@ pub trait Backend<T: Send + Sync + 'static>: Clone + Send + Sync + 'static
 where
     Self::Node<Z>: Leaf<T>,
 {
-    /// The type of nodes carrying messages of type `T`, indexed by height `H`.
+    /// The type of nodes, indexed by height `H`; leaf payloads are
+    /// erased in storage and decode as `T` at the wire boundary.
     type Node<H: Height>: Node<T, Height = H, Backend = Self> + Clone + Send + 'static;
 
     /// One runtime representation shared by every height's
diff --git a/src/tree/mirror/streaming/backend/local.rs b/src/tree/mirror/streaming/backend/local.rs
index 8bac7f470..0ced7ea05 100644
--- a/src/tree/mirror/streaming/backend/local.rs
+++ b/src/tree/mirror/streaming/backend/local.rs
@@ -31,7 +31,7 @@ mod tests;
 #[cfg(test)]
 pub use adversarial::with_schedule;
 
-impl<T: Send + Sync + 'static, H: Height> Node<T> for typed::Node<T, H> {
+impl<T: Send + Sync + 'static, H: Height> Node<T> for typed::Node<H> {
     type Backend = Local;
     type Height = H;
 
@@ -58,7 +58,7 @@ impl<T: Send + Sync + 'static, H: Height> Node<T> for typed::Node<T, H> {
 
 // The typed node is `repr(transparent)` over the untyped node, so the
 // erased observations are the same field reads the typed ones are.
-impl<T: Send + Sync + 'static> ErasedNode for typed::untyped::Node<T> {
+impl ErasedNode for typed::untyped::Node {
     fn span(&self) -> Span<'_> {
         self.span()
     }
@@ -72,7 +72,7 @@ impl<T: Send + Sync + 'static> ErasedNode for typed::untyped::Node<T> {
     }
 }
 
-impl<T: Send + Sync + 'static> Leaf<T> for typed::Node<T, Z> {
+impl<T: Send + Sync + 'static> Leaf<T> for typed::Node<Z> {
     fn message(&self) -> &Message {
         self.message()
     }
@@ -101,20 +101,19 @@ impl Local {
     /// height-typed veneer is `repr(transparent)` over that handle, so
     /// every height costs the same.
     pub(crate) fn node_bytes(_children: usize, _version_bound: usize) -> usize {
-        std::mem::size_of::<typed::Node<(), Z>>()
+        std::mem::size_of::<typed::Node<Z>>()
     }
 }
 
 /// The handle really is pointer-sized: the window's per-reference price
 /// rests on it.
-const _: () =
-    assert!(std::mem::size_of::<typed::Node<(), Z>>() == std::mem::size_of::<*const ()>());
+const _: () = assert!(std::mem::size_of::<typed::Node<Z>>() == std::mem::size_of::<*const ()>());
 
 impl<T: Send + Sync + 'static> Backend<T> for Local {
-    type Node<H: Height> = typed::Node<T, H>;
+    type Node<H: Height> = typed::Node<H>;
     // One representation for every height already: the typed node is a
     // phantom tag over this, so both conversions are field moves.
-    type Erased = typed::untyped::Node<T>;
+    type Erased = typed::untyped::Node;
     type Error = Infallible;
 
     fn erase<H: Height>(node: Self::Node<H>) -> Self::Erased {
@@ -206,7 +205,7 @@ impl<T: Send + Sync + 'static> Backend<T> for Local {
         let assembled = try_stream! {
             let mut leaves = pin!(leaves);
             let mut current: Option<Prefix<H>> = None;
-            let mut run: Vec<(Prefix<Z>, typed::Node<T, Z>)> = Vec::new();
+            let mut run: Vec<(Prefix<Z>, typed::Node<Z>)> = Vec::new();
             while let Some(item) = leaves.next().await {
                 let (prefix, leaf) = item?;
                 let target = Prefix::<H>::containing(&Path::from(prefix));
@@ -234,14 +233,14 @@ impl<T: Send + Sync + 'static> Backend<T> for Local {
 // `tree::Root` is exactly the `Local` instance of the session's generic
 // `Root`: the same (ceiling, optional root node) pair, concretely typed.
 
-impl<T: Send + Sync + 'static> From<tree::Root<T>> for Root<Local, T> {
-    fn from(root: tree::Root<T>) -> Self {
+impl<T: Send + Sync + 'static> From<tree::Root> for Root<Local, T> {
+    fn from(root: tree::Root) -> Self {
         let tree::Root { ceiling, root } = root;
         Root { ceiling, root }
     }
 }
 
-impl<T: Send + Sync + 'static> From<Root<Local, T>> for tree::Root<T> {
+impl<T: Send + Sync + 'static> From<Root<Local, T>> for tree::Root {
     fn from(root: Root<Local, T>) -> Self {
         let Root { ceiling, root } = root;
         tree::Root { ceiling, root }
diff --git a/src/tree/mirror/streaming/backend/local/tests.rs b/src/tree/mirror/streaming/backend/local/tests.rs
index bc6844ead..54608d7cf 100644
--- a/src/tree/mirror/streaming/backend/local/tests.rs
+++ b/src/tree/mirror/streaming/backend/local/tests.rs
@@ -27,7 +27,7 @@ use crate::{
 
 use super::Local;
 
-type LeafRun = Vec<(Prefix<Z>, typed::Node<(), Z>)>;
+type LeafRun = Vec<(Prefix<Z>, typed::Node<Z>)>;
 
 /// One distinct-version leaf per path, in the (ascending) order given.
 fn leaves_at(paths: impl IntoIterator<Item = [u8; 32]>) -> LeafRun {
@@ -49,21 +49,21 @@ fn boxed(run: LeafRun) -> BoxNodeStream<'static, Local, (), Z> {
 }
 
 /// Assemble through the level-by-level default, bypassing Local's override.
-fn assemble_default<H: Convert>(run: LeafRun) -> Vec<(Prefix<H>, typed::Node<(), H>)> {
+fn assemble_default<H: Convert>(run: LeafRun) -> Vec<(Prefix<H>, typed::Node<H>)> {
     pollster::block_on(H::assemble(Local, boxed(run)).try_collect())
         .unwrap_or_else(|error| match error {})
 }
 
 /// Assemble through the backend seam, which Local overrides in bulk.
-fn assemble_local<H: Convert>(run: LeafRun) -> Vec<(Prefix<H>, typed::Node<(), H>)> {
+fn assemble_local<H: Convert>(run: LeafRun) -> Vec<(Prefix<H>, typed::Node<H>)> {
     pollster::block_on(Local.assemble::<H>(boxed(run)).try_collect())
         .unwrap_or_else(|error| match error {})
 }
 
 /// Explode through the level-by-level default, bypassing Local's override.
-fn leaves_default<H: Convert>(prefix: Prefix<H>, node: typed::Node<(), H>) -> LeafRun {
+fn leaves_default<H: Convert>(prefix: Prefix<H>, node: typed::Node<H>) -> LeafRun {
     pollster::block_on(
-        H::explode(
+        H::explode::<_, ()>(
             Local,
             Box::pin(stream::once(async move { Ok((prefix, node)) })),
         )
@@ -73,8 +73,8 @@ fn leaves_default<H: Convert>(prefix: Prefix<H>, node: typed::Node<(), H>) -> Le
 }
 
 /// Walk leaves through the backend seam, which Local overrides directly.
-fn leaves_local<H: Convert>(prefix: Prefix<H>, node: typed::Node<(), H>) -> LeafRun {
-    pollster::block_on(Local.leaves(prefix, node).try_collect())
+fn leaves_local<H: Convert>(prefix: Prefix<H>, node: typed::Node<H>) -> LeafRun {
+    pollster::block_on(<Local as Backend<()>>::leaves(Local, prefix, node).try_collect())
         .unwrap_or_else(|error| match error {})
 }
 
diff --git a/src/tree/mirror/streaming/convert/tests.rs b/src/tree/mirror/streaming/convert/tests.rs
index 5a6b9b7f3..e1d401fbe 100644
--- a/src/tree/mirror/streaming/convert/tests.rs
+++ b/src/tree/mirror/streaming/convert/tests.rs
@@ -21,7 +21,7 @@ use crate::{
 
 /// A distinct leaf per call: content is irrelevant to grouping; the versions
 /// only need to differ so the resulting parents' hashes do.
-fn leaf(version: &mut Version) -> typed::Node<(), Z> {
+fn leaf(version: &mut Version) -> typed::Node<Z> {
     version.tick(&nth_party(0));
     typed::Node::leaf(version.clone(), Message::new(()))
 }
@@ -42,25 +42,21 @@ fn parent_prefix(parent: u8) -> Prefix<S<Z>> {
 
 /// Build the expected parent of a radix group directly through the backend,
 /// bypassing the fold under test.
-fn parent_of(
-    prefix: Prefix<S<Z>>,
-    children: Vec<(u8, typed::Node<(), Z>)>,
-) -> typed::Node<(), S<Z>> {
-    pollster::block_on(
-        Local.parent(
-            prefix,
-            children
-                .into_iter()
-                .map(|(radix, child)| (radix, Some(child)))
-                .collect(),
-        ),
-    )
+fn parent_of(prefix: Prefix<S<Z>>, children: Vec<(u8, typed::Node<Z>)>) -> typed::Node<S<Z>> {
+    pollster::block_on(<Local as Backend<()>>::parent(
+        Local,
+        prefix,
+        children
+            .into_iter()
+            .map(|(radix, child)| (radix, Some(child)))
+            .collect(),
+    ))
     .unwrap_or_else(|e| match e {})
     .expect("a non-empty all-real group always constructs its parent")
 }
 
 /// Drive the fold of an in-memory child stream to completion.
-fn fold(children: Vec<(Prefix<Z>, typed::Node<(), Z>)>) -> Vec<(Prefix<S<Z>>, Hash)> {
+fn fold(children: Vec<(Prefix<Z>, typed::Node<Z>)>) -> Vec<(Prefix<S<Z>>, Hash)> {
     pollster::block_on(
         fold_parents::<Local, (), Z>(
             Local,
@@ -86,7 +82,7 @@ proptest! {
     ) {
         let mut version = Version::new();
         let mut input = Vec::new();
-        let mut expected_groups: Vec<(u8, Vec<(u8, typed::Node<(), Z>)>)> = Vec::new();
+        let mut expected_groups: Vec<(u8, Vec<(u8, typed::Node<Z>)>)> = Vec::new();
         for (parent, radix) in keys {
             let node = leaf(&mut version);
             input.push((key(parent, radix), node.clone()));
diff --git a/src/tree/mirror/streaming/materialized/tests.rs b/src/tree/mirror/streaming/materialized/tests.rs
index 18c45f43f..6779f3a76 100644
--- a/src/tree/mirror/streaming/materialized/tests.rs
+++ b/src/tree/mirror/streaming/materialized/tests.rs
@@ -52,7 +52,7 @@ fn absorb_scripted(
     leaf_version: Version,
 ) -> (
     Result<(), Error<Infallible>>,
-    Option<Option<typed::Node<(), Z>>>,
+    Option<Option<typed::Node<Z>>>,
 ) {
     // The request whose answer the script supplies: the leaf radix is the
     // path's last byte, zero here.
diff --git a/src/tree/mirror/streaming/materialized/unknown/tests.rs b/src/tree/mirror/streaming/materialized/unknown/tests.rs
index 8d5857cf3..cbef059d2 100644
--- a/src/tree/mirror/streaming/materialized/unknown/tests.rs
+++ b/src/tree/mirror/streaming/materialized/unknown/tests.rs
@@ -26,7 +26,7 @@ use crate::{
 /// Splitting leaves across two parties guarantees cross-party concurrency, so
 /// the "floor concurrent, keep whole subtree" fast path is exercised alongside
 /// the drop path.
-fn tree_and_known(flags_a: &[bool], flags_b: &[bool]) -> (Option<typed::node::Root<()>>, Version) {
+fn tree_and_known(flags_a: &[bool], flags_b: &[bool]) -> (Option<typed::node::Root>, Version) {
     let mut actions: Vec<(Path, Version, Action)> = Vec::new();
     let mut known = Version::new();
 
@@ -44,15 +44,12 @@ fn tree_and_known(flags_a: &[bool], flags_b: &[bool]) -> (Option<typed::node::Ro
         }
     }
 
-    (act(None, actions, |_| ()), known)
+    (act(None, actions, &mut |_| ()), known)
 }
 
 /// Prune an optional root through the single-node streaming filter, driving
 /// the future to completion with a trivial executor.
-fn stream_prune(
-    root: Option<typed::node::Root<()>>,
-    known: &Version,
-) -> Option<typed::node::Root<()>> {
+fn stream_prune(root: Option<typed::node::Root>, known: &Version) -> Option<typed::node::Root> {
     root.and_then(|node| {
         pollster::block_on(unknown::<Local, ()>(
             &Local,
diff --git a/src/tree/mirror/streaming/materialized/work/tests.rs b/src/tree/mirror/streaming/materialized/work/tests.rs
index cc255ff81..2b426af86 100644
--- a/src/tree/mirror/streaming/materialized/work/tests.rs
+++ b/src/tree/mirror/streaming/materialized/work/tests.rs
@@ -38,12 +38,12 @@ use crate::{
 type Erased = <Local as Backend<()>>::Erased;
 
 /// Erase one typed leaf the way the walk's payloads carry it.
-fn erased(node: typed::Node<(), Z>) -> Erased {
+fn erased(node: typed::Node<Z>) -> Erased {
     <Local as Backend<()>>::erase(node)
 }
 
 /// A distinct leaf per call: the versions differ so hashes do.
-fn leaf(version: &mut Version) -> typed::Node<(), Z> {
+fn leaf(version: &mut Version) -> typed::Node<Z> {
     version.tick(&nth_party(0));
     typed::Node::leaf(version.clone(), Message::new(()))
 }
@@ -65,9 +65,10 @@ fn parent_prefix(parent: u8) -> Prefix<S<Z>> {
 /// Build the expected parent of a radix group directly through the backend.
 fn parent_of(
     prefix: Prefix<S<Z>>,
-    children: Vec<(u8, Option<typed::Node<(), Z>>)>,
-) -> Option<typed::Node<(), S<Z>>> {
-    pollster::block_on(Local.parent(prefix, children)).unwrap_or_else(|e| match e {})
+    children: Vec<(u8, Option<typed::Node<Z>>)>,
+) -> Option<typed::Node<S<Z>>> {
+    pollster::block_on(<Local as Backend<()>>::parent(Local, prefix, children))
+        .unwrap_or_else(|e| match e {})
 }
 
 type Item = Result<Resolution<Erased>, Error<Infallible>>;
@@ -224,9 +225,12 @@ fn chains_two_instances() {
 
     let inner = parent_of(parent_prefix(3), vec![(1, Some(a)), (7, Some(b))])
         .expect("a non-empty all-real group constructs its parent");
-    let expected =
-        pollster::block_on(Local.parent(parent_prefix(3).pop().0, vec![(3, Some(inner))]))
-            .unwrap_or_else(|e| match e {});
+    let expected = pollster::block_on(<Local as Backend<()>>::parent(
+        Local,
+        parent_prefix(3).pop().0,
+        vec![(3, Some(inner))],
+    ))
+    .unwrap_or_else(|e| match e {});
     assert_eq!(
         output
             .into_iter()
diff --git a/src/tree/mirror/streaming/materialized/work/tests/violations.rs b/src/tree/mirror/streaming/materialized/work/tests/violations.rs
index b52e40df5..ff7d5d2ac 100644
--- a/src/tree/mirror/streaming/materialized/work/tests/violations.rs
+++ b/src/tree/mirror/streaming/materialized/work/tests/violations.rs
@@ -73,11 +73,11 @@ fn arb_injection() -> impl Strategy<Value = Injection> {
 
 /// Build a node at any traversal height from one path-compressed leaf.
 trait TestHeight: Height + Sized {
-    fn node(version: &mut Version) -> typed::Node<(), Self>;
+    fn node(version: &mut Version) -> typed::Node<Self>;
 }
 
 impl TestHeight for Z {
-    fn node(version: &mut Version) -> typed::Node<(), Self> {
+    fn node(version: &mut Version) -> typed::Node<Self> {
         leaf(version)
     }
 }
@@ -86,7 +86,7 @@ impl<H: TestHeight> TestHeight for S<H>
 where
     S<H>: Height,
 {
-    fn node(version: &mut Version) -> typed::Node<(), Self> {
+    fn node(version: &mut Version) -> typed::Node<Self> {
         typed::Node::beneath(H::node(version), 0)
     }
 }
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/backend_errors.rs b/src/tree/mirror/streaming/remote/adapter/tests/backend_errors.rs
index 0eb0dff9e..3cae2c57d 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/backend_errors.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/backend_errors.rs
@@ -26,11 +26,11 @@ use crate::tree::mirror::streaming::{
 
 /// Construct the same one-leaf subtree at any concrete reply height.
 trait BackendHeight: Convert {
-    fn node(leaf: &LeafCase) -> typed::Node<u64, Self>;
+    fn node(leaf: &LeafCase) -> typed::Node<Self>;
 }
 
 impl BackendHeight for Z {
-    fn node(leaf: &LeafCase) -> typed::Node<u64, Self> {
+    fn node(leaf: &LeafCase) -> typed::Node<Self> {
         typed::Node::leaf(leaf.version.clone(), leaf.message.clone())
     }
 }
@@ -40,7 +40,7 @@ where
     H: BackendHeight,
     S<H>: Convert,
 {
-    fn node(leaf: &LeafCase) -> typed::Node<u64, Self> {
+    fn node(leaf: &LeafCase) -> typed::Node<Self> {
         let path: [u8; 32] = leaf.path().into();
         typed::Node::beneath(H::node(leaf), path[31 - H::HEIGHT])
     }
@@ -81,7 +81,7 @@ where
                     Reaction::Supply(supply_radix, supply),
                 ]
             };
-            let mut encoded = encode_reply(
+            let mut encoded = encode_reply::<_, u64>(
                 backend.clone(),
                 RunBudget::default(),
                 Scope::new(parent.erase(), &listing),
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs b/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs
index edd93886a..d8f5841e0 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs
@@ -115,7 +115,7 @@ fn an_unpositioned_match_is_rejected_in_both_directions() {
         replies: vec![Reaction::Match, Reaction::Match],
     };
     let encode_error = runtime().block_on(async {
-        encode_reply(
+        encode_reply::<_, u64>(
             Local,
             RunBudget::default(),
             Scope::new(parent.erase(), &[(1, hash(1))]),
@@ -165,7 +165,7 @@ fn an_unpositioned_query_is_rejected_in_both_directions() {
         replies: vec![Reaction::Query(listing)],
     };
     let encode_error = runtime().block_on(async {
-        encode_reply(
+        encode_reply::<_, u64>(
             Local,
             RunBudget::default(),
             Scope::new(parent.erase(), &[]),
@@ -209,7 +209,7 @@ fn leaf_query_matrix_is_exhaustive() {
             } else {
                 None
             };
-            let expected_frame =
+            let expected_frame: Frame<u64> =
                 Frame::Reaction(WireReaction::Query(query_listing.clone()), Flow::End);
 
             let reply = Reply::<<Local as Backend<()>>::Erased> {
@@ -354,17 +354,17 @@ fn a_multi_leaf_run_is_one_supplied_subtree() {
             panic!("one leaf run must become one supplied node")
         };
         let supplied_prefix = Prefix::<UnderRoot>::containing(&leaves[0].2);
-        let rebuilt = Local
-            .leaves(
-                supplied_prefix,
-                <Local as Backend<u64>>::assume::<UnderRoot>(node.clone()),
-            )
-            .try_collect::<Vec<_>>()
-            .await
-            .expect("the local backend is infallible");
+        let rebuilt = <Local as Backend<u64>>::leaves(
+            Local,
+            supplied_prefix,
+            <Local as Backend<u64>>::assume::<UnderRoot>(node.clone()),
+        )
+        .try_collect::<Vec<_>>()
+        .await
+        .expect("the local backend is infallible");
         assert_eq!(rebuilt.len(), 2);
 
-        encode_reply(Local, RunBudget::default(), scope, decoded.reply)
+        encode_reply::<_, u64>(Local, RunBudget::default(), scope, decoded.reply)
             .map_ok(|encoded| encoded.into_parts().0)
             .try_collect::<Vec<_>>()
             .await
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/opening.rs b/src/tree/mirror/streaming/remote/adapter/tests/opening.rs
index 5f9631b25..f7004d7bf 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/opening.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/opening.rs
@@ -26,7 +26,7 @@ use crate::tree::{
 };
 
 /// One erased opening node over the unit payload.
-fn erased(node: typed::Node<(), UnderRoot>) -> <Local as Backend<()>>::Erased {
+fn erased(node: typed::Node<UnderRoot>) -> <Local as Backend<()>>::Erased {
     <Local as Backend<()>>::erase(node)
 }
 
@@ -36,11 +36,11 @@ use super::{
 };
 
 trait OpeningNode: Height {
-    fn node() -> typed::Node<(), Self>;
+    fn node() -> typed::Node<Self>;
 }
 
 impl OpeningNode for Z {
-    fn node() -> typed::Node<(), Self> {
+    fn node() -> typed::Node<Self> {
         typed::Node::leaf(Version::new(), Message::new(()))
     }
 }
@@ -49,7 +49,7 @@ impl<H: OpeningNode> OpeningNode for S<H>
 where
     S<H>: Height,
 {
-    fn node() -> typed::Node<(), Self> {
+    fn node() -> typed::Node<Self> {
         typed::Node::beneath(H::node(), 0)
     }
 }
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/parking.rs b/src/tree/mirror/streaming/remote/adapter/tests/parking.rs
index 798a6b5ee..93207530f 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/parking.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/parking.rs
@@ -67,13 +67,13 @@ fn parked_supply_reply_holds_handles_not_subtrees() {
     // `replies.len()` pointers plus the skeleton — the subtree's bytes live
     // in backend custody behind the handle.
     assert_eq!(
-        mem::size_of::<typed::Node<u64, UnderRoot>>(),
+        mem::size_of::<typed::Node<UnderRoot>>(),
         mem::size_of::<usize>(),
         "a parked supply must be a shared handle, not an owned subtree",
     );
 
     let party = before::Party::seed();
-    let mut tree = Tree::new();
+    let mut tree = Tree::<()>::new();
     tree.act(&party, (0..LEAVES).map(|v| Action::Insert(Message::new(v))));
     let root = tree
         .root
@@ -83,8 +83,7 @@ fn parked_supply_reply_holds_handles_not_subtrees() {
 
     // The real root fan: version-addressed leaves scatter across first
     // bytes, so the fan is wide and its children are multi-leaf.
-    let children: Vec<(u8, typed::Node<u64, UnderRoot>)> =
-        root.into_children().into_iter().collect();
+    let children: Vec<(u8, typed::Node<UnderRoot>)> = root.into_children().into_iter().collect();
     let expected: Vec<(u8, Hash, usize)> = children
         .iter()
         .map(|(radix, node)| (*radix, node.hash(), node.len()))
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/properties.rs b/src/tree/mirror/streaming/remote/adapter/tests/properties.rs
index 512034fad..3ad4eaba1 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/properties.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/properties.rs
@@ -58,7 +58,7 @@ impl PositionalCase {
 
 /// Exercise an adapter law at one concrete type-level reply height.
 trait AdapterHeight: Convert {
-    fn node(leaf: &LeafCase) -> typed::Node<u64, Self>;
+    fn node(leaf: &LeafCase) -> typed::Node<Self>;
 
     fn supplied_leaf_is_lossless(
         leaf: &LeafCase,
@@ -95,7 +95,7 @@ trait AdapterHeight: Convert {
 }
 
 impl AdapterHeight for Z {
-    fn node(leaf: &LeafCase) -> typed::Node<u64, Self> {
+    fn node(leaf: &LeafCase) -> typed::Node<Self> {
         typed::Node::leaf(leaf.version.clone(), leaf.message.clone())
     }
 
@@ -353,7 +353,7 @@ where
     S<H>: Convert,
     S<S<H>>: Height,
 {
-    fn node(leaf: &LeafCase) -> typed::Node<u64, Self> {
+    fn node(leaf: &LeafCase) -> typed::Node<Self> {
         let path: [u8; 32] = leaf.path().into();
         typed::Node::beneath(H::node(leaf), path[31 - H::HEIGHT])
     }
@@ -667,7 +667,7 @@ fn mixed_reply<H: Height>(
     query_listing: &[(u8, Hash)],
     supply_at: usize,
     supply_radix: u8,
-    supply: typed::Node<u64, H>,
+    supply: typed::Node<H>,
 ) -> Reply<ErasedU64> {
     let mut supply = Some(<Local as Backend<u64>>::erase(supply));
     let mut replies = Vec::with_capacity(case.radixes.len() + 1);
@@ -820,11 +820,14 @@ where
 {
     let prefix = Prefix::<H>::containing(&expected_leaf.path());
     let leaves = runtime.block_on(async {
-        Local
-            .leaves(prefix, <Local as Backend<u64>>::assume::<H>(node.clone()))
-            .try_collect::<Vec<_>>()
-            .await
-            .expect("the local backend is infallible")
+        <Local as Backend<u64>>::leaves(
+            Local,
+            prefix,
+            <Local as Backend<u64>>::assume::<H>(node.clone()),
+        )
+        .try_collect::<Vec<_>>()
+        .await
+        .expect("the local backend is infallible")
     });
     prop_assert_eq!(leaves.len(), 1, "height {}", H::HEIGHT);
     let (actual_prefix, actual_leaf) = &leaves[0];
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/runs.rs b/src/tree/mirror/streaming/remote/adapter/tests/runs.rs
index 9c5bfb60d..07885eaed 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/runs.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/runs.rs
@@ -280,14 +280,14 @@ fn a_batched_run_round_trips_the_reply() {
     };
     let prefix = Prefix::<UnderRoot>::containing(&leaves[0].path());
     let rebuilt = runtime.block_on(async {
-        Local
-            .leaves(
-                prefix,
-                <Local as Backend<u64>>::assume::<UnderRoot>(node.clone()),
-            )
-            .try_collect::<Vec<_>>()
-            .await
-            .expect("the local backend is infallible")
+        <Local as Backend<u64>>::leaves(
+            Local,
+            prefix,
+            <Local as Backend<u64>>::assume::<UnderRoot>(node.clone()),
+        )
+        .try_collect::<Vec<_>>()
+        .await
+        .expect("the local backend is infallible")
     });
     assert_eq!(rebuilt.len(), leaves.len());
 }
diff --git a/src/tree/mirror/streaming/remote/proxy/tests.rs b/src/tree/mirror/streaming/remote/proxy/tests.rs
index a845eb1b8..ea56d609c 100644
--- a/src/tree/mirror/streaming/remote/proxy/tests.rs
+++ b/src/tree/mirror/streaming/remote/proxy/tests.rs
@@ -51,9 +51,9 @@ mod transport;
 const TRANSPORT_CAPACITY: usize = 37;
 
 /// Drive two local starts, each paired directly with its remote protocol start.
-async fn reconcile(a: TreeRoot<()>, b: TreeRoot<()>) -> (TreeRoot<()>, TreeRoot<()>) {
-    let a = Handshaking::start(Local, Root::from(a)).window(WindowConfig::FLOOR);
-    let b = Handshaking::start(Local, Root::from(b)).window(WindowConfig::FLOOR);
+async fn reconcile(a: TreeRoot, b: TreeRoot) -> (TreeRoot, TreeRoot) {
+    let a = Handshaking::start(Local, Root::<Local, ()>::from(a)).window(WindowConfig::FLOOR);
+    let b = Handshaking::start(Local, Root::<Local, ()>::from(b)).window(WindowConfig::FLOOR);
 
     let (a_link, b_link) = memory_with_capacity(TRANSPORT_CAPACITY);
     let remote_b = RemoteHandshaking::start(Local, a_link).window(WindowConfig::FLOOR);
@@ -68,15 +68,15 @@ async fn reconcile(a: TreeRoot<()>, b: TreeRoot<()>) -> (TreeRoot<()>, TreeRoot<
 /// Drive the production topology: each materialized local is the client of
 /// its own proxy, so both physical endpoints execute `Accept` concurrently.
 async fn reconcile_symmetric_accepts<T>(
-    a: TreeRoot<T>,
-    b: TreeRoot<T>,
+    a: TreeRoot,
+    b: TreeRoot,
     transport_capacity: usize,
-) -> (TreeRoot<T>, TreeRoot<T>)
+) -> (TreeRoot, TreeRoot)
 where
     T: DeserializeOwned + Send + Sync + 'static,
 {
-    let a = Handshaking::start(Local, Root::from(a)).window(WindowConfig::FLOOR);
-    let b = Handshaking::start(Local, Root::from(b)).window(WindowConfig::FLOOR);
+    let a = Handshaking::start(Local, Root::<Local, T>::from(a)).window(WindowConfig::FLOOR);
+    let b = Handshaking::start(Local, Root::<Local, T>::from(b)).window(WindowConfig::FLOOR);
     let (a_link, b_link) = memory_with_capacity(transport_capacity);
     let remote_b = RemoteHandshaking::start(Local, a_link).window(WindowConfig::FLOOR);
     let remote_a = RemoteHandshaking::start(Local, b_link).window(WindowConfig::FLOOR);
@@ -98,16 +98,16 @@ const REORDER_BATCH: usize = 3;
 /// `reordered` counts the genuine inversions both ends release; the caller
 /// asserts its disposition across the run.
 async fn reconcile_symmetric_accepts_reordered<T>(
-    a: TreeRoot<T>,
-    b: TreeRoot<T>,
+    a: TreeRoot,
+    b: TreeRoot,
     transport_capacity: usize,
     reordered: Arc<AtomicUsize>,
-) -> (TreeRoot<T>, TreeRoot<T>)
+) -> (TreeRoot, TreeRoot)
 where
     T: DeserializeOwned + Send + Sync + 'static,
 {
-    let a = Handshaking::start(Local, Root::from(a)).window(WindowConfig::FLOOR);
-    let b = Handshaking::start(Local, Root::from(b)).window(WindowConfig::FLOOR);
+    let a = Handshaking::start(Local, Root::<Local, T>::from(a)).window(WindowConfig::FLOOR);
+    let b = Handshaking::start(Local, Root::<Local, T>::from(b)).window(WindowConfig::FLOOR);
     let (a_link, b_link) = memory_with_capacity(transport_capacity);
     let a_link = reorder_accepts(a_link, REORDER_BATCH, reordered.clone());
     let b_link = reorder_accepts(b_link, REORDER_BATCH, reordered);
@@ -122,12 +122,12 @@ where
 
 /// Drive the production proxy topology after the shared preamble on the same
 /// transport halves, proving that neither phase consumes the other's bytes.
-async fn reconcile_after_preamble<T>(a: TreeRoot<T>, b: TreeRoot<T>) -> (TreeRoot<T>, TreeRoot<T>)
+async fn reconcile_after_preamble<T>(a: TreeRoot, b: TreeRoot) -> (TreeRoot, TreeRoot)
 where
     T: DeserializeOwned + Send + Sync + 'static,
 {
-    let a = Handshaking::start(Local, Root::from(a)).window(WindowConfig::FLOOR);
-    let b = Handshaking::start(Local, Root::from(b)).window(WindowConfig::FLOOR);
+    let a = Handshaking::start(Local, Root::<Local, T>::from(a)).window(WindowConfig::FLOOR);
+    let b = Handshaking::start(Local, Root::<Local, T>::from(b)).window(WindowConfig::FLOOR);
     let (mut a_link, mut b_link) = memory_with_capacity(64 * 1024);
     let network = crate::Network::from_bytes([1; 16]);
     let mut a_staged = handshake::Staged::new();
@@ -162,9 +162,9 @@ where
 }
 
 /// Reconcile the same pair entirely in process as the behavioral oracle.
-async fn reconcile_locally(a: TreeRoot<()>, b: TreeRoot<()>) -> (TreeRoot<()>, TreeRoot<()>) {
-    let a = Handshaking::start(Local, Root::from(a)).window(WindowConfig::FLOOR);
-    let b = Handshaking::start(Local, Root::from(b)).window(WindowConfig::FLOOR);
+async fn reconcile_locally(a: TreeRoot, b: TreeRoot) -> (TreeRoot, TreeRoot) {
+    let a = Handshaking::start(Local, Root::<Local, ()>::from(a)).window(WindowConfig::FLOOR);
+    let b = Handshaking::start(Local, Root::<Local, ()>::from(b)).window(WindowConfig::FLOOR);
     let (a, b) = Box::pin(mirror(a, b))
         .await
         .expect("two honest local participants should reconcile");
@@ -172,7 +172,7 @@ async fn reconcile_locally(a: TreeRoot<()>, b: TreeRoot<()>) -> (TreeRoot<()>, T
 }
 
 /// Translate a local root into the composable failing backend's node type.
-fn failing_root(root: TreeRoot<()>) -> Root<Failing<Local>, ()> {
+fn failing_root(root: TreeRoot) -> Root<Failing<Local>, ()> {
     Root {
         ceiling: root.ceiling,
         root: root.root.map(FailingNode::new),
@@ -181,8 +181,8 @@ fn failing_root(root: TreeRoot<()>) -> Root<Failing<Local>, ()> {
 
 /// Reconcile with exactly one proxy using the supplied failing backend.
 async fn reconcile_with_failing_proxy(
-    a: TreeRoot<()>,
-    b: TreeRoot<()>,
+    a: TreeRoot,
+    b: TreeRoot,
     failing: Failing<Local>,
     fail_left: bool,
 ) -> (Result<(), LeftFailure>, Result<(), RightFailure>) {
@@ -193,8 +193,8 @@ async fn reconcile_with_failing_proxy(
 
 /// Reconcile with independently stackable backend and transport failures.
 async fn reconcile_with_stacked_failures(
-    a: TreeRoot<()>,
-    b: TreeRoot<()>,
+    a: TreeRoot,
+    b: TreeRoot,
     failing: Failing<Local>,
     fail_left: bool,
     io_plan: IoPlan,
@@ -274,7 +274,7 @@ async fn equal_versions_return_both_roots() {
 /// Concurrent version-addressed leaves cross every proxy layer and converge.
 #[pollster::test]
 async fn divergent_leaves_converge() {
-    let mut a = Tree::new();
+    let mut a = Tree::<()>::new();
     a.act(&nth_party(0), [Action::Insert(Message::new(()))]);
     let mut b = Tree::new();
     b.act(&nth_party(1), [Action::Insert(Message::new(()))]);
@@ -295,7 +295,7 @@ fn symmetric_accept_handshakes_are_live() {
     let mut b = Tree::<()>::new();
     b.act(&nth_party(1), [Action::Insert(Message::new(()))]);
 
-    let (a, b) = run_to_quiescence(reconcile_symmetric_accepts(a.root, b.root, 1))
+    let (a, b) = run_to_quiescence(reconcile_symmetric_accepts::<()>(a.root, b.root, 1))
         .expect("the production proxy topology became quiescent");
     assert_eq!(a, b);
 }
@@ -311,7 +311,7 @@ fn symmetric_accepts_with_distinct_payloads_are_live() {
     let mut b = Tree::<u64>::new();
     b.act(&b_party, [Action::Insert(Message::new(2_u64))]);
 
-    let (a, b) = run_to_quiescence(reconcile_after_preamble(a.root, b.root))
+    let (a, b) = run_to_quiescence(reconcile_after_preamble::<u64>(a.root, b.root))
         .expect("distinct-payload proxy topology became quiescent");
     assert_eq!(a, b);
 }
@@ -324,7 +324,7 @@ proptest! {
     fn symmetric_accepts_match_local((a, b) in arb_divergent_pair()) {
         let expected = run_to_quiescence(reconcile_locally(a.clone(), b.clone()))
             .expect("local reconciliation should remain live");
-        let actual = run_to_quiescence(reconcile_symmetric_accepts(a, b, TRANSPORT_CAPACITY))
+        let actual = run_to_quiescence(reconcile_symmetric_accepts::<()>(a, b, TRANSPORT_CAPACITY))
             .map_err(|stopped| TestCaseError::fail(format!(
                 "symmetric proxy reconciliation became quiescent: {stopped:?}",
             )))?;
@@ -381,7 +381,7 @@ proptest! {
     fn wide_symmetric_accepts_match_local((a, b) in arb_wide_divergent_pair()) {
         let expected = run_to_quiescence(reconcile_locally(a.clone(), b.clone()))
             .expect("local reconciliation should remain live");
-        let actual = run_to_quiescence(reconcile_symmetric_accepts(a, b, 1))
+        let actual = run_to_quiescence(reconcile_symmetric_accepts::<()>(a, b, 1))
             .map_err(|stopped| TestCaseError::fail(format!(
                 "wide symmetric proxy reconciliation became quiescent: {stopped:?}",
             )))?;
@@ -485,7 +485,7 @@ fn wide_symmetric_accepts_reordered_match_local() {
     let cases = runner.run(&arb_wide_divergent_pair(), move |(a, b)| {
         let expected = run_to_quiescence(reconcile_locally(a.clone(), b.clone()))
             .expect("local reconciliation should remain live");
-        let actual = run_to_quiescence(reconcile_symmetric_accepts_reordered(
+        let actual = run_to_quiescence(reconcile_symmetric_accepts_reordered::<()>(
             a,
             b,
             1,
@@ -527,17 +527,18 @@ fn early_first_child_dispute_is_live() {
     let (a, b) = early_first_child_dispute_pair();
     let expected = run_to_quiescence(reconcile_locally(a.clone(), b.clone()))
         .expect("local reconciliation of the trigger geometry remains live");
-    let (left, right) = run_to_quiescence(reconcile_symmetric_accepts(a, b, TRANSPORT_CAPACITY))
-        .expect("the trigger geometry must reconcile over the wire");
+    let (left, right) =
+        run_to_quiescence(reconcile_symmetric_accepts::<()>(a, b, TRANSPORT_CAPACITY))
+            .expect("the trigger geometry must reconcile over the wire");
     assert_eq!((left, right), expected);
 }
 
 /// Every proxy queue kind is exercised and remains within its one-slot bound.
 #[test]
 fn instrumented_channels_cover_every_proxy_edge() {
-    let mut a = Tree::new();
+    let mut a = Tree::<()>::new();
     a.act(&nth_party(0), [Action::Insert(Message::new(()))]);
-    let mut b = Tree::new();
+    let mut b = Tree::<()>::new();
     b.act(&nth_party(1), [Action::Insert(Message::new(()))]);
     let (result, report, trace) = instrumented_reconcile(a.root, b.root, Vec::new());
     result.expect("the instrumented wire session should remain live");
@@ -553,11 +554,11 @@ fn instrumented_channels_cover_every_proxy_edge() {
 
 /// Reconcile once under channel scheduling while collecting both instruments.
 fn instrumented_reconcile(
-    a: TreeRoot<()>,
-    b: TreeRoot<()>,
+    a: TreeRoot,
+    b: TreeRoot,
     schedule: Vec<u8>,
 ) -> (
-    Result<(TreeRoot<()>, TreeRoot<()>), Quiescence>,
+    Result<(TreeRoot, TreeRoot), Quiescence>,
     ChannelReport,
     Trace,
 ) {
diff --git a/src/tree/mirror/streaming/remote/proxy/tests/containment.rs b/src/tree/mirror/streaming/remote/proxy/tests/containment.rs
index 6de686857..c1788708d 100644
--- a/src/tree/mirror/streaming/remote/proxy/tests/containment.rs
+++ b/src/tree/mirror/streaming/remote/proxy/tests/containment.rs
@@ -25,14 +25,11 @@ use super::harness::{LeftError, RightError};
 /// Drive the two-proxy topology, returning each endpoint's result instead
 /// of asserting success.
 async fn reconcile_results(
-    a: TreeRoot<()>,
-    b: TreeRoot<()>,
-) -> (
-    Result<TreeRoot<()>, LeftError>,
-    Result<TreeRoot<()>, RightError>,
-) {
-    let a = Handshaking::start(Local, Root::from(a)).window(WindowConfig::FLOOR);
-    let b = Handshaking::start(Local, Root::from(b)).window(WindowConfig::FLOOR);
+    a: TreeRoot,
+    b: TreeRoot,
+) -> (Result<TreeRoot, LeftError>, Result<TreeRoot, RightError>) {
+    let a = Handshaking::start(Local, Root::<Local, ()>::from(a)).window(WindowConfig::FLOOR);
+    let b = Handshaking::start(Local, Root::<Local, ()>::from(b)).window(WindowConfig::FLOOR);
 
     let (a_link, b_link) = memory_with_capacity(TRANSPORT_CAPACITY);
     let remote_b = RemoteHandshaking::start(Local, a_link).window(WindowConfig::FLOOR);
diff --git a/src/tree/mirror/streaming/remote/proxy/tests/declarations.rs b/src/tree/mirror/streaming/remote/proxy/tests/declarations.rs
index f37297bfb..2b8e3fec5 100644
--- a/src/tree/mirror/streaming/remote/proxy/tests/declarations.rs
+++ b/src/tree/mirror/streaming/remote/proxy/tests/declarations.rs
@@ -31,24 +31,24 @@ use crate::tree::{
 use super::harness::{self, GreetingRewrite};
 
 /// The observable root hash of a reconciled `tree::Root`.
-fn hash_of(root: &crate::tree::Root<()>) -> [u8; MERKLE_HASH_LEN] {
-    Tree { root: root.clone() }.hash()
+fn hash_of(root: &crate::tree::Root) -> [u8; MERKLE_HASH_LEN] {
+    Tree::<()>::from_root(root.clone()).hash()
 }
 
 /// The expected reconciled union, computed by the in-memory join oracle.
-fn union_hash(a: &crate::tree::Root<()>, b: &crate::tree::Root<()>) -> [u8; MERKLE_HASH_LEN] {
-    let mut union = Tree { root: a.clone() };
-    union.join(Tree { root: b.clone() });
+fn union_hash(a: &crate::tree::Root, b: &crate::tree::Root) -> [u8; MERKLE_HASH_LEN] {
+    let mut union = Tree::<()>::from_root(a.clone());
+    union.join(Tree::from_root(b.clone()));
     union.hash()
 }
 
 /// A divergent pair whose live set sizes differ strictly: one message
 /// against four, on distinct parties, so the smaller side wins the
 /// initiator election under honest declarations.
-fn uneven_pair() -> (crate::tree::Root<()>, crate::tree::Root<()>) {
-    let mut small = Tree::new();
+fn uneven_pair() -> (crate::tree::Root, crate::tree::Root) {
+    let mut small = Tree::<()>::new();
     small.act(&nth_party(1), [Action::Insert(Message::new(()))]);
-    let mut large = Tree::new();
+    let mut large = Tree::<()>::new();
     large.act(
         &nth_party(0),
         (0..4).map(|_| Action::Insert(Message::new(()))),
@@ -68,10 +68,10 @@ const BULK_MESSAGES: usize = FAN + 1;
 /// exclusive root children — at least one of which spans multiple leaves
 /// — reach it as whole supplied subtrees, so the traffic toward the small
 /// side includes a genuinely batched multi-record run.
-fn batched_uneven_pair() -> (crate::tree::Root<()>, crate::tree::Root<()>) {
-    let mut small = Tree::new();
+fn batched_uneven_pair() -> (crate::tree::Root, crate::tree::Root) {
+    let mut small = Tree::<()>::new();
     small.act(&nth_party(1), [Action::Insert(Message::new(()))]);
-    let mut large = Tree::new();
+    let mut large = Tree::<()>::new();
     large.act(
         &nth_party(0),
         (0..BULK_MESSAGES).map(|_| Action::Insert(Message::new(()))),
@@ -272,13 +272,13 @@ fn understated_set_len_fails_the_session() {
 /// A divergent pair of four messages against eight, on distinct parties:
 /// the four-message side wins the initiator election, and its whole
 /// exclusive content rides the opening-supply stream as one reply.
-fn opening_bulk_pair() -> (crate::tree::Root<()>, crate::tree::Root<()>) {
-    let mut small = Tree::new();
+fn opening_bulk_pair() -> (crate::tree::Root, crate::tree::Root) {
+    let mut small = Tree::<()>::new();
     small.act(
         &nth_party(1),
         (0..4).map(|_| Action::Insert(Message::new(()))),
     );
-    let mut large = Tree::new();
+    let mut large = Tree::<()>::new();
     large.act(
         &nth_party(0),
         (0..8).map(|_| Action::Insert(Message::new(()))),
diff --git a/src/tree/mirror/streaming/remote/proxy/tests/failures.rs b/src/tree/mirror/streaming/remote/proxy/tests/failures.rs
index 8ee6a36e1..7a5a7550c 100644
--- a/src/tree/mirror/streaming/remote/proxy/tests/failures.rs
+++ b/src/tree/mirror/streaming/remote/proxy/tests/failures.rs
@@ -53,13 +53,13 @@ fn injected<E>(error: &RemoteError<E>) -> Option<InjectedIo> {
 }
 
 /// A deterministic pair whose proxy backends perform real conversion work.
-fn stacked_pair() -> (crate::tree::Root<()>, crate::tree::Root<()>) {
-    let mut left = Tree::new();
+fn stacked_pair() -> (crate::tree::Root, crate::tree::Root) {
+    let mut left = Tree::<()>::new();
     left.act(
         &nth_party(0),
         (0..8).map(|_| Action::Insert(Message::new(()))),
     );
-    let mut right = Tree::new();
+    let mut right = Tree::<()>::new();
     right.act(
         &nth_party(1),
         (0..8).map(|_| Action::Insert(Message::new(()))),
diff --git a/src/tree/mirror/streaming/remote/proxy/tests/greeting.rs b/src/tree/mirror/streaming/remote/proxy/tests/greeting.rs
index 62bca8ac9..4ddaf39d1 100644
--- a/src/tree/mirror/streaming/remote/proxy/tests/greeting.rs
+++ b/src/tree/mirror/streaming/remote/proxy/tests/greeting.rs
@@ -18,16 +18,16 @@ use crate::tree::{
 use super::harness;
 
 /// The observable root hash of a reconciled `tree::Root`.
-fn hash_of(root: &crate::tree::Root<()>) -> [u8; MERKLE_HASH_LEN] {
-    Tree { root: root.clone() }.hash()
+fn hash_of(root: &crate::tree::Root) -> [u8; MERKLE_HASH_LEN] {
+    Tree::<()>::from_root(root.clone()).hash()
 }
 
 /// Reconcile through the two-proxy wire harness, requiring both sides to
 /// succeed, and return `(left, right)` reconciled roots.
 fn wire_reconcile(
-    left: crate::tree::Root<()>,
-    right: crate::tree::Root<()>,
-) -> (crate::tree::Root<()>, crate::tree::Root<()>) {
+    left: crate::tree::Root,
+    right: crate::tree::Root,
+) -> (crate::tree::Root, crate::tree::Root) {
     let outcome = run_to_quiescence(harness::reconcile(
         left,
         right,
@@ -44,9 +44,9 @@ fn wire_reconcile(
 
 /// The deep divergent pair's expected union, computed by the in-memory join
 /// oracle.
-fn union_hash(a: &crate::tree::Root<()>, b: &crate::tree::Root<()>) -> [u8; MERKLE_HASH_LEN] {
-    let mut union = Tree { root: a.clone() };
-    union.join(Tree { root: b.clone() });
+fn union_hash(a: &crate::tree::Root, b: &crate::tree::Root) -> [u8; MERKLE_HASH_LEN] {
+    let mut union = Tree::<()>::from_root(a.clone());
+    union.join(Tree::from_root(b.clone()));
     union.hash()
 }
 
@@ -82,15 +82,15 @@ fn carried_listing_converges_with_right_initiator() {
 /// will elect initiator (the smaller live set; ties fall back to the greater
 /// causal version in canonical bytes).
 fn order_by_election(
-    a: crate::tree::Root<()>,
-    b: crate::tree::Root<()>,
-) -> (crate::tree::Root<()>, crate::tree::Root<()>) {
+    a: crate::tree::Root,
+    b: crate::tree::Root,
+) -> (crate::tree::Root, crate::tree::Root) {
     assert_ne!(
         a.ceiling.as_bytes(),
         b.ceiling.as_bytes(),
         "a divergent fixture must elect deterministically"
     );
-    let len = |root: &crate::tree::Root<()>| {
+    let len = |root: &crate::tree::Root| {
         root.root
             .as_ref()
             .map(|node| node.len() as u64)
@@ -114,7 +114,7 @@ fn order_by_election(
 #[test]
 fn empty_carried_listing_asks_for_everything() {
     // The populated responder: one message on party 0.
-    let mut populated = Tree::new();
+    let mut populated = Tree::<()>::new();
     populated.act(&nth_party(0), [Action::Insert(Message::new(()))]);
 
     // The emptied initiator: insert-then-forget on party 1 ticks its version
@@ -150,7 +150,7 @@ fn empty_carried_listing_asks_for_everything() {
 #[test]
 fn converged_session_carries_listings_unused() {
     let build = || {
-        let mut tree = Tree::new();
+        let mut tree = Tree::<()>::new();
         tree.act(&nth_party(0), [Action::Insert(Message::new(()))]);
         tree
     };
@@ -187,7 +187,7 @@ fn converged_session_carries_listings_unused() {
 #[test]
 fn mixed_empty_and_populated_converges() {
     let empty = Tree::<()>::new();
-    let mut populated = Tree::new();
+    let mut populated = Tree::<()>::new();
     populated.act(
         &nth_party(0),
         (0..4).map(|_| Action::Insert(Message::new(()))),
@@ -238,7 +238,7 @@ fn overlapping_sessions_lose_innocent_leaf_after_honored_redaction() {
     // redaction empties its root radix — and sweeping the redacted leaf
     // puts shared runs on both sides of every divergence point.
     let p = nth_party(0);
-    let mut t0 = Tree::new();
+    let mut t0 = Tree::<()>::new();
     t0.act(&p, (0..25).map(|_| Action::Insert(Message::new(()))));
     let leaves: Vec<_> = t0
         .iter()
@@ -254,9 +254,7 @@ fn overlapping_sessions_lose_innocent_leaf_after_honored_redaction() {
         // S1's counterparty: converged at T0, then redacted the leaf at
         // `k` (a local act rebuilds its own fans afresh; the sharing that
         // matters is created by our install below, not here).
-        let mut twin = Tree {
-            root: t0.root.clone(),
-        };
+        let mut twin = Tree::<()>::from_root(t0.root.clone());
         twin.act(&nth_party(1), [Action::Forget(*k)]);
 
         // S1's session and install: reconcile T0 against the redacting
@@ -264,19 +262,13 @@ fn overlapping_sessions_lose_innocent_leaf_after_honored_redaction() {
         // Deletion honoring drops radix `r_h`: the live tree's root fan is
         // now a clone-derived sibling of M0 missing one radix.
         let (s1_reconciled, _) = wire_reconcile(t0.root.clone(), twin.root.clone());
-        let mut live = Tree {
-            root: t0.root.clone(),
-        };
-        live.join(Tree {
-            root: s1_reconciled,
-        });
+        let mut live = Tree::<()>::from_root(t0.root.clone());
+        live.join(Tree::from_root(s1_reconciled));
         let expected = live.hash();
 
         // S2's install, after S1's: joining our own causal past must be an
         // identity on the tree.
-        live.join(Tree {
-            root: s2_reconciled.clone(),
-        });
+        live.join(Tree::from_root(s2_reconciled.clone()));
 
         if live.hash() != expected {
             let missing: Vec<_> = leaves
diff --git a/src/tree/mirror/streaming/remote/proxy/tests/harness.rs b/src/tree/mirror/streaming/remote/proxy/tests/harness.rs
index 411a0cb1b..19576413b 100644
--- a/src/tree/mirror/streaming/remote/proxy/tests/harness.rs
+++ b/src/tree/mirror/streaming/remote/proxy/tests/harness.rs
@@ -53,9 +53,9 @@ pub type RightError = MirrorError<RemoteError<Infallible>, MaterializedError<Inf
 /// Both endpoint results and their physical-I/O observations.
 pub struct Outcome {
     /// The first materialized tree, or its session failure.
-    pub left: Result<TreeRoot<()>, LeftError>,
+    pub left: Result<TreeRoot, LeftError>,
     /// The second materialized tree, or its session failure.
-    pub right: Result<TreeRoot<()>, RightError>,
+    pub right: Result<TreeRoot, RightError>,
     /// I/O performed by the first proxy endpoint.
     pub left_io: IoReportHandle,
     /// I/O performed by the second proxy endpoint.
@@ -344,8 +344,8 @@ impl<R: AsyncRead + Unpin> AsyncRead for RewriteRead<R> {
 
 /// Reconcile one pair through two proxies over independently wrapped links.
 pub async fn reconcile(
-    left: TreeRoot<()>,
-    right: TreeRoot<()>,
+    left: TreeRoot,
+    right: TreeRoot,
     capacity: usize,
     left_plan: IoPlan,
     right_plan: IoPlan,
@@ -369,14 +369,11 @@ pub async fn reconcile(
 /// Runs under the default budget-derived window so the rewritten
 /// declarations flow into the live window solve, not a fixed test floor.
 pub async fn reconcile_rewritten_greetings(
-    left: TreeRoot<()>,
-    right: TreeRoot<()>,
+    left: TreeRoot,
+    right: TreeRoot,
     left_hears: Option<GreetingRewrite>,
     right_hears: Option<GreetingRewrite>,
-) -> (
-    Result<TreeRoot<()>, LeftError>,
-    Result<TreeRoot<()>, RightError>,
-) {
+) -> (Result<TreeRoot, LeftError>, Result<TreeRoot, RightError>) {
     let (left_link, right_link) = memory_with_capacity(TRANSPORT_CAPACITY);
     drive(
         left,
@@ -418,8 +415,8 @@ fn rewritten(
 /// initiates is a function of live counts and canonical version bytes,
 /// both of which move whenever the wire coding or a fixture's content
 /// addresses do.
-pub fn left_initiates(left: &TreeRoot<()>, right: &TreeRoot<()>) -> bool {
-    let len = |root: &TreeRoot<()>| {
+pub fn left_initiates(left: &TreeRoot, right: &TreeRoot) -> bool {
+    let len = |root: &TreeRoot| {
         root.root
             .as_ref()
             .map(|node| node.len() as u64)
@@ -435,14 +432,11 @@ pub fn left_initiates(left: &TreeRoot<()>, right: &TreeRoot<()>) -> bool {
 
 /// Reconcile while mutating at most one data-stream frame on each side.
 pub async fn reconcile_scripted(
-    left: TreeRoot<()>,
-    right: TreeRoot<()>,
+    left: TreeRoot,
+    right: TreeRoot,
     left_script: Option<Script>,
     right_script: Option<Script>,
-) -> (
-    Result<TreeRoot<()>, LeftError>,
-    Result<TreeRoot<()>, RightError>,
-) {
+) -> (Result<TreeRoot, LeftError>, Result<TreeRoot, RightError>) {
     let (left_link, right_link) = memory_with_capacity(TRANSPORT_CAPACITY);
     drive(
         left,
@@ -480,15 +474,12 @@ fn scripted(
 
 /// Drive the shared two-mirror topology over already-wrapped links.
 async fn drive<LR, LW, LC, LA, RR, RW, RC, RA>(
-    left: TreeRoot<()>,
-    right: TreeRoot<()>,
+    left: TreeRoot,
+    right: TreeRoot,
     left_link: Link<LR, LW, LC, LA>,
     right_link: Link<RR, RW, RC, RA>,
     window: WindowConfig,
-) -> (
-    Result<TreeRoot<()>, LeftError>,
-    Result<TreeRoot<()>, RightError>,
-)
+) -> (Result<TreeRoot, LeftError>, Result<TreeRoot, RightError>)
 where
     LR: AsyncRead + Unpin + Send,
     LW: AsyncWrite + Unpin + Send,
@@ -499,8 +490,8 @@ where
     RC: Connector,
     RA: Acceptor,
 {
-    let left = Handshaking::start(Local, Root::from(left)).window(window);
-    let right = Handshaking::start(Local, Root::from(right)).window(window);
+    let left = Handshaking::start(Local, Root::<Local, ()>::from(left)).window(window);
+    let right = Handshaking::start(Local, Root::<Local, ()>::from(right)).window(window);
     let remote_right = RemoteHandshaking::start(Local, left_link).window(window);
     let remote_left = RemoteHandshaking::start(Local, right_link).window(window);
     let (left, right) = join!(
diff --git a/src/tree/mirror/streaming/remote/proxy/tests/malformed.rs b/src/tree/mirror/streaming/remote/proxy/tests/malformed.rs
index 68dd500c5..a1a2d3aab 100644
--- a/src/tree/mirror/streaming/remote/proxy/tests/malformed.rs
+++ b/src/tree/mirror/streaming/remote/proxy/tests/malformed.rs
@@ -23,7 +23,7 @@ use crate::tree::{
 /// first data frame is its first *reply*.) The divergent
 /// branching dispute also guarantees nonempty queries in both directions,
 /// which the unordered-query mutation needs to find.
-fn deep_pair() -> (crate::tree::Root<()>, crate::tree::Root<()>) {
+fn deep_pair() -> (crate::tree::Root, crate::tree::Root) {
     early_first_child_dispute_pair()
 }
 
@@ -42,8 +42,8 @@ fn reserved_signal(error: &RemoteError<std::convert::Infallible>) -> Option<u8>
 /// Borrow the remote error detected opposite the corrupt writer.
 fn receiving_error<'a>(
     corrupt_left: bool,
-    left: &'a Result<crate::tree::Root<()>, harness::LeftError>,
-    right: &'a Result<crate::tree::Root<()>, harness::RightError>,
+    left: &'a Result<crate::tree::Root, harness::LeftError>,
+    right: &'a Result<crate::tree::Root, harness::RightError>,
 ) -> &'a RemoteError<std::convert::Infallible> {
     if corrupt_left {
         match right {
diff --git a/src/tree/mirror/streaming/remote/proxy/tests/transport.rs b/src/tree/mirror/streaming/remote/proxy/tests/transport.rs
index 575b8b350..18086351e 100644
--- a/src/tree/mirror/streaming/remote/proxy/tests/transport.rs
+++ b/src/tree/mirror/streaming/remote/proxy/tests/transport.rs
@@ -24,12 +24,12 @@ fn plan(read_chunk: usize, write_chunk: usize, delays: Vec<u8>, hold_until_flush
 /// protocol.
 #[test]
 fn flush_only_one_byte_transport_reconciles() {
-    let mut left = Tree::new();
+    let mut left = Tree::<()>::new();
     left.act(
         &nth_party(0),
         (0..8).map(|_| Action::Insert(Message::new(()))),
     );
-    let mut right = Tree::new();
+    let mut right = Tree::<()>::new();
     right.act(
         &nth_party(1),
         (0..8).map(|_| Action::Insert(Message::new(()))),
diff --git a/src/tree/mirror/streaming/testing/faulting.rs b/src/tree/mirror/streaming/testing/faulting.rs
index 1533930c2..35b5ba660 100644
--- a/src/tree/mirror/streaming/testing/faulting.rs
+++ b/src/tree/mirror/streaming/testing/faulting.rs
@@ -125,10 +125,10 @@ fn escaped_version() -> Version {
 /// Construct a valid supplied node at any reply height.
 trait FaultHeight: height::Height + Sized {
     /// A node whose single leaf carries `version`.
-    fn node_at(version: Version) -> typed::Node<(), Self>;
+    fn node_at(version: Version) -> typed::Node<Self>;
 
     /// A node at the canonical contained version.
-    fn node() -> typed::Node<(), Self> {
+    fn node() -> typed::Node<Self> {
         Self::node_at(contained_version())
     }
 }
@@ -162,7 +162,7 @@ impl<B: FaultBackend> FaultBackend for Failing<B> {
 }
 
 impl FaultHeight for height::Z {
-    fn node_at(version: Version) -> typed::Node<(), Self> {
+    fn node_at(version: Version) -> typed::Node<Self> {
         typed::Node::leaf(version, Message::new(()))
     }
 }
@@ -171,7 +171,7 @@ impl<H: FaultHeight> FaultHeight for height::S<H>
 where
     height::S<H>: height::Height,
 {
-    fn node_at(version: Version) -> typed::Node<(), Self> {
+    fn node_at(version: Version) -> typed::Node<Self> {
         typed::Node::beneath(H::node_at(version), 0)
     }
 }
diff --git a/src/tree/mirror/streaming/tests.rs b/src/tree/mirror/streaming/tests.rs
index 84903dd8d..c0eb8b10f 100644
--- a/src/tree/mirror/streaming/tests.rs
+++ b/src/tree/mirror/streaming/tests.rs
@@ -62,26 +62,22 @@ fn terminal_errors_preempt_parked_peers() {
 
 /// Reconcile `a` and `b` through the streaming local backend, returning both
 /// sides' reconciled roots in argument order, with no convergence assertion.
-fn streaming_mirror_sides(a: Root<()>, b: Root<()>) -> (Root<()>, Root<()>) {
+fn streaming_mirror_sides(a: Root, b: Root) -> (Root, Root) {
     streaming_mirror_sides_with_schedule(a, b, Vec::new())
 }
 
 /// Reconcile under an explicit, shrinkable channel-poll schedule.
-fn streaming_mirror_sides_with_schedule(
-    a: Root<()>,
-    b: Root<()>,
-    schedule: Vec<u8>,
-) -> (Root<()>, Root<()>) {
+fn streaming_mirror_sides_with_schedule(a: Root, b: Root, schedule: Vec<u8>) -> (Root, Root) {
     streaming_mirror_sides_with_schedules(a, b, schedule, Vec::new())
 }
 
 /// Reconcile under independent channel and Local-backend poll schedules.
 fn streaming_mirror_sides_with_schedules(
-    a: Root<()>,
-    b: Root<()>,
+    a: Root,
+    b: Root,
     channel_schedule: Vec<u8>,
     backend_schedule: Vec<u8>,
-) -> (Root<()>, Root<()>) {
+) -> (Root, Root) {
     let (a, b): (StreamingRoot<Local, ()>, StreamingRoot<Local, ()>) = (a.into(), b.into());
     let client = Handshaking::start(Local, a.clone()).window(WindowConfig::FLOOR);
     let server = Handshaking::start(Local, b.clone()).window(WindowConfig::FLOOR);
@@ -108,9 +104,9 @@ fn streaming_mirror_sides_with_schedules(
 /// so payload-perturbation twins (same paths, different contents) can run
 /// through the identical machinery.
 fn transcribed_mirror_sides<T: Send + Sync + 'static>(
-    a: Root<T>,
-    b: Root<T>,
-) -> (Root<T>, Root<T>, Trace, Transcript) {
+    a: Root,
+    b: Root,
+) -> (Root, Root, Trace, Transcript) {
     let (a, b): (StreamingRoot<Local, T>, StreamingRoot<Local, T>) = (a.into(), b.into());
     let client = Handshaking::start(Local, a).window(WindowConfig::FLOOR);
     let server = Handshaking::start(Local, b).window(WindowConfig::FLOOR);
@@ -125,14 +121,14 @@ fn transcribed_mirror_sides<T: Send + Sync + 'static>(
 
 /// Reconcile `a` and `b` through the streaming local backend, asserting the
 /// two sides converge to the same root, and return it.
-fn streaming_mirror(a: Root<()>, b: Root<()>) -> Root<()> {
+fn streaming_mirror(a: Root, b: Root) -> Root {
     let (ours, theirs) = streaming_mirror_sides(a, b);
     assert_eq!(ours, theirs, "streaming endpoints should converge");
     ours
 }
 
 /// Reconcile under an explicit channel-poll schedule, asserting convergence.
-fn scheduled_streaming_mirror(a: Root<()>, b: Root<()>, schedule: Vec<u8>) -> Root<()> {
+fn scheduled_streaming_mirror(a: Root, b: Root, schedule: Vec<u8>) -> Root {
     let (ours, theirs) = streaming_mirror_sides_with_schedule(a, b, schedule);
     assert_eq!(
         ours, theirs,
@@ -143,11 +139,11 @@ fn scheduled_streaming_mirror(a: Root<()>, b: Root<()>, schedule: Vec<u8>) -> Ro
 
 /// Reconcile under independent channel and Local-backend poll schedules.
 fn fully_scheduled_streaming_mirror(
-    a: Root<()>,
-    b: Root<()>,
+    a: Root,
+    b: Root,
     channel_schedule: Vec<u8>,
     backend_schedule: Vec<u8>,
-) -> Root<()> {
+) -> Root {
     let (ours, theirs) =
         streaming_mirror_sides_with_schedules(a, b, channel_schedule, backend_schedule);
     assert_eq!(
@@ -161,11 +157,11 @@ fn fully_scheduled_streaming_mirror(
 /// behavioral oracle the streaming protocol must reproduce exactly —
 /// returning both sides' roots in argument order, with no convergence
 /// assertion.
-fn alternating_mirror_sides(a: Root<()>, b: Root<()>) -> (Root<()>, Root<()>) {
+fn alternating_mirror_sides(a: Root, b: Root) -> (Root, Root) {
     pollster::block_on(async {
         let local_a = alternating::local::Exchange::start(a);
         let local_b = alternating::local::Exchange::start(b);
-        alternating::mirror(local_a, local_b)
+        alternating::mirror::<_, _, ()>(local_a, local_b)
             .await
             .expect("two honest oracle endpoints speak no violations")
     })
@@ -173,7 +169,7 @@ fn alternating_mirror_sides(a: Root<()>, b: Root<()>) -> (Root<()>, Root<()>) {
 
 /// Reconcile `a` and `b` through the alternating oracle, asserting the two
 /// sides converge to the same root, and return it.
-fn alternating_mirror(a: Root<()>, b: Root<()>) -> Root<()> {
+fn alternating_mirror(a: Root, b: Root) -> Root {
     let (ours, theirs) = alternating_mirror_sides(a, b);
     assert_eq!(ours, theirs, "oracle endpoints should converge");
     ours
@@ -184,7 +180,7 @@ fn alternating_mirror(a: Root<()>, b: Root<()>) -> Root<()> {
 /// The union covers shared-history divergence (including redactions and
 /// matched subtrees), independent party histories (including empty bootstrap
 /// shapes), and the equal-version short circuit.
-fn arb_oracle_pair() -> impl Strategy<Value = (Root<()>, Root<()>)> {
+fn arb_oracle_pair() -> impl Strategy<Value = (Root, Root)> {
     prop_oneof![
         4 => arb_divergent_pair(),
         2 => (arb_tree_root(0, 0..=8), arb_tree_root(1, 0..=8)),
diff --git a/src/tree/mirror/streaming/tests/announced.rs b/src/tree/mirror/streaming/tests/announced.rs
index 1266af6b6..27c6d048e 100644
--- a/src/tree/mirror/streaming/tests/announced.rs
+++ b/src/tree/mirror/streaming/tests/announced.rs
@@ -52,7 +52,7 @@ proptest! {
     fn announced_skeleton_reconstructs_the_session(spec in arb_divergence()) {
         let run = |value: u64| {
             let (local, remote, _) = spec.trees(&value);
-            transcribed_mirror_sides(local, remote)
+            transcribed_mirror_sides::<()>(local, remote)
         };
 
         let (ours, theirs, trace, transcript) = run(0);
diff --git a/src/tree/mirror/streaming/tests/capacity.rs b/src/tree/mirror/streaming/tests/capacity.rs
index 9c30de707..2f7af8c32 100644
--- a/src/tree/mirror/streaming/tests/capacity.rs
+++ b/src/tree/mirror/streaming/tests/capacity.rs
@@ -23,7 +23,7 @@ use crate::tree::{
 };
 
 /// Whether the session stalls at a selected capacity for the fan return queue.
-fn underbuffered_mirror_stalls(a: Root<()>, b: Root<()>, capacity: usize) -> bool {
+fn underbuffered_mirror_stalls(a: Root, b: Root, capacity: usize) -> bool {
     let (a, b): (StreamingRoot<Local, ()>, StreamingRoot<Local, ()>) = (a.into(), b.into());
     let client = Handshaking::start(Local, a).window(WindowConfig::FLOOR);
     let server = Handshaking::start(Local, b).window(WindowConfig::FLOOR);
@@ -36,7 +36,7 @@ fn underbuffered_mirror_stalls(a: Root<()>, b: Root<()>, capacity: usize) -> boo
 }
 
 /// Check one structural stress case under endpoint and poll-order variations.
-fn assert_capacity_case(name: &'static str, pair: (Root<()>, Root<()>)) {
+fn assert_capacity_case(name: &'static str, pair: (Root, Root)) {
     let (a, b) = pair;
     let expected = alternating_mirror(a.clone(), b.clone());
     let schedules = [
@@ -196,7 +196,7 @@ fn capacity_stress_witness_requires_inter_level_fan() {
 
 /// Whether one shape stalls at a return capacity under explicit poll schedules.
 fn shape_stalls(
-    pair: &(Root<()>, Root<()>),
+    pair: &(Root, Root),
     capacity: usize,
     channel_schedule: Vec<u8>,
     backend_schedule: Vec<u8>,
@@ -235,7 +235,7 @@ fn probe_schedules() -> [(Vec<u8>, Vec<u8>); 5] {
 }
 
 /// Whether a shape stalls under any probe schedule at the given capacity.
-fn stalls_under_any_schedule(pair: &(Root<()>, Root<()>), capacity: usize) -> bool {
+fn stalls_under_any_schedule(pair: &(Root, Root), capacity: usize) -> bool {
     probe_schedules()
         .into_iter()
         .any(|(chan, back)| shape_stalls(pair, capacity, chan, back))
diff --git a/src/tree/mirror/streaming/tests/faults.rs b/src/tree/mirror/streaming/tests/faults.rs
index 6ff8c33c5..d6ca7c5a8 100644
--- a/src/tree/mirror/streaming/tests/faults.rs
+++ b/src/tree/mirror/streaming/tests/faults.rs
@@ -21,7 +21,7 @@ use crate::tree::mirror::{
     },
 };
 
-fn failing_root(root: crate::tree::Root<()>) -> StreamingRoot<Failing<Local>, ()> {
+fn failing_root(root: crate::tree::Root) -> StreamingRoot<Failing<Local>, ()> {
     StreamingRoot {
         ceiling: root.ceiling,
         root: root.root.map(FailingNode::new),
@@ -162,7 +162,7 @@ proptest! {
                 }
             }
             (None, Ok((ours, theirs))) => {
-                let (ours, theirs): (crate::tree::Root<()>, crate::tree::Root<()>) =
+                let (ours, theirs): (crate::tree::Root, crate::tree::Root) =
                     (ours.into(), theirs.into());
                 let (base_client, base_server) =
                     streaming_mirror_sides(client_root.clone(), server_root.clone());
diff --git a/src/tree/mirror/streaming/tests/fixtures.rs b/src/tree/mirror/streaming/tests/fixtures.rs
index aec6f689e..1183f2204 100644
--- a/src/tree/mirror/streaming/tests/fixtures.rs
+++ b/src/tree/mirror/streaming/tests/fixtures.rs
@@ -32,12 +32,12 @@ pub(super) fn path_at(prefix: &[u8]) -> Path {
 /// they change versions or contents (hence every hash on the path) without
 /// touching the path structure the reconciliation keys on.
 pub(super) fn grown<T>(
-    node: Option<TreeNode<T, height::Root>>,
+    node: Option<TreeNode<height::Root>>,
     party: usize,
     stride: usize,
     value: &T,
     paths: &[Path],
-) -> Option<TreeNode<T, height::Root>>
+) -> Option<TreeNode<height::Root>>
 where
     T: Serialize + Clone + Send + Sync + 'static,
 {
@@ -55,11 +55,11 @@ where
             Action::Insert(Message::new(value.clone())),
         ));
     }
-    act(node, actions, |_| ())
+    act(node, actions, &mut |_| ())
 }
 
 /// Wrap a node as a [`Root`] whose ceiling is the node's own.
-pub(super) fn rooted<T>(node: Option<TreeNode<T, height::Root>>) -> Root<T> {
+pub(super) fn rooted(node: Option<TreeNode<height::Root>>) -> Root {
     Root {
         ceiling: node
             .as_ref()
@@ -80,7 +80,7 @@ pub(super) fn rooted<T>(node: Option<TreeNode<T, height::Root>>) -> Root<T> {
 /// semantically inert here: deletion-pruning compares leaf versions against
 /// the PEER's ceiling, and every fixture keeps each side's supplies on
 /// chains the other side's ceiling never covers.
-pub(super) fn rooted_at<T>(node: Option<TreeNode<T, height::Root>>, ceiling: Version) -> Root<T> {
+pub(super) fn rooted_at(node: Option<TreeNode<height::Root>>, ceiling: Version) -> Root {
     Root {
         ceiling,
         root: node,
@@ -88,7 +88,7 @@ pub(super) fn rooted_at<T>(node: Option<TreeNode<T, height::Root>>, ceiling: Ver
 }
 
 /// The ceiling a node would advertise on its own.
-pub(super) fn ceiling_of<T>(node: &Option<TreeNode<T, height::Root>>) -> Version {
+pub(super) fn ceiling_of(node: &Option<TreeNode<height::Root>>) -> Version {
     node.as_ref()
         .map(TreeNode::ceiling)
         .cloned()
@@ -236,7 +236,7 @@ impl Divergence {
     /// role election's keys — set size first, version bytes on ties — are
     /// identical across the two sessions and the local tree plays one role
     /// in both.
-    pub fn trees<T>(&self, value: &T) -> (Root<T>, Root<T>, Root<T>)
+    pub fn trees<T>(&self, value: &T) -> (Root, Root, Root)
     where
         T: Serialize + Clone + Send + Sync + 'static,
     {
@@ -325,7 +325,7 @@ pub(super) fn arb_divergence() -> impl Strategy<Value = Divergence> {
 /// both sides with different content, every root child disputes but nothing
 /// disputes below it: the session's descent is empty, and the whole diff
 /// resolves in the first descending stage.
-pub(super) fn one_sided_pair(spec: &[(u8, u8, u8)]) -> (Root<()>, Root<()>) {
+pub(super) fn one_sided_pair(spec: &[(u8, u8, u8)]) -> (Root, Root) {
     let path = |b0: u8, b1: u8| {
         let mut bytes = [0u8; 32];
         bytes[0] = b0;
@@ -349,7 +349,7 @@ pub(super) fn one_sided_pair(spec: &[(u8, u8, u8)]) -> (Root<()>, Root<()>) {
             ));
         }
     }
-    let a_node = act(None, shared, |_| ());
+    let a_node = act(None, shared, &mut |_| ());
 
     // b's extras: a separate chain on a disjoint party, so they are causally
     // concurrent with a's version and survive deletion-pruning when provided.
@@ -367,9 +367,9 @@ pub(super) fn one_sided_pair(spec: &[(u8, u8, u8)]) -> (Root<()>, Root<()>) {
             ));
         }
     }
-    let b_node = act(a_node.clone(), extras, |_| ());
+    let b_node = act(a_node.clone(), extras, &mut |_| ());
 
-    let root = |node: Option<TreeNode<(), height::Root>>| Root {
+    let root = |node: Option<TreeNode<height::Root>>| Root {
         ceiling: node
             .as_ref()
             .map(TreeNode::ceiling)
@@ -411,7 +411,7 @@ pub(super) fn divergent_cells_pair(
     cells: &[Vec<u8>],
     shared: usize,
     order: LeafOrder,
-) -> (Root<()>, Root<()>) {
+) -> (Root, Root) {
     assert!(cells.iter().all(|cell| cell.len() < 32));
     let (shared_slots, a_slot, b_slot) = order.slots(shared);
     let path = |cell: &[u8], slot: u8| {
@@ -438,7 +438,7 @@ pub(super) fn divergent_cells_pair(
             ));
         }
     }
-    let base_node = act(None, base, |_| ());
+    let base_node = act(None, base, &mut |_| ());
 
     // Each side's extras ride their own party's chain, concurrent with the
     // shared chain and with each other, so both survive deletion-pruning
@@ -457,10 +457,10 @@ pub(super) fn divergent_cells_pair(
         }
         actions
     };
-    let a_node = act(base_node.clone(), extras(2, a_slot), |_| ());
-    let b_node = act(base_node, extras(1, b_slot), |_| ());
+    let a_node = act(base_node.clone(), extras(2, a_slot), &mut |_| ());
+    let b_node = act(base_node, extras(1, b_slot), &mut |_| ());
 
-    let root = |node: Option<TreeNode<(), height::Root>>| Root {
+    let root = |node: Option<TreeNode<height::Root>>| Root {
         ceiling: node
             .as_ref()
             .map(TreeNode::ceiling)
@@ -472,11 +472,7 @@ pub(super) fn divergent_cells_pair(
 }
 
 /// Build a cartesian pyramid whose disputes descend every controlled level.
-pub(super) fn pyramid_pair(
-    widths: &[usize],
-    shared: usize,
-    order: LeafOrder,
-) -> (Root<()>, Root<()>) {
+pub(super) fn pyramid_pair(widths: &[usize], shared: usize, order: LeafOrder) -> (Root, Root) {
     assert!(widths.iter().all(|&width| (1..=256).contains(&width)));
     let mut cells: Vec<Vec<u8>> = vec![Vec::new()];
     for &width in widths {
@@ -495,7 +491,7 @@ pub(super) fn pyramid_pair(
 }
 
 /// Build a linear-size comb with a dispute branching from every trie level.
-pub(super) fn full_depth_comb_pair(shared: usize, order: LeafOrder) -> (Root<()>, Root<()>) {
+pub(super) fn full_depth_comb_pair(shared: usize, order: LeafOrder) -> (Root, Root) {
     let mut cells = vec![vec![0; 31]];
     for depth in 0..31 {
         let mut cell = vec![0; 31];
diff --git a/src/tree/mirror/streaming/tests/local_eq.rs b/src/tree/mirror/streaming/tests/local_eq.rs
index c9aafab59..a921b32dc 100644
--- a/src/tree/mirror/streaming/tests/local_eq.rs
+++ b/src/tree/mirror/streaming/tests/local_eq.rs
@@ -110,8 +110,8 @@ proptest! {
         );
 
         let local_paths = spec.local_path_set();
-        let (_, _, trace_0, _) = transcribed_mirror_sides(local.clone(), remote_0);
-        let (_, _, trace_1, _) = transcribed_mirror_sides(local, remote_1);
+        let (_, _, trace_0, _) = transcribed_mirror_sides::<()>(local.clone(), remote_0);
+        let (_, _, trace_1, _) = transcribed_mirror_sides::<()>(local, remote_1);
         let decoded_0 = decode(&trace_0);
         let decoded_1 = decode(&trace_1);
 
@@ -223,8 +223,8 @@ fn free_insertions_are_invisible_to_the_local_view() {
         let remote_0 = rooted_at(remote_plus(shallow), join.clone());
         let remote_1 = rooted_at(remote_plus(deep), join);
 
-        let (_, _, trace_0, _) = transcribed_mirror_sides(local.clone(), remote_0);
-        let (_, _, trace_1, _) = transcribed_mirror_sides(local, remote_1);
+        let (_, _, trace_0, _) = transcribed_mirror_sides::<()>(local.clone(), remote_0);
+        let (_, _, trace_1, _) = transcribed_mirror_sides::<()>(local, remote_1);
         let decoded_0 = decode(&trace_0);
         let decoded_1 = decode(&trace_1);
 
@@ -296,14 +296,14 @@ fn leaf_requests_are_erased_from_the_view() {
     /// Run the two sessions and assert the leafReqs-only difference is
     /// invisible to the local view.
     fn check(
-        local: crate::tree::Root<()>,
-        remote_0: crate::tree::Root<()>,
-        remote_1: crate::tree::Root<()>,
+        local: crate::tree::Root,
+        remote_0: crate::tree::Root,
+        remote_1: crate::tree::Root,
         local_paths: &BTreeSet<[u8; 32]>,
         p: Party,
     ) {
-        let (_, _, trace_0, _) = transcribed_mirror_sides(local.clone(), remote_0);
-        let (_, _, trace_1, _) = transcribed_mirror_sides(local, remote_1);
+        let (_, _, trace_0, _) = transcribed_mirror_sides::<()>(local.clone(), remote_0);
+        let (_, _, trace_1, _) = transcribed_mirror_sides::<()>(local, remote_1);
         let decoded_0 = decode(&trace_0);
         let decoded_1 = decode(&trace_1);
         assert_view_sound(&decoded_0, p, local_paths);
diff --git a/src/tree/mirror/streaming/tests/skeleton.rs b/src/tree/mirror/streaming/tests/skeleton.rs
index e65dcbb5c..bb9a516e1 100644
--- a/src/tree/mirror/streaming/tests/skeleton.rs
+++ b/src/tree/mirror/streaming/tests/skeleton.rs
@@ -145,7 +145,7 @@ pub(super) fn asks(p: Party, height: usize) -> bool {
 ///
 /// If the advertised versions are equal: such a session short-circuits
 /// without descending, so it has no skeleton to talk about.
-pub(super) fn client_role<T>(client: &TreeRoot<T>, server: &TreeRoot<T>) -> Party {
+pub(super) fn client_role(client: &TreeRoot, server: &TreeRoot) -> Party {
     if crate::tree::mirror::streaming::message::initiates(
         advertised_len(client),
         &client.ceiling,
@@ -160,7 +160,7 @@ pub(super) fn client_role<T>(client: &TreeRoot<T>, server: &TreeRoot<T>) -> Part
 
 /// The live message count a root advertises in its greeting: the election's
 /// primary key.
-fn advertised_len<T>(root: &TreeRoot<T>) -> u64 {
+fn advertised_len(root: &TreeRoot) -> u64 {
     root.root
         .as_ref()
         .map(|node| node.len() as u64)
diff --git a/src/tree/mirror/streaming/tests/stats.rs b/src/tree/mirror/streaming/tests/stats.rs
index 7aa116c04..6fae69aac 100644
--- a/src/tree/mirror/streaming/tests/stats.rs
+++ b/src/tree/mirror/streaming/tests/stats.rs
@@ -40,9 +40,9 @@ use super::fixtures::LeafOrder;
 /// harness pins the walk's counters (disputes, gains, sheds) and the
 /// window grant.
 fn mirror_with_stats<T: Send + Sync + 'static>(
-    a: Root<T>,
-    b: Root<T>,
-) -> (Root<T>, Root<T>, SessionStats, SessionStats) {
+    a: Root,
+    b: Root,
+) -> (Root, Root, SessionStats, SessionStats) {
     let (a, b): (StreamingRoot<Local, T>, StreamingRoot<Local, T>) = (a.into(), b.into());
     let a_recorder = Recorder::default();
     let b_recorder = Recorder::default();
@@ -64,7 +64,7 @@ fn mirror_with_stats<T: Send + Sync + 'static>(
 }
 
 /// The live-leaf count of a tree root, for conservation checks.
-fn live(root: &Root<()>) -> u64 {
+fn live(root: &Root) -> u64 {
     let root: StreamingRoot<Local, ()> = root.clone().into();
     root.len()
 }
@@ -72,7 +72,7 @@ fn live(root: &Root<()>) -> u64 {
 /// Whether `a` wins the initiator election against `b`, mirroring the
 /// session's role election (the smaller exchanged set initiates,
 /// canonical version bytes break ties).
-fn a_initiates(a: &Root<()>, b: &Root<()>) -> bool {
+fn a_initiates(a: &Root, b: &Root) -> bool {
     let (a, b): (StreamingRoot<Local, ()>, StreamingRoot<Local, ()>) =
         (a.clone().into(), b.clone().into());
     initiates(a.len(), &a.ceiling, b.len(), &b.ceiling)
@@ -139,7 +139,7 @@ fn arb_cells() -> impl Strategy<Value = Vec<Vec<u8>>> {
 fn equal_trees_report_zero_stats() {
     let node = grown(None, 0, 1, &(), &[path_at(&[0x11]), path_at(&[0x22])]);
     let (a, b) = (rooted(node.clone()), rooted(node));
-    let (ours, theirs, a_stats, b_stats) = mirror_with_stats(a, b);
+    let (ours, theirs, a_stats, b_stats) = mirror_with_stats::<()>(a, b);
     assert_eq!(ours, theirs, "equal endpoints stay equal");
     assert_eq!(a_stats, SessionStats::default());
     assert_eq!(b_stats, SessionStats::default());
@@ -160,7 +160,7 @@ fn pyramid_disputes_match_the_prefix_closure() {
     let b_before = live(&b);
     let a_leads = a_initiates(&a, &b);
 
-    let (ours, theirs, a_stats, b_stats) = mirror_with_stats(a, b);
+    let (ours, theirs, a_stats, b_stats) = mirror_with_stats::<()>(a, b);
     assert_eq!(ours, theirs, "endpoints converge");
 
     let by_depth = expected_disputes_by_depth(&cells);
@@ -202,7 +202,7 @@ fn pyramid_disputes_match_the_prefix_closure() {
 #[test]
 fn honored_redaction_counts_as_shed() {
     let (a, b, expected) = leaf_parent_redaction_pair();
-    let (ours, theirs, a_stats, b_stats) = mirror_with_stats(a, b);
+    let (ours, theirs, a_stats, b_stats) = mirror_with_stats::<()>(a, b);
     assert_eq!(ours, expected, "the redacted leaf survives nowhere");
     assert_eq!(theirs, expected);
 
@@ -239,7 +239,7 @@ proptest! {
         let equal = a_before == 0 && b_before == 0;
         let a_leads = !equal && a_initiates(&a, &b);
 
-        let (ours, theirs, a_stats, b_stats) = mirror_with_stats(a, b);
+        let (ours, theirs, a_stats, b_stats) = mirror_with_stats::<()>(a, b);
         prop_assert_eq!(&ours, &theirs);
 
         let by_depth = expected_disputes_by_depth(&cells);
diff --git a/src/tree/mirror/streaming/tests/wedge.rs b/src/tree/mirror/streaming/tests/wedge.rs
index 066a6efdd..f32179027 100644
--- a/src/tree/mirror/streaming/tests/wedge.rs
+++ b/src/tree/mirror/streaming/tests/wedge.rs
@@ -87,7 +87,7 @@ fn wedge_generator_matches_the_lean_literal() {
 /// smaller-set-initiates election; because the ballast is the *responder's*
 /// exclusive content, it ships as whole root-level supplies and never enters
 /// the dispute skeleton.
-fn wedge_trees() -> (Root<()>, Root<()>) {
+fn wedge_trees() -> (Root, Root) {
     let shared = grown(None, 0, 1, &(), &[path_at(&[0u8; 32])]);
 
     let mut wall_paths = Vec::new();
@@ -132,7 +132,7 @@ fn session_realizes_the_wedge_shape() {
          if tree construction changes"
     );
 
-    let (ours, theirs, trace, _) = transcribed_mirror_sides(wall, chain);
+    let (ours, theirs, trace, _) = transcribed_mirror_sides::<()>(wall, chain);
     assert_eq!(ours, theirs, "sanity: the session converges");
 
     let decoded = decode(&trace);
diff --git a/src/tree/mirror/streaming/window.rs b/src/tree/mirror/streaming/window.rs
index 08ff08dd3..846823a24 100644
--- a/src/tree/mirror/streaming/window.rs
+++ b/src/tree/mirror/streaming/window.rs
@@ -151,7 +151,7 @@ const KEY_DEPTH: usize = 32;
 /// pointer-class node handles; a backend whose `Node` demands a wider
 /// layout pads the real slots beyond this constant and owes that padding
 /// to its own `node_bytes` price.
-const REFERENCE_SLOT_BYTES: usize = std::mem::size_of::<(u8, typed::Node<(), Z>)>()
+const REFERENCE_SLOT_BYTES: usize = std::mem::size_of::<(u8, typed::Node<Z>)>()
     + std::mem::size_of::<(u8, Resolve<<Local as Backend<()>>::Erased>)>()
     + std::mem::size_of::<(u8, typed::Hash)>();
 
@@ -172,8 +172,8 @@ const LEAF_REQUEST_BYTES: usize = 40;
 /// whose `Node<Z>` demands wider alignment pads the real slot beyond
 /// `node_bytes + FAN_SLOT_BYTES` and owes that padding to its own
 /// `node_bytes` price.
-const FAN_SLOT_BYTES: usize = std::mem::size_of::<(Prefix<Z>, typed::Node<(), Z>)>()
-    - std::mem::size_of::<typed::Node<(), Z>>();
+const FAN_SLOT_BYTES: usize =
+    std::mem::size_of::<(Prefix<Z>, typed::Node<Z>)>() - std::mem::size_of::<typed::Node<Z>>();
 
 /// Worst-case bytes the decode fans of one session keep resident, under
 /// the in-memory backend's pricing.
@@ -189,7 +189,7 @@ const FAN_SLOT_BYTES: usize = std::mem::size_of::<(Prefix<Z>, typed::Node<(), Z>
 /// docs quote.
 #[cfg(any(test, feature = "test-internals"))]
 pub(crate) const SUPPLY_DECODE_ENVELOPE_BYTES: usize =
-    STREAM_COUNT * (FAN + 1) * (std::mem::size_of::<typed::Node<(), Z>>() + FAN_SLOT_BYTES);
+    STREAM_COUNT * (FAN + 1) * (std::mem::size_of::<typed::Node<Z>>() + FAN_SLOT_BYTES);
 
 /// The specification link's bandwidth-delay product, in bytes: 12.5 MB,
 /// where the two spec links coincide.
diff --git a/src/tree/tests.rs b/src/tree/tests.rs
index 1e0cc7e2b..dd2a6c3aa 100644
--- a/src/tree/tests.rs
+++ b/src/tree/tests.rs
@@ -310,7 +310,7 @@ proptest! {
         prop_assert_eq!(joined.hash(), direct.hash());
 
         // The canonical bulk construction over the sorted live leaf set.
-        let mut entries: Vec<([u8; 32], Option<untyped::Node<Bytes>>)> = direct
+        let mut entries: Vec<([u8; 32], Option<untyped::Node>)> = direct
             .iter()
             .map(|(version, value)| {
                 (
@@ -881,8 +881,8 @@ proptest! {
         end_sel in any::<prop::sample::Index>(),
         form in 0usize..12,
     ) {
-        let tree = Tree { root: a };
-        let other = Tree { root: b };
+        let tree = Tree::from_root(a);
+        let other = Tree::<()>::from_root(b);
 
         // Bound candidates spanning the partial order's relationships to the
         // walked tree: its own leaf versions and ceiling (dominated/equal),
@@ -922,7 +922,7 @@ proptest! {
             let mut frozen = tree.range_owned(query);
             let mut thawed = Vec::new();
             while let Some((_, leaf)) = frozen.next() {
-                thawed.push((leaf.version().clone(), leaf.value().clone()));
+                thawed.push((leaf.version().clone(), leaf.value::<()>()));
             }
             prop_assert_eq!(&thawed, &naive, "the frozen walk must equal the naive filter");
             Ok(())
@@ -962,7 +962,7 @@ proptest! {
         root in crate::tree::arb::arb_tree_root(0, 0..24),
         flip in any::<prop::sample::Index>(),
     ) {
-        let tree = Tree { root };
+        let tree = Tree::<()>::from_root(root);
 
         let forward: Vec<_> = tree.iter().map(owned).collect();
         prop_assert_eq!(tree.iter().len(), forward.len());
@@ -1174,9 +1174,9 @@ proptest! {
     fn join_changed_flag_tracks_the_root_hash(
         (a, b) in crate::tree::arb::arb_divergent_pair(),
     ) {
-        let mut tree = Tree { root: a };
+        let mut tree = Tree::<()>::from_root(a);
         let before = tree.hash();
-        let changed = tree.join(Tree { root: b });
+        let changed = tree.join(Tree::from_root(b));
         prop_assert_eq!(changed, tree.hash() != before);
     }
 
@@ -1192,9 +1192,9 @@ proptest! {
     fn join_changed_flag_tracks_the_root_hash_at_depth(
         (a, b) in crate::tree::arb::arb_deep_divergent_pair(),
     ) {
-        let mut tree = Tree { root: a };
+        let mut tree = Tree::<()>::from_root(a);
         let before = tree.hash();
-        let changed = tree.join(Tree { root: b });
+        let changed = tree.join(Tree::from_root(b));
         prop_assert_eq!(changed, tree.hash() != before);
     }
 }
@@ -1211,18 +1211,18 @@ fn deep_divergent_join_changed_flag_is_exact() {
     // Gain in both directions.
     let (a, b, expected) = crate::tree::arb::leaf_parent_dispute_pair();
     for (receiver, counter) in [(a.clone(), b.clone()), (b, a.clone())] {
-        let mut tree = Tree { root: receiver };
+        let mut tree = Tree::<()>::from_root(receiver);
         let before = tree.hash();
-        let changed = tree.join(Tree { root: counter });
+        let changed = tree.join(Tree::from_root(counter));
         assert_eq!(changed, tree.hash() != before, "deep gain is biconditional");
         assert!(changed, "a deep gain must report changed");
     }
 
     // The deep no-op: the receiver already holds everything the
     // counterparty has, so the full-depth divergent descent nets nothing.
-    let mut tree = Tree { root: expected };
+    let mut tree = Tree::<()>::from_root(expected);
     let before = tree.hash();
-    let changed = tree.join(Tree { root: a });
+    let changed = tree.join(Tree::from_root(a));
     assert_eq!(
         changed,
         tree.hash() != before,
@@ -1232,9 +1232,9 @@ fn deep_divergent_join_changed_flag_is_exact() {
 
     // Deletion honoring at depth.
     let (a, b, _survivor) = crate::tree::arb::leaf_parent_redaction_pair();
-    let mut tree = Tree { root: a };
+    let mut tree = Tree::<()>::from_root(a);
     let before = tree.hash();
-    let changed = tree.join(Tree { root: b });
+    let changed = tree.join(Tree::from_root(b));
     assert_eq!(
         changed,
         tree.hash() != before,
@@ -1303,9 +1303,9 @@ fn act_changed_flag_is_conservative_only_in_a_poisoned_store() {
     let (receiver, poisoned, key, escaped) = super::arb::uncontained_supply_pair();
     let receiver_party = super::arb::nth_party(0);
 
-    let mut tree = Tree { root: receiver };
+    let mut tree = Tree::<()>::from_root(receiver);
     assert!(
-        tree.join(Tree { root: poisoned }),
+        tree.join(Tree::from_root(poisoned)),
         "planting the escaped leaf is a real change",
     );
 
@@ -1344,8 +1344,8 @@ fn escaped_version_defeats_redaction_in_a_poisoned_store() {
 
     // Plant the escaped leaf by in-memory join: `Tree::join` is a local
     // merge, not wire ingestion, so no session tripwire guards it.
-    let mut tree = Tree { root: receiver };
-    tree.join(Tree { root: poisoned });
+    let mut tree = Tree::from_root(receiver);
+    tree.join(Tree::from_root(poisoned));
     assert!(
         tree.get(&escaped).is_some(),
         "the join plants the escaped leaf"
diff --git a/src/tree/traverse/act.rs b/src/tree/traverse/act.rs
index af8af9692..568ed87d3 100644
--- a/src/tree/traverse/act.rs
+++ b/src/tree/traverse/act.rs
@@ -21,8 +21,11 @@ pub enum Action {
 /// existed observes nothing, which is what lets the caller join versions only
 /// for actions that changed the tree.
 ///
-/// `actions` is consumed lazily: the only materialization is the radix sort
-/// at each branch level, so callers can feed a `map` chain straight in.
+/// `actions` arrives materialized, and the walk's signature is deliberately
+/// monomorphic — a concrete `Vec` and a `&mut dyn FnMut` observer — so the
+/// entire per-height apply tower compiles once, into this crate: a generic
+/// entry would re-instantiate all of it (radix grouping included) in every
+/// downstream crate that applies a batch.
 ///
 /// # Panics
 ///
@@ -33,16 +36,11 @@ pub enum Action {
 /// party linearity keeps regions disjoint), and no wire-derived leaf
 /// passes through this walk — so the panic marks a bug in this crate,
 /// never an environmental failure.
-pub fn act<T, F, I>(
-    node: Option<Node<T, Root>>,
-    actions: I,
-    mut on_action: F,
-) -> Option<Node<T, Root>>
-where
-    T: Send + Sync,
-    F: FnMut(&Version),
-    I: IntoIterator<Item = (Path, Version, Action)>,
-{
+pub fn act(
+    node: Option<Node<Root>>,
+    actions: Vec<(Path, Version, Action)>,
+    on_action: &mut dyn FnMut(&Version),
+) -> Option<Node<Root>> {
     // Test-only unwind source for the panic-atomicity pins: this walk is
     // the unwind-source region of `Tree::react`'s commit section, and its entry
     // burns the first fuse step (each branch-level step below burns one
@@ -50,7 +48,7 @@ where
     #[cfg(test)]
     crate::tree::panic_injection::fire_if_armed();
 
-    Act::act(node, actions, &mut on_action)
+    Act::act(node, actions, &mut |v| on_action(v))
 }
 
 /// The inductive step of the batch-apply, implemented per [`Height`]: the
@@ -61,13 +59,8 @@ where
 /// (synchronous) call one height down (always instantiated at `I = Vec<…>`,
 /// the per-radix group the branch level collects).
 pub trait Act: Height {
-    fn act<T, F, I>(
-        node: Option<Node<T, Self>>,
-        actions: I,
-        on_action: &mut F,
-    ) -> Option<Node<T, Self>>
+    fn act<F, I>(node: Option<Node<Self>>, actions: I, on_action: &mut F) -> Option<Node<Self>>
     where
-        T: Send + Sync,
         F: FnMut(&Version),
         I: IntoIterator<Item = (Path<Self>, Version, Action)>;
 }
@@ -76,13 +69,8 @@ impl<H: Act> Act for S<H>
 where
     S<H>: Height,
 {
-    fn act<T, F, I>(
-        node: Option<Node<T, S<H>>>,
-        actions: I,
-        on_action: &mut F,
-    ) -> Option<Node<T, S<H>>>
+    fn act<F, I>(node: Option<Node<S<H>>>, actions: I, on_action: &mut F) -> Option<Node<S<H>>>
     where
-        T: Send + Sync,
         F: FnMut(&Version),
         I: IntoIterator<Item = (Path<Self>, Version, Action)>,
     {
@@ -112,15 +100,10 @@ where
         // map exploded from the node
         let mut updated: Vec<_> = Vec::new();
         for (radix, group) in &by_radix {
-            // This collect is load-bearing: it type-erases the group before
-            // the recursion. `Act` is instantiated once per `Height` level,
-            // so a lazy iterator here would weave this level's iterator type
-            // (closures capturing `I` and all) into the next level's `I`; the
-            // type compounds across all 32 levels and monomorphization
-            // explodes at codegen — tens of GiB of rustc memory in every
-            // downstream crate that links this one. `Vec` resets `I` to the
-            // same flat type at every level. It also lets the short-circuit
-            // below inspect the actions without consuming them.
+            // Materialize the group: the recursion takes each level's
+            // actions as a concrete `Vec` (the monomorphic signature the
+            // once-compiled tower rests on), and the short-circuit below
+            // inspects the actions without consuming them.
             let actions: Vec<_> = group
                 .map(|(_, path, version, action)| (path, version, action))
                 .collect();
@@ -148,13 +131,8 @@ where
 }
 
 impl Act for Z {
-    fn act<T, F, I>(
-        mut node: Option<Node<T, Self>>,
-        actions: I,
-        on_action: &mut F,
-    ) -> Option<Node<T, Z>>
+    fn act<F, I>(mut node: Option<Node<Self>>, actions: I, on_action: &mut F) -> Option<Node<Z>>
     where
-        T: Send + Sync,
         F: FnMut(&Version),
         I: IntoIterator<Item = (Path<Self>, Version, Action)>,
     {
diff --git a/src/tree/traverse/join.rs b/src/tree/traverse/join.rs
index 8b6fa74d5..a04f552dd 100644
--- a/src/tree/traverse/join.rs
+++ b/src/tree/traverse/join.rs
@@ -54,16 +54,13 @@ use height::{Height, Root, S, Z};
 /// drops live at distinct version-addressed paths and each is monotone at its
 /// path, so they cannot cancel: an untouched flag really means the merged
 /// tree is `a`, content-identical, equal root hash.
-pub fn join<T>(
-    a: Option<Node<T, Root>>,
-    b: Option<Node<T, Root>>,
+pub fn join(
+    a: Option<Node<Root>>,
+    b: Option<Node<Root>>,
     a_version: &Version,
     b_version: &Version,
     changed: &mut bool,
-) -> Option<Node<T, Root>>
-where
-    T: Send + Sync,
-{
+) -> Option<Node<Root>> {
     // Test-only unwind source for the panic-atomicity pin: the merge walk
     // is the unwind-source region of `Tree::join`'s commit section (deletion
     // honoring and the duplicate-subtree drops run `T` destructors), and its
@@ -82,31 +79,26 @@ where
 /// on any gain from `b` or any deletion-honoring drop from `a`, left
 /// alone when the result is content-identical to `a`.
 pub trait Join: Unknown {
-    fn join<T>(
-        a: Option<Node<T, Self>>,
-        b: Option<Node<T, Self>>,
+    fn join(
+        a: Option<Node<Self>>,
+        b: Option<Node<Self>>,
         a_version: &Version,
         b_version: &Version,
         changed: &mut bool,
-    ) -> Option<Node<T, Self>>
-    where
-        T: Send + Sync;
+    ) -> Option<Node<Self>>;
 }
 
 impl<H: Join> Join for S<H>
 where
     S<H>: Height + Unknown,
 {
-    fn join<T>(
-        a: Option<Node<T, S<H>>>,
-        b: Option<Node<T, S<H>>>,
+    fn join(
+        a: Option<Node<S<H>>>,
+        b: Option<Node<S<H>>>,
         a_version: &Version,
         b_version: &Version,
         changed: &mut bool,
-    ) -> Option<Node<T, S<H>>>
-    where
-        T: Send + Sync,
-    {
+    ) -> Option<Node<S<H>>> {
         // Test-only unwind source, continued: every branch-level merge step
         // burns one fuse step, so a fuse armed past the entry unwinds only
         // after earlier steps completed real merge work.
@@ -207,16 +199,13 @@ where
 }
 
 impl Join for Z {
-    fn join<T>(
-        a: Option<Node<T, Z>>,
-        b: Option<Node<T, Z>>,
+    fn join(
+        a: Option<Node<Z>>,
+        b: Option<Node<Z>>,
         a_version: &Version,
         b_version: &Version,
         changed: &mut bool,
-    ) -> Option<Node<T, Z>>
-    where
-        T: Send + Sync,
-    {
+    ) -> Option<Node<Z>> {
         match (a, b) {
             (None, None) => None,
             // The leaf-level base of the asymmetric arms' change detection:
diff --git a/src/tree/traverse/join/tests.rs b/src/tree/traverse/join/tests.rs
index ec464b8b0..32a08e79c 100644
--- a/src/tree/traverse/join/tests.rs
+++ b/src/tree/traverse/join/tests.rs
@@ -12,11 +12,11 @@ use crate::tree::{Root, Tree};
 
 /// Drives the local-local mirror directly: the oracle that `Tree::join`
 /// must match.
-fn mirror_merge(a: Root<()>, b: Root<()>) -> Root<()> {
+fn mirror_merge(a: Root, b: Root) -> Root {
     pollster::block_on(async {
         let l = local::Exchange::start(a);
         let r = local::Exchange::start(b);
-        match mirror(l, r).await {
+        match mirror::<_, _, ()>(l, r).await {
             Ok((merged, _)) => merged,
             Err(e) => panic!("honest oracle endpoints speak no violations: {e}"),
         }
@@ -24,9 +24,9 @@ fn mirror_merge(a: Root<()>, b: Root<()>) -> Root<()> {
 }
 
 /// Merges via `Tree::join`.
-fn join_tree(a: Root<()>, b: Root<()>) -> Root<()> {
-    let mut a = Tree { root: a };
-    a.join(Tree { root: b });
+fn join_tree(a: Root, b: Root) -> Root {
+    let mut a = Tree::<()>::from_root(a);
+    a.join(Tree::from_root(b));
     a.root
 }
 
diff --git a/src/tree/traverse/unknown.rs b/src/tree/traverse/unknown.rs
index 1f6ba33c3..763200370 100644
--- a/src/tree/traverse/unknown.rs
+++ b/src/tree/traverse/unknown.rs
@@ -23,19 +23,14 @@ pub trait Unknown: Height {
     /// Filters this subtree down to the nodes a counterparty at `known` is
     /// missing, honoring deletions: a node causally `<=` `known` is already
     /// known there (or was deleted there) and drops out.
-    fn unknown<T>(node: Option<Node<T, Self>>, known: &Version) -> Option<Node<T, Self>>
-    where
-        T: Send + Sync;
+    fn unknown(node: Option<Node<Self>>, known: &Version) -> Option<Node<Self>>;
 }
 
 impl<H: Unknown> Unknown for S<H>
 where
     S<H>: Height,
 {
-    fn unknown<T>(node: Option<Node<T, Self>>, known: &Version) -> Option<Node<T, Self>>
-    where
-        T: Send + Sync,
-    {
+    fn unknown(node: Option<Node<Self>>, known: &Version) -> Option<Node<Self>> {
         // If the node doesn't exist, we can't return information about it
         let node = node?;
 
@@ -80,10 +75,7 @@ where
 }
 
 impl Unknown for Z {
-    fn unknown<T>(node: Option<Node<T, Self>>, known: &Version) -> Option<Node<T, Self>>
-    where
-        T: Send + Sync,
-    {
+    fn unknown(node: Option<Node<Self>>, known: &Version) -> Option<Node<Self>> {
         // If the node doesn't exist, we can't return information about it
         let node = node?;
 
diff --git a/src/tree/traverse/unknown/tests.rs b/src/tree/traverse/unknown/tests.rs
index 1f816e8d6..8759e9494 100644
--- a/src/tree/traverse/unknown/tests.rs
+++ b/src/tree/traverse/unknown/tests.rs
@@ -32,19 +32,14 @@ use super::Unknown;
 /// suite additionally asserts the pruned trees match.
 trait TwoPass: Height {
     /// The two-check spelling of [`Unknown::unknown`] at this height.
-    fn unknown<T>(node: Option<Node<T, Self>>, known: &Version) -> Option<Node<T, Self>>
-    where
-        T: Send + Sync;
+    fn unknown(node: Option<Node<Self>>, known: &Version) -> Option<Node<Self>>;
 }
 
 impl<H: TwoPass> TwoPass for S<H>
 where
     S<H>: Height,
 {
-    fn unknown<T>(node: Option<Node<T, Self>>, known: &Version) -> Option<Node<T, Self>>
-    where
-        T: Send + Sync,
-    {
+    fn unknown(node: Option<Node<Self>>, known: &Version) -> Option<Node<Self>> {
         let node = node?;
         // Check one: a floor the known version does not contain
         // (concurrent with or above `known`) is a wholly unknown subtree.
@@ -70,10 +65,7 @@ where
 }
 
 impl TwoPass for Z {
-    fn unknown<T>(node: Option<Node<T, Self>>, known: &Version) -> Option<Node<T, Self>>
-    where
-        T: Send + Sync,
-    {
+    fn unknown(node: Option<Node<Self>>, known: &Version) -> Option<Node<Self>> {
         let node = node?;
         if causally::before(known).contains(node.ceiling()) {
             return None;
@@ -93,7 +85,7 @@ impl TwoPass for Z {
 fn wide_divergence(
     known_leaves: usize,
     divergent_leaves: usize,
-) -> (Option<typed::node::Root<()>>, Version) {
+) -> (Option<typed::node::Root>, Version) {
     let mut actions: Vec<(Path, Version, Action)> = Vec::new();
     let mut known = Version::new();
 
@@ -111,7 +103,7 @@ fn wide_divergence(
         }
     }
 
-    (act(None, actions, |_| ()), known)
+    (act(None, actions, &mut |_| ()), known)
 }
 
 /// `body`'s result with its scanned-bits reading, on a fresh counter.
diff --git a/src/tree/typed.rs b/src/tree/typed.rs
index fab783da9..cb13ce1fd 100644
--- a/src/tree/typed.rs
+++ b/src/tree/typed.rs
@@ -5,7 +5,7 @@
 //! traversals want the height in the type, so each inductive step
 //! monomorphizes separately and the recursion provably bottoms out at
 //! [`Z`](height::Z) instead of trusting a runtime depth counter. This
-//! module is the adapter: [`Node<T, H>`](Node) pairs an untyped node with
+//! module is the adapter: [`Node<H>`](Node) pairs an untyped node with
 //! a phantom [`Height`](height::Height), and the typed surface
 //! ([`Path`], [`Children`]) keeps every descent and reassembly height-correct
 //! at compile time. The selectable alternating protocol also retains its typed
diff --git a/src/tree/typed/levels.rs b/src/tree/typed/levels.rs
index 35429c6c7..e5bb604dc 100644
--- a/src/tree/typed/levels.rs
+++ b/src/tree/typed/levels.rs
@@ -12,7 +12,7 @@ mod level;
 pub use level::Level;
 
 /// Create a new [`Levels`] from the root of a tree.
-pub fn levels<T>(root: Option<Node<T, Root>>) -> Top<T> {
+pub fn levels(root: Option<Node<Root>>) -> Top {
     Top {
         root: Level::from_iter(root.map(|root| (Prefix::new(), root))),
     }
@@ -20,33 +20,20 @@ pub fn levels<T>(root: Option<Node<T, Root>>) -> Top<T> {
 
 /// A multi-zipper into a tree.
 pub trait Levels: Default + Clone + sealed::Sealed {
-    /// The message type of the underlying nodes.
-    ///
-    /// `Send + Sync` is required because the traversal futures
-    /// ([`Unknown::unknown`](crate::tree::traverse::unknown::Unknown::unknown),
-    /// [`Act::act`](crate::tree::traverse::act::Act::act)) are declared as
-    /// `-> impl Future + Send` so that the recursive `Box::pin` inside each
-    /// inductive case can coerce to `Pin<Box<dyn Future + Send>>`. That
-    /// coercion discharges the inner state machine's auto-trait check at each
-    /// recursion site, terminating what would otherwise be a height-deep walk
-    /// through every level's captured state; the captured node values
-    /// (containing messages) must therefore be `Send + Sync`.
-    type Message: Send + Sync;
-
     /// The height of the bottom-most level.
     type Height: Height;
 
     /// Collapse a [`Levels`] back to a node by folding all the levels together.
-    fn collapse(self) -> Option<Node<Self::Message, Root>>;
+    fn collapse(self) -> Option<Node<Root>>;
 
     /// Get an immutable reference to the bottom-most level.
-    fn level(&self) -> &Level<Self::Message, Self::Height>;
+    fn level(&self) -> &Level<Self::Height>;
 
     /// Get a mutable reference to the bottom-most level.
-    fn level_mut(&mut self) -> &mut Level<Self::Message, Self::Height>;
+    fn level_mut(&mut self) -> &mut Level<Self::Height>;
 
     /// Tack a new level onto the bottom of this [`Levels`], decreasing its height by one.
-    fn down<H>(self, below: Level<Self::Message, H>) -> Below<H, Self>
+    fn down<H>(self, below: Level<H>) -> Below<H, Self>
     where
         S<H>: Height,
         H: Height,
@@ -61,42 +48,23 @@ pub trait Levels: Default + Clone + sealed::Sealed {
 
 /// The one-level zipper: just the root level. Every descent starts here,
 /// and every [`collapse`](Levels::collapse) folds back to here.
-pub struct Top<T> {
-    root: Level<T, Root>,
-}
-
-impl<T> Clone for Top<T> {
-    fn clone(&self) -> Self {
-        Self {
-            root: self.root.clone(),
-        }
-    }
+#[derive(Clone, Default)]
+pub struct Top {
+    root: Level<Root>,
 }
 
-impl<T> Default for Top<T> {
-    fn default() -> Self {
-        Self {
-            root: Default::default(),
-        }
-    }
-}
-
-impl<T> Levels for Top<T>
-where
-    T: Send + Sync,
-{
-    type Message = T;
+impl Levels for Top {
     type Height = Root;
 
-    fn collapse(mut self) -> Option<Node<T, Root>> {
+    fn collapse(mut self) -> Option<Node<Root>> {
         self.root.remove(&Prefix::new())
     }
 
-    fn level(&self) -> &Level<T, Self::Height> {
+    fn level(&self) -> &Level<Self::Height> {
         &self.root
     }
 
-    fn level_mut(&mut self) -> &mut Level<T, Self::Height> {
+    fn level_mut(&mut self) -> &mut Level<Self::Height> {
         &mut self.root
     }
 }
@@ -111,7 +79,7 @@ where
     A: Levels<Height = S<H>>,
     H: Height,
 {
-    here: Level<A::Message, H>,
+    here: Level<H>,
     above: A,
 }
 
@@ -147,10 +115,9 @@ where
     S<H>: Height,
     H: Height,
 {
-    type Message = A::Message;
     type Height = <A::Height as Pred>::Pred;
 
-    fn collapse(mut self) -> Option<Node<A::Message, Root>> {
+    fn collapse(mut self) -> Option<Node<Root>> {
         // Pop each child's prefix to get its radix and parent prefix. `Level`
         // iteration is sorted, so siblings are adjacent.
         let siblings = self.here.into_iter().map(|(prefix, node)| {
@@ -201,11 +168,11 @@ where
         self.above.collapse()
     }
 
-    fn level(&self) -> &Level<A::Message, Self::Height> {
+    fn level(&self) -> &Level<Self::Height> {
         &self.here
     }
 
-    fn level_mut(&mut self) -> &mut Level<A::Message, Self::Height> {
+    fn level_mut(&mut self) -> &mut Level<Self::Height> {
         &mut self.here
     }
 }
@@ -214,7 +181,7 @@ mod sealed {
     use super::{Below, Height, Levels, Pred, S, Top};
 
     pub trait Sealed {}
-    impl<T> Sealed for Top<T> {}
+    impl Sealed for Top {}
     impl<A: Levels<Height = S<H>> + Sealed, H: Height> Sealed for Below<H, A> where A::Height: Pred {}
 }
 
diff --git a/src/tree/typed/levels/level.rs b/src/tree/typed/levels/level.rs
index 2f91708b3..3912df082 100644
--- a/src/tree/typed/levels/level.rs
+++ b/src/tree/typed/levels/level.rs
@@ -1,5 +1,5 @@
 //! A single zipper level: a flat, strictly-ascending association of
-//! [`Prefix<H>`] to [`Node<T, H>`].
+//! [`Prefix<H>`] to [`Node<H>`].
 //!
 //! The mirror protocol builds a fresh level (often two) on each side every
 //! round and discards it once the zipper descends. Those levels are small
@@ -13,12 +13,12 @@ use crate::tree::typed::{Node, Prefix, height::Height};
 
 /// A zipper level: `(prefix, node)` pairs kept in a flat `Vec`, strictly
 /// ascending by prefix, with no duplicate prefixes.
-pub struct Level<T, H: Height> {
+pub struct Level<H: Height> {
     /// Invariant: strictly ascending by prefix, no duplicates.
-    entries: Vec<(Prefix<H>, Node<T, H>)>,
+    entries: Vec<(Prefix<H>, Node<H>)>,
 }
 
-impl<T, H: Height> Default for Level<T, H> {
+impl<H: Height> Default for Level<H> {
     fn default() -> Self {
         Self {
             entries: Vec::new(),
@@ -26,7 +26,7 @@ impl<T, H: Height> Default for Level<T, H> {
     }
 }
 
-impl<T, H: Height> Clone for Level<T, H> {
+impl<H: Height> Clone for Level<H> {
     fn clone(&self) -> Self {
         Self {
             entries: self.entries.clone(),
@@ -34,7 +34,7 @@ impl<T, H: Height> Clone for Level<T, H> {
     }
 }
 
-impl<T, H: Height> Level<T, H> {
+impl<H: Height> Level<H> {
     /// Whether the level holds no entries.
     pub fn is_empty(&self) -> bool {
         self.entries.is_empty()
@@ -46,7 +46,7 @@ impl<T, H: Height> Level<T, H> {
     /// Debug builds assert the invariant. Pairs with [`Level::extend`] to
     /// absorb a sorted batch in one O(n+m) merge rather than m binary-search
     /// inserts.
-    pub fn from_sorted(entries: Vec<(Prefix<H>, Node<T, H>)>) -> Self {
+    pub fn from_sorted(entries: Vec<(Prefix<H>, Node<H>)>) -> Self {
         debug_assert!(
             entries.windows(2).all(|w| w[0].0 < w[1].0),
             "Level::from_sorted given non-ascending or duplicated entries",
@@ -56,7 +56,7 @@ impl<T, H: Height> Level<T, H> {
 
     /// Iterate the level in ascending prefix order, mirroring
     /// `BTreeMap::iter`'s `(&key, &value)` shape.
-    pub fn iter(&self) -> impl Iterator<Item = (&Prefix<H>, &Node<T, H>)> + '_ {
+    pub fn iter(&self) -> impl Iterator<Item = (&Prefix<H>, &Node<H>)> + '_ {
         self.entries.iter().map(|(prefix, node)| (prefix, node))
     }
 
@@ -67,7 +67,7 @@ impl<T, H: Height> Level<T, H> {
     /// this O(1) append is the common build path; an out-of-order push trips a
     /// debug assertion (in release it would silently break the invariant the
     /// binary searches rely on).
-    pub fn push(&mut self, prefix: Prefix<H>, node: Node<T, H>) {
+    pub fn push(&mut self, prefix: Prefix<H>, node: Node<H>) {
         debug_assert!(
             self.entries.last().is_none_or(|(last, _)| *last < prefix),
             "Level::push given a prefix not greater than the current last",
@@ -76,7 +76,7 @@ impl<T, H: Height> Level<T, H> {
     }
 
     /// Remove and return the node at `prefix`, if present.
-    pub fn remove(&mut self, prefix: &Prefix<H>) -> Option<Node<T, H>> {
+    pub fn remove(&mut self, prefix: &Prefix<H>) -> Option<Node<H>> {
         match self.entries.binary_search_by(|(p, _)| p.cmp(prefix)) {
             Ok(i) => Some(self.entries.remove(i).1),
             Err(_) => None,
@@ -123,15 +123,15 @@ impl<T, H: Height> Level<T, H> {
     }
 }
 
-impl<T, H: Height> FromIterator<(Prefix<H>, Node<T, H>)> for Level<T, H> {
+impl<H: Height> FromIterator<(Prefix<H>, Node<H>)> for Level<H> {
     /// Collect `(prefix, node)` pairs into a level.
     ///
     /// Callers feed pairs already in ascending prefix order (a node's children,
     /// sorted by radix), so this sorts only to defend the invariant and
     /// `debug_assert`s the input was canonical (strictly ascending, no
     /// duplicates).
-    fn from_iter<I: IntoIterator<Item = (Prefix<H>, Node<T, H>)>>(iter: I) -> Self {
-        let mut entries: Vec<(Prefix<H>, Node<T, H>)> = iter.into_iter().collect();
+    fn from_iter<I: IntoIterator<Item = (Prefix<H>, Node<H>)>>(iter: I) -> Self {
+        let mut entries: Vec<(Prefix<H>, Node<H>)> = iter.into_iter().collect();
         entries.sort_by_key(|(a, _)| *a);
         debug_assert!(
             entries.windows(2).all(|w| w[0].0 != w[1].0),
@@ -141,9 +141,9 @@ impl<T, H: Height> FromIterator<(Prefix<H>, Node<T, H>)> for Level<T, H> {
     }
 }
 
-impl<T, H: Height> IntoIterator for Level<T, H> {
-    type Item = (Prefix<H>, Node<T, H>);
-    type IntoIter = std::vec::IntoIter<(Prefix<H>, Node<T, H>)>;
+impl<H: Height> IntoIterator for Level<H> {
+    type Item = (Prefix<H>, Node<H>);
+    type IntoIter = std::vec::IntoIter<(Prefix<H>, Node<H>)>;
 
     /// Consume the level in ascending prefix order.
     fn into_iter(self) -> Self::IntoIter {
diff --git a/src/tree/typed/levels/tests.rs b/src/tree/typed/levels/tests.rs
index 4af3f33f3..5ce189b7a 100644
--- a/src/tree/typed/levels/tests.rs
+++ b/src/tree/typed/levels/tests.rs
@@ -17,20 +17,18 @@ trait Descend: Height {
     fn descend_and_collapse<L>(
         levels: L,
         decisions: &mut impl Iterator<Item = bool>,
-    ) -> Option<Node<L::Message, Root>>
+    ) -> Option<Node<Root>>
     where
-        L: Levels<Height = Self>,
-        L::Message: Clone + Send + Sync;
+        L: Levels<Height = Self>;
 }
 
 impl Descend for Z {
     fn descend_and_collapse<L>(
         levels: L,
         _decisions: &mut impl Iterator<Item = bool>,
-    ) -> Option<Node<L::Message, Root>>
+    ) -> Option<Node<Root>>
     where
         L: Levels<Height = Self>,
-        L::Message: Clone + Send + Sync,
     {
         levels.collapse()
     }
@@ -44,15 +42,14 @@ where
     fn descend_and_collapse<L>(
         mut levels: L,
         decisions: &mut impl Iterator<Item = bool>,
-    ) -> Option<Node<L::Message, Root>>
+    ) -> Option<Node<Root>>
     where
         L: Levels<Height = Self>,
-        L::Message: Clone + Send + Sync,
     {
         let current = std::mem::take(levels.level_mut());
 
         let mut stay = Level::default();
-        let mut below: Level<L::Message, H> = Level::default();
+        let mut below: Level<H> = Level::default();
 
         // `current` iterates in ascending prefix order, and each node's children
         // ascend by radix, so both partitions are built strictly ascending —
diff --git a/src/tree/typed/node.rs b/src/tree/typed/node.rs
index 4cfdbe470..d87de8f2e 100644
--- a/src/tree/typed/node.rs
+++ b/src/tree/typed/node.rs
@@ -12,23 +12,25 @@ use super::levels::{Top, levels};
 use super::untyped;
 #[cfg(any(test, feature = "protocol-v1"))]
 use crate::tree::wire;
+#[cfg(any(test, feature = "protocol-v1"))]
+use crate::tree::wire::Decode;
 use untyped::fan::{self, Fan};
 
 #[cfg(any(test, feature = "protocol-v1"))]
 use serde::de::DeserializeOwned;
 
 /// The typed node with a height of 32; the root of the tree.
-pub type Root<T> = Node<T, height::Root>;
+pub type Root = Node<height::Root>;
 
 /// The radix-indexed children of a branch one level above height `H`: a
 /// typed shell over the untyped radix fan, so inserts and removals stay
 /// height-correct at compile time.
-pub struct Children<T, H: Height> {
+pub struct Children<H: Height> {
     height: PhantomData<fn() -> H>,
-    inner: Fan<T>,
+    inner: Fan,
 }
 
-impl<T, H: Height> Default for Children<T, H> {
+impl<H: Height> Default for Children<H> {
     fn default() -> Self {
         Self {
             height: PhantomData,
@@ -37,7 +39,7 @@ impl<T, H: Height> Default for Children<T, H> {
     }
 }
 
-impl<T, H: Height> Clone for Children<T, H> {
+impl<H: Height> Clone for Children<H> {
     fn clone(&self) -> Self {
         Self {
             height: PhantomData,
@@ -46,15 +48,15 @@ impl<T, H: Height> Clone for Children<T, H> {
     }
 }
 
-impl<T, H: Height> Children<T, H> {
-    fn from_fan(inner: Fan<T>) -> Self {
+impl<H: Height> Children<H> {
+    fn from_fan(inner: Fan) -> Self {
         Self {
             height: PhantomData,
             inner,
         }
     }
 
-    fn into_fan(self) -> Fan<T> {
+    fn into_fan(self) -> Fan {
         self.inner
     }
 
@@ -69,14 +71,14 @@ impl<T, H: Height> Children<T, H> {
     }
 
     /// Insert `child` at `radix`, returning any child it displaced.
-    pub fn insert(&mut self, radix: u8, child: Node<T, H>) -> Option<Node<T, H>> {
+    pub fn insert(&mut self, radix: u8, child: Node<H>) -> Option<Node<H>> {
         self.inner
             .insert(radix, child.into_untyped())
             .map(Node::from_untyped)
     }
 
     /// Remove and return the child at `radix`, if any.
-    pub fn remove(&mut self, radix: u8) -> Option<Node<T, H>> {
+    pub fn remove(&mut self, radix: u8) -> Option<Node<H>> {
         self.inner.remove(radix).map(Node::from_untyped)
     }
 
@@ -86,15 +88,15 @@ impl<T, H: Height> Children<T, H> {
     /// The engine of [`Tree::join`](crate::tree::Tree::join)'s recursion:
     /// the merge walk pairs two of these streams by radix and prunes equal
     /// pairs by [`Node`]'s pointer-or-hash equality before descending.
-    pub fn iter(&self) -> impl Iterator<Item = (u8, Node<T, H>)> + '_ {
+    pub fn iter(&self) -> impl Iterator<Item = (u8, Node<H>)> + '_ {
         self.inner
             .iter()
             .map(|(radix, child)| (radix, Node::from_untyped(child.clone())))
     }
 }
 
-impl<T, H: Height> FromIterator<(u8, Node<T, H>)> for Children<T, H> {
-    fn from_iter<I: IntoIterator<Item = (u8, Node<T, H>)>>(iter: I) -> Self {
+impl<H: Height> FromIterator<(u8, Node<H>)> for Children<H> {
+    fn from_iter<I: IntoIterator<Item = (u8, Node<H>)>>(iter: I) -> Self {
         Self::from_fan(
             iter.into_iter()
                 .map(|(radix, child)| (radix, child.into_untyped()))
@@ -103,18 +105,18 @@ impl<T, H: Height> FromIterator<(u8, Node<T, H>)> for Children<T, H> {
     }
 }
 
-fn typed_child<T, H: Height>((radix, inner): (u8, untyped::Node<T>)) -> (u8, Node<T, H>) {
+fn typed_child<H: Height>((radix, inner): (u8, untyped::Node)) -> (u8, Node<H>) {
     (radix, Node::from_untyped(inner))
 }
 
-impl<T, H: Height> IntoIterator for Children<T, H> {
-    type Item = (u8, Node<T, H>);
-    type IntoIter = Map<fan::IntoIter<T>, fn((u8, untyped::Node<T>)) -> (u8, Node<T, H>)>;
+impl<H: Height> IntoIterator for Children<H> {
+    type Item = (u8, Node<H>);
+    type IntoIter = Map<fan::IntoIter, fn((u8, untyped::Node)) -> (u8, Node<H>)>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.inner
             .into_iter()
-            .map(typed_child::<T, H> as fn((u8, untyped::Node<T>)) -> (u8, Node<T, H>))
+            .map(typed_child::<H> as fn((u8, untyped::Node)) -> (u8, Node<H>))
     }
 }
 
@@ -130,12 +132,12 @@ impl<T, H: Height> IntoIterator for Children<T, H> {
 /// variable `H` is purely phantom and never constructs anything that
 /// could fail to be `Send`/`Sync`.
 #[repr(transparent)]
-pub struct Node<T, H: Height> {
+pub struct Node<H: Height> {
     height: PhantomData<fn() -> H>,
-    inner: untyped::Node<T>,
+    inner: untyped::Node,
 }
 
-impl<T, H: Height> Clone for Node<T, H> {
+impl<H: Height> Clone for Node<H> {
     fn clone(&self) -> Self {
         Self {
             height: self.height,
@@ -144,9 +146,8 @@ impl<T, H: Height> Clone for Node<T, H> {
     }
 }
 
-impl<T, H> Debug for Node<T, H>
+impl<H> Debug for Node<H>
 where
-    T: Debug,
     H: Height,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -154,14 +155,14 @@ where
     }
 }
 
-impl<T, H: Height> Node<T, H> {
+impl<H: Height> Node<H> {
     /// Tag an untyped node at height `H`: the caller asserts the height.
     ///
     /// The streaming mirror's erasure seam
     /// ([`Backend::assume`](crate::tree::mirror::streaming::Backend::assume))
     /// re-tags nodes it erased at the same height; internal tree code tags
     /// nodes whose height its own traversal establishes.
-    pub(crate) fn from_untyped(inner: untyped::Node<T>) -> Self {
+    pub(crate) fn from_untyped(inner: untyped::Node) -> Self {
         Self {
             height: PhantomData,
             inner,
@@ -170,7 +171,7 @@ impl<T, H: Height> Node<T, H> {
 
     /// Forget this node's height tag; the inverse of
     /// [`from_untyped`](Self::from_untyped).
-    pub(crate) fn into_untyped(self) -> untyped::Node<T> {
+    pub(crate) fn into_untyped(self) -> untyped::Node {
         self.inner
     }
 
@@ -277,10 +278,7 @@ impl<T, H: Height> Node<T, H> {
     pub(crate) fn leaves(
         self,
         prefix: &super::Prefix<H>,
-    ) -> impl Iterator<Item = (super::Prefix<Z>, Node<T, Z>)> + Send + use<T, H>
-    where
-        T: Send + Sync,
-    {
+    ) -> impl Iterator<Item = (super::Prefix<Z>, Node<Z>)> + Send + use<H> {
         let mut walk =
             untyped::RangeOwned::within(Some(self.inner), prefix.as_bytes(), causally::all());
         std::iter::from_fn(move || {
@@ -302,7 +300,7 @@ impl<T, H: Height> Node<T, H> {
     /// [`untyped::Node::from_sorted_leaves`] for the cost argument.
     pub(crate) fn from_sorted_leaves(
         prefix: &super::Prefix<H>,
-        run: Vec<(super::Prefix<Z>, Node<T, Z>)>,
+        run: Vec<(super::Prefix<Z>, Node<Z>)>,
     ) -> Self {
         let depth = prefix.as_bytes().len();
         debug_assert!(
@@ -310,7 +308,7 @@ impl<T, H: Height> Node<T, H> {
                 .all(|(path, _)| path.as_bytes().starts_with(prefix.as_bytes())),
             "every leaf in a run falls under the run's prefix",
         );
-        let mut entries: Vec<([u8; 32], Option<untyped::Node<T>>)> = run
+        let mut entries: Vec<([u8; 32], Option<untyped::Node>)> = run
             .into_iter()
             .map(|(path, leaf)| {
                 let path = <[u8; 32]>::try_from(path.as_bytes())
@@ -322,13 +320,13 @@ impl<T, H: Height> Node<T, H> {
     }
 }
 
-impl<T, H: Height> Node<T, S<H>>
+impl<H: Height> Node<S<H>>
 where
     S<H>: Height,
 {
     /// Construct a new branch node from a map of children (inverse to
     /// [`Node::into_children`]).
-    pub fn branch(children: Children<T, H>) -> Option<Self> {
+    pub fn branch(children: Children<H>) -> Option<Self> {
         Some(Node {
             height: PhantomData,
             inner: untyped::Node::branch(children.into_fan())?,
@@ -337,7 +335,7 @@ where
 
     /// Convert a node into a map from child index to child node (inverse to
     /// [`Node::branch`]).
-    pub fn into_children(self) -> Children<T, H> {
+    pub fn into_children(self) -> Children<H> {
         let children = match self.inner.into_children() {
             Ok(children) => children,
             Err(_) => unreachable!("typed nonzero-height node cannot be an uncompressed leaf"),
@@ -353,7 +351,7 @@ where
     /// `untyped::Node::beneath`: it path-compresses a single-child wrap into
     /// the underlying node's prefix without materializing the intervening
     /// branch level.
-    pub fn beneath(child: Node<T, H>, index: u8) -> Self {
+    pub fn beneath(child: Node<H>, index: u8) -> Self {
         Node {
             height: PhantomData,
             inner: child.inner.beneath(index),
@@ -361,7 +359,7 @@ where
     }
 }
 
-impl<T> Node<T, Z> {
+impl Node<Z> {
     /// Construct a new leaf node from a versioned message.
     pub fn leaf(version: Version, message: Message) -> Self {
         Self {
@@ -378,12 +376,12 @@ impl<T> Node<T, Z> {
     }
 }
 
-impl<T> Node<T, height::Root> {
+impl Node<height::Root> {
     /// Open the multi-level zipper over this (possibly absent) root: the
     /// starting state of a mirror descent (see
     /// [`Levels`](super::levels::Levels)).
     #[cfg(any(test, feature = "protocol-v1"))]
-    pub fn levels(node: Option<Root<T>>) -> Top<T> {
+    pub fn levels(node: Option<Root>) -> Top {
         levels(node)
     }
 
@@ -398,7 +396,7 @@ impl<T> Node<T, height::Root> {
     ///
     /// Delegates to the height-agnostic untyped walk; because this is a
     /// height-32 root, every yielded path is a full 32-byte array.
-    pub fn iter(&self) -> untyped::Iter<'_, T> {
+    pub fn iter(&self) -> untyped::Iter<'_> {
         untyped::Iter::root(&self.inner)
     }
 
@@ -410,7 +408,7 @@ impl<T> Node<T, height::Root> {
     pub fn range_owned<P: causally::Polarity>(
         node: Option<&Self>,
         query: causally::Query<'static, P>,
-    ) -> untyped::RangeOwned<T, P> {
+    ) -> untyped::RangeOwned<P> {
         untyped::RangeOwned::root(node.map(|node| node.inner.clone()), query)
     }
 
@@ -422,12 +420,12 @@ impl<T> Node<T, height::Root> {
     pub fn range<'a, P: causally::Polarity>(
         node: Option<&'a Self>,
         query: causally::Query<'a, P>,
-    ) -> untyped::Range<'a, T, P> {
+    ) -> untyped::Range<'a, P> {
         untyped::Range::root(node.map(|node| &node.inner), query)
     }
 
     /// The observable hash of a possibly-absent root.
-    pub fn root_hash(node: &Option<Root<T>>) -> Hash {
+    pub fn root_hash(node: &Option<Root>) -> Hash {
         // An absent root is the empty tree, which hashes as a prefixless
         // branch with no children (`blake3(BRANCH_TAG ‖ 0 ‖ 0u16)`), not as
         // the all-zero default.
@@ -437,23 +435,23 @@ impl<T> Node<T, height::Root> {
     }
 }
 
-impl<T, H: Height> Eq for Node<T, H> {}
+impl<H: Height> Eq for Node<H> {}
 
-impl<T, H: Height> PartialEq for Node<T, H> {
+impl<H: Height> PartialEq for Node<H> {
     fn eq(&self, other: &Self) -> bool {
         self.inner == other.inner
     }
 }
 
 // Wire format (see [`crate::tree::wire`]). Serialization is
-// height-uniform: every typed `Node<T, H>` delegates to
+// height-uniform: every typed `Node<H>` delegates to
 // [`untyped::Node::serialize_to`], which emits the in-memory
 // representation directly (prefix length, head bytes, then either a leaf
 // body or a `count_minus_two` + children list). No leaf-vs-branch tag is
 // needed on the wire — at the receiver, the typed height together with
 // the running `prefix_len` names the body's shape.
 //
-// Deserialization at typed height `H` reads `prefix_len`, then either
+// Deserialization at typed height `H` ([`DecodeNode`]) reads `prefix_len`, then either
 // decodes the body directly (when `prefix_len == 0`) or peels one head
 // byte and recurses at the next-finer typed height — synthesizing the
 // `prefix_len - 1` byte for the inner reader via
@@ -472,7 +470,7 @@ impl<T, H: Height> PartialEq for Node<T, H> {
 // appending binary-search miss, so the rebuild costs no shifting.
 
 #[cfg(any(test, feature = "protocol-v1"))]
-impl<T, H> wire::Encode for Node<T, H>
+impl<H> wire::Encode for Node<H>
 where
     H: Height,
 {
@@ -482,11 +480,28 @@ where
 }
 
 #[cfg(any(test, feature = "protocol-v1"))]
-impl<T> wire::Decode for Node<T, Z>
-where
-    T: DeserializeOwned + Send + Sync + 'static,
-{
-    fn read_wire<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
+/// The typed-payload decode of the node wire shape, per height.
+///
+/// The node itself is erased, but a leaf's payload decodes as a concrete
+/// `T` (the alternating protocol's typed ingress: malformed payloads fail
+/// here, at the wire boundary), so the decoder is a generic method rather
+/// than a [`wire::Decode`] impl — the height trait carries the same
+/// one-step-down recursion as the batch-apply walk
+/// ([`Act`](crate::tree::traverse::act::Act)).
+pub trait DecodeNode: Height {
+    fn read_node<T, R>(reader: &mut R) -> std::io::Result<Node<Self>>
+    where
+        T: DeserializeOwned + Send + Sync + 'static,
+        R: std::io::Read;
+}
+
+#[cfg(any(test, feature = "protocol-v1"))]
+impl DecodeNode for Z {
+    fn read_node<T, R>(reader: &mut R) -> std::io::Result<Node<Z>>
+    where
+        T: DeserializeOwned + Send + Sync + 'static,
+        R: std::io::Read,
+    {
         let prefix_len = u8::read_wire(reader)?;
         if prefix_len != 0 {
             return Err(wire::invalid("leaf height cannot carry a prefix"));
@@ -498,14 +513,16 @@ where
 }
 
 #[cfg(any(test, feature = "protocol-v1"))]
-impl<T, H> wire::Decode for Node<T, S<H>>
+impl<H> DecodeNode for S<H>
 where
-    T: DeserializeOwned + Send + Sync + 'static,
-    H: Height,
+    H: DecodeNode,
     S<H>: Height,
-    Node<T, H>: wire::Decode,
 {
-    fn read_wire<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
+    fn read_node<T, R>(reader: &mut R) -> std::io::Result<Node<S<H>>>
+    where
+        T: DeserializeOwned + Send + Sync + 'static,
+        R: std::io::Read,
+    {
         let prefix_len = u8::read_wire(reader)?;
         if (prefix_len as usize) > <S<H>>::HEIGHT {
             return Err(wire::invalid("prefix length exceeds typed height"));
@@ -516,7 +533,7 @@ where
             if count > 256 {
                 return Err(wire::invalid("branch children count exceeds 256"));
             }
-            let mut children = Children::<T, H>::default();
+            let mut children = Children::<H>::default();
             let mut prev: Option<u8> = None;
             for _ in 0..count {
                 let radix = u8::read_wire(reader)?;
@@ -526,7 +543,7 @@ where
                     return Err(wire::invalid("branch radices not strictly ascending"));
                 }
                 prev = Some(radix);
-                let child = Node::<T, H>::read_wire(reader)?;
+                let child = H::read_node::<T, R>(reader)?;
                 children.insert(radix, child);
             }
             Node::branch(children).ok_or_else(|| wire::invalid("branch could not be reconstructed"))
@@ -534,11 +551,11 @@ where
             let head = u8::read_wire(reader)?;
             // Prepend `prefix_len - 1` to the rest of the stream so the
             // inner typed level reads it as if it were on the wire,
-            // synthesizing the singleton-chain recursion without a helper
-            // trait.
+            // synthesizing the singleton-chain recursion without a second
+            // dispatch layer.
             let synthesized = [prefix_len - 1];
             let mut chained = std::io::Read::chain(synthesized.as_slice(), &mut *reader);
-            let inner = Node::<T, H>::read_wire(&mut chained)?;
+            let inner = H::read_node::<T, _>(&mut chained)?;
             Ok(Node::beneath(inner, head))
         }
     }
diff --git a/src/tree/typed/untyped.rs b/src/tree/typed/untyped.rs
index e224d4d16..3ee842cca 100644
--- a/src/tree/typed/untyped.rs
+++ b/src/tree/typed/untyped.rs
@@ -1,4 +1,3 @@
-use std::fmt::Debug;
 use std::mem;
 use std::sync::{Arc, OnceLock};
 
@@ -7,7 +6,6 @@ use tinyvec::ArrayVec;
 use before::{Dominance, Span};
 
 use crate::{Version, message::Message, tree::typed::Hash};
-use std::marker::PhantomData;
 
 pub mod fan;
 mod iter;
@@ -20,11 +18,11 @@ pub use iter::{Iter, Leaf, Range, RangeOwned};
 /// The single representation beneath the height-typed veneer (see
 /// [`typed`](super)); cloning is an `Arc` bump, and mutation is
 /// copy-on-write.
-pub struct Node<T> {
-    inner: Arc<NodeInner<T>>,
+pub struct Node {
+    inner: Arc<NodeInner>,
 }
 
-impl<T> Clone for Node<T> {
+impl Clone for Node {
     fn clone(&self) -> Self {
         Self::from_inner(self.inner.clone())
     }
@@ -32,7 +30,7 @@ impl<T> Clone for Node<T> {
 
 /// Handles are counted, so a dropped one must check out; see [`census`].
 #[cfg(any(test, feature = "test-internals"))]
-impl<T> Drop for Node<T> {
+impl Drop for Node {
     fn drop(&mut self) {
         census::dropped();
     }
@@ -77,14 +75,7 @@ pub(crate) mod census {
     }
 }
 
-struct NodeInner<T> {
-    /// The payload type the containing tree's facade reads its leaves at.
-    ///
-    /// Stored messages are type-erased ([`Message`] holds `dyn Any`), so
-    /// nothing structural consumes `T` here: the marker keeps the veneer's
-    /// parameter anchored (as `fn() -> T`, so auto-traits never descend
-    /// into `T`) until the typed boundary downcasts at the crate's API.
-    marker: PhantomData<fn() -> T>,
+struct NodeInner {
     /// Compressed path above this node's own branching level, stored with the
     /// deepest byte at index 0 and the shallowest byte at the last index. An
     /// empty prefix means the node is not path-compressed above its level.
@@ -106,13 +97,12 @@ struct NodeInner<T> {
     /// *or* `children` invalidates it and must reset this cell.
     hash: OnceLock<Hash>,
     /// The children of this node: either a leaf, or a branch point.
-    children: Children<T>,
+    children: Children,
 }
 
-impl<T> Clone for NodeInner<T> {
+impl Clone for NodeInner {
     fn clone(&self) -> Self {
         Self {
-            marker: PhantomData,
             prefix: self.prefix.clone(),
             hash: self.hash.clone(),
             children: self.children.clone(),
@@ -120,7 +110,7 @@ impl<T> Clone for NodeInner<T> {
     }
 }
 
-impl<T: Debug> Debug for Node<T> {
+impl std::fmt::Debug for Node {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Node")
             .field("prefix", &hex::encode(&self.inner.prefix))
@@ -131,7 +121,7 @@ impl<T: Debug> Debug for Node<T> {
 
 /// The children of a node.
 #[derive(Debug)]
-enum Children<T> {
+enum Children {
     /// A direct leaf, at the true bottom of the tree.
     Leaf {
         /// The version of this leaf.
@@ -167,11 +157,11 @@ enum Children<T> {
         /// prefix does.
         version_bytes: OnceLock<usize>,
         /// The children of this branch.
-        children: Fan<T>,
+        children: Fan,
     },
 }
 
-impl<T> Clone for Children<T> {
+impl Clone for Children {
     fn clone(&self) -> Self {
         match self {
             Self::Leaf { version, message } => Self::Leaf {
@@ -196,13 +186,13 @@ impl<T> Clone for Children<T> {
     }
 }
 
-impl<T> Node<T> {
+impl Node {
     /// Wrap built node state as a handle.
     ///
     /// Every handle in the crate passes through here or [`Clone`] — the
     /// funnel that makes the test-only [`census`] an exact residency
     /// count.
-    fn from_inner(inner: Arc<NodeInner<T>>) -> Self {
+    fn from_inner(inner: Arc<NodeInner>) -> Self {
         #[cfg(any(test, feature = "test-internals"))]
         census::created();
         Node { inner }
@@ -210,7 +200,7 @@ impl<T> Node<T> {
 
     /// Construct a new branch node from a list of children with distinct
     /// indices (inverse to [`Node::into_children`]).
-    pub fn branch(children: Fan<T>) -> Option<Self> {
+    pub fn branch(children: Fan) -> Option<Self> {
         match children.len() {
             0 => None,
             1 => {
@@ -220,7 +210,6 @@ impl<T> Node<T> {
                 Some(node.beneath(index))
             }
             _ => Some(Node::from_inner(Arc::new(NodeInner {
-                marker: PhantomData,
                 prefix: Vec::new(),
                 hash: OnceLock::new(),
                 children: Children::Branch {
@@ -237,7 +226,7 @@ impl<T> Node<T> {
     /// [`Node::branch`]).
     ///
     /// If `self` is a leaf node, returns `Err(self)`.
-    pub fn into_children(mut self) -> Result<Fan<T>, Node<T>> {
+    pub fn into_children(mut self) -> Result<Fan, Node> {
         if !self.inner.prefix.is_empty() {
             // Path-compressed: pop the top (shallowest) byte and rewrap self
             // under it. Popping shortens the prefix, so the observable hash
@@ -339,7 +328,6 @@ impl<T> Node<T> {
         debug_assert!(children.len() >= 2, "a branch point separates >= 2 runs");
 
         Node::from_inner(Arc::new(NodeInner {
-            marker: PhantomData,
             prefix: first[depth..branch_at].iter().rev().copied().collect(),
             hash: OnceLock::new(),
             children: Children::Branch {
@@ -354,7 +342,6 @@ impl<T> Node<T> {
     /// Construct a new leaf node.
     pub fn leaf(version: Version, value: Message) -> Self {
         Node::from_inner(Arc::new(NodeInner {
-            marker: PhantomData,
             prefix: Vec::new(),
             hash: OnceLock::new(),
             children: Children::Leaf {
@@ -596,7 +583,7 @@ impl<T> Node<T> {
     /// the subtree contains, so the prefix plays no part; and neither
     /// fold is ever empty, because a branch always has >= 2 children by
     /// the path-compression invariant.
-    fn bounds<'a>(bounds: &'a OnceLock<Span<'static>>, children: &Fan<T>) -> &'a Span<'static> {
+    fn bounds<'a>(bounds: &'a OnceLock<Span<'static>>, children: &Fan) -> &'a Span<'static> {
         bounds.get_or_init(|| {
             if children.values().all(Node::is_leaf) {
                 let mut versions = children.values().map(|child| match &child.inner.children {
@@ -727,7 +714,7 @@ impl<T> Node<T> {
     /// Pushing onto the prefix raises the observable hash by one virtual
     /// level, so the memoized hash is invalidated and recomputed lazily on the
     /// next read.
-    pub fn beneath(mut self, index: u8) -> Node<T> {
+    pub fn beneath(mut self, index: u8) -> Node {
         let inner = Arc::make_mut(&mut self.inner);
         inner.prefix.push(index);
         inner.hash = OnceLock::new();
@@ -750,9 +737,9 @@ impl<T> Node<T> {
     }
 }
 
-impl<T> Eq for Node<T> {}
+impl Eq for Node {}
 
-impl<T> PartialEq for Node<T> {
+impl PartialEq for Node {
     fn eq(&self, other: &Self) -> bool {
         // Shared backing settles equality with no hashing (and even cold): the
         // common case for forked/cloned trees and the subtrees they share.
diff --git a/src/tree/typed/untyped/fan.rs b/src/tree/typed/untyped/fan.rs
index bb1c17e6e..dfe1fa78c 100644
--- a/src/tree/typed/untyped/fan.rs
+++ b/src/tree/typed/untyped/fan.rs
@@ -19,7 +19,6 @@
 //! inside the container would buy nothing that the walk following every
 //! clone does not already pay for.
 
-use std::fmt::Debug;
 use std::mem;
 
 use smallvec::SmallVec;
@@ -31,7 +30,7 @@ mod tests;
 
 /// Entries a [`Fan`] holds inline before spilling to the heap.
 ///
-/// An entry is 16 bytes (`(u8, Node<T>)`, padded to the handle's
+/// An entry is 16 bytes (`(u8, Node)`, padded to the handle's
 /// alignment), so the fan occupies `8 + max(16 × FAN_INLINE, 16)` bytes
 /// inline — 40 at 2. Two entries cover the modal materialized branch (path
 /// compression guarantees at least two children, and interior branches
@@ -51,12 +50,12 @@ const FAN_INLINE: usize = 2;
 /// mutator preserves it, so consumers read ascending radix order
 /// structurally — the hash preimage and the wire encoding need no re-sort
 /// and no caller discipline.
-pub struct Fan<T> {
+pub struct Fan {
     /// Invariant: strictly ascending by radix, no duplicates.
-    entries: SmallVec<[(u8, Node<T>); FAN_INLINE]>,
+    entries: SmallVec<[(u8, Node); FAN_INLINE]>,
 }
 
-impl<T> Default for Fan<T> {
+impl Default for Fan {
     fn default() -> Self {
         Self {
             entries: SmallVec::new(),
@@ -64,7 +63,7 @@ impl<T> Default for Fan<T> {
     }
 }
 
-impl<T> Clone for Fan<T> {
+impl Clone for Fan {
     fn clone(&self) -> Self {
         Self {
             entries: self.entries.clone(),
@@ -72,13 +71,13 @@ impl<T> Clone for Fan<T> {
     }
 }
 
-impl<T: Debug> Debug for Fan<T> {
+impl std::fmt::Debug for Fan {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_map().entries(self.iter()).finish()
     }
 }
 
-impl<T> Fan<T> {
+impl Fan {
     /// The empty fan.
     pub fn new() -> Self {
         Self::default()
@@ -89,7 +88,7 @@ impl<T> Fan<T> {
     /// The single-entry shape is transient — it exists between exploding a
     /// path-compressed node and the `branch` constructor collapsing it back
     /// — and fits inline, so building it never allocates.
-    pub fn unit(radix: u8, child: Node<T>) -> Self {
+    pub fn unit(radix: u8, child: Node) -> Self {
         let mut entries = SmallVec::new();
         entries.push((radix, child));
         Self { entries }
@@ -113,12 +112,12 @@ impl<T> Fan<T> {
     }
 
     /// The child at `radix`, if any.
-    pub fn get(&self, radix: u8) -> Option<&Node<T>> {
+    pub fn get(&self, radix: u8) -> Option<&Node> {
         self.search(radix).ok().map(|at| &self.entries[at].1)
     }
 
     /// Insert `child` at `radix`, returning any child it displaced.
-    pub fn insert(&mut self, radix: u8, child: Node<T>) -> Option<Node<T>> {
+    pub fn insert(&mut self, radix: u8, child: Node) -> Option<Node> {
         match self.search(radix) {
             Ok(at) => Some(mem::replace(&mut self.entries[at].1, child)),
             Err(at) => {
@@ -129,7 +128,7 @@ impl<T> Fan<T> {
     }
 
     /// Remove and return the child at `radix`, if any.
-    pub fn remove(&mut self, radix: u8) -> Option<Node<T>> {
+    pub fn remove(&mut self, radix: u8) -> Option<Node> {
         self.search(radix).ok().map(|at| self.entries.remove(at).1)
     }
 
@@ -138,7 +137,7 @@ impl<T> Fan<T> {
     /// The resume point of a suspended ascending walk: one binary search,
     /// so the entries between the cursor and the answer are never
     /// enumerated and no sibling handle is materialized.
-    pub fn successor(&self, radix: u8) -> Option<(u8, &Node<T>)> {
+    pub fn successor(&self, radix: u8) -> Option<(u8, &Node)> {
         let at = self
             .entries
             .partition_point(|(present, _)| *present < radix);
@@ -152,7 +151,7 @@ impl<T> Fan<T> {
     /// this O(1) append is their build path; an out-of-order push trips a
     /// debug assertion (in release it would silently break the invariant
     /// the binary searches rely on).
-    pub fn push(&mut self, radix: u8, child: Node<T>) {
+    pub fn push(&mut self, radix: u8, child: Node) {
         debug_assert!(
             self.entries.last().is_none_or(|(last, _)| *last < radix),
             "Fan::push given a radix not greater than the current last",
@@ -164,14 +163,14 @@ impl<T> Fan<T> {
     ///
     /// Double-ended, and the length reported by `size_hint` is exact at
     /// every step: preimage assembly sizes its buffer from it.
-    pub fn iter(&self) -> Iter<'_, T> {
+    pub fn iter(&self) -> Iter<'_> {
         Iter {
             inner: self.entries.iter(),
         }
     }
 
     /// Iterate the children alone, in ascending radix order.
-    pub fn values(&self) -> impl DoubleEndedIterator<Item = &Node<T>> + ExactSizeIterator {
+    pub fn values(&self) -> impl DoubleEndedIterator<Item = &Node> + ExactSizeIterator {
         self.entries.iter().map(|(_, child)| child)
     }
 }
@@ -182,12 +181,12 @@ impl<T> Fan<T> {
 /// [`insert`](Fan::insert). Every reassembly in the crate feeds pairs
 /// already strictly ascending and duplicate-free, which this recognizes in
 /// one pass; anything else pays one stable sort.
-impl<T> FromIterator<(u8, Node<T>)> for Fan<T> {
-    fn from_iter<I: IntoIterator<Item = (u8, Node<T>)>>(iter: I) -> Self {
-        let mut entries: SmallVec<[(u8, Node<T>); FAN_INLINE]> = iter.into_iter().collect();
+impl FromIterator<(u8, Node)> for Fan {
+    fn from_iter<I: IntoIterator<Item = (u8, Node)>>(iter: I) -> Self {
+        let mut entries: SmallVec<[(u8, Node); FAN_INLINE]> = iter.into_iter().collect();
         if !entries.windows(2).all(|pair| pair[0].0 < pair[1].0) {
             entries.sort_by_key(|(radix, _)| *radix);
-            let mut deduped: SmallVec<[(u8, Node<T>); FAN_INLINE]> =
+            let mut deduped: SmallVec<[(u8, Node); FAN_INLINE]> =
                 SmallVec::with_capacity(entries.len());
             for (radix, child) in entries {
                 match deduped.last_mut() {
@@ -202,12 +201,12 @@ impl<T> FromIterator<(u8, Node<T>)> for Fan<T> {
 }
 
 /// The borrowing walk over a fan, ascending by radix; see [`Fan::iter`].
-pub struct Iter<'a, T> {
-    inner: std::slice::Iter<'a, (u8, Node<T>)>,
+pub struct Iter<'a> {
+    inner: std::slice::Iter<'a, (u8, Node)>,
 }
 
-impl<'a, T> Iterator for Iter<'a, T> {
-    type Item = (u8, &'a Node<T>);
+impl<'a> Iterator for Iter<'a> {
+    type Item = (u8, &'a Node);
 
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next().map(|(radix, child)| (*radix, child))
@@ -218,21 +217,21 @@ impl<'a, T> Iterator for Iter<'a, T> {
     }
 }
 
-impl<T> DoubleEndedIterator for Iter<'_, T> {
+impl DoubleEndedIterator for Iter<'_> {
     fn next_back(&mut self) -> Option<Self::Item> {
         self.inner.next_back().map(|(radix, child)| (*radix, child))
     }
 }
 
-impl<T> ExactSizeIterator for Iter<'_, T> {}
+impl ExactSizeIterator for Iter<'_> {}
 
 /// The consuming walk over a fan, ascending by radix.
-pub struct IntoIter<T> {
-    inner: smallvec::IntoIter<[(u8, Node<T>); FAN_INLINE]>,
+pub struct IntoIter {
+    inner: smallvec::IntoIter<[(u8, Node); FAN_INLINE]>,
 }
 
-impl<T> Iterator for IntoIter<T> {
-    type Item = (u8, Node<T>);
+impl Iterator for IntoIter {
+    type Item = (u8, Node);
 
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next()
@@ -243,17 +242,17 @@ impl<T> Iterator for IntoIter<T> {
     }
 }
 
-impl<T> DoubleEndedIterator for IntoIter<T> {
+impl DoubleEndedIterator for IntoIter {
     fn next_back(&mut self) -> Option<Self::Item> {
         self.inner.next_back()
     }
 }
 
-impl<T> ExactSizeIterator for IntoIter<T> {}
+impl ExactSizeIterator for IntoIter {}
 
-impl<T> IntoIterator for Fan<T> {
-    type Item = (u8, Node<T>);
-    type IntoIter = IntoIter<T>;
+impl IntoIterator for Fan {
+    type Item = (u8, Node);
+    type IntoIter = IntoIter;
 
     /// Consume the fan in ascending radix order.
     fn into_iter(self) -> Self::IntoIter {
diff --git a/src/tree/typed/untyped/fan/tests.rs b/src/tree/typed/untyped/fan/tests.rs
index a826aadc2..c235b85e4 100644
--- a/src/tree/typed/untyped/fan/tests.rs
+++ b/src/tree/typed/untyped/fan/tests.rs
@@ -14,7 +14,7 @@ use super::Fan;
 /// Each call yields a distinct `Arc`, so `Node::ptr_eq` distinguishes any
 /// two children a test creates: the differential comparisons below check
 /// *which* handle a fan holds, not merely that one is present.
-fn child() -> Node<()> {
+fn child() -> Node {
     Node::leaf(Version::new(), Message::new(()))
 }
 
@@ -43,7 +43,7 @@ fn arb_ops() -> impl Strategy<Value = Vec<Op>> {
 /// and per-child identity), the values-only walk both ways, point lookups
 /// across the whole alphabet, and the successor probe against the oracle's
 /// range query.
-fn equivalent(fan: &Fan<()>, oracle: &BTreeMap<u8, Node<()>>) -> Result<(), TestCaseError> {
+fn equivalent(fan: &Fan, oracle: &BTreeMap<u8, Node>) -> Result<(), TestCaseError> {
     prop_assert_eq!(fan.len(), oracle.len());
     prop_assert_eq!(fan.is_empty(), oracle.is_empty());
 
@@ -166,7 +166,7 @@ proptest! {
         radixes in proptest::collection::btree_set(any::<u8>(), 0..16),
         splits in (0usize..=16, 0usize..=16),
     ) {
-        let fan: Fan<()> = radixes.iter().map(|radix| (*radix, child())).collect();
+        let fan: Fan = radixes.iter().map(|radix| (*radix, child())).collect();
         let n = fan.len();
         let (j, k) = splits;
         let (j, k) = (j.min(n), k.min(n - j.min(n)));
@@ -197,10 +197,10 @@ proptest! {
     /// fan: later pairs displace earlier ones at the same radix.
     #[test]
     fn collect_agrees_with_sequential_insert(radixes in vec(any::<u8>(), 0..32)) {
-        let pairs: Vec<(u8, Node<()>)> =
+        let pairs: Vec<(u8, Node)> =
             radixes.into_iter().map(|radix| (radix, child())).collect();
 
-        let collected: Fan<()> = pairs.iter().map(|(radix, node)| (*radix, node.clone())).collect();
+        let collected: Fan = pairs.iter().map(|(radix, node)| (*radix, node.clone())).collect();
         let mut sequential = Fan::new();
         for (radix, node) in pairs {
             sequential.insert(radix, node);
@@ -220,8 +220,8 @@ proptest! {
     /// handles the fan held, in order.
     #[test]
     fn into_iter_collect_round_trips(radixes in proptest::collection::btree_set(any::<u8>(), 0..16)) {
-        let fan: Fan<()> = radixes.iter().map(|radix| (*radix, child())).collect();
-        let round_tripped: Fan<()> = fan.clone().into_iter().collect();
+        let fan: Fan = radixes.iter().map(|radix| (*radix, child())).collect();
+        let round_tripped: Fan = fan.clone().into_iter().collect();
 
         prop_assert_eq!(round_tripped.len(), fan.len());
         for ((radix, child), (expected_radix, expected)) in
@@ -237,14 +237,14 @@ proptest! {
     /// agree wherever both apply.
     #[test]
     fn push_agrees_with_collect(radixes in proptest::collection::btree_set(any::<u8>(), 0..16)) {
-        let pairs: Vec<(u8, Node<()>)> =
+        let pairs: Vec<(u8, Node)> =
             radixes.iter().map(|radix| (*radix, child())).collect();
 
         let mut pushed = Fan::new();
         for (radix, node) in &pairs {
             pushed.push(*radix, node.clone());
         }
-        let collected: Fan<()> = pairs.into_iter().collect();
+        let collected: Fan = pairs.into_iter().collect();
 
         prop_assert_eq!(pushed.len(), collected.len());
         for ((radix, child), (expected_radix, expected)) in
@@ -270,7 +270,7 @@ fn unit_holds_exactly_one_child() {
 
 /// The fan occupies 40 bytes on 64-bit targets.
 ///
-/// An entry is 16 bytes (`(u8, Node<T>)` padded to the 8-byte handle
+/// An entry is 16 bytes (`(u8, Node)` padded to the 8-byte handle
 /// alignment), so the inline form is 8 bytes of capacity plus
 /// `16 × FAN_INLINE` of storage — the packed overlay of inline and spilled
 /// forms that `smallvec`'s `union` feature provides (without it a
@@ -280,5 +280,5 @@ fn unit_holds_exactly_one_child() {
 #[cfg(target_pointer_width = "64")]
 #[test]
 fn fan_is_forty_bytes() {
-    assert_eq!(std::mem::size_of::<Fan<()>>(), 40);
+    assert_eq!(std::mem::size_of::<Fan>(), 40);
 }
diff --git a/src/tree/typed/untyped/iter.rs b/src/tree/typed/untyped/iter.rs
index ed01632a9..ddc927333 100644
--- a/src/tree/typed/untyped/iter.rs
+++ b/src/tree/typed/untyped/iter.rs
@@ -16,9 +16,9 @@ use crate::{Version, causally, message::Message};
 use super::{Children, Node};
 
 /// One pending subtree in a walk's frontier.
-struct Frame<'a, T> {
+struct Frame<'a> {
     /// The subtree not yet entered.
-    node: &'a Node<T>,
+    node: &'a Node,
     /// Whether an ancestor was already promoted: every leaf beneath `node`
     /// is known to satisfy the walk's range, so its descent skips the
     /// version comparisons.
@@ -50,14 +50,14 @@ struct Frame<'a, T> {
 /// its verdict degenerates to membership and prune-or-promote is
 /// exhaustive: the walk never compares versions leaf-by-leaf.
 ///
-struct Walk<'a, T, P: Polarity> {
+struct Walk<'a, P: Polarity> {
     /// Pending [`Frame`]s, held in ascending key order front-to-back.
     ///
     /// Forward steps consume the front, backward steps the back; a branch is
     /// expanded in place into its children (preserving the ordering), so the
     /// frontier always describes exactly the not-yet-yielded leaves. Empty
     /// once exhausted.
-    frames: VecDeque<Frame<'a, T>>,
+    frames: VecDeque<Frame<'a>>,
     /// Leaves not yet visited — the leaf count still reachable from the
     /// frontier.
     ///
@@ -73,8 +73,8 @@ struct Walk<'a, T, P: Polarity> {
     query: Query<'a, P>,
 }
 
-impl<'a, T, P: Polarity> Walk<'a, T, P> {
-    fn new(node: Option<&'a Node<T>>, query: Query<'a, P>) -> Self {
+impl<'a, P: Polarity> Walk<'a, P> {
+    fn new(node: Option<&'a Node>, query: Query<'a, P>) -> Self {
         match node {
             None => Self {
                 frames: VecDeque::new(),
@@ -173,15 +173,15 @@ impl<'a, T, P: Polarity> Walk<'a, T, P> {
 /// and `Tree::join` lean on the ascending forward order for their own
 /// deterministic callback delivery.)
 ///
-/// `Iter` is `Send + Sync` whenever `T: Send + Sync`: it holds only
-/// `&Node<T>` references.
-pub struct Iter<'a, T> {
-    walk: Walk<'a, T, causally::Neutral>,
+/// `Iter` is `Send + Sync`: it holds only `&Node` references, and the
+/// stored payloads are `Send + Sync` by [`Message`]'s construction bound.
+pub struct Iter<'a> {
+    walk: Walk<'a, causally::Neutral>,
 }
 
-impl<'a, T> Iter<'a, T> {
+impl<'a> Iter<'a> {
     /// Iterate the subtree rooted at `node`.
-    pub(crate) fn root(node: &'a Node<T>) -> Self {
+    pub(crate) fn root(node: &'a Node) -> Self {
         Self {
             walk: Walk::new(Some(node), causally::all()),
         }
@@ -195,7 +195,7 @@ impl<'a, T> Iter<'a, T> {
     }
 }
 
-impl<'a, T> Iterator for Iter<'a, T> {
+impl<'a> Iterator for Iter<'a> {
     type Item = (&'a Version, &'a Message);
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -210,13 +210,13 @@ impl<'a, T> Iterator for Iter<'a, T> {
     }
 }
 
-impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
+impl<'a> DoubleEndedIterator for Iter<'a> {
     fn next_back(&mut self) -> Option<Self::Item> {
         self.walk.step(true)
     }
 }
 
-impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
+impl<'a> ExactSizeIterator for Iter<'a> {}
 
 /// The leaf walk filtered to a causal [`Query`].
 ///
@@ -233,21 +233,21 @@ impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 /// [`ExactSizeIterator`]: how many leaves pass is unknown until they are
 /// visited, so [`size_hint`](Iterator::size_hint) reports only an upper
 /// bound.
-pub struct Range<'a, T, P: Polarity> {
-    walk: Walk<'a, T, P>,
+pub struct Range<'a, P: Polarity> {
+    walk: Walk<'a, P>,
 }
 
-impl<'a, T, P: Polarity> Range<'a, T, P> {
+impl<'a, P: Polarity> Range<'a, P> {
     /// Iterate the leaves of the (possibly absent) height-32 root `node`
     /// whose versions the causal `query` admits.
-    pub(crate) fn root(node: Option<&'a Node<T>>, query: Query<'a, P>) -> Self {
+    pub(crate) fn root(node: Option<&'a Node>, query: Query<'a, P>) -> Self {
         Self {
             walk: Walk::new(node, query),
         }
     }
 }
 
-impl<'a, T, P: Polarity> Iterator for Range<'a, T, P> {
+impl<'a, P: Polarity> Iterator for Range<'a, P> {
     type Item = (&'a Version, &'a Message);
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -261,7 +261,7 @@ impl<'a, T, P: Polarity> Iterator for Range<'a, T, P> {
     }
 }
 
-impl<'a, T, P: Polarity> DoubleEndedIterator for Range<'a, T, P> {
+impl<'a, P: Polarity> DoubleEndedIterator for Range<'a, P> {
     fn next_back(&mut self) -> Option<Self::Item> {
         self.walk.step(true)
     }
@@ -288,13 +288,13 @@ impl<'a, T, P: Polarity> DoubleEndedIterator for Range<'a, T, P> {
 /// Yields each passing leaf as an owned [`Leaf`] handle alongside its
 /// reconstructed 32-byte path; the version and value read out of the
 /// handle as shared, clone-cheap references into the tree's storage.
-pub struct RangeOwned<T, P: Polarity> {
+pub struct RangeOwned<P: Polarity> {
     /// The not-yet-visited root, consumed by the first advance.
-    start: Option<Node<T>>,
+    start: Option<Node>,
     /// The descent spine: index 0 is the root's level, the last entry is the
     /// level currently being walked. Always branch nodes (leaves are yielded,
     /// never pushed).
-    spine: Vec<Level<T>>,
+    spine: Vec<Level>,
     /// The path bytes accumulated along the spine, extended and rolled back
     /// as the walk descends and ascends; a leaf is yielded exactly when it
     /// reaches 32 bytes.
@@ -305,9 +305,9 @@ pub struct RangeOwned<T, P: Polarity> {
 }
 
 /// One level of a [`RangeOwned`] walk's descent spine.
-struct Level<T> {
+struct Level {
     /// The branch node this level walks.
-    node: Node<T>,
+    node: Node,
     /// The smallest child radix not yet visited; `256` means exhausted.
     next: u16,
     /// Whether an ancestor (or this level itself) was promoted: every leaf
@@ -321,20 +321,21 @@ struct Level<T> {
 
 /// A live leaf popped out of a [`RangeOwned`] walk: an owned handle on the leaf
 /// node, lending its version and value to whoever holds it.
-pub struct Leaf<T>(Node<T>);
+pub struct Leaf(Node);
 
-impl<T> Leaf<T> {
+impl Leaf {
     /// The causal [`Version`] at which this message was observed.
     pub fn version(&self) -> &Version {
         self.0.ceiling()
     }
 
-    /// The message's value: an owned handle, one reference bump on the
-    /// shared allocation.
-    pub fn value(&self) -> std::sync::Arc<T>
-    where
-        T: Send + Sync + 'static,
-    {
+    /// The message's value as its concrete payload type: an owned handle,
+    /// one reference bump on the shared allocation.
+    ///
+    /// # Panics
+    ///
+    /// If the payload is not a `T` (see [`Message::message`]).
+    pub fn value<T: Send + Sync + 'static>(&self) -> std::sync::Arc<T> {
         self.0
             .as_leaf()
             .expect("a Leaf wraps a leaf node, by construction")
@@ -348,7 +349,7 @@ impl<T> Leaf<T> {
     /// (its hash commits an empty suffix, not the stored spine). The stored handle
     /// is reused when it is already bare; otherwise a fresh prefix-free
     /// leaf is built around the same message handle.
-    pub(crate) fn into_node(self) -> Node<T> {
+    pub(crate) fn into_node(self) -> Node {
         if self.0.inner.prefix.is_empty() {
             return self.0;
         }
@@ -361,10 +362,10 @@ impl<T> Leaf<T> {
     }
 }
 
-impl<T, P: Polarity> RangeOwned<T, P> {
+impl<P: Polarity> RangeOwned<P> {
     /// Walk the leaves of the (possibly absent) height-32 root `node`
     /// whose versions the causal `query` admits.
-    pub(crate) fn root(node: Option<Node<T>>, query: Query<'static, P>) -> Self {
+    pub(crate) fn root(node: Option<Node>, query: Query<'static, P>) -> Self {
         Self::within(node, &[], query)
     }
 
@@ -375,7 +376,7 @@ impl<T, P: Polarity> RangeOwned<T, P> {
     /// each leaf still reconstructs a full 32-byte
     /// 32-byte path. `path.len()` plus the height of
     /// `node` must therefore be 32.
-    pub(crate) fn within(node: Option<Node<T>>, path: &[u8], query: Query<'static, P>) -> Self {
+    pub(crate) fn within(node: Option<Node>, path: &[u8], query: Query<'static, P>) -> Self {
         let mut buf = ArrayVec::new();
         buf.extend_from_slice(path);
         Self {
@@ -391,7 +392,7 @@ impl<T, P: Polarity> RangeOwned<T, P> {
 
     /// Advance to the next passing leaf. The same classification as the
     /// borrowing walk, with the leaf handed out by value.
-    pub(crate) fn next(&mut self) -> Option<([u8; 32], Leaf<T>)> {
+    pub(crate) fn next(&mut self) -> Option<([u8; 32], Leaf)> {
         loop {
             // Obtain the next unvisited node — the initial root, or the next
             // child at the deepest spine level, ascending past exhausted
diff --git a/src/tree/typed/untyped/tests.rs b/src/tree/typed/untyped/tests.rs
index 352ad4d6e..fb9a08b33 100644
--- a/src/tree/typed/untyped/tests.rs
+++ b/src/tree/typed/untyped/tests.rs
@@ -43,7 +43,7 @@ const TREE_LEAF_BUDGET: usize = 16;
 /// child gets at least 1 and the shares sum to the parent's budget). This
 /// guarantees all leaves sit at a common depth, and no more than `budget`
 /// leaves are generated. `budget` must be at least 1.
-fn arb_tree(depth: usize, budget: usize) -> BoxedStrategy<Node<()>> {
+fn arb_tree(depth: usize, budget: usize) -> BoxedStrategy<Node> {
     if depth == 0 {
         // The leaf payload is not examined at this abstraction layer, so we
         // stuff in a fixed empty value rather than generating one; only the
@@ -79,7 +79,7 @@ fn arb_tree(depth: usize, budget: usize) -> BoxedStrategy<Node<()>> {
                 (Just(indices), subtrees)
             })
             .prop_map(|(indices, subtrees)| {
-                let children: Fan<()> = indices.into_iter().zip(subtrees).collect();
+                let children: Fan = indices.into_iter().zip(subtrees).collect();
                 Node::branch(children).expect("branch input has >= 1 child")
             })
             .boxed()
@@ -94,7 +94,7 @@ fn arb_tree(depth: usize, budget: usize) -> BoxedStrategy<Node<()>> {
 /// yields them. The version is the leaf's own version as recorded by
 /// `Node::leaf`, and is preserved across path compression because
 /// `into_children` never mutates `version` — only `prefix`.
-fn enumerate_leaves(node: Node<()>, path: Vec<u8>) -> Vec<(Vec<u8>, Version, Message)> {
+fn enumerate_leaves(node: Node, path: Vec<u8>) -> Vec<(Vec<u8>, Version, Message)> {
     match node.into_children() {
         Ok(children) => children
             .into_iter()
@@ -125,7 +125,7 @@ fn enumerate_leaves(node: Node<()>, path: Vec<u8>) -> Vec<(Vec<u8>, Version, Mes
 /// leaves pass their original version back into `Node::leaf`, and branch
 /// versions are recomputed by `Node::branch` from the same per-child
 /// versions we started with.
-fn rebuild_with<F>(node: Node<()>, f: &F) -> Node<()>
+fn rebuild_with<F>(node: Node, f: &F) -> Node
 where
     F: Fn(&Message) -> Message,
 {
@@ -138,7 +138,7 @@ where
             Node::leaf(version, f(leaf))
         }
         Ok(children) => {
-            let rebuilt: Fan<()> = children
+            let rebuilt: Fan = children
                 .into_iter()
                 .map(|(k, v)| (k, rebuild_with(v, f)))
                 .collect();
@@ -155,7 +155,7 @@ where
 /// one-child case is handled by `beneath`-collapse instead.
 #[test]
 fn empty_branch_is_none() {
-    let empty: Fan<()> = Fan::new();
+    let empty: Fan = Fan::new();
     assert!(Node::branch(empty).is_none());
 }
 
@@ -285,7 +285,7 @@ proptest! {
     fn bounds_are_the_leaf_fold_at_every_node(
         tree in (0..=MAX_TEST_DEPTH).prop_flat_map(|d| arb_tree(d, TREE_LEAF_BUDGET)),
     ) {
-        fn check(node: &Node<()>) -> Result<Vec<Version>, TestCaseError> {
+        fn check(node: &Node) -> Result<Vec<Version>, TestCaseError> {
             let floor = node.floor().clone();
             let ceiling = node.ceiling().clone();
             let leaves = match node.clone().into_children() {
@@ -497,7 +497,7 @@ proptest! {
 /// `BRANCH_TAG ‖ len ‖ prefix ‖ count(u16 BE) ‖ (radix ‖ hash)*` for a
 /// branch — with every child hash computed by the same reference
 /// recursively, never by [`Node::hash`].
-fn reference_hash(mut node: Node<()>) -> super::Hash {
+fn reference_hash(mut node: Node) -> super::Hash {
     const LEAF_TAG: u8 = 0;
     const BRANCH_TAG: u8 = 1;
     let mut prefix: Vec<u8> = Vec::new();
@@ -549,8 +549,8 @@ fn full_depth_paths() -> impl Strategy<Value = BTreeSet<[u8; 32]>> {
 /// Leaf versions are all genesis: the hash convention never commits a
 /// version, so varying them adds nothing to the hash properties checked
 /// against this reference.
-fn canonical_at(depth: usize, paths: &[[u8; 32]]) -> Node<()> {
-    let mut entries: Vec<([u8; 32], Option<Node<()>>)> = paths
+fn canonical_at(depth: usize, paths: &[[u8; 32]]) -> Node {
+    let mut entries: Vec<([u8; 32], Option<Node>)> = paths
         .iter()
         .map(|path| (*path, Some(Node::leaf(Version::new(), Message::new(())))))
         .collect();
@@ -560,11 +560,7 @@ fn canonical_at(depth: usize, paths: &[[u8; 32]]) -> Node<()> {
 /// Recursively explode `node` (observed from `depth`, holding exactly the
 /// leaves at `paths`) one virtual level at a time, checking at every
 /// position that its hash matches the canonical from-scratch construction.
-fn check_virtual_levels(
-    node: Node<()>,
-    depth: usize,
-    paths: &[[u8; 32]],
-) -> Result<(), TestCaseError> {
+fn check_virtual_levels(node: Node, depth: usize, paths: &[[u8; 32]]) -> Result<(), TestCaseError> {
     prop_assert_eq!(node.hash(), canonical_at(depth, paths).hash());
     match node.into_children() {
         // A bare leaf: the walk consumed the entire 32-byte path.
@@ -593,7 +589,7 @@ fn check_virtual_levels(
 #[test]
 fn node_hash_preimage_is_in_path_order() {
     const LEAF_TAG: u8 = 0;
-    let leaf = Node::<()>::leaf(Version::new(), Message::new(()));
+    let leaf = Node::leaf(Version::new(), Message::new(()));
     let wrapped = leaf.beneath(0xAA).beneath(0xBB);
     assert_eq!(wrapped.hash(), super::Hash::of(&[LEAF_TAG, 2, 0xBB, 0xAA]));
 }
@@ -658,9 +654,9 @@ mod memo_fold_cost {
     /// One full-fanout branch of leaves carrying `versions`, radix `i`
     /// holding `versions[i]`, plus the same children for the reference
     /// fold to walk (a fan clone bumps each child's `Arc`).
-    fn wide_branch(versions: Vec<Version>) -> (Node<()>, Fan<()>) {
+    fn wide_branch(versions: Vec<Version>) -> (Node, Fan) {
         assert_eq!(versions.len(), FANOUT, "one version per radix");
-        let children: Fan<()> = versions
+        let children: Fan = versions
             .into_iter()
             .enumerate()
             .map(|(radix, version)| {
@@ -693,7 +689,7 @@ mod memo_fold_cost {
     /// floors (seeded from the first child, the meet's own seed rule),
     /// with the composed `(limb ops, scan bits, digit touches)`
     /// reading.
-    fn sequential_bounds(children: &Fan<()>) -> (Version, Version, u64, u64, u64) {
+    fn sequential_bounds(children: &Fan) -> (Version, Version, u64, u64, u64) {
         let ((join, meet), limb, scan, touch) = metered(|| {
             let mut join = Version::new();
             for child in children.values() {
@@ -836,9 +832,9 @@ mod memo_fold_cost {
     fn interior_bounds_memo_undercuts_sequential_folds() {
         let (packed, _) = Shape::StaggerPopulation.population(FANOUT, 16);
         let mut versions = packed.iter().map(|packed| packed.version());
-        let children: Fan<()> = (0..FANOUT / 2)
+        let children: Fan = (0..FANOUT / 2)
             .map(|radix| {
-                let pair: Fan<()> = [0u8, 1u8]
+                let pair: Fan = [0u8, 1u8]
                     .into_iter()
                     .map(|slot| {
                         let version = versions.next().expect("one version per slot");
@@ -891,7 +887,7 @@ mod memo_fold_cost {
 #[test]
 #[cfg(target_pointer_width = "64")]
 fn node_inner_stays_within_budget() {
-    assert!(std::mem::size_of::<Fan<()>>() <= 40);
-    assert!(std::mem::size_of::<super::Children<()>>() <= 160);
-    assert!(std::mem::size_of::<super::NodeInner<()>>() <= 208);
+    assert!(std::mem::size_of::<Fan>() <= 40);
+    assert!(std::mem::size_of::<super::Children>() <= 160);
+    assert!(std::mem::size_of::<super::NodeInner>() <= 208);
 }
diff --git a/src/tree/wire.rs b/src/tree/wire.rs
index 5fedbe644..2b179c038 100644
--- a/src/tree/wire.rs
+++ b/src/tree/wire.rs
@@ -220,8 +220,9 @@ mod tests {
     use super::*;
     use crate::message::Message;
     use crate::tree::arb::nth_party;
+    use crate::tree::typed::Node;
     use crate::tree::typed::height::Z;
-    use crate::tree::typed::{Node, Prefix};
+    use crate::tree::typed::node::DecodeNode;
 
     /// Every wire atom round-trips through `to_vec`/`from_slice`, alone
     /// and composed: the version and message as CBOR values, the node's
@@ -245,20 +246,14 @@ mod tests {
         let back = Message::from_reader::<(), _>(&mut enc.as_slice()).unwrap();
         assert_eq!(back.as_slice(), m.as_slice());
 
-        let leaf: Node<(), Z> = Node::leaf(version.clone(), Message::new(()));
+        let leaf: Node<Z> = Node::leaf(version.clone(), Message::new(()));
         let enc = to_vec(&leaf).unwrap();
-        let back: Node<(), Z> = from_slice(&enc).unwrap();
+        let mut input = enc.as_slice();
+        let back = Z::read_node::<(), _>(&mut input).unwrap();
+        assert!(
+            input.is_empty(),
+            "the node decode consumes exactly its bytes"
+        );
         assert_eq!(back.hash(), leaf.hash());
-
-        let pair: Vec<(Prefix<Z>, Node<(), Z>)> = vec![(
-            Prefix::from(<[u8; 32]>::from(crate::tree::typed::Path::for_leaf(
-                &version,
-            ))),
-            leaf.clone(),
-        )];
-        let enc = to_vec(&pair).unwrap();
-        let back: Vec<(Prefix<Z>, Node<(), Z>)> = from_slice(&enc).unwrap();
-        assert_eq!(back.len(), 1);
-        assert_eq!(back[0].1.hash(), leaf.hash());
     }
 }

From 48bc31df9594a451f28b0c4d86eda126e55333bf Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Thu, 20 Aug 2026 00:39:42 -0400
Subject: [PATCH 13/18] session: erase the payload type; decode through the
 peer's deserializer (part II stage 3)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The streaming session drops its payload parameter everywhere: Backend,
Node, Leaf, and Measure lose T, and with them the message vocabulary,
the typestates, the walk and proxy workers, the codec's Frame/LeafRun,
the stream binders, and the drivers. The payload type's one residue in
a running session is a PayloadDeserializer — a plain fn pointer minted
by Message::deserializer::<T>() at Peer construction (seed and
bootstrap now carry T: DeserializeOwned; the gossip entry points carry
no serde bounds at all) and threaded to each protocol's handshake
entry, where wire ingress builds every supplied payload through it
(Message::from_wire). A mispaired deserializer fails at ingress — the
tripwire caught exactly that during the sweep, when a blanket
unit-payload deserializer in the proxy tests met u64 leaves.

The V1 oracle joins the same regime rather than staying typed:
DecodeNode::read_node and the payload-bearing messages' DecodeWith take
the deserializer, recv_msg_with carries it through the framing, and the
remote Exchange stores it — which dissolves the phantom decode-context
fields stage 2 had introduced and leaves the V1 protocol traits
non-generic.

One deliberate error-taxonomy change, named per the snapshot policy:
the error atlas is re-accepted because record-level trailing payload
bytes now classify as a malformed payload
(DecodeLeafError::Message(InvalidData)) — the payload runs to the
record's end, so the deserializer owns the exactly-one-value check —
and the unreachable TrailingBytes variant is gone. The wire snapshots
are untouched: this is diagnostics classification, not wire format.

Measured (cargo llvm-lines, debug, default features): the lib grows
~102k -> 354,431 lines / 12,716 copies — the session now compiles
once, into the rlib — while pairwise sits flat at 719,377 / 30,252,
because Peer::<T>'s session-driving methods are still generic funnels:
gossip_inner::<u64> monomorphizes in the consumer crate and drags the
whole (now T-free, still B-generic) session tower with it. Sealing
those entry points non-generic is the next commit, and the number that
decides the erasure's cost/benefit.
---
 design/item-erasure.md                        |  40 +++-
 src/conformance/backend.rs                    |  75 ++++----
 src/conformance/backend/tests.rs              |  44 ++---
 src/message.rs                                |  68 +++++--
 src/message/tests.rs                          |   4 +-
 src/peer.rs                                   |  15 +-
 src/peer/bootstrap.rs                         |   5 +-
 src/peer/gossip.rs                            |  46 +++--
 src/peer/gossip/tests.rs                      |   9 +-
 src/rumors.rs                                 |   6 +-
 src/tests.rs                                  |   5 +-
 src/tree/mirror/alternating.rs                |  52 +++--
 src/tree/mirror/alternating/backend/local.rs  |  60 ++----
 .../alternating/backend/local/partition.rs    |  16 +-
 src/tree/mirror/alternating/backend/remote.rs | 146 +++++++++-----
 .../alternating/backend/remote/tests.rs       |  18 +-
 src/tree/mirror/alternating/message.rs        | 115 +++++------
 src/tree/mirror/alternating/message/tests.rs  |  44 +++--
 src/tree/mirror/alternating/protocol.rs       | 163 ++++++----------
 src/tree/mirror/alternating/tests.rs          |  16 +-
 src/tree/mirror/alternating/wire_snapshot.rs  |  17 +-
 src/tree/mirror/streaming.rs                  |  55 +++---
 src/tree/mirror/streaming/backend.rs          |  38 ++--
 src/tree/mirror/streaming/backend/local.rs    |  24 +--
 .../mirror/streaming/backend/local/tests.rs   |   6 +-
 src/tree/mirror/streaming/convert.rs          |  45 ++---
 src/tree/mirror/streaming/convert/tests.rs    |   4 +-
 src/tree/mirror/streaming/driver.rs           |  18 +-
 src/tree/mirror/streaming/erased.rs           |  59 +++---
 src/tree/mirror/streaming/materialized.rs     | 138 ++++++--------
 .../mirror/streaming/materialized/common.rs   |   5 +-
 .../mirror/streaming/materialized/tests.rs    |  11 +-
 .../mirror/streaming/materialized/unknown.rs  |  10 +-
 .../streaming/materialized/unknown/tests.rs   |   6 +-
 .../mirror/streaming/materialized/work.rs     |  14 +-
 .../streaming/materialized/work/answer.rs     |   5 +-
 .../streaming/materialized/work/assembly.rs   |  12 +-
 .../streaming/materialized/work/levels.rs     |  71 ++++---
 .../streaming/materialized/work/queues.rs     |  70 +++----
 .../streaming/materialized/work/resolver.rs   |  10 +-
 .../streaming/materialized/work/tests.rs      |  16 +-
 .../materialized/work/tests/violations.rs     |  12 +-
 src/tree/mirror/streaming/message.rs          |   6 +-
 src/tree/mirror/streaming/protocol.rs         |  88 ++++-----
 src/tree/mirror/streaming/protocol/peer.rs    |  64 +++----
 src/tree/mirror/streaming/remote/adapter.rs   |   4 +-
 .../mirror/streaming/remote/adapter/decode.rs |  86 +++++----
 .../mirror/streaming/remote/adapter/encode.rs |  36 ++--
 .../mirror/streaming/remote/adapter/tests.rs  |   2 +-
 .../remote/adapter/tests/backend_errors.rs    |   9 +-
 .../remote/adapter/tests/fan_occupancy.rs     |  10 +-
 .../remote/adapter/tests/malformed.rs         |  75 +++++---
 .../streaming/remote/adapter/tests/opening.rs |  46 +++--
 .../streaming/remote/adapter/tests/parking.rs |  10 +-
 .../remote/adapter/tests/properties.rs        |  53 +++---
 .../streaming/remote/adapter/tests/runs.rs    |  24 +--
 src/tree/mirror/streaming/remote/codec.rs     |   2 +-
 .../mirror/streaming/remote/codec/capture.rs  |   2 +-
 .../streaming/remote/codec/capture/tests.rs   |   2 +-
 .../mirror/streaming/remote/codec/decode.rs   |  17 +-
 .../streaming/remote/codec/decode/async_io.rs |  12 +-
 .../streaming/remote/codec/decode/tests.rs    |  76 +++++---
 .../mirror/streaming/remote/codec/encode.rs   |  16 +-
 .../streaming/remote/codec/encode/async_io.rs |   6 +-
 .../streaming/remote/codec/encode/tests.rs    |  10 +-
 .../mirror/streaming/remote/codec/error.rs    |   2 -
 .../mirror/streaming/remote/codec/frame.rs    |  68 +++----
 .../streaming/remote/codec/frame/tests.rs     |   4 +-
 .../mirror/streaming/remote/codec/tests.rs    |  33 ++--
 .../remote/codec/tests/error_atlas.rs         |  63 +++---
 ...ror_atlas__codec_error_atlas_snapshot.snap |   5 +-
 .../mirror/streaming/remote/proxy/start.rs    |  75 ++++----
 .../mirror/streaming/remote/proxy/state.rs    | 134 ++++++-------
 .../mirror/streaming/remote/proxy/tests.rs    |  54 +++---
 .../remote/proxy/tests/containment.rs         |  11 +-
 .../streaming/remote/proxy/tests/harness.rs   |  11 +-
 .../mirror/streaming/remote/proxy/work.rs     |  25 ++-
 .../streaming/remote/proxy/work/encode.rs     |  37 ++--
 .../streaming/remote/proxy/work/pump.rs       | 179 ++++++++++--------
 .../streaming/remote/proxy/work/tests.rs      |   8 +-
 src/tree/mirror/streaming/remote/streams.rs   |  43 ++---
 .../mirror/streaming/remote/streams/tests.rs  |  31 ++-
 src/tree/mirror/streaming/testing/failing.rs  |  35 +---
 src/tree/mirror/streaming/testing/faulting.rs |  73 +++----
 src/tree/mirror/streaming/tests.rs            |  13 +-
 src/tree/mirror/streaming/tests/announced.rs  |   2 +-
 src/tree/mirror/streaming/tests/capacity.rs   |   4 +-
 src/tree/mirror/streaming/tests/faults.rs     |   2 +-
 src/tree/mirror/streaming/tests/local_eq.rs   |  12 +-
 src/tree/mirror/streaming/tests/stats.rs      |  20 +-
 src/tree/mirror/streaming/tests/wedge.rs      |   2 +-
 src/tree/mirror/streaming/window.rs           |   2 +-
 src/tree/traverse/join/tests.rs               |   2 +-
 src/tree/typed/node.rs                        |  38 ++--
 src/tree/wire.rs                              |   5 +-
 tests/bootstrap_snapshot.rs                   |   2 +-
 tests/gossip_snapshot.rs                      |   2 +-
 tests/network.rs                              |   2 +-
 tests/opening_supply.rs                       |   2 +-
 tests/single_peer.rs                          |  11 ++
 100 files changed, 1592 insertions(+), 1669 deletions(-)

diff --git a/design/item-erasure.md b/design/item-erasure.md
index 646072b77..d1ce2a755 100644
--- a/design/item-erasure.md
+++ b/design/item-erasure.md
@@ -81,9 +81,9 @@ struct Message /* erased */ {
 ```
 
 with the typed boundary reading by checked downcast (a `TypeId`
-compare; a failed downcast is a *caught* mispairing — stronger
-witnessing than the height seam's debug-only prefix asserts). The one
-per-`T` residue beyond the facade is a deserialize witness
+compare; a failed downcast is a *caught* mispairing — a stronger
+tripwire than the height seam's debug-only prefix asserts). The one
+per-`T` residue beyond the facade is a payload deserializer
 (`fn(&[u8]) -> Result<Arc<dyn Any + Send + Sync>, _>`) threaded from
 peer construction to the wire-decode boundary, which keeps malformed
 payloads failing at ingress as `DecodeError::Record` exactly as today.
@@ -134,10 +134,10 @@ security-relevant: payload validation stays exactly where it is
 
 ## Rulings (owner-resolved)
 
-1. **Witness minting**: at `Peer<T>` construction — one witness per
-   peer lifetime, stored alongside the erased tree in the shared inner
-   state and threaded to every session. `DeserializeOwned` lives at
-   construction; the gossip entry points carry no serde bounds.
+1. **Deserializer minting**: at `Peer<T>` construction — one payload
+   deserializer per peer lifetime, stored on the peer and threaded to
+   every session. `DeserializeOwned` lives at construction; the gossip
+   entry points carry no serde bounds.
 2. **Sealing**: non-generic core functions in the rlib, with the
    public API unchanged — byte-for-byte the same signatures. If the
    non-generic sealing turns structurally hairy, back it out and fall
@@ -196,10 +196,30 @@ security-relevant: payload validation stays exactly where it is
    streaming session, still generic over `(B, T)` — stage 3's scope,
    and where the trade's verdict lands.
 3. **The erased session**: `Backend<T>` drops `T`; the codec's record
-   decode keeps the wire bytes and builds payloads through the witness;
-   sessions receive the witness from the peer. Measure.
+   decode keeps the wire bytes and builds payloads through the
+   deserializer (a plain `fn` pointer — `PayloadDeserializer`, minted
+   by `Message::deserializer::<T>()` at peer construction); sessions
+   receive it at their handshake entry. The V1 oracle joins the same
+   regime (`DecodeNode::read_node` and the payload-bearing messages'
+   `DecodeWith` take the deserializer), which dissolves the phantom
+   decode-context fields stage 2 introduced, and the gossip entry
+   points drop their serde bounds entirely — `DeserializeOwned` lives
+   at `seed`/`bootstrap`, `Serialize` at `send`. One taxonomy
+   consequence, deliberately re-accepted in the error atlas: a record's
+   trailing payload bytes now classify as a malformed payload
+   (`DecodeLeafError::Message(InvalidData)`), because the payload runs
+   to the record's end and the deserializer owns the
+   exactly-one-value check; the record-level `TrailingBytes` variant
+   became unreachable and is gone. Measure.
+   *Measured*: the lib grows ~102k → 354,431 / 12,716 — the session
+   now compiles once, into the rlib — but `pairwise` sits flat at
+   719,377 / 30,252, because `Peer::<T>`'s session-driving methods
+   are still generic funnels: `gossip_inner::<u64>` monomorphizes in
+   the consumer crate and drags the whole (now `T`-free, still
+   `B`-generic) session tower with it. The cut lands with stage 4's
+   sealing of those entry points.
 4. **Sealing**: the session core's entry points go non-generic over
-   the erased tree, witness, and dyn-erased link (public API
+   the erased tree, deserializer, and dyn-erased link (public API
    unchanged). The new meter lands here: IR lines of a minimal
    downstream binary (one `gossip` call) — the "what the next consumer
    pays" number. Measure; bench pin at the end.
diff --git a/src/conformance/backend.rs b/src/conformance/backend.rs
index 527fb9067..488ddb78c 100644
--- a/src/conformance/backend.rs
+++ b/src/conformance/backend.rs
@@ -79,7 +79,7 @@ use crate::{
 /// keeps alive per session reference. It is the ground truth the
 /// [`node_bytes`](Backend::node_bytes) contract is checked against, so
 /// it must not consult the cost function it validates.
-pub(crate) trait Measure<T: Send + Sync + 'static>: Backend<T, Node<Z>: Leaf<T>> {
+pub(crate) trait Measure: Backend<Node<Z>: Leaf> {
     /// The actual resident bytes of one node value, measured.
     fn measure<H: Height>(node: &Self::Node<H>) -> usize;
 }
@@ -196,11 +196,10 @@ impl<N> Drop for ChargedNode<N> {
     }
 }
 
-impl<T, N> Node<T> for ChargedNode<N>
+impl<N> Node for ChargedNode<N>
 where
-    T: Send + Sync + 'static,
-    N: Node<T> + Clone + Send + 'static,
-    N::Backend: Measure<T>,
+    N: Node + Clone + Send + 'static,
+    N::Backend: Measure,
 {
     type Backend = Charged<N::Backend>;
     type Height = N::Height;
@@ -236,11 +235,10 @@ impl<E: ErasedNode> ErasedNode for ChargedNode<E> {
     }
 }
 
-impl<T, N> Leaf<T> for ChargedNode<N>
+impl<N> Leaf for ChargedNode<N>
 where
-    T: Send + Sync + 'static,
-    N: Leaf<T> + Clone + Send + 'static,
-    N::Backend: Measure<T>,
+    N: Leaf + Clone + Send + 'static,
+    N::Backend: Measure,
 {
     fn message(&self) -> &Message {
         self.inner().message()
@@ -249,15 +247,15 @@ where
     async fn leaf(
         version: Version,
         message: Message,
-    ) -> Result<Self, <N::Backend as Backend<T>>::Error> {
+    ) -> Result<Self, <N::Backend as Backend>::Error> {
         let node = N::leaf(version, message).await?;
-        let measured = <N::Backend as Measure<T>>::measure::<N::Height>(&node);
+        let measured = <N::Backend as Measure>::measure::<N::Height>(&node);
         // The pointwise contract at the leaf seam: after construction has
         // had its chance to persist the payload, the cost function at
         // `children = 0` and the node's own bounds must cover what the
         // handle keeps resident — this is the price the session budget
         // charges every decode-fan slot.
-        let priced = <N::Backend as Backend<T>>::node_bytes(0, bound_bytes::<T, _>(&node));
+        let priced = <N::Backend as Backend>::node_bytes(0, bound_bytes(&node));
         if measured > priced {
             ledger::violation(format!(
                 "underpriced leaf: measured {measured} B, node_bytes priced {priced} B",
@@ -268,19 +266,17 @@ where
 }
 
 /// The two encoded version bounds a node keeps resident, in bytes.
-fn bound_bytes<T, N>(node: &N) -> usize
+fn bound_bytes<N>(node: &N) -> usize
 where
-    T: Send + Sync + 'static,
-    N: Node<T>,
+    N: Node,
 {
     let bounds = node.span();
     bounds.hi().as_bytes().len() + bounds.lo().as_bytes().len()
 }
 
-impl<B, T> Backend<T> for Charged<B>
+impl<B> Backend for Charged<B>
 where
-    B: Measure<T> + Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Measure + Backend<Node<Z>: Leaf>,
 {
     type Node<H: Height> = ChargedNode<B::Node<H>>;
     type Erased = ChargedNode<B::Erased>;
@@ -331,7 +327,7 @@ where
             let measured = B::measure(&node);
             // The pointwise contract: the cost function evaluated at this
             // node's own fan and bounds must cover its measured bytes.
-            let priced = B::node_bytes(fan, bound_bytes::<T, _>(&node));
+            let priced = B::node_bytes(fan, bound_bytes(&node));
             if measured > priced {
                 ledger::violation(format!(
                     "underpriced node: fan {fan} measured {measured} B, \
@@ -364,11 +360,7 @@ where
         }))
     }
 
-    fn children<H>(
-        self,
-        prefix: Prefix<S<H>>,
-        parent: Self::Node<S<H>>,
-    ) -> impl NodeStream<Self, T, H>
+    fn children<H>(self, prefix: Prefix<S<H>>, parent: Self::Node<S<H>>) -> impl NodeStream<Self, H>
     where
         H: Height,
         S<H>: Height,
@@ -388,7 +380,7 @@ where
         self,
         prefix: Prefix<H>,
         node: Self::Node<H>,
-    ) -> impl NodeStream<Self, T, Z> {
+    ) -> impl NodeStream<Self, Z> {
         // Delegate to the wrapped backend's own override: the bulk walk
         // is the path the wire encoder runs, so its yields must land on
         // the census and answer the walked node's aggregates.
@@ -406,7 +398,7 @@ where
                     // The pointwise contract at the walk: a walked leaf
                     // is a fan slot the session budget prices at
                     // `children = 0`.
-                    let priced = B::node_bytes(0, bound_bytes::<T, _>(&leaf));
+                    let priced = B::node_bytes(0, bound_bytes(&leaf));
                     if measured > priced {
                         ledger::violation(format!(
                             "underpriced walked leaf: measured {measured} B, \
@@ -437,15 +429,15 @@ where
 
     fn assemble<'a, H: Convert>(
         self,
-        leaves: BoxNodeStream<'a, Self, T, Z>,
-    ) -> impl NodeStream<Self, T, H> + 'a {
+        leaves: BoxNodeStream<'a, Self, Z>,
+    ) -> impl NodeStream<Self, H> + 'a {
         // Delegate to the wrapped backend's own override: bulk assembly
         // is the path the wire decoder runs. The wrapper records each
         // maximal same-prefix run as it feeds the inner stream, then
         // holds every assembled node to account for its run.
         let runs: Arc<Mutex<BTreeMap<Prefix<H>, Run>>> = Arc::default();
         let recorded = Arc::clone(&runs);
-        let supplied: BoxNodeStream<'a, B, T, Z> = Box::pin(leaves.map(move |item| {
+        let supplied: BoxNodeStream<'a, B, Z> = Box::pin(leaves.map(move |item| {
             item.map(|(prefix, leaf)| {
                 let mut runs = recorded
                     .lock()
@@ -475,7 +467,7 @@ where
                             "unsupplied assembly: a node yielded at {prefix:?} \
                              without a leaf run",
                         )),
-                        Some(run) => check_assembled::<B, T, H>(&node, measured, &run),
+                        Some(run) => check_assembled::<B, H>(&node, measured, &run),
                     }
                     (prefix, ChargedNode::wrap(node, measured))
                 });
@@ -510,10 +502,9 @@ struct Run {
 }
 
 /// Hold one bulk-assembled node to its run's account.
-fn check_assembled<B, T, H>(node: &B::Node<H>, measured: usize, run: &Run)
+fn check_assembled<B, H>(node: &B::Node<H>, measured: usize, run: &Run)
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     H: Height,
 {
     // The len aggregate is exact: a run's node answers its leaf count.
@@ -545,7 +536,7 @@ where
     // the radix (`FAN`) or the run's leaf count, and the contract
     // requires `node_bytes` monotone in fan, so a measurement above
     // this price is above the price at the node's own fan too.
-    let priced = B::node_bytes(run.leaves.min(FAN), bound_bytes::<T, _>(node));
+    let priced = B::node_bytes(run.leaves.min(FAN), bound_bytes(node));
     if measured > priced {
         ledger::violation(format!(
             "bulk-assembled node over-holds: measured {measured} B, \
@@ -592,7 +583,7 @@ fn sweep_bounds() -> Vec<usize> {
 /// bounds, and every adjacent bound pair at each swept fan.
 fn node_bytes_monotone<B>()
 where
-    B: Measure<u64> + Clone,
+    B: Measure + Clone,
     B::Error: std::fmt::Debug,
 {
     let bounds = sweep_bounds();
@@ -654,7 +645,7 @@ const DIVERGENT: usize = 1_024;
 /// - the session failed to converge the corpora.
 pub(crate) async fn check<B>(backend: B, budget_bytes: usize)
 where
-    B: Measure<u64> + Clone,
+    B: Measure + Clone,
     B::Error: std::fmt::Debug,
 {
     node_bytes_monotone::<B>();
@@ -681,7 +672,7 @@ where
 /// measured bytes above the resting corpora.
 async fn run<B>(backend: B, window: WindowConfig) -> usize
 where
-    B: Measure<u64> + Clone,
+    B: Measure + Clone,
     B::Error: std::fmt::Debug,
 {
     let charged = Charged::new(backend);
@@ -735,9 +726,9 @@ where
 }
 
 /// Drain one corpus's bulk leaf walk so the walk seam's checks run.
-async fn walk<B>(charged: &Charged<B>, corpus: &Root<Charged<B>, u64>)
+async fn walk<B>(charged: &Charged<B>, corpus: &Root<Charged<B>>)
 where
-    B: Measure<u64> + Clone,
+    B: Measure + Clone,
     B::Error: std::fmt::Debug,
 {
     let Some(root) = corpus.root.clone() else {
@@ -756,16 +747,16 @@ where
 async fn corpus<B>(
     charged: &Charged<B>,
     messages: impl Iterator<Item = &(Version, u64)>,
-) -> Root<Charged<B>, u64>
+) -> Root<Charged<B>>
 where
-    B: Measure<u64> + Clone,
+    B: Measure + Clone,
     B::Error: std::fmt::Debug,
 {
     let mut leaves: Vec<(Prefix<Z>, ChargedNode<B::Node<Z>>)> = Vec::new();
     for (version, payload) in messages {
         let message = Message::new(*payload);
         let path = Path::for_leaf(version);
-        let leaf = <ChargedNode<B::Node<Z>> as Leaf<u64>>::leaf(version.clone(), message)
+        let leaf = <ChargedNode<B::Node<Z>> as Leaf>::leaf(version.clone(), message)
             .await
             .expect("corpus leaves construct at rest");
         leaves.push((Prefix::from(path), leaf));
diff --git a/src/conformance/backend/tests.rs b/src/conformance/backend/tests.rs
index 3fbe9c975..8637518a6 100644
--- a/src/conformance/backend/tests.rs
+++ b/src/conformance/backend/tests.rs
@@ -111,7 +111,7 @@ impl Drop for Dishonest {
     }
 }
 
-impl<T: Send + Sync + 'static> Measure<T> for Local {
+impl Measure for Local {
     fn measure<H: Height>(node: &Self::Node<H>) -> usize {
         // A `Local` node is an `Arc` handle into the session-resident
         // tree: its shallow size is everything it keeps resident.
@@ -206,9 +206,8 @@ impl<N> MaterializedNode<N> {
     }
 }
 
-impl<T, H> Node<T> for MaterializedNode<typed::Node<H>>
+impl<H> Node for MaterializedNode<typed::Node<H>>
 where
-    T: Send + Sync + 'static,
     H: Height,
 {
     type Backend = Materializing;
@@ -242,10 +241,7 @@ where
     }
 }
 
-impl<T> Leaf<T> for MaterializedNode<typed::Node<Z>>
-where
-    T: Send + Sync + 'static,
-{
+impl Leaf for MaterializedNode<typed::Node<Z>> {
     fn message(&self) -> &Message {
         self.inner.message()
     }
@@ -282,10 +278,7 @@ impl<E: ErasedNode> ErasedNode for MaterializedNode<E> {
     }
 }
 
-impl<T> Backend<T> for Materializing
-where
-    T: Send + Sync + 'static,
-{
+impl Backend for Materializing {
     type Node<H: Height> = MaterializedNode<typed::Node<H>>;
     type Erased = MaterializedNode<typed::untyped::Node>;
     type Error = Infallible;
@@ -337,24 +330,20 @@ where
             .into_iter()
             .map(|(radix, child)| (radix, child.map(|child| child.inner)))
             .collect();
-        let parent = <Local as Backend<T>>::parent(Local, prefix, children).await?;
+        let parent = <Local as Backend>::parent(Local, prefix, children).await?;
         Ok(parent.map(|node| {
             let row = ROW_HEADER + ROW_ENTRY * fan + bounds_of(&node);
             MaterializedNode::wrap(node, row)
         }))
     }
 
-    fn children<H>(
-        self,
-        prefix: Prefix<S<H>>,
-        parent: Self::Node<S<H>>,
-    ) -> impl NodeStream<Self, T, H>
+    fn children<H>(self, prefix: Prefix<S<H>>, parent: Self::Node<S<H>>) -> impl NodeStream<Self, H>
     where
         H: Height,
         S<H>: Height,
     {
         stream! {
-            let mut children = pin!(<Local as Backend<T>>::children(Local, prefix, parent.inner));
+            let mut children = pin!(<Local as Backend>::children(Local, prefix, parent.inner));
             while let Some(child) = children.next().await {
                 yield child.map(|(prefix, node)| {
                     // A lazily loaded row: header and bounds, its child
@@ -370,12 +359,12 @@ where
         self,
         prefix: Prefix<H>,
         node: Self::Node<H>,
-    ) -> impl NodeStream<Self, T, Z> {
+    ) -> impl NodeStream<Self, Z> {
         // The reference bulk walk: the default explosion behind knobs
         // that drop leaves ([`WALK_SKIPS`]) and inflate the yielded rows
         // ([`WALK_SLACK`]) — honest at rest, the negative controls'
         // subject when set.
-        H::explode::<Self, T>(
+        H::explode::<Self>(
             self,
             Box::pin(futures_stream::once(async move { Ok((prefix, node)) })),
         )
@@ -390,13 +379,13 @@ where
 
     fn assemble<'a, H: Convert>(
         self,
-        leaves: BoxNodeStream<'a, Self, T, Z>,
-    ) -> impl NodeStream<Self, T, H> + 'a {
+        leaves: BoxNodeStream<'a, Self, Z>,
+    ) -> impl NodeStream<Self, H> + 'a {
         // The reference bulk assembly: the default fold behind knobs
         // that drop supplied leaves ([`ASSEMBLE_SKIPS`]) and inflate the
         // assembled rows ([`ASSEMBLE_SLACK`]) — honest at rest, the
         // negative controls' subject when set.
-        let supplied: BoxNodeStream<'a, Self, T, Z> = Box::pin(leaves.skip(ASSEMBLE_SKIPS.get()));
+        let supplied: BoxNodeStream<'a, Self, Z> = Box::pin(leaves.skip(ASSEMBLE_SKIPS.get()));
         H::assemble(self, supplied).map(|item| {
             item.map(|(prefix, mut node)| {
                 node.row.resize(node.row.len() + ASSEMBLE_SLACK.get(), 0);
@@ -406,10 +395,7 @@ where
     }
 }
 
-impl<T> Measure<T> for Materializing
-where
-    T: Send + Sync + 'static,
-{
+impl Measure for Materializing {
     fn measure<H: Height>(node: &Self::Node<H>) -> usize {
         std::mem::size_of_val(node) + node.row.len()
     }
@@ -539,7 +525,7 @@ fn dipping_node_bytes_fails_the_monotonicity_sweep() {
 fn leaf_underpricing_fails_at_construction() {
     let _dishonest = PRICED_HEADER.set(0);
     let leaf = pollster::block_on(
-        <super::ChargedNode<MaterializedNode<typed::Node<Z>>> as Leaf<u64>>::leaf(
+        <super::ChargedNode<MaterializedNode<typed::Node<Z>>> as Leaf>::leaf(
             Version::new(),
             Message::new(7),
         ),
@@ -566,7 +552,7 @@ fn ledger_settles_over_clone_and_drop() {
         ledger::reset_peak();
         ledger::peak()
     };
-    let leaf = pollster::block_on(<super::ChargedNode<typed::Node<Z>> as Leaf<u64>>::leaf(
+    let leaf = pollster::block_on(<super::ChargedNode<typed::Node<Z>> as Leaf>::leaf(
         Version::new(),
         Message::new(7),
     ))
diff --git a/src/message.rs b/src/message.rs
index a847abf79..423cbccf9 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -54,6 +54,10 @@ pub struct Message {
     serialized: Bytes,
 }
 
+/// Deserializes one exact CBOR payload encoding into a type-erased payload
+/// value; see [`Message::deserializer`].
+pub(crate) type PayloadDeserializer = fn(&[u8]) -> io::Result<Arc<dyn Any + Send + Sync>>;
+
 /// Map a ciborium deserialization failure into `io::Error`, keeping the
 /// truncation/corruption split callers classify by: a reader's own error
 /// passes through, everything else is invalid data.
@@ -119,21 +123,46 @@ impl Message {
         })
     }
 
-    /// Pairs an already-decoded object with the exact bytes it was decoded
-    /// from.
+    /// Decodes wire payload bytes into a `Message` through a
+    /// [`PayloadDeserializer`]: the one deserialization every gossip
+    /// ingress performs, with the deserializer carrying the payload type
+    /// the peer was constructed with.
+    ///
+    /// The deserializer validates the bytes are exactly one CBOR value of
+    /// its type ([`from_slice`](Self::from_slice)'s contract), so the
+    /// cache is always the payload's exact encoding and a malformed
+    /// payload fails here, at the wire boundary.
+    pub(crate) fn from_wire(bytes: Bytes, deserializer: PayloadDeserializer) -> io::Result<Self> {
+        Ok(Message {
+            message: deserializer(&bytes)?,
+            serialized: bytes,
+        })
+    }
+
+    /// The deserializer for payloads of type `T`: what a
+    /// [`Peer`](crate::Peer) mints at construction and threads to every
+    /// session's wire ingress ([`from_wire`](Self::from_wire)).
     ///
-    /// The caller certifies the pairing: `serialized` must be exactly the
-    /// CBOR encoding `message` was parsed out of (the wire codec's record
-    /// parser upholds this — it hands over precisely the bytes its parse
-    /// consumed).
-    pub(crate) fn from_decoded<T>(message: T, serialized: Bytes) -> Self
+    /// A plain function pointer, so everything that carries it stays
+    /// non-generic: the payload type's only residue in a running session.
+    pub(crate) fn deserializer<T>() -> PayloadDeserializer
     where
-        T: Send + Sync + 'static,
+        T: DeserializeOwned + Send + Sync + 'static,
     {
-        Message {
-            message: Arc::new(message),
-            serialized,
+        fn deserialize<T: DeserializeOwned + Send + Sync + 'static>(
+            bytes: &[u8],
+        ) -> io::Result<Arc<dyn Any + Send + Sync>> {
+            let mut input = bytes;
+            let message: T = ciborium::de::from_reader(&mut input).map_err(de_error)?;
+            if !input.is_empty() {
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    format!("{} trailing bytes after the message payload", input.len()),
+                ));
+            }
+            Ok(Arc::new(message))
         }
+        deserialize::<T>
     }
 
     /// Creates a `Message` from already-shared serialized bytes, without
@@ -178,21 +207,18 @@ impl Message {
     /// Reads one `Message` off a byte stream, consuming exactly its bytes.
     ///
     /// The shape is one CBOR byte string wrapping the payload's own CBOR
-    /// encoding (the same shape [`Serialize`] writes), decoded as a `T`
-    /// under [`from_slice`](Self::from_slice)'s exactly-one-value
-    /// contract.
-    ///
-    /// Trailing data after the byte string survives for the next field:
-    /// the property the wire codec's mid-stream decodes rest on. Gated to
-    /// the alternating protocol's codec, its only production consumer.
+    /// encoding (the same shape [`Serialize`] writes), decoded through
+    /// the peer's payload deserializer. Trailing data after the byte
+    /// string survives for the next field: the property the wire codec's
+    /// mid-stream decodes rest on. Gated to the alternating protocol's
+    /// codec, its only production consumer.
     #[cfg(any(test, feature = "protocol-v1"))]
-    pub(crate) fn from_reader<T, R>(reader: R) -> io::Result<Self>
+    pub(crate) fn from_reader<R>(reader: R, deserializer: PayloadDeserializer) -> io::Result<Self>
     where
-        T: DeserializeOwned + Send + Sync + 'static,
         R: io::Read,
     {
         let bytes: Vec<u8> = ciborium::de::from_reader(reader).map_err(de_error)?;
-        Self::from_slice::<T>(&bytes)
+        Self::from_wire(Bytes::from(bytes), deserializer)
     }
 
     /// Borrows the payload as its concrete type.
diff --git a/src/message/tests.rs b/src/message/tests.rs
index 146eee7bf..b6ca22eb3 100644
--- a/src/message/tests.rs
+++ b/src/message/tests.rs
@@ -105,7 +105,7 @@ proptest! {
     fn serde_roundtrip(p in payload()) {
         let m = Message::new(p);
         let bytes = cbor_vec(&m);
-        let back = Message::from_reader::<Payload, _>(bytes.as_slice()).unwrap();
+        let back = Message::from_reader(bytes.as_slice(), Message::deserializer::<Payload>()).unwrap();
         prop_assert_eq!(&m, &back);
         prop_assert_eq!(m.bytes(), back.bytes());
     }
@@ -121,7 +121,7 @@ proptest! {
         combined.extend_from_slice(&trailer);
 
         let mut slice: &[u8] = &combined;
-        let back = Message::from_reader::<Payload, _>(&mut slice).unwrap();
+        let back = Message::from_reader(&mut slice, Message::deserializer::<Payload>()).unwrap();
         prop_assert_eq!(back.bytes(), m.bytes());
         prop_assert_eq!(slice, trailer.as_slice());
         prop_assert_eq!(combined.len() - slice.len(), expected.len());
diff --git a/src/peer.rs b/src/peer.rs
index 64b9728fe..f5270c49d 100644
--- a/src/peer.rs
+++ b/src/peer.rs
@@ -11,6 +11,7 @@ use tokio::sync::{Mutex, watch};
 
 use crate::bookmark::{BookmarkError, Bookmarked, NoBookmark};
 use crate::link::{Acceptor, Connector, Link};
+use crate::message::{Message, PayloadDeserializer};
 use crate::tree::Tree;
 pub use crate::tree::mirror::streaming::remote::DEFAULT_TARGET_MESSAGE_SIZE;
 use crate::tree::mirror::streaming::remote::RunBudget;
@@ -157,6 +158,10 @@ pub struct Peer<T, B: BookmarkError = NoBookmark> {
     /// Separate from `inner` because persisting is `async` and the record is
     /// `!Clone`; see [`Bookmarked`].
     pub(crate) bookmark: Arc<Mutex<Bookmarked<B>>>,
+    /// The payload deserializer minted at construction: the typed ingress
+    /// every gossip session's supplied leaf records decode through (see
+    /// [`Message::deserializer`](crate::message::Message::deserializer)).
+    pub(crate) deserializer: PayloadDeserializer,
 }
 
 /// The replica's shared mutable state, behind the `watch` channel every
@@ -184,11 +189,16 @@ impl<T, B: BookmarkError> std::fmt::Debug for Peer<T, B> {
     }
 }
 
-impl<T> Peer<T, NoBookmark> {
+impl<T: DeserializeOwned + Send + Sync + 'static> Peer<T, NoBookmark> {
     /// Create the distinguished seed rumor set: the single root from which
     /// every other participant must [`bootstrap`](Peer::bootstrap).
     ///
     /// Call this exactly once per universe of cooperating peers.
+    ///
+    /// The payload type's [`DeserializeOwned`] lives here, at
+    /// construction: the peer mints its payload deserializer once, and
+    /// every gossip session decodes through it, so the gossip entry
+    /// points themselves carry no serde bounds.
     pub fn seed() -> Self {
         Self::seed_rng(&mut OsRng)
     }
@@ -207,6 +217,7 @@ impl<T> Peer<T, NoBookmark> {
                 tree: Tree::new(),
             }),
             bookmark: Arc::new(Mutex::new(Bookmarked::new(NoBookmark))),
+            deserializer: Message::deserializer::<T>(),
         }
     }
 }
@@ -275,7 +286,7 @@ impl<T, B: Bookmark> Peer<T, B> {
     /// promises](crate::link::Link#what-a-session-promises).
     pub async fn retire<CR, CW, C, A>(self, link: &mut Link<CR, CW, C, A>) -> Retire<T, B>
     where
-        T: DeserializeOwned + Serialize + Send + Sync + 'static,
+        T: Send + Sync + 'static,
         CR: AsyncRead + Unpin + Send,
         CW: AsyncWrite + Unpin + Send,
         C: Connector,
diff --git a/src/peer/bootstrap.rs b/src/peer/bootstrap.rs
index 46f33746c..da574953c 100644
--- a/src/peer/bootstrap.rs
+++ b/src/peer/bootstrap.rs
@@ -14,7 +14,6 @@ use crate::{Error, Peer, Protocol};
 
 use super::gossip::Unbookmarked;
 
-use serde::Serialize;
 use serde::de::DeserializeOwned;
 /// Configuration for joining an existing universe: the builder behind
 /// [`Peer::bootstrap`].
@@ -217,7 +216,7 @@ impl<T> Bootstrap<T> {
         link: &mut Link<CR, CW, C, A>,
     ) -> Result<Option<Peer<T>>, Error>
     where
-        T: DeserializeOwned + Serialize + Send + Sync + 'static,
+        T: DeserializeOwned + Send + Sync + 'static,
         CR: AsyncRead + Unpin + Send,
         CW: AsyncWrite + Unpin + Send,
         C: Connector,
@@ -297,7 +296,7 @@ impl<T, B: Bookmark> BookmarkedBootstrap<T, B> {
     /// in every outcome that never used it.
     pub async fn join<CR, CW, C, A>(self, link: &mut Link<CR, CW, C, A>) -> Joined<T, B>
     where
-        T: DeserializeOwned + Serialize + Send + Sync + 'static,
+        T: DeserializeOwned + Send + Sync + 'static,
         CR: AsyncRead + Unpin + Send,
         CW: AsyncWrite + Unpin + Send,
         C: Connector,
diff --git a/src/peer/gossip.rs b/src/peer/gossip.rs
index e20f57af2..153063407 100644
--- a/src/peer/gossip.rs
+++ b/src/peer/gossip.rs
@@ -20,6 +20,7 @@ use crate::link::{
     Acceptor, Connector, Link, SessionState,
     erased::{DynAcceptor, DynConnector},
 };
+use crate::message::Message;
 #[cfg(any(test, feature = "protocol-v1"))]
 use crate::tree::mirror::{
     alternating::{self, local as alternating_local, remote as alternating_remote},
@@ -41,7 +42,6 @@ use crate::{
 
 use super::{Inner, Peer, bootstrap::Bootstrap};
 
-use serde::Serialize;
 use serde::de::DeserializeOwned;
 /// Magic bytes that open every `rumors` gossip session's preamble frame.
 pub const PROTOCOL_MAGIC: [u8; 6] = *b"RUMORS";
@@ -211,7 +211,7 @@ impl<T> Peer<T, NoBookmark> {
         link: &'a mut Link<CR, CW, C, A>,
     ) -> BoxFuture<'a, Result<Option<Self>, Error>>
     where
-        T: DeserializeOwned + Serialize + Send + Sync + 'static,
+        T: DeserializeOwned + Send + Sync + 'static,
         CR: AsyncRead + Unpin + Send,
         CW: AsyncWrite + Unpin + Send,
         C: Connector,
@@ -238,10 +238,14 @@ impl<T> Peer<T, NoBookmark> {
         link: DynLinkParts<'a>,
     ) -> BoxFuture<'a, Result<Option<Self>, Error>>
     where
-        T: DeserializeOwned + Serialize + Send + Sync + 'static,
+        T: DeserializeOwned + Send + Sync + 'static,
     {
         Box::pin(async move {
             let (read, write, connector, acceptor, epoch) = link;
+            // The peer-to-be's payload deserializer, minted before it
+            // exists: the bootstrap session's ingress decodes through it,
+            // and the constructed peer inherits it.
+            let deserializer = Message::deserializer::<T>();
             // Magic/version/network/intent preamble first, before either protocol
             // is allowed to trust peer-declared frame lengths.
             let mut staged = handshake::Staged::new();
@@ -272,7 +276,7 @@ impl<T> Peer<T, NoBookmark> {
                 Result<Option<(tree::Root, DynRead<'a>, DynWrite<'a>)>, Error>,
             > = match config.protocol {
                 Protocol::V2 => Box::pin(async move {
-                    let local_root: streaming::Root<Local, T> = tree::Root::default().into();
+                    let local_root: streaming::Root<Local> = tree::Root::default().into();
                     // The window choice is passed for uniformity with gossip,
                     // but no choice can widen this session: disputes require
                     // joint occupancy and this side's replica is empty, so
@@ -284,8 +288,8 @@ impl<T> Peer<T, NoBookmark> {
                         .window(config.window)
                         .target_message_size(config.run_budget.bytes() as u64);
                     let carrier = Link::for_session(read, write, connector, acceptor, epoch);
-                    let proxy =
-                        streaming_remote::Handshaking::start(Local, carrier).window(config.window);
+                    let proxy = streaming_remote::Handshaking::start(Local, carrier, deserializer)
+                        .window(config.window);
                     let handshaken = streaming::handshake(local, proxy)
                         .await
                         .map_err(streaming_error)?;
@@ -312,9 +316,10 @@ impl<T> Peer<T, NoBookmark> {
                 #[cfg(any(test, feature = "protocol-v1"))]
                 Protocol::V1 => Box::pin(async move {
                     let local = alternating_local::Exchange::start(tree::Root::default());
-                    let proxy = alternating_remote::Exchange::<T, _, _, _, _>::start(
+                    let proxy = alternating_remote::Exchange::start(
                         FrameRead::new(read),
                         FrameWrite::new(write),
+                        deserializer,
                     );
                     let handshaken = alternating::handshake(local, proxy)
                         .await
@@ -354,6 +359,7 @@ impl<T> Peer<T, NoBookmark> {
                     tree: Tree::from_root(root),
                 }),
                 bookmark: Arc::new(Mutex::new(Bookmarked::new(NoBookmark))),
+                deserializer,
             };
             Ok(Some(peer))
         })
@@ -370,6 +376,7 @@ impl<T> Peer<T, NoBookmark> {
             window,
             run_budget,
             inner,
+            deserializer,
             ..
         } = self;
         let peer = Peer {
@@ -379,6 +386,7 @@ impl<T> Peer<T, NoBookmark> {
             run_budget,
             inner,
             bookmark: Arc::new(Mutex::new(Bookmarked::new(bookmark))),
+            deserializer,
         };
 
         // A pristine seed has no identity worth recording yet; persisting it
@@ -407,6 +415,7 @@ impl<T> Peer<T, NoBookmark> {
                     run_budget: peer.run_budget,
                     inner: peer.inner,
                     bookmark: Arc::new(Mutex::new(Bookmarked::new(NoBookmark))),
+                    deserializer: peer.deserializer,
                 },
                 error,
             }),
@@ -437,7 +446,7 @@ impl<T, B: Persist> Peer<T, B> {
         link: &mut Link<CR, CW, C, A>,
     ) -> Retire<T, B>
     where
-        T: DeserializeOwned + Serialize + Send + Sync + 'static,
+        T: Send + Sync + 'static,
         CR: AsyncRead + Unpin + Send,
         CW: AsyncWrite + Unpin + Send,
         C: Connector,
@@ -476,7 +485,7 @@ impl<T, B: Persist> Peer<T, B> {
         link: &mut Link<CR, CW, C, A>,
     ) -> Result<Gossiped, Error<B>>
     where
-        T: DeserializeOwned + Serialize + Send + Sync + 'static,
+        T: Send + Sync + 'static,
         CR: AsyncRead + Unpin + Send,
         CW: AsyncWrite + Unpin + Send,
         C: Connector,
@@ -616,9 +625,10 @@ impl<T, B: Persist> Peer<T, B> {
         link: DynLinkParts<'a>,
     ) -> (Intent, Result<(Version, SessionStats), Error<B>>)
     where
-        T: DeserializeOwned + Serialize + Send + Sync + 'static,
+        T: Send + Sync + 'static,
     {
         let (read, write, connector, acceptor, epoch) = link;
+        let deserializer = self.deserializer;
         // The session's stats recorder: under V2, both protocol
         // participants below share it (the walk counts disputes, gains,
         // sheds, and the window grant; the proxy's codec seam counts
@@ -744,13 +754,12 @@ impl<T, B: Persist> Peer<T, B> {
             Result<(tree::Root, DynRead<'a>, DynWrite<'a>), Error>,
         > = match self.protocol {
             Protocol::V2 => Box::pin(async move {
-                let local =
-                    materialized::Handshaking::<_, T, _>::start(Local, prior_tree.root.into())
-                        .window(window)
-                        .target_message_size(run_budget.bytes() as u64)
-                        .stats(session_stats.clone());
+                let local = materialized::Handshaking::<_, _>::start(Local, prior_tree.root.into())
+                    .window(window)
+                    .target_message_size(run_budget.bytes() as u64)
+                    .stats(session_stats.clone());
                 let carrier = Link::for_session(read, write, connector, acceptor, epoch);
-                let proxy = streaming_remote::Handshaking::start(Local, carrier)
+                let proxy = streaming_remote::Handshaking::start(Local, carrier, deserializer)
                     .window(window)
                     .stats(session_stats);
                 let handshaken = streaming::handshake(local, proxy)
@@ -772,9 +781,10 @@ impl<T, B: Persist> Peer<T, B> {
             #[cfg(any(test, feature = "protocol-v1"))]
             Protocol::V1 => Box::pin(async move {
                 let local = alternating_local::Exchange::start(prior_tree.root);
-                let proxy = alternating_remote::Exchange::<T, _, _, _, _>::start(
+                let proxy = alternating_remote::Exchange::start(
                     FrameRead::new(read),
                     FrameWrite::new(write),
+                    deserializer,
                 );
                 let handshaken = alternating::handshake(local, proxy)
                     .await
@@ -965,7 +975,7 @@ impl<T, B: Bookmark> Peer<T, B> {
         link: &'a mut Link<CR, CW, C, A>,
     ) -> impl Stream<Item = Result<Gossiped, Error<B>>> + Unpin + 'a
     where
-        T: DeserializeOwned + Serialize + Send + Sync + 'static,
+        T: Send + Sync + 'static,
         CR: AsyncRead + Unpin + Send,
         CW: AsyncWrite + Unpin + Send,
         C: Connector,
diff --git a/src/peer/gossip/tests.rs b/src/peer/gossip/tests.rs
index 95814157c..5cc72fed0 100644
--- a/src/peer/gossip/tests.rs
+++ b/src/peer/gossip/tests.rs
@@ -30,6 +30,7 @@
 //! [`gossip_inner`]: super::Peer::gossip_inner
 //! [`Network::BOOTSTRAP`]: Network
 
+use crate::message::Message;
 use before::Party;
 use futures::future::BoxFuture;
 use tokio::io::{duplex, split};
@@ -194,10 +195,11 @@ async fn claim_bootstrap_v2(
     )
     .await
     .map_err(Error::from)?;
-    let local_root: streaming::Root<Local, u64> = root.into();
+    let local_root: streaming::Root<Local> = root.into();
     let local = materialized::Handshaking::start(Local, local_root);
     let carrier = Link::for_session(read, write, connector, acceptor, epoch);
-    let proxy = streaming_remote::Handshaking::start(Local, carrier);
+    let proxy =
+        streaming_remote::Handshaking::start(Local, carrier, Message::deserializer::<u64>());
     let handshaken = streaming::handshake(local, proxy)
         .await
         .map_err(streaming_error)?;
@@ -230,9 +232,10 @@ async fn claim_bootstrap_v1(
     .await
     .map_err(Error::from)?;
     let local = alternating_local::Exchange::start(root);
-    let proxy = alternating_remote::Exchange::<u64, _, _, _, _>::start(
+    let proxy = alternating_remote::Exchange::start(
         FrameRead::new(read),
         FrameWrite::new(write),
+        Message::deserializer::<u64>(),
     );
     let handshaken = alternating::handshake(local, proxy)
         .await
diff --git a/src/rumors.rs b/src/rumors.rs
index 80d9a858e..504fea473 100644
--- a/src/rumors.rs
+++ b/src/rumors.rs
@@ -18,7 +18,6 @@ use tokio::{
 };
 
 use serde::Serialize;
-use serde::de::DeserializeOwned;
 /// A handle for [`send`](Rumors::send)ing and [`redact`](Rumors::redact)ing
 /// messages, and [`gossip`](Rumors::gossip)ing the result with peers.
 ///
@@ -70,6 +69,7 @@ impl<T, B: BookmarkError> Clone for Rumors<T, B> {
                 run_budget: self.peer.run_budget,
                 inner: self.peer.inner.clone(),
                 bookmark: Arc::clone(&self.peer.bookmark),
+                deserializer: self.peer.deserializer,
             },
             extant: self.extant.clone(),
         }
@@ -393,7 +393,7 @@ impl<T, B: Bookmark> Rumors<T, B> {
         link: &mut Link<CR, CW, C, A>,
     ) -> Result<Gossiped, Error<B>>
     where
-        T: DeserializeOwned + Serialize + Send + Sync + 'static,
+        T: Send + Sync + 'static,
         CR: AsyncRead + Unpin + Send,
         CW: AsyncWrite + Unpin + Send,
         C: Connector,
@@ -509,7 +509,7 @@ impl<T, B: Bookmark> Rumors<T, B> {
         link: &'a mut Link<CR, CW, C, A>,
     ) -> impl Stream<Item = Result<Gossiped, Error<B>>> + Unpin + 'a
     where
-        T: DeserializeOwned + Serialize + Send + Sync + 'static,
+        T: Send + Sync + 'static,
         CR: AsyncRead + Unpin + Send,
         CW: AsyncWrite + Unpin + Send,
         C: Connector,
diff --git a/src/tests.rs b/src/tests.rs
index 1b622354a..6b2419996 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -95,6 +95,7 @@ fn overlapping_retiree_party_is_rejected() {
     // region (not a disjoint fork), with an empty tree so its version equals the
     // survivor's and the survivor takes the absorb branch.
     let forged = Peer::<u64> {
+        deserializer: crate::message::Message::deserializer::<u64>(),
         network: survivor.network,
         protocol: survivor.protocol,
         window: survivor.window,
@@ -265,8 +266,8 @@ impl<W: AsyncWrite + Unpin> AsyncWrite for Fuse<W> {
 fn greeting_frame_len(retiree: &Peer<u64>) -> usize {
     use crate::tree::mirror::streaming::{self, Local, materialized};
 
-    let root: streaming::Root<Local, u64> = retiree.inner.borrow().tree.clone().root.into();
-    let fan = pollster::block_on(materialized::greeting_fan::<_, u64>(&Local, root.root))
+    let root: streaming::Root<Local> = retiree.inner.borrow().tree.clone().root.into();
+    let fan = pollster::block_on(materialized::greeting_fan(&Local, root.root))
         .unwrap_or_else(|never| match never {});
     // The listing frame is raw radix-hash records: one byte plus a Merkle
     // hash per child, the frame length carrying the count.
diff --git a/src/tree/mirror/alternating.rs b/src/tree/mirror/alternating.rs
index 02a6643cc..b93b9be87 100644
--- a/src/tree/mirror/alternating.rs
+++ b/src/tree/mirror/alternating.rs
@@ -164,14 +164,13 @@ macro_rules! x {
 
 // The inner mirror protocol, between an initiator and a responder (who may or
 // may not correspond with the original client/server distinction).
-async fn mirror_connected<I, R, T>(
+async fn mirror_connected<I, R>(
     i: I,
     r: R,
 ) -> Result<(I::Output, R::Output), Error<I::Error, R::Error>>
 where
-    T: Send + Sync,
-    I: Peer<T>,
-    R: Peer<T>,
+    I: Peer,
+    R: Peer,
 {
     x! { let x = i.initiator() }
     x! { i.open_initiator <=x== r.responder }
@@ -190,19 +189,18 @@ where
 
 /// The client's exchange after the connect phase: the [`Peer`] it has descended
 /// to once `connect` then `complete_connect` have run.
-pub(crate) type ClientConnected<C, T> = <<C as Connect<T>>::Next as CompleteConnect<T>>::Next;
+pub(crate) type ClientConnected<C> = <<C as Connect>::Next as CompleteConnect>::Next;
 
 /// The server's exchange after the connect phase: the [`Peer`] it has descended
 /// to once `accept` has run.
-pub(crate) type ServerConnected<S, T> = <S as Accept<T>>::Next;
+pub(crate) type ServerConnected<S> = <S as Accept>::Next;
 
 /// The result of the connect phase ([`handshake`]): the causal versions have
 /// been exchanged and either agree or are ready for descent.
-pub(crate) enum Handshaken<C, S, T>
+pub(crate) enum Handshaken<C, S>
 where
-    T: Send + Sync,
-    C: Client<T>,
-    S: Server<T>,
+    C: Client,
+    S: Server,
 {
     /// The two versions were equal: already converged, no descent. Carries the
     /// client's reconciled root and the server's output (the remote side's
@@ -215,18 +213,17 @@ where
     /// The versions differ: the connected exchanges are ready for [`descend`].
     /// Carries both versions for the descent's role tiebreak.
     Diverged {
-        local: ClientConnected<C, T>,
-        remote: ServerConnected<S, T>,
+        local: ClientConnected<C>,
+        remote: ServerConnected<S>,
         our_version: Version,
         peer: Handshake,
     },
 }
 
-impl<C, S, T> Handshaken<C, S, T>
+impl<C, S> Handshaken<C, S>
 where
-    T: Send + Sync,
-    C: Client<T>,
-    S: Server<T>,
+    C: Client,
+    S: Server,
 {
     /// The peer's causal-version greeting.
     pub(crate) fn peer(&self) -> &Handshake {
@@ -275,14 +272,13 @@ where
 /// version.
 ///
 /// Stops there, handing the equal/divergent outcome to [`Handshaken`].
-pub(crate) async fn handshake<C, S, T>(
+pub(crate) async fn handshake<C, S>(
     c: C,
     s: S,
-) -> Result<Handshaken<C, S, T>, Error<C::Error, S::Error>>
+) -> Result<Handshaken<C, S>, Error<C::Error, S::Error>>
 where
-    T: Send + Sync,
-    C: Client<T>,
-    S: Server<T>,
+    C: Client,
+    S: Server,
 {
     // The client emits its handshake. `connect` is statically `Continue` (its
     // `Done` carries `Infallible`), so this `let` is irrefutable.
@@ -338,16 +334,15 @@ where
 /// Run the steady-state descent between two connected [`Peer`]s, choosing the
 /// initiator by the canonical-byte tiebreak on the two (necessarily distinct)
 /// versions, and returning the outputs in `(local, remote)` order.
-pub(crate) async fn descend<I, R, T>(
+pub(crate) async fn descend<I, R>(
     local: I,
     remote: R,
     local_version: Version,
     remote_version: Version,
 ) -> Result<(I::Output, R::Output), Error<I::Error, R::Error>>
 where
-    T: Send + Sync,
-    I: Peer<T>,
-    R: Peer<T>,
+    I: Peer,
+    R: Peer,
 {
     // Their causal order is only partial (they may be concurrent), so to pick
     // an initiator we compare canonical bytes lexicographically: an arbitrary
@@ -376,14 +371,13 @@ where
 /// on the peer's [`Handshake`] in between; this whole-session shortcut serves
 /// only the in-process protocol tests.
 #[cfg(test)]
-pub async fn mirror<'a, C, S, T>(
+pub async fn mirror<'a, C, S>(
     c: C,
     s: S,
 ) -> Result<(C::Output, S::Output), Error<C::Error, S::Error>>
 where
-    T: Send + Sync + 'a,
-    C: Client<T> + 'a,
-    S: Server<T> + 'a,
+    C: Client + 'a,
+    S: Server + 'a,
 {
     // Box the future so that callers don't need to handle its big future type.
     Box::pin(async move {
diff --git a/src/tree/mirror/alternating/backend/local.rs b/src/tree/mirror/alternating/backend/local.rs
index 9edfd6afa..e8e58a4a5 100644
--- a/src/tree/mirror/alternating/backend/local.rs
+++ b/src/tree/mirror/alternating/backend/local.rs
@@ -196,10 +196,7 @@ where
     type Error = Violation;
 }
 
-impl<T> protocol::Connect<T> for Exchange<Start, Top>
-where
-    T: Send + Sync,
-{
+impl protocol::Connect for Exchange<Start, Top> {
     type Next = Exchange<Connecting, Top>;
 
     async fn connect(
@@ -225,10 +222,7 @@ where
     }
 }
 
-impl<T> protocol::CompleteConnect<T> for Exchange<Connecting, Top>
-where
-    T: Send + Sync,
-{
+impl protocol::CompleteConnect for Exchange<Connecting, Top> {
     type Next = Exchange<Connected, Top>;
 
     async fn complete_connect(
@@ -262,10 +256,7 @@ where
     }
 }
 
-impl<T> protocol::Accept<T> for Exchange<Start, Top>
-where
-    T: Send + Sync,
-{
+impl protocol::Accept for Exchange<Start, Top> {
     type Next = Exchange<Connected, Top>;
 
     async fn accept(
@@ -307,10 +298,7 @@ where
     }
 }
 
-impl<T> protocol::Initiator<T> for Exchange<Connected, Top>
-where
-    T: Send + Sync,
-{
+impl protocol::Initiator for Exchange<Connected, Top> {
     type Next = Exchange<Connected, Top>;
 
     async fn initiator(
@@ -329,10 +317,7 @@ where
     }
 }
 
-impl<T> protocol::Responder<T> for Exchange<Connected, Top>
-where
-    T: Send + Sync,
-{
+impl protocol::Responder for Exchange<Connected, Top> {
     type Next = Exchange<Connected, Below<UnderRoot, Top>>;
 
     async fn responder(
@@ -382,9 +367,8 @@ where
     }
 }
 
-impl<T, L> protocol::OpenInitiator<T> for Exchange<Connected, L>
+impl<L> protocol::OpenInitiator for Exchange<Connected, L>
 where
-    T: Send + Sync,
     L: Levels<Height = Root> + Send,
 {
     type Next = Exchange<Connected, Below<UnderUnderRoot, Below<UnderRoot, L>>>;
@@ -393,16 +377,15 @@ where
         self,
         request: message::Opening,
     ) -> Result<
-        protocol::Step<message::Exchange<T, UnderUnderRoot>, Self::Next, Self::Output>,
+        protocol::Step<message::Exchange<UnderUnderRoot>, Self::Next, Self::Output>,
         Self::Error,
     > {
         self.reply(request)
     }
 }
 
-impl<T, H, L> protocol::Exchange<T> for Exchange<Connected, L>
+impl<H, L> protocol::Exchange for Exchange<Connected, L>
 where
-    T: Send + Sync,
     L: Levels<Height = S<S<H>>> + Send,
     S<S<H>>: Height,
     S<H>: Height,
@@ -410,49 +393,45 @@ where
     // Assumed at impl-validation time so we don't have to case-analyze `H`
     // here: at use sites `H` is concrete and one of the three blanket impls
     // discharges it.
-    Exchange<Connected, Below<H, Below<S<H>, L>>>: protocol::AfterExchange<T, H>,
+    Exchange<Connected, Below<H, Below<S<H>, L>>>: protocol::AfterExchange<H>,
 {
     type Next = Exchange<Connected, Below<H, Below<S<H>, L>>>;
 
     async fn exchange(
         self,
-        request: message::Exchange<T, S<H>>,
-    ) -> Result<protocol::Step<message::Exchange<T, H>, Self::Next, Self::Output>, Self::Error>
-    {
+        request: message::Exchange<S<H>>,
+    ) -> Result<protocol::Step<message::Exchange<H>, Self::Next, Self::Output>, Self::Error> {
         self.reply(request)
     }
 }
 
-impl<T, L> protocol::CloseResponder<T> for Exchange<Connected, L>
+impl<L> protocol::CloseResponder for Exchange<Connected, L>
 where
-    T: Send + Sync,
     L: Levels<Height = S<Z>> + Send,
 {
     type Next = Exchange<Connected, Below<Z, L>>;
 
     async fn close_responder(
         self,
-        request: message::Exchange<T, Z>,
-    ) -> Result<protocol::Step<message::Closing<T>, Self::Next, Self::Output>, Self::Error> {
+        request: message::Exchange<Z>,
+    ) -> Result<protocol::Step<message::Closing, Self::Next, Self::Output>, Self::Error> {
         self.close(request)
     }
 }
 
-impl<T, L> protocol::CompleteInitiator<T> for Exchange<Connected, L>
+impl<L> protocol::CompleteInitiator for Exchange<Connected, L>
 where
-    T: Send + Sync,
     L: Levels<Height = Z> + Send,
 {
     async fn complete_initiator(
         mut self,
-        request: message::Closing<T>,
-    ) -> Result<protocol::Step<message::Complete<T>, Infallible, Self::Output>, Violation> {
+        request: message::Closing,
+    ) -> Result<protocol::Step<message::Complete, Infallible, Self::Output>, Violation> {
         self.absorb_providing(request.providing)?;
         let providing = self.answer_requested_leaves(request.requested);
         Ok(protocol::Step::Done {
             msg: message::Complete {
                 providing: providing.into_iter().collect(),
-                payload: std::marker::PhantomData,
             },
             output: tree::Root {
                 ceiling: self.versions.our_version | self.versions.their_version,
@@ -462,14 +441,13 @@ where
     }
 }
 
-impl<T, L> protocol::CompleteResponder<T> for Exchange<Connected, L>
+impl<L> protocol::CompleteResponder for Exchange<Connected, L>
 where
-    T: Send + Sync,
     L: Levels<Height = Z> + Send,
 {
     async fn complete_responder(
         mut self,
-        request: message::Complete<T>,
+        request: message::Complete,
     ) -> Result<protocol::Step<(), Infallible, Self::Output>, Violation> {
         self.absorb_providing(request.providing)?;
         Ok(protocol::Step::Done {
diff --git a/src/tree/mirror/alternating/backend/local/partition.rs b/src/tree/mirror/alternating/backend/local/partition.rs
index cb423a113..6bd94de08 100644
--- a/src/tree/mirror/alternating/backend/local/partition.rs
+++ b/src/tree/mirror/alternating/backend/local/partition.rs
@@ -487,11 +487,11 @@ where
     /// [`Step::Done`](protocol::Step::Done) when nothing was requested:
     /// the counterparty's [`message::Complete`] would carry nothing.
     #[allow(clippy::type_complexity)]
-    pub(super) fn close<T>(
+    pub(super) fn close(
         mut self,
-        request: message::Exchange<T, Z>,
+        request: message::Exchange<Z>,
     ) -> Result<
-        protocol::Step<message::Closing<T>, Exchange<Connected, Below<Z, L>>, tree::Root>,
+        protocol::Step<message::Closing, Exchange<Connected, Below<Z, L>>, tree::Root>,
         Violation,
     >
     where
@@ -501,7 +501,6 @@ where
             providing,
             requested,
             uncertain,
-            payload: _,
         } = request;
 
         self.absorb_providing(providing)?;
@@ -521,7 +520,6 @@ where
         let response = message::Closing {
             providing: providing.into_iter().collect(),
             requested: partition.requested,
-            payload: std::marker::PhantomData,
         };
 
         // The counterparty may only answer the leaves we just requested.
@@ -569,7 +567,7 @@ where
     /// [`close_responder`](protocol::CloseResponder::close_responder); they
     /// differ only in how they assemble the outgoing message.
     #[allow(clippy::type_complexity)]
-    pub(super) fn reply<Request, Response, H, T>(
+    pub(super) fn reply<Request, Response, H>(
         mut self,
         request: Request,
     ) -> Result<
@@ -577,8 +575,8 @@ where
         Violation,
     >
     where
-        Request: Into<message::Exchange<T, S<H>>>,
-        Response: From<message::Exchange<T, H>>,
+        Request: Into<message::Exchange<S<H>>>,
+        Response: From<message::Exchange<H>>,
         L: Levels<Height = S<S<H>>>,
         S<S<H>>: Height,
         S<H>: Height,
@@ -588,7 +586,6 @@ where
             providing,
             requested,
             uncertain,
-            payload: _,
         } = request.into();
 
         // Phase 1: absorb the counterparty's `providing` into our frontier.
@@ -633,7 +630,6 @@ where
             providing: providing.into_iter().collect(),
             requested: partition.requested,
             uncertain,
-            payload: std::marker::PhantomData,
         };
 
         // Record which parents the counterparty may `provide` against in its
diff --git a/src/tree/mirror/alternating/backend/remote.rs b/src/tree/mirror/alternating/backend/remote.rs
index 92fddcfc7..956c7bbdd 100644
--- a/src/tree/mirror/alternating/backend/remote.rs
+++ b/src/tree/mirror/alternating/backend/remote.rs
@@ -1,7 +1,7 @@
 //! Wire-bound counterpart to [`super::local`].
 //!
 //! Where `local::Exchange` realizes the protocol trait family by traversing an
-//! in-memory zipper, `remote::Exchange<T, R, W, H>` realizes it as a proxy of
+//! in-memory zipper, `remote::Exchange<R, W, H>` realizes it as a proxy of
 //! the *counterparty*: each protocol method serializes its incoming request
 //! into the writer and deserializes the counterparty's response from the
 //! reader. The struct carries only a paired `(reader, writer)` plus a phantom
@@ -50,6 +50,7 @@ use std::marker::PhantomData;
 
 use tokio::io::{AsyncRead, AsyncWrite};
 
+use crate::message::PayloadDeserializer;
 use crate::tree::wire;
 
 use crate::Error;
@@ -64,8 +65,6 @@ use super::super::{
     protocol::{self, Step},
 };
 
-use serde::Serialize;
-use serde::de::DeserializeOwned;
 /// The version state for an [`Exchange`] which has just been initialized but
 /// has not yet connected.
 pub struct Start;
@@ -79,38 +78,53 @@ pub struct Connected;
 /// Holds the underlying reader/writer (each wrapped for exact-read framing) and
 /// a phantom tag pinning the height; the counterparty's actual zipper lives on
 /// the far side of the wire.
-pub struct Exchange<T, R, W, V, H: Height> {
+pub struct Exchange<R, W, V, H: Height> {
     reader: FrameRead<R>,
     writer: FrameWrite<W>,
-    #[allow(clippy::type_complexity)]
-    _phantom: PhantomData<fn() -> (T, V, H)>,
+    /// The peer's payload deserializer: every `providing` channel this
+    /// proxy decodes builds its leaf payloads through it.
+    deserializer: PayloadDeserializer,
+    _phantom: PhantomData<fn() -> (V, H)>,
 }
 
-impl<T, R, W> Exchange<T, R, W, Start, Root> {
+impl<R, W> Exchange<R, W, Start, Root> {
     /// Begin an [`Exchange`] on transport halves wrapped after the shared raw
     /// preamble has completed.
-    pub fn start(reader: FrameRead<R>, writer: FrameWrite<W>) -> Self {
+    ///
+    /// `deserializer` is the peer's payload deserializer, the typed
+    /// ingress for every leaf this session decodes.
+    pub fn start(
+        reader: FrameRead<R>,
+        writer: FrameWrite<W>,
+        deserializer: PayloadDeserializer,
+    ) -> Self {
         Self {
             reader,
             writer,
+            deserializer,
             _phantom: PhantomData,
         }
     }
 }
 
-impl<T, R, W, H: Height> Exchange<T, R, W, Connected, H> {
+impl<R, W, H: Height> Exchange<R, W, Connected, H> {
     /// Construct a [`Connected`]-state [`Exchange`] from already-framed
     /// reader/writer halves, threading them through from a predecessor stage.
-    fn connected(reader: FrameRead<R>, writer: FrameWrite<W>) -> Self {
+    fn connected(
+        reader: FrameRead<R>,
+        writer: FrameWrite<W>,
+        deserializer: PayloadDeserializer,
+    ) -> Self {
         Self {
             reader,
             writer,
+            deserializer,
             _phantom: PhantomData,
         }
     }
 }
 
-impl<T, R: Send, W: Send, V, H: Height> protocol::Stage for Exchange<T, R, W, V, H> {
+impl<R: Send, W: Send, V, H: Height> protocol::Stage for Exchange<R, W, V, H> {
     type Height = H;
     /// The reconciled tree lives on the local side; the proxy yields its
     /// framed reader/writer halves back to the caller, which stays the
@@ -164,17 +178,49 @@ where
     wire::from_slice(&frame).map_err(Error::Io)
 }
 
+/// [`recv_msg`] for the payload-bearing messages: the frame decodes
+/// through [`message::DecodeWith`], its leaf payloads through the peer's
+/// deserializer.
+pub(super) async fn recv_msg_with<M, R>(
+    reader: &mut FrameRead<R>,
+    deserializer: PayloadDeserializer,
+) -> Result<M, Error>
+where
+    R: AsyncRead + Unpin + Send,
+    M: message::DecodeWith,
+{
+    let frame = reader
+        .frame()
+        .await
+        .map_err(|e| match e.kind() {
+            std::io::ErrorKind::UnexpectedEof => std::io::Error::new(
+                std::io::ErrorKind::UnexpectedEof,
+                "peer closed before sending expected message",
+            ),
+            _ => e,
+        })
+        .map_err(Error::Io)?;
+    let mut slice = frame.as_slice();
+    let msg = M::read_wire_with(&mut slice, deserializer).map_err(Error::Io)?;
+    if !slice.is_empty() {
+        return Err(Error::Io(wire::invalid(format!(
+            "{} trailing bytes after the decoded message",
+            slice.len()
+        ))));
+    }
+    Ok(msg)
+}
+
 // One protocol-trait impl block per trait, each at the specific height it
 // pertains to. Together with the [`protocol::AfterExchange`] blanket impls,
 // they discharge every transition in the protocol's height schedule.
 
-impl<T, R, W> protocol::Accept<T> for Exchange<T, R, W, Start, Root>
+impl<R, W> protocol::Accept for Exchange<R, W, Start, Root>
 where
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
-    T: Serialize + DeserializeOwned + Send + Sync + 'static,
 {
-    type Next = Exchange<T, R, W, Connected, Root>;
+    type Next = Exchange<R, W, Connected, Root>;
 
     async fn accept(
         mut self,
@@ -203,19 +249,18 @@ where
 
         Ok(protocol::Step::Continue {
             msg: peer,
-            next: Exchange::connected(self.reader, self.writer),
+            next: Exchange::connected(self.reader, self.writer, self.deserializer),
         })
     }
 }
 
-impl<T, R, W> protocol::Initiator<T> for Exchange<T, R, W, Connected, Root>
+impl<R, W> protocol::Initiator for Exchange<R, W, Connected, Root>
 where
-    T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
     UnderRoot: DecodeNode,
 {
-    type Next = Exchange<T, R, W, Connected, Root>;
+    type Next = Exchange<R, W, Connected, Root>;
 
     async fn initiator(mut self) -> Result<Step<message::Initiate, Self::Next, Infallible>, Error> {
         // No write: the real initiator (on the far side of the wire) has
@@ -225,19 +270,18 @@ where
         // is `Infallible`, so `Done` is uninhabitable here.
         Ok(Step::Continue {
             msg,
-            next: Exchange::connected(self.reader, self.writer),
+            next: Exchange::connected(self.reader, self.writer, self.deserializer),
         })
     }
 }
 
-impl<T, R, W> protocol::Responder<T> for Exchange<T, R, W, Connected, Root>
+impl<R, W> protocol::Responder for Exchange<R, W, Connected, Root>
 where
-    T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
     UnderRoot: DecodeNode,
 {
-    type Next = Exchange<T, R, W, Connected, UnderRoot>;
+    type Next = Exchange<R, W, Connected, UnderRoot>;
 
     async fn responder(
         mut self,
@@ -253,30 +297,30 @@ where
         let response: message::Opening = recv_msg(&mut self.reader).await?;
         Ok(Step::Continue {
             msg: response,
-            next: Exchange::connected(self.reader, self.writer),
+            next: Exchange::connected(self.reader, self.writer, self.deserializer),
         })
     }
 }
 
-impl<T, R, W> protocol::OpenInitiator<T> for Exchange<T, R, W, Connected, Root>
+impl<R, W> protocol::OpenInitiator for Exchange<R, W, Connected, Root>
 where
-    T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
     UnderRoot: DecodeNode,
 {
-    type Next = Exchange<T, R, W, Connected, UnderUnderRoot>;
+    type Next = Exchange<R, W, Connected, UnderUnderRoot>;
 
     async fn open_initiator(
         mut self,
         request: message::Opening,
-    ) -> Result<Step<message::Exchange<T, UnderUnderRoot>, Self::Next, Self::Output>, Error> {
+    ) -> Result<Step<message::Exchange<UnderUnderRoot>, Self::Next, Self::Output>, Error> {
         send_msg(&mut self.writer, &request).await?;
 
         // We always await a response: even an empty `Opening` can prompt the
         // counterparty to send back a non-trivial `providing` (the "we have,
         // they lack" Left case when we are the empty side).
-        let response: message::Exchange<T, UnderUnderRoot> = recv_msg(&mut self.reader).await?;
+        let response: message::Exchange<UnderUnderRoot> =
+            recv_msg_with(&mut self.reader, self.deserializer).await?;
 
         if response.requested.is_empty() && response.uncertain.is_empty() {
             Ok(Step::Done {
@@ -286,15 +330,14 @@ where
         } else {
             Ok(Step::Continue {
                 msg: response,
-                next: Exchange::connected(self.reader, self.writer),
+                next: Exchange::connected(self.reader, self.writer, self.deserializer),
             })
         }
     }
 }
 
-impl<T, R, W, H> protocol::Exchange<T> for Exchange<T, R, W, Connected, S<S<H>>>
+impl<R, W, H> protocol::Exchange for Exchange<R, W, Connected, S<S<H>>>
 where
-    T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
     H: Height,
@@ -304,14 +347,14 @@ where
     // Assumed at impl-validation time so we don't have to case-analyze `H`
     // here: at use sites `H` is concrete and one of the three blanket impls
     // in `super::protocol` discharges it.
-    Exchange<T, R, W, Connected, H>: protocol::AfterExchange<T, H>,
+    Exchange<R, W, Connected, H>: protocol::AfterExchange<H>,
 {
-    type Next = Exchange<T, R, W, Connected, H>;
+    type Next = Exchange<R, W, Connected, H>;
 
     async fn exchange(
         mut self,
-        request: message::Exchange<T, S<H>>,
-    ) -> Result<Step<message::Exchange<T, H>, Self::Next, Self::Output>, Error> {
+        request: message::Exchange<S<H>>,
+    ) -> Result<Step<message::Exchange<H>, Self::Next, Self::Output>, Error> {
         // If the message we just sent will cause the other party to be done,
         // they won't ever respond, so don't await their response.
         let counterparty_finished = request.requested.is_empty() && request.uncertain.is_empty();
@@ -325,7 +368,8 @@ where
             });
         }
 
-        let response: message::Exchange<T, H> = recv_msg(&mut self.reader).await?;
+        let response: message::Exchange<H> =
+            recv_msg_with(&mut self.reader, self.deserializer).await?;
 
         if response.requested.is_empty() && response.uncertain.is_empty() {
             Ok(Step::Done {
@@ -335,24 +379,23 @@ where
         } else {
             Ok(Step::Continue {
                 msg: response,
-                next: Exchange::connected(self.reader, self.writer),
+                next: Exchange::connected(self.reader, self.writer, self.deserializer),
             })
         }
     }
 }
 
-impl<T, R, W> protocol::CloseResponder<T> for Exchange<T, R, W, Connected, S<Z>>
+impl<R, W> protocol::CloseResponder for Exchange<R, W, Connected, S<Z>>
 where
-    T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
 {
-    type Next = Exchange<T, R, W, Connected, Z>;
+    type Next = Exchange<R, W, Connected, Z>;
 
     async fn close_responder(
         mut self,
-        request: message::Exchange<T, Z>,
-    ) -> Result<Step<message::Closing<T>, Self::Next, Self::Output>, Error> {
+        request: message::Exchange<Z>,
+    ) -> Result<Step<message::Closing, Self::Next, Self::Output>, Error> {
         // If the message we just sent will cause the other party to be done,
         // they won't ever respond, so don't await their response.
         let counterparty_finished = request.requested.is_empty() && request.uncertain.is_empty();
@@ -366,7 +409,7 @@ where
             });
         }
 
-        let response: message::Closing<T> = recv_msg(&mut self.reader).await?;
+        let response: message::Closing = recv_msg_with(&mut self.reader, self.deserializer).await?;
 
         if response.requested.is_empty() {
             Ok(Step::Done {
@@ -376,22 +419,21 @@ where
         } else {
             Ok(Step::Continue {
                 msg: response,
-                next: Exchange::connected(self.reader, self.writer),
+                next: Exchange::connected(self.reader, self.writer, self.deserializer),
             })
         }
     }
 }
 
-impl<T, R, W> protocol::CompleteInitiator<T> for Exchange<T, R, W, Connected, Z>
+impl<R, W> protocol::CompleteInitiator for Exchange<R, W, Connected, Z>
 where
-    T: DeserializeOwned + Send + Sync + 'static,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
 {
     async fn complete_initiator(
         mut self,
-        request: message::Closing<T>,
-    ) -> Result<Step<message::Complete<T>, Infallible, Self::Output>, Error> {
+        request: message::Closing,
+    ) -> Result<Step<message::Complete, Infallible, Self::Output>, Error> {
         // If the message we just sent will cause the other party to be done,
         // they won't ever respond, so don't await their response.
         let counterparty_finished = request.requested.is_empty();
@@ -405,7 +447,8 @@ where
             });
         }
 
-        let response: message::Complete<T> = recv_msg(&mut self.reader).await?;
+        let response: message::Complete =
+            recv_msg_with(&mut self.reader, self.deserializer).await?;
 
         // `CompleteInitiator` is statically `Done`: the `Next` slot is
         // `Infallible`, so `Continue` is uninhabitable here.
@@ -416,15 +459,14 @@ where
     }
 }
 
-impl<T, R, W> protocol::CompleteResponder<T> for Exchange<T, R, W, Connected, Z>
+impl<R, W> protocol::CompleteResponder for Exchange<R, W, Connected, Z>
 where
-    T: Send + Sync,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
 {
     async fn complete_responder(
         mut self,
-        request: message::Complete<T>,
+        request: message::Complete,
     ) -> Result<Step<(), Infallible, Self::Output>, Error> {
         // Final write; the real responder absorbs this and is done.
         send_msg(&mut self.writer, &request).await?;
diff --git a/src/tree/mirror/alternating/backend/remote/tests.rs b/src/tree/mirror/alternating/backend/remote/tests.rs
index 1dfa344fb..b4320081c 100644
--- a/src/tree/mirror/alternating/backend/remote/tests.rs
+++ b/src/tree/mirror/alternating/backend/remote/tests.rs
@@ -11,11 +11,12 @@
 //! `alternating/message/tests.rs`; the exact wire bytes in
 //! `alternating/wire_snapshot.rs`.
 
+use crate::message::Message;
 use proptest::collection::vec;
 use proptest::prelude::*;
 
 use super::super::super::message;
-use super::{FrameRead, recv_msg};
+use super::{FrameRead, recv_msg, recv_msg_with};
 use crate::tree::arb::nth_party;
 use crate::tree::mirror::framing::LENGTH_HEADER_LEN;
 use crate::tree::typed::height::UnderRoot;
@@ -38,6 +39,15 @@ fn recv<M: wire::Decode>(bytes: &[u8]) -> Result<M, Error> {
     })
 }
 
+/// [`recv`] for the payload-bearing messages, through the production
+/// deserializer-parameterized ingress with a unit-payload deserializer.
+fn recv_with<M: message::DecodeWith>(bytes: &[u8]) -> Result<M, Error> {
+    pollster::block_on(async {
+        let mut reader = FrameRead::new(bytes);
+        recv_msg_with::<M, _>(&mut reader, Message::deserializer::<()>()).await
+    })
+}
+
 /// The canonical encoding of a greeting whose version is nonempty, so a
 /// truncation leaves bytes to cut.
 fn handshake_bytes() -> Vec<u8> {
@@ -177,15 +187,15 @@ proptest! {
             Ok(()) | Err(Error::Io(_)),
         ));
         prop_assert!(matches!(
-            recv::<message::Exchange<u64, UnderRoot>>(&framed).map(|_| ()),
+            recv_with::<message::Exchange<UnderRoot>>(&framed).map(|_| ()),
             Ok(()) | Err(Error::Io(_)),
         ));
         prop_assert!(matches!(
-            recv::<message::Closing<u64>>(&framed).map(|_| ()),
+            recv_with::<message::Closing>(&framed).map(|_| ()),
             Ok(()) | Err(Error::Io(_)),
         ));
         prop_assert!(matches!(
-            recv::<message::Complete<u64>>(&framed).map(|_| ()),
+            recv_with::<message::Complete>(&framed).map(|_| ()),
             Ok(()) | Err(Error::Io(_)),
         ));
     }
diff --git a/src/tree/mirror/alternating/message.rs b/src/tree/mirror/alternating/message.rs
index c30a44763..34bb07737 100644
--- a/src/tree/mirror/alternating/message.rs
+++ b/src/tree/mirror/alternating/message.rs
@@ -72,8 +72,20 @@
 //! the wire: the protocol's height schedule names the type each side expects
 //! next.
 
+use crate::message::PayloadDeserializer;
 use crate::tree::wire::{self, Decode, Encode};
 
+/// Wire decode for the payload-bearing protocol messages: parses each
+/// `providing` channel's leaf payloads through the peer's deserializer
+/// (see [`read_providing`]); the payload-free messages stay on the plain
+/// [`Decode`].
+pub trait DecodeWith: Sized {
+    fn read_wire_with<R: std::io::Read>(
+        reader: &mut R,
+        deserializer: PayloadDeserializer,
+    ) -> std::io::Result<Self>;
+}
+
 use crate::Version;
 use crate::tree::typed::{
     Hash, Node, Prefix,
@@ -81,8 +93,6 @@ use crate::tree::typed::{
     node::DecodeNode,
 };
 
-use serde::de::DeserializeOwned;
-use std::marker::PhantomData;
 #[cfg(test)]
 mod tests;
 
@@ -92,11 +102,13 @@ mod tests;
 pub type Providing<H> = Vec<(Prefix<H>, Node<H>)>;
 
 /// Decode one `providing` channel: a `u32` count, then `(prefix, node)`
-/// pairs, the nodes' leaf payloads parsed as `T` (the protocol's typed
-/// ingress; see [`DecodeNode`]).
-fn read_providing<T, H, R>(reader: &mut R) -> std::io::Result<Providing<H>>
+/// pairs, the nodes' leaf payloads parsed through the peer's
+/// deserializer (the protocol's typed ingress; see [`DecodeNode`]).
+fn read_providing<H, R>(
+    reader: &mut R,
+    deserializer: PayloadDeserializer,
+) -> std::io::Result<Providing<H>>
 where
-    T: DeserializeOwned + Send + Sync + 'static,
     H: DecodeNode,
     R: std::io::Read,
 {
@@ -106,7 +118,7 @@ where
     let mut items = Vec::new();
     for _ in 0..count {
         let prefix = Prefix::<H>::read_wire(reader)?;
-        let node = H::read_node::<T, R>(reader)?;
+        let node = H::read_node(reader, deserializer)?;
         items.push((prefix, node));
     }
     Ok(items)
@@ -197,7 +209,7 @@ impl Decode for Opening {
 /// The steady-state message: carries all three channels (see the
 /// asymmetry-matrix table in the [`super::local`] module docs).
 #[derive(Clone)]
-pub struct Exchange<T, H>
+pub struct Exchange<H>
 where
     S<H>: Height,
     H: Height,
@@ -228,13 +240,9 @@ where
     /// [`super::local`] module docs) on the receiving side. Strictly ascending
     /// by prefix.
     pub uncertain: Vec<(Prefix<H>, Hash)>,
-    /// The payload type this message's leaves decode as: the nodes are
-    /// erased in memory, so the type rides the message as decode context
-    /// only (`fn() -> T` keeps auto-traits off the payload type).
-    pub payload: PhantomData<fn() -> T>,
 }
 
-impl<T, H> Encode for Exchange<T, H>
+impl<H> Encode for Exchange<H>
 where
     S<H>: Height,
     H: Height,
@@ -246,14 +254,16 @@ where
     }
 }
 
-impl<T, H> Decode for Exchange<T, H>
+impl<H> DecodeWith for Exchange<H>
 where
-    T: DeserializeOwned + Send + Sync + 'static,
     S<H>: DecodeNode,
     H: Height,
 {
-    fn read_wire<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
-        let providing: Providing<S<H>> = read_providing::<T, S<H>, R>(reader)?;
+    fn read_wire_with<R: std::io::Read>(
+        reader: &mut R,
+        deserializer: PayloadDeserializer,
+    ) -> std::io::Result<Self> {
+        let providing: Providing<S<H>> = read_providing(reader, deserializer)?;
         verify_pairs_canonical(&providing, "Exchange.providing")?;
         let requested: Vec<Prefix<S<H>>> = Decode::read_wire(reader)?;
         verify_keys_canonical(&requested, "Exchange.requested")?;
@@ -263,12 +273,11 @@ where
             providing,
             requested,
             uncertain,
-            payload: PhantomData,
         })
     }
 }
 
-impl<T> From<Opening> for Exchange<T, UnderRoot> {
+impl From<Opening> for Exchange<UnderRoot> {
     fn from(Opening { uncertain }: Opening) -> Self {
         Exchange {
             uncertain,
@@ -277,7 +286,7 @@ impl<T> From<Opening> for Exchange<T, UnderRoot> {
     }
 }
 
-impl<T, H> Default for Exchange<T, H>
+impl<H> Default for Exchange<H>
 where
     S<H>: Height,
     H: Height,
@@ -287,7 +296,6 @@ where
             providing: Default::default(),
             requested: Default::default(),
             uncertain: Default::default(),
-            payload: PhantomData,
         }
     }
 }
@@ -309,8 +317,8 @@ where
 /// [`complete_initiator`](super::protocol::CompleteInitiator::complete_initiator)
 /// consume `Closing` directly, without a runtime check against an
 /// out-of-spec responder.
-#[derive(Clone)]
-pub struct Closing<T> {
+#[derive(Clone, Default)]
+pub struct Closing {
     /// Leaves only the responder holds that the initiator has not deleted:
     /// answers to the initiator's final `requested`, plus leaves the
     /// initiator's `uncertain` listing proved it lacks.
@@ -322,44 +330,31 @@ pub struct Closing<T> {
     /// leaf at or before the responder's version was deleted there, and
     /// drops on both sides instead of shipping.
     pub requested: Vec<Prefix<Z>>,
-    /// The leaves' payload type, as decode context (see [`Exchange::payload`]).
-    pub payload: PhantomData<fn() -> T>,
 }
 
-impl<T> Encode for Closing<T> {
+impl Encode for Closing {
     fn write_wire<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
         self.providing.write_wire(writer)?;
         self.requested.write_wire(writer)
     }
 }
 
-impl<T> Decode for Closing<T>
-where
-    T: DeserializeOwned + Send + Sync + 'static,
-{
-    fn read_wire<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
-        let providing: Providing<Z> = read_providing::<T, Z, R>(reader)?;
+impl DecodeWith for Closing {
+    fn read_wire_with<R: std::io::Read>(
+        reader: &mut R,
+        deserializer: PayloadDeserializer,
+    ) -> std::io::Result<Self> {
+        let providing: Providing<Z> = read_providing(reader, deserializer)?;
         verify_pairs_canonical(&providing, "Closing.providing")?;
         let requested: Vec<Prefix<Z>> = Decode::read_wire(reader)?;
         verify_keys_canonical(&requested, "Closing.requested")?;
         Ok(Self {
             providing,
             requested,
-            payload: PhantomData,
         })
     }
 }
 
-impl<T> Default for Closing<T> {
-    fn default() -> Self {
-        Self {
-            providing: Default::default(),
-            requested: Default::default(),
-            payload: PhantomData,
-        }
-    }
-}
-
 /// The initiator's terminal message: the final `providing` at leaf height,
 /// answering the responder's closing `requested`.
 ///
@@ -370,39 +365,25 @@ impl<T> Default for Closing<T> {
 ///
 /// No `requested` (the responder never replies after this) and no `uncertain`
 /// (vacuous at leaf height, same reasoning as [`Closing`]).
-#[derive(Clone)]
-pub struct Complete<T> {
+#[derive(Clone, Default)]
+pub struct Complete {
     pub providing: Providing<Z>,
-    /// The leaves' payload type, as decode context (see [`Exchange::payload`]).
-    pub payload: PhantomData<fn() -> T>,
 }
 
-impl<T> Encode for Complete<T> {
+impl Encode for Complete {
     fn write_wire<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
         self.providing.write_wire(writer)
     }
 }
 
-impl<T> Decode for Complete<T>
-where
-    T: DeserializeOwned + Send + Sync + 'static,
-{
-    fn read_wire<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
-        let providing: Providing<Z> = read_providing::<T, Z, R>(reader)?;
+impl DecodeWith for Complete {
+    fn read_wire_with<R: std::io::Read>(
+        reader: &mut R,
+        deserializer: PayloadDeserializer,
+    ) -> std::io::Result<Self> {
+        let providing: Providing<Z> = read_providing(reader, deserializer)?;
         verify_pairs_canonical(&providing, "Complete.providing")?;
-        Ok(Self {
-            providing,
-            payload: PhantomData,
-        })
-    }
-}
-
-impl<T> Default for Complete<T> {
-    fn default() -> Self {
-        Self {
-            providing: Default::default(),
-            payload: PhantomData,
-        }
+        Ok(Self { providing })
     }
 }
 
diff --git a/src/tree/mirror/alternating/message/tests.rs b/src/tree/mirror/alternating/message/tests.rs
index 492904f0b..9e62c4571 100644
--- a/src/tree/mirror/alternating/message/tests.rs
+++ b/src/tree/mirror/alternating/message/tests.rs
@@ -118,15 +118,14 @@ proptest! {
         );
         let requested = canonical_keys(requested);
         let uncertain = canonical_pairs(uncertain);
-        let m: message::Exchange<(), message::UnderRoot> = message::Exchange {
+        let m: message::Exchange<message::UnderRoot> = message::Exchange {
             providing: providing.clone(),
             requested: requested.clone(),
             uncertain: uncertain.clone(),
-            payload: std::marker::PhantomData,
         };
         let bytes = wire::to_vec(&m).unwrap();
         let decoded =
-            wire::from_slice::<message::Exchange<(), message::UnderRoot>>(&bytes).unwrap();
+            from_slice_with::<message::Exchange<message::UnderRoot>>(&bytes).unwrap();
         prop_assert_eq!(decoded.providing, providing);
         prop_assert_eq!(decoded.requested, requested);
         prop_assert_eq!(decoded.uncertain, uncertain);
@@ -141,13 +140,12 @@ proptest! {
     ) {
         let providing = canonical_providing(providing_entries);
         let requested = canonical_keys(requested);
-        let m: message::Closing<()> = message::Closing {
+        let m: message::Closing = message::Closing {
             providing: providing.clone(),
             requested: requested.clone(),
-            payload: std::marker::PhantomData,
         };
         let bytes = wire::to_vec(&m).unwrap();
-        let decoded = wire::from_slice::<message::Closing<()>>(&bytes).unwrap();
+        let decoded = from_slice_with::<message::Closing>(&bytes).unwrap();
         prop_assert_eq!(decoded.providing, providing);
         prop_assert_eq!(decoded.requested, requested);
     }
@@ -159,9 +157,9 @@ proptest! {
         providing_entries in vec((arb_prefix::<Z>(), arb_leaf()), 0..=4),
     ) {
         let providing = canonical_providing(providing_entries);
-        let m: message::Complete<()> = message::Complete { providing: providing.clone(), payload: std::marker::PhantomData };
+        let m: message::Complete = message::Complete { providing: providing.clone() };
         let bytes = wire::to_vec(&m).unwrap();
-        let decoded = wire::from_slice::<message::Complete<()>>(&bytes).unwrap();
+        let decoded = from_slice_with::<message::Complete>(&bytes).unwrap();
         prop_assert_eq!(decoded.providing, providing);
     }
 
@@ -180,17 +178,31 @@ proptest! {
         let mut permuted = canonical.clone();
         permuted.rotate_left(rotate % canonical.len());
         prop_assume!(permuted != canonical);
-        let m = message::Complete::<()> { providing: permuted, payload: std::marker::PhantomData };
+        let m = message::Complete { providing: permuted };
         let bytes = wire::to_vec(&m).unwrap();
-        prop_assert!(wire::from_slice::<message::Complete<()>>(&bytes).is_err());
+        prop_assert!(from_slice_with::<message::Complete>(&bytes).is_err());
     }
 }
 
+/// Decode one payload-bearing message from an exact slice through the
+/// unit-payload deserializer, rejecting trailing bytes.
+fn from_slice_with<M: message::DecodeWith>(bytes: &[u8]) -> std::io::Result<M> {
+    let mut input = bytes;
+    let m = M::read_wire_with(&mut input, Message::deserializer::<()>())?;
+    if !input.is_empty() {
+        return Err(std::io::Error::new(
+            std::io::ErrorKind::InvalidData,
+            format!("{} trailing bytes after the decoded message", input.len()),
+        ));
+    }
+    Ok(m)
+}
+
 /// Decode one erased node at height `H` from an exact slice, rejecting
 /// trailing bytes: the test-side door to [`DecodeNode`], with unit payloads.
 fn node_from_slice<H: DecodeNode>(bytes: &[u8]) -> std::io::Result<Node<H>> {
     let mut input = bytes;
-    let node = H::read_node::<(), _>(&mut input)?;
+    let node = H::read_node(&mut input, Message::deserializer::<()>())?;
     if !input.is_empty() {
         return Err(std::io::Error::new(
             std::io::ErrorKind::InvalidData,
@@ -214,27 +226,25 @@ fn one_version() -> Version {
 fn providing_rejects_duplicate_prefix() {
     let prefix = prefix_from_bytes::<Z>(&[7u8; 32]);
     let leaf = Node::leaf(one_version(), Message::new(()));
-    let m = message::Complete::<()> {
+    let m = message::Complete {
         providing: vec![(prefix, leaf.clone()), (prefix, leaf)],
-        payload: std::marker::PhantomData,
     };
     let bytes = wire::to_vec(&m).unwrap();
-    assert!(wire::from_slice::<message::Complete<()>>(&bytes).is_err());
+    assert!(from_slice_with::<message::Complete>(&bytes).is_err());
 }
 
 /// A `requested` frame whose prefixes descend is rejected.
 #[test]
 fn requested_rejects_descending_order() {
-    let m = message::Closing::<()> {
+    let m = message::Closing {
         providing: Vec::new(),
         requested: vec![
             prefix_from_bytes::<Z>(&[2u8; 32]),
             prefix_from_bytes::<Z>(&[1u8; 32]),
         ],
-        payload: std::marker::PhantomData,
     };
     let bytes = wire::to_vec(&m).unwrap();
-    assert!(wire::from_slice::<message::Closing<()>>(&bytes).is_err());
+    assert!(from_slice_with::<message::Closing>(&bytes).is_err());
 }
 
 /// An `uncertain` frame with a duplicate prefix is rejected.
diff --git a/src/tree/mirror/alternating/protocol.rs b/src/tree/mirror/alternating/protocol.rs
index 985078cfb..6b4c04ee0 100644
--- a/src/tree/mirror/alternating/protocol.rs
+++ b/src/tree/mirror/alternating/protocol.rs
@@ -88,12 +88,9 @@ pub trait Stage: Send {
 /// Open the connect phase on the client side: emit our [`message::Handshake`]
 /// greeting. Always continues (the `Done` slot is [`Infallible`]): a side
 /// cannot know it has converged before hearing the peer's version.
-pub trait Connect<T>: Stage<Height = Root> + Sized
-where
-    T: Send + Sync,
-{
+pub trait Connect: Stage<Height = Root> + Sized {
     /// The state that absorbs the peer's version ([`CompleteConnect`]).
-    type Next: CompleteConnect<T> + Stage<Output = Self::Output, Height = Root, Error = Self::Error>;
+    type Next: CompleteConnect + Stage<Output = Self::Output, Height = Root, Error = Self::Error>;
 
     fn connect(
         self,
@@ -106,13 +103,10 @@ where
 /// descent; `Continue` hands over a state ready to play either role
 /// (`Next` is both [`Initiator`] and [`Responder`]; the byte tiebreak picks
 /// which, see [`descend`](super::descend)).
-pub trait CompleteConnect<T>: Stage<Height = Root> + Sized
-where
-    T: Send + Sync,
-{
+pub trait CompleteConnect: Stage<Height = Root> + Sized {
     /// The connected state, able to play either descent role.
-    type Next: Initiator<T>
-        + Responder<T>
+    type Next: Initiator
+        + Responder
         + Stage<Output = Self::Output, Height = Root, Error = Self::Error>;
 
     fn complete_connect(
@@ -126,13 +120,10 @@ where
 ///
 /// `Done` mirrors [`CompleteConnect`]'s convergence case; the two sides always
 /// agree on it (both compare the same pair of versions).
-pub trait Accept<T>: Stage<Height = Root> + Sized
-where
-    T: Send + Sync,
-{
+pub trait Accept: Stage<Height = Root> + Sized {
     /// The connected state, able to play either descent role.
-    type Next: Initiator<T>
-        + Responder<T>
+    type Next: Initiator
+        + Responder
         + Stage<Output = Self::Output, Height = Root, Error = Self::Error>;
 
     fn accept(
@@ -147,12 +138,9 @@ where
 ///
 /// The trait is implemented by the state type that the constructor produces;
 /// `Self::Next == Self` for any straightforward implementation.
-pub trait Initiator<T>: Stage<Height = Root> + Sized
-where
-    T: Send + Sync,
-{
+pub trait Initiator: Stage<Height = Root> + Sized {
     /// The state that consumes the responder's [`message::Opening`].
-    type Next: OpenInitiator<T> + Stage<Output = Self::Output, Height = Root, Error = Self::Error>;
+    type Next: OpenInitiator + Stage<Output = Self::Output, Height = Root, Error = Self::Error>;
 
     /// Begin the protocol as the initiator.
     ///
@@ -170,12 +158,9 @@ where
 }
 
 /// Continue the protocol as the responder.
-pub trait Responder<T>: Stage<Height = Root> + Sized
-where
-    T: Send + Sync,
-{
+pub trait Responder: Stage<Height = Root> + Sized {
     /// The first steady-state [`Exchange`] from the responder's side.
-    type Next: Exchange<T> + Stage<Output = Self::Output, Height = UnderRoot, Error = Self::Error>;
+    type Next: Exchange + Stage<Output = Self::Output, Height = UnderRoot, Error = Self::Error>;
 
     /// Begin the protocol as the responder, processing the initiator's
     /// [`message::Initiate`].
@@ -197,13 +182,9 @@ where
 /// Distinct from [`Exchange`] because the opening carries only `uncertain`,
 /// and the responder may list children of the initiator's absent root, a
 /// case the steady-state [`Exchange`] is allowed to debug-assert against.
-pub trait OpenInitiator<T>: Stage<Height = Root> + Sized
-where
-    T: Send + Sync,
-{
+pub trait OpenInitiator: Stage<Height = Root> + Sized {
     /// The first steady-state [`Exchange`] from the initiator's side.
-    type Next: Exchange<T>
-        + Stage<Output = Self::Output, Height = UnderUnderRoot, Error = Self::Error>;
+    type Next: Exchange + Stage<Output = Self::Output, Height = UnderUnderRoot, Error = Self::Error>;
 
     /// Process the initiator's first round, applied to the responder's
     /// [`message::Opening`].
@@ -220,7 +201,7 @@ where
         request: message::Opening,
     ) -> impl Future<
         Output = Result<
-            Step<message::Exchange<T, UnderUnderRoot>, Self::Next, Self::Output>,
+            Step<message::Exchange<UnderUnderRoot>, Self::Next, Self::Output>,
             Self::Error,
         >,
     > + Send;
@@ -232,9 +213,8 @@ where
 /// message's is `Self::Height − 1`); both are recovered from `Stage::Height`
 /// via `Pred` projections, so each implementing type's exchange height is
 /// determined by its `Stage::Height` alone.
-pub trait Exchange<T>: Stage + Sized
+pub trait Exchange: Stage + Sized
 where
-    T: Send + Sync,
     Self::Height: Pred,
     <Self::Height as Pred>::Pred: Pred,
     S<<Self::Height as Pred>::Pred>: Height,
@@ -242,7 +222,7 @@ where
 {
     /// Whichever of [`Exchange`], [`CloseResponder`], or [`CompleteInitiator`]
     /// is appropriate at the outgoing message's height. See [`AfterExchange`].
-    type Next: AfterExchange<T, <<Self::Height as Pred>::Pred as Pred>::Pred>
+    type Next: AfterExchange<<<Self::Height as Pred>::Pred as Pred>::Pred>
         + Stage<
             Output = Self::Output,
             Height = <<Self::Height as Pred>::Pred as Pred>::Pred,
@@ -259,11 +239,11 @@ where
     #[allow(clippy::type_complexity)]
     fn exchange(
         self,
-        request: message::Exchange<T, <Self::Height as Pred>::Pred>,
+        request: message::Exchange<<Self::Height as Pred>::Pred>,
     ) -> impl Future<
         Output = Result<
             Step<
-                message::Exchange<T, <<Self::Height as Pred>::Pred as Pred>::Pred>,
+                message::Exchange<<<Self::Height as Pred>::Pred as Pred>::Pred>,
                 Self::Next,
                 Self::Output,
             >,
@@ -281,12 +261,9 @@ where
 /// two leaves at one path are the same leaf — so the reply carries only
 /// `providing` and `requested`, which is exactly what [`message::Closing`]
 /// encodes.
-pub trait CloseResponder<T>: Stage<Height = S<Z>> + Sized
-where
-    T: Send + Sync,
-{
+pub trait CloseResponder: Stage<Height = S<Z>> + Sized {
     /// The terminal responder state.
-    type Next: CompleteResponder<T> + Stage<Output = Self::Output, Height = Z, Error = Self::Error>;
+    type Next: CompleteResponder + Stage<Output = Self::Output, Height = Z, Error = Self::Error>;
 
     /// The responder's closing round, descending the zipper from `S<Z>` to
     /// `Z` and emitting [`message::Closing`].
@@ -297,18 +274,13 @@ where
     #[allow(clippy::type_complexity)]
     fn close_responder(
         self,
-        request: message::Exchange<T, Z>,
-    ) -> impl Future<
-        Output = Result<Step<message::Closing<T>, Self::Next, Self::Output>, Self::Error>,
-    > + Send;
+        request: message::Exchange<Z>,
+    ) -> impl Future<Output = Result<Step<message::Closing, Self::Next, Self::Output>, Self::Error>> + Send;
 }
 
 /// The initiator's terminal round; absorbs the responder's
 /// [`message::Closing`] and answers it with [`message::Complete`].
-pub trait CompleteInitiator<T>: Stage<Height = Z> + Sized
-where
-    T: Send + Sync,
-{
+pub trait CompleteInitiator: Stage<Height = Z> + Sized {
     /// The initiator's final round.
     ///
     /// Absorbs the responder's last batch of `providing`, answers its final
@@ -322,18 +294,14 @@ where
     #[allow(clippy::type_complexity)]
     fn complete_initiator(
         self,
-        request: message::Closing<T>,
-    ) -> impl Future<
-        Output = Result<Step<message::Complete<T>, Infallible, Self::Output>, Self::Error>,
-    > + Send;
+        request: message::Closing,
+    ) -> impl Future<Output = Result<Step<message::Complete, Infallible, Self::Output>, Self::Error>>
+    + Send;
 }
 
 /// The responder's terminal round; absorbs the initiator's
 /// [`message::Complete`].
-pub trait CompleteResponder<T>: Stage<Height = Z> + Sized
-where
-    T: Send + Sync,
-{
+pub trait CompleteResponder: Stage<Height = Z> + Sized {
     /// The responder's final round.
     ///
     /// Absorbs the initiator's last batch of `providing` (from
@@ -343,7 +311,7 @@ where
     #[allow(clippy::type_complexity)]
     fn complete_responder(
         self,
-        request: message::Complete<T>,
+        request: message::Complete,
     ) -> impl Future<Output = Result<Step<(), Infallible, Self::Output>, Self::Error>> + Send;
 }
 
@@ -361,42 +329,25 @@ where
 /// Heights `Z` and `S<Z>` are handled via the blanket impls below, keyed off
 /// the appropriate terminal trait. `S<S<Z>>` needs its own blanket only
 /// because it does not unify with the `S<S<S<H>>>` pattern.
-pub trait AfterExchange<T, H>: Sized
+pub trait AfterExchange<H>: Sized
 where
-    T: Send + Sync,
     H: Height,
 {
 }
 
-impl<T, X> AfterExchange<T, Z> for X
-where
-    T: Send + Sync,
-    X: CompleteInitiator<T>,
-{
-}
+impl<X> AfterExchange<Z> for X where X: CompleteInitiator {}
 
-impl<T, X> AfterExchange<T, S<Z>> for X
-where
-    T: Send + Sync,
-    X: CloseResponder<T>,
-{
-}
+impl<X> AfterExchange<S<Z>> for X where X: CloseResponder {}
 
-impl<T, X> AfterExchange<T, S<S<Z>>> for X
-where
-    T: Send + Sync,
-    X: Exchange<T> + Stage<Height = S<S<Z>>>,
-{
-}
+impl<X> AfterExchange<S<S<Z>>> for X where X: Exchange + Stage<Height = S<S<Z>>> {}
 
-impl<T, H, X> AfterExchange<T, S<S<S<H>>>> for X
+impl<H, X> AfterExchange<S<S<S<H>>>> for X
 where
-    T: Send + Sync,
     H: Height,
     S<H>: Height,
     S<S<H>>: Height,
     S<S<S<H>>>: Height,
-    X: Exchange<T> + Stage<Height = S<S<S<H>>>>,
+    X: Exchange + Stage<Height = S<S<S<H>>>>,
 {
 }
 
@@ -405,7 +356,7 @@ where
 /// position.
 ///
 /// The macro emits the chains tt-munched ahead of time: the
-/// initiator side wraps `$init_terminal` in N `Exchange<T, Next: …>`
+/// initiator side wraps `$init_terminal` in N `Exchange<Next: …>`
 /// layers (where N is the count of `_` tokens in `init: […]`), and the
 /// responder side does the same for `$resp_terminal`.
 ///
@@ -422,12 +373,12 @@ macro_rules! define_peer {
         define_peer!(@step
             init: [$($init_count)*],
             resp: [$($resp_count)*],
-            init_chain: (CompleteInitiator<T>),
-            resp_chain: (CloseResponder<T>),
+            init_chain: ( CompleteInitiator),
+            resp_chain: ( CloseResponder),
         );
     };
 
-    // Wrap one `Exchange<T, Next: …>` around the init-chain accumulator
+    // Wrap one `Exchange<Next: …>` around the init-chain accumulator
     // until the init-side counter is exhausted.
     (@step
         init: [_ $($init_rest:tt)*],
@@ -438,7 +389,7 @@ macro_rules! define_peer {
         define_peer!(@step
             init: [$($init_rest)*],
             resp: [$($resp_count)*],
-            init_chain: (Exchange<T, Next: $($init_chain)*>),
+            init_chain: (Exchange<Next: $($init_chain)*>),
             resp_chain: ($($resp_chain)*),
         );
     };
@@ -454,7 +405,7 @@ macro_rules! define_peer {
             init: [],
             resp: [$($resp_rest)*],
             init_chain: ($($init_chain)*),
-            resp_chain: (Exchange<T, Next: $($resp_chain)*>),
+            resp_chain: (Exchange<Next: $($resp_chain)*>),
         );
     };
 
@@ -475,53 +426,47 @@ macro_rules! define_peer {
         ///
         /// Both `local::Exchange` and `remote::Exchange` pick this up for
         /// free via the blanket impl below; downstream call sites take a
-        /// single `Peer<T>` bound on each argument and the chain bounds
+        /// single `Peer` bound on each argument and the chain bounds
         /// propagate.
-        pub trait Peer<T>:
-            Initiator<T, Next: OpenInitiator<T, Next: $($init_chain)*>> + Responder<T, Next: $($resp_chain)*>
+        pub trait Peer:
+            Initiator<Next: OpenInitiator<Next: $($init_chain)*>> + Responder<Next: $($resp_chain)*>
         where
-            T: Send + Sync,
         {
         }
 
-        impl<X, T> Peer<T> for X
+        impl<X> Peer for X
         where
-            T: Send + Sync,
-            X: Initiator<T, Next: OpenInitiator<T, Next: $($init_chain)*>> + Responder<T, Next: $($resp_chain)*>
+            X: Initiator<Next: OpenInitiator<Next: $($init_chain)*>> + Responder<Next: $($resp_chain)*>
         {
         }
 
         /// A [`Peer`] entered through the server side of the connect phase:
         /// [`Accept`] first, then either descent role. The whole-session
         /// bound the wire-facing driver takes for the remote party.
-        pub trait Server<T>:
-            Accept<T, Next: Initiator<T, Next: OpenInitiator<T, Next: $($init_chain)*>> + Responder<T, Next: $($resp_chain)*>>
+        pub trait Server:
+            Accept<Next: Initiator<Next: OpenInitiator<Next: $($init_chain)*>> + Responder<Next: $($resp_chain)*>>
         where
-            T: Send + Sync,
         {
         }
 
-        impl<X, T> Server<T> for X
+        impl<X> Server for X
         where
-            T: Send + Sync,
-            X: Accept<T, Next: Initiator<T, Next: OpenInitiator<T, Next: $($init_chain)*>> + Responder<T, Next: $($resp_chain)*>>
+            X: Accept<Next: Initiator<Next: OpenInitiator<Next: $($init_chain)*>> + Responder<Next: $($resp_chain)*>>
         {
         }
 
         /// A [`Peer`] entered through the client side of the connect phase:
         /// [`Connect`] then [`CompleteConnect`], then either descent role.
         /// The whole-session bound the drivers take for the local party.
-        pub trait Client<T>:
-            Connect<T, Next: CompleteConnect<T, Next: Initiator<T, Next: OpenInitiator<T, Next: $($init_chain)*>> + Responder<T, Next: $($resp_chain)*>>>
+        pub trait Client:
+            Connect<Next: CompleteConnect<Next: Initiator<Next: OpenInitiator<Next: $($init_chain)*>> + Responder<Next: $($resp_chain)*>>>
         where
-            T: Send + Sync,
         {
         }
 
-        impl<X, T> Client<T> for X
+        impl<X> Client for X
         where
-            T: Send + Sync,
-            X: Connect<T, Next: CompleteConnect<T, Next: Initiator<T, Next: OpenInitiator<T, Next: $($init_chain)*>> + Responder<T, Next: $($resp_chain)*>>>
+            X: Connect<Next: CompleteConnect<Next: Initiator<Next: OpenInitiator<Next: $($init_chain)*>> + Responder<Next: $($resp_chain)*>>>
         {
         }
 
diff --git a/src/tree/mirror/alternating/tests.rs b/src/tree/mirror/alternating/tests.rs
index eb27d3a35..22e5f6f30 100644
--- a/src/tree/mirror/alternating/tests.rs
+++ b/src/tree/mirror/alternating/tests.rs
@@ -82,7 +82,7 @@ fn mirror_via(a: crate::tree::Root, b: crate::tree::Root, scenario: Scenario) ->
             Scenario::LocalLocal => {
                 let local_a = local::Exchange::start(a);
                 let local_b = local::Exchange::start(b);
-                match mirror::<_, _, ()>(local_a, local_b).await {
+                match mirror(local_a, local_b).await {
                     Err(e) => panic!("honest endpoints speak no violations: {e}"),
                     Ok((ours, theirs)) => {
                         assert_eq!(ours, theirs, "local-local endpoints should converge");
@@ -101,16 +101,18 @@ fn mirror_via(a: crate::tree::Root, b: crate::tree::Root, scenario: Scenario) ->
                 let (b_r, b_w) = tokio::io::split(b_side);
 
                 let local_a = local::Exchange::start(a);
-                let remote_b = remote::Exchange::<(), _, _, _, _>::start(
+                let remote_b = remote::Exchange::start(
                     FrameRead::new(a_r),
                     FrameWrite::new(a_w),
+                    Message::deserializer::<()>(),
                 );
                 let client = mirror(local_a, remote_b);
 
                 let local_b = local::Exchange::start(b);
-                let remote_a = remote::Exchange::<(), _, _, _, _>::start(
+                let remote_a = remote::Exchange::start(
                     FrameRead::new(b_r),
                     FrameWrite::new(b_w),
+                    Message::deserializer::<()>(),
                 );
                 let server = mirror(local_b, remote_a);
 
@@ -294,7 +296,7 @@ fn uncontained_supply_is_rejected() {
     // violation.
     {
         let (receiver, poisoned, _, _) = uncontained_supply_pair();
-        let result = block_on(mirror::<_, _, ()>(
+        let result = block_on(mirror(
             local::Exchange::start(receiver),
             local::Exchange::start(poisoned),
         ));
@@ -314,16 +316,18 @@ fn uncontained_supply_is_rejected() {
             let (b_r, b_w) = tokio::io::split(b_side);
 
             let local_receiver = local::Exchange::start(receiver);
-            let remote_b = remote::Exchange::<(), _, _, _, _>::start(
+            let remote_b = remote::Exchange::start(
                 FrameRead::new(a_r),
                 FrameWrite::new(a_w),
+                Message::deserializer::<()>(),
             );
             let receiver_side = mirror(local_receiver, remote_b);
 
             let local_poisoned = local::Exchange::start(poisoned);
-            let remote_a = remote::Exchange::<(), _, _, _, _>::start(
+            let remote_a = remote::Exchange::start(
                 FrameRead::new(b_r),
                 FrameWrite::new(b_w),
+                Message::deserializer::<()>(),
             );
             let poisoned_side = mirror(local_poisoned, remote_a);
 
diff --git a/src/tree/mirror/alternating/wire_snapshot.rs b/src/tree/mirror/alternating/wire_snapshot.rs
index 30d209144..6289103bd 100644
--- a/src/tree/mirror/alternating/wire_snapshot.rs
+++ b/src/tree/mirror/alternating/wire_snapshot.rs
@@ -262,7 +262,7 @@ fn message_opening_one_entry() {
 /// An `Exchange` with all three sets empty: the in-band termination shape.
 #[test]
 fn message_exchange_empty() {
-    let m: message::Exchange<(), UnderRoot> = message::Exchange::default();
+    let m: message::Exchange<UnderRoot> = message::Exchange::default();
     insta::assert_snapshot!(snap(&m));
 }
 
@@ -292,11 +292,10 @@ fn message_exchange_populated() {
         Hash([3u8; MERKLE_HASH_LEN]),
     )];
 
-    let m: message::Exchange<(), UnderRoot> = message::Exchange {
+    let m: message::Exchange<UnderRoot> = message::Exchange {
         providing,
         requested,
         uncertain,
-        payload: std::marker::PhantomData,
     };
     insta::assert_snapshot!(snap(&m));
 }
@@ -304,7 +303,7 @@ fn message_exchange_populated() {
 /// An empty `Closing`: the responder's closing round with nothing left.
 #[test]
 fn message_closing_empty() {
-    let m: message::Closing<()> = message::Closing::default();
+    let m: message::Closing = message::Closing::default();
     insta::assert_snapshot!(snap(&m));
 }
 
@@ -313,10 +312,9 @@ fn message_closing_empty() {
 fn message_closing_populated() {
     let providing = vec![(prefix_from_bytes::<Z>(&[0u8; 32]), leaf("a", 1))];
     let requested = vec![prefix_from_bytes::<Z>(&[0xffu8; 32])];
-    let m: message::Closing<()> = message::Closing {
+    let m: message::Closing = message::Closing {
         providing,
         requested,
-        payload: std::marker::PhantomData,
     };
     insta::assert_snapshot!(snap(&m));
 }
@@ -324,7 +322,7 @@ fn message_closing_populated() {
 /// An empty `Complete`: the initiator's sign-off with nothing owed.
 #[test]
 fn message_complete_empty() {
-    let m: message::Complete<()> = message::Complete::default();
+    let m: message::Complete = message::Complete::default();
     insta::assert_snapshot!(snap(&m));
 }
 
@@ -332,9 +330,6 @@ fn message_complete_empty() {
 #[test]
 fn message_complete_populated() {
     let providing = vec![(prefix_from_bytes::<Z>(&[0u8; 32]), leaf("a", 1))];
-    let m: message::Complete<()> = message::Complete {
-        providing,
-        payload: std::marker::PhantomData,
-    };
+    let m: message::Complete = message::Complete { providing };
     insta::assert_snapshot!(snap(&m));
 }
diff --git a/src/tree/mirror/streaming.rs b/src/tree/mirror/streaming.rs
index 275ca3e2e..88baf7129 100644
--- a/src/tree/mirror/streaming.rs
+++ b/src/tree/mirror/streaming.rs
@@ -76,18 +76,17 @@ use crate::{Version, tree::typed::height::Z};
 use driver::{mirror_connected, try_join_mapped};
 use protocol::*;
 
-type ClientConnected<C, B, T> = <<C as Connect<B, T>>::Next as CompleteConnect<B, T>>::Next;
-type ServerConnected<S, B, T> = <S as Accept<B, T>>::Next;
+type ClientConnected<C, B> = <<C as Connect<B>>::Next as CompleteConnect<B>>::Next;
+type ServerConnected<S, B> = <S as Accept<B>>::Next;
 
-pub(crate) struct Handshaken<C, S, B, T>
+pub(crate) struct Handshaken<C, S, B>
 where
-    T: Send + Sync + 'static,
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    C: Client<B, T>,
-    S: Server<B, T>,
+    B: Backend<Node<Z>: Leaf>,
+    C: Client<B>,
+    S: Server<B>,
 {
-    client: ClientConnected<C, B, T>,
-    server: ServerConnected<S, B, T>,
+    client: ClientConnected<C, B>,
+    server: ServerConnected<S, B>,
     our_version: Version,
     /// Our advertised live message count: our half of the role election's
     /// primary key ([`message::initiates`]).
@@ -95,12 +94,11 @@ where
     peer: message::Greeting,
 }
 
-impl<C, S, B, T> Handshaken<C, S, B, T>
+impl<C, S, B> Handshaken<C, S, B>
 where
-    T: Send + Sync + 'static,
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    C: Client<B, T>,
-    S: Server<B, T>,
+    B: Backend<Node<Z>: Leaf>,
+    C: Client<B>,
+    S: Server<B>,
 {
     pub(crate) fn peer(&self) -> &message::Greeting {
         let Handshaken { peer, .. } = self;
@@ -144,29 +142,27 @@ where
 /// vocabulary crossing between them. Equal handshake versions resolve both
 /// connected states without opening the descent.
 #[cfg(test)]
-pub(crate) async fn mirror<C, S, B, T>(
+pub(crate) async fn mirror<C, S, B>(
     client: C,
     server: S,
 ) -> Result<(C::Output, S::Output), Error<C::Error, S::Error>>
 where
-    T: Send + Sync + 'static,
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    C: Client<B, T>,
-    S: Server<B, T>,
+    B: Backend<Node<Z>: Leaf>,
+    C: Client<B>,
+    S: Server<B>,
 {
     handshake(client, server).await?.reconcile().await
 }
 
 /// Exchange versions and return both connected protocol states.
-pub(crate) async fn handshake<C, S, B, T>(
+pub(crate) async fn handshake<C, S, B>(
     client: C,
     server: S,
-) -> Result<Handshaken<C, S, B, T>, Error<C::Error, S::Error>>
+) -> Result<Handshaken<C, S, B>, Error<C::Error, S::Error>>
 where
-    T: Send + Sync + 'static,
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    C: Client<B, T>,
-    S: Server<B, T>,
+    B: Backend<Node<Z>: Leaf>,
+    C: Client<B>,
+    S: Server<B>,
 {
     let (our_handshake, client) = client.connect().await.map_err(Error::Client)?;
     let our_version = our_handshake.version.clone();
@@ -187,7 +183,7 @@ where
 }
 
 /// Elect the initiator from the exchanged greetings and reconcile or complete.
-pub(crate) async fn descend<L, R, B, T>(
+pub(crate) async fn descend<L, R, B>(
     local: L,
     remote: R,
     local_version: Version,
@@ -196,10 +192,9 @@ pub(crate) async fn descend<L, R, B, T>(
     remote_len: u64,
 ) -> Result<(L::Output, R::Output), Error<L::Error, R::Error>>
 where
-    T: Send + Sync + 'static,
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    L: Peer<B, T>,
-    R: Peer<B, T>,
+    B: Backend<Node<Z>: Leaf>,
+    L: Peer<B>,
+    R: Peer<B>,
 {
     if local_version == remote_version {
         return try_join_mapped(
diff --git a/src/tree/mirror/streaming/backend.rs b/src/tree/mirror/streaming/backend.rs
index 0f0505f78..f2fa2c393 100644
--- a/src/tree/mirror/streaming/backend.rs
+++ b/src/tree/mirror/streaming/backend.rs
@@ -43,13 +43,13 @@ pub use local::Local;
 pub(super) use local::with_schedule as with_local_schedule;
 
 /// A backend value is a cheap cloneable *handle* to its storage.
-pub trait Backend<T: Send + Sync + 'static>: Clone + Send + Sync + 'static
+pub trait Backend: Clone + Send + Sync + 'static
 where
-    Self::Node<Z>: Leaf<T>,
+    Self::Node<Z>: Leaf,
 {
     /// The type of nodes, indexed by height `H`; leaf payloads are
     /// erased in storage and decode as `T` at the wire boundary.
-    type Node<H: Height>: Node<T, Height = H, Backend = Self> + Clone + Send + 'static;
+    type Node<H: Height>: Node<Height = H, Backend = Self> + Clone + Send + 'static;
 
     /// One runtime representation shared by every height's
     /// [`Node<H>`](Self::Node).
@@ -150,7 +150,7 @@ where
         self,
         prefix: Prefix<S<H>>,
         parent: Self::Node<S<H>>,
-    ) -> impl NodeStream<Self, T, H>
+    ) -> impl NodeStream<Self, H>
     where
         H: Height,
         S<H>: Height;
@@ -169,7 +169,7 @@ where
         self,
         prefix: Prefix<H>,
         node: Self::Node<H>,
-    ) -> impl NodeStream<Self, T, Z> {
+    ) -> impl NodeStream<Self, Z> {
         H::explode(
             self,
             Box::pin(stream::once(async move { Ok((prefix, node)) })),
@@ -197,16 +197,16 @@ where
     /// session can meet it.
     fn assemble<'a, H: Convert>(
         self,
-        leaves: BoxNodeStream<'a, Self, T, Z>,
-    ) -> impl NodeStream<Self, T, H> + 'a {
+        leaves: BoxNodeStream<'a, Self, Z>,
+    ) -> impl NodeStream<Self, H> + 'a {
         H::assemble(self, leaves)
     }
 }
 
 /// The inspection operations of a backend's individual node type.
-pub trait Node<T: Send + Sync + 'static> {
+pub trait Node {
     /// The backend to which this node belongs.
-    type Backend: Backend<T, Node<Z>: Leaf<T>, Node<Self::Height> = Self>;
+    type Backend: Backend<Node<Z>: Leaf, Node<Self::Height> = Self>;
 
     /// The height of the node above the leaf level.
     type Height: Height;
@@ -305,7 +305,7 @@ pub trait ErasedNode {
 
 /// What crosses between backends at the conversion boundary, and the one node
 /// shape every backend must represent faithfully.
-pub trait Leaf<T: Send + Sync + 'static>: Node<T> {
+pub trait Leaf: Node {
     /// The message stored at this leaf node.
     fn message(&self) -> &Message;
 
@@ -340,33 +340,31 @@ pub trait Leaf<T: Send + Sync + 'static>: Node<T> {
     fn leaf(
         version: Version,
         message: Message,
-    ) -> impl Future<Output = Result<Self, <Self::Backend as Backend<T>>::Error>> + Send
+    ) -> impl Future<Output = Result<Self, <Self::Backend as Backend>::Error>> + Send
     where
         Self: Sized;
 }
 
 /// Type synonym for a fallible [`Stream`] of prefix-keyed nodes represented by
 /// a given backend.
-pub trait NodeStream<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height>:
+pub trait NodeStream<B: Backend<Node<Z>: Leaf>, H: Height>:
     Stream<Item = Result<(Prefix<H>, B::Node<H>), B::Error>> + Send
 {
 }
-impl<N, B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height> NodeStream<B, T, H>
-    for N
-where
-    N: Stream<Item = Result<(Prefix<H>, B::Node<H>), B::Error>> + Send,
+impl<N, B: Backend<Node<Z>: Leaf>, H: Height> NodeStream<B, H> for N where
+    N: Stream<Item = Result<(Prefix<H>, B::Node<H>), B::Error>> + Send
 {
 }
 
 /// A [`NodeStream`] erased to one level of type depth.
-pub(crate) type BoxNodeStream<'a, B, T, H> = Pin<Box<dyn NodeStream<B, T, H> + 'a>>;
+pub(crate) type BoxNodeStream<'a, B, H> = Pin<Box<dyn NodeStream<B, H> + 'a>>;
 
 /// A backend's whole tree at rest: what a mirror session consumes and produces.
 ///
 /// This is the backend-generic form of [`tree::Root`](crate::tree::Root); the
 /// `Local` backend converts between the two with [`From`].
 #[derive(Debug)]
-pub struct Root<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> {
+pub struct Root<B: Backend<Node<Z>: Leaf>> {
     /// The maximum version this tree has incorporated.
     pub ceiling: Version,
     /// The root node, or nothing when the tree is empty.
@@ -375,7 +373,7 @@ pub struct Root<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> {
 
 // Manual because the derive would demand `T: Clone`; nodes are cloneable
 // handles regardless of the message type they carry.
-impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> Clone for Root<B, T> {
+impl<B: Backend<Node<Z>: Leaf>> Clone for Root<B> {
     fn clone(&self) -> Self {
         Root {
             ceiling: self.ceiling.clone(),
@@ -384,7 +382,7 @@ impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> Clone for Root<B
     }
 }
 
-impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> Root<B, T> {
+impl<B: Backend<Node<Z>: Leaf>> Root<B> {
     /// The tree's live message count: the root node's [`len`](Node::len)
     /// aggregate, or zero when empty. What the session greeting carries
     /// as the exact set size.
diff --git a/src/tree/mirror/streaming/backend/local.rs b/src/tree/mirror/streaming/backend/local.rs
index 0ced7ea05..862ff4323 100644
--- a/src/tree/mirror/streaming/backend/local.rs
+++ b/src/tree/mirror/streaming/backend/local.rs
@@ -31,7 +31,7 @@ mod tests;
 #[cfg(test)]
 pub use adversarial::with_schedule;
 
-impl<T: Send + Sync + 'static, H: Height> Node<T> for typed::Node<H> {
+impl<H: Height> Node for typed::Node<H> {
     type Backend = Local;
     type Height = H;
 
@@ -72,7 +72,7 @@ impl ErasedNode for typed::untyped::Node {
     }
 }
 
-impl<T: Send + Sync + 'static> Leaf<T> for typed::Node<Z> {
+impl Leaf for typed::Node<Z> {
     fn message(&self) -> &Message {
         self.message()
     }
@@ -109,7 +109,7 @@ impl Local {
 /// rests on it.
 const _: () = assert!(std::mem::size_of::<typed::Node<Z>>() == std::mem::size_of::<*const ()>());
 
-impl<T: Send + Sync + 'static> Backend<T> for Local {
+impl Backend for Local {
     type Node<H: Height> = typed::Node<H>;
     // One representation for every height already: the typed node is a
     // phantom tag over this, so both conversions are field moves.
@@ -128,11 +128,7 @@ impl<T: Send + Sync + 'static> Backend<T> for Local {
         Local::node_bytes(children, version_bound)
     }
 
-    fn children<H>(
-        self,
-        prefix: Prefix<S<H>>,
-        parent: Self::Node<S<H>>,
-    ) -> impl NodeStream<Self, T, H>
+    fn children<H>(self, prefix: Prefix<S<H>>, parent: Self::Node<S<H>>) -> impl NodeStream<Self, H>
     where
         H: Height,
         S<H>: Height,
@@ -181,7 +177,7 @@ impl<T: Send + Sync + 'static> Backend<T> for Local {
         self,
         prefix: Prefix<H>,
         node: Self::Node<H>,
-    ) -> impl NodeStream<Self, T, Z> {
+    ) -> impl NodeStream<Self, Z> {
         // The default level-by-level explosion pays an allocation per
         // *virtual* level — ruinous for path-compressed spines. In-memory
         // nodes walk their own leaves directly, skipping compressed spans.
@@ -194,8 +190,8 @@ impl<T: Send + Sync + 'static> Backend<T> for Local {
 
     fn assemble<'a, H: Convert>(
         self,
-        leaves: BoxNodeStream<'a, Self, T, Z>,
-    ) -> impl NodeStream<Self, T, H> + 'a {
+        leaves: BoxNodeStream<'a, Self, Z>,
+    ) -> impl NodeStream<Self, H> + 'a {
         // The bulk counterpart of `leaves`: buffer each maximal
         // same-prefix run and build its subtree in one pass, rather than
         // folding it up one virtual level at a time. The buffered run is
@@ -233,15 +229,15 @@ impl<T: Send + Sync + 'static> Backend<T> for Local {
 // `tree::Root` is exactly the `Local` instance of the session's generic
 // `Root`: the same (ceiling, optional root node) pair, concretely typed.
 
-impl<T: Send + Sync + 'static> From<tree::Root> for Root<Local, T> {
+impl From<tree::Root> for Root<Local> {
     fn from(root: tree::Root) -> Self {
         let tree::Root { ceiling, root } = root;
         Root { ceiling, root }
     }
 }
 
-impl<T: Send + Sync + 'static> From<Root<Local, T>> for tree::Root {
-    fn from(root: Root<Local, T>) -> Self {
+impl From<Root<Local>> for tree::Root {
+    fn from(root: Root<Local>) -> Self {
         let Root { ceiling, root } = root;
         tree::Root { ceiling, root }
     }
diff --git a/src/tree/mirror/streaming/backend/local/tests.rs b/src/tree/mirror/streaming/backend/local/tests.rs
index 54608d7cf..46f18e7fb 100644
--- a/src/tree/mirror/streaming/backend/local/tests.rs
+++ b/src/tree/mirror/streaming/backend/local/tests.rs
@@ -44,7 +44,7 @@ fn leaves_at(paths: impl IntoIterator<Item = [u8; 32]>) -> LeafRun {
         .collect()
 }
 
-fn boxed(run: LeafRun) -> BoxNodeStream<'static, Local, (), Z> {
+fn boxed(run: LeafRun) -> BoxNodeStream<'static, Local, Z> {
     Box::pin(stream::iter(run.into_iter().map(Ok::<_, Infallible>)))
 }
 
@@ -63,7 +63,7 @@ fn assemble_local<H: Convert>(run: LeafRun) -> Vec<(Prefix<H>, typed::Node<H>)>
 /// Explode through the level-by-level default, bypassing Local's override.
 fn leaves_default<H: Convert>(prefix: Prefix<H>, node: typed::Node<H>) -> LeafRun {
     pollster::block_on(
-        H::explode::<_, ()>(
+        H::explode::<_>(
             Local,
             Box::pin(stream::once(async move { Ok((prefix, node)) })),
         )
@@ -74,7 +74,7 @@ fn leaves_default<H: Convert>(prefix: Prefix<H>, node: typed::Node<H>) -> LeafRu
 
 /// Walk leaves through the backend seam, which Local overrides directly.
 fn leaves_local<H: Convert>(prefix: Prefix<H>, node: typed::Node<H>) -> LeafRun {
-    pollster::block_on(<Local as Backend<()>>::leaves(Local, prefix, node).try_collect())
+    pollster::block_on(<Local as Backend>::leaves(Local, prefix, node).try_collect())
         .unwrap_or_else(|error| match error {})
 }
 
diff --git a/src/tree/mirror/streaming/convert.rs b/src/tree/mirror/streaming/convert.rs
index da55a940e..5dc7eda6e 100644
--- a/src/tree/mirror/streaming/convert.rs
+++ b/src/tree/mirror/streaming/convert.rs
@@ -28,32 +28,28 @@ use crate::tree::{
 pub trait Convert: Height {
     /// Disassemble a stream of `backend`'s nodes at this height into the
     /// prefix-ordered stream of every leaf beneath them.
-    fn explode<B, T>(backend: B, stream: BoxNodeStream<B, T, Self>) -> BoxNodeStream<B, T, Z>
+    fn explode<B>(backend: B, stream: BoxNodeStream<B, Self>) -> BoxNodeStream<B, Z>
     where
-        B: Backend<T, Node<Z>: Leaf<T>>,
-        T: Send + Sync + 'static;
+        B: Backend<Node<Z>: Leaf>;
 
     /// Assemble a prefix-ordered leaf stream into the stream of `backend`'s
     /// nodes at this height.
-    fn assemble<B, T>(backend: B, leaves: BoxNodeStream<B, T, Z>) -> BoxNodeStream<B, T, Self>
+    fn assemble<B>(backend: B, leaves: BoxNodeStream<B, Z>) -> BoxNodeStream<B, Self>
     where
-        B: Backend<T, Node<Z>: Leaf<T>>,
-        T: Send + Sync + 'static;
+        B: Backend<Node<Z>: Leaf>;
 }
 
 impl Convert for Z {
-    fn explode<B, T>(_backend: B, stream: BoxNodeStream<B, T, Z>) -> BoxNodeStream<B, T, Z>
+    fn explode<B>(_backend: B, stream: BoxNodeStream<B, Z>) -> BoxNodeStream<B, Z>
     where
-        B: Backend<T, Node<Z>: Leaf<T>>,
-        T: Send + Sync + 'static,
+        B: Backend<Node<Z>: Leaf>,
     {
         stream
     }
 
-    fn assemble<B, T>(_backend: B, leaves: BoxNodeStream<B, T, Z>) -> BoxNodeStream<B, T, Z>
+    fn assemble<B>(_backend: B, leaves: BoxNodeStream<B, Z>) -> BoxNodeStream<B, Z>
     where
-        B: Backend<T, Node<Z>: Leaf<T>>,
-        T: Send + Sync + 'static,
+        B: Backend<Node<Z>: Leaf>,
     {
         leaves
     }
@@ -64,13 +60,12 @@ where
     H: Convert,
     S<H>: Height,
 {
-    fn explode<B, T>(backend: B, stream: BoxNodeStream<B, T, S<H>>) -> BoxNodeStream<B, T, Z>
+    fn explode<B>(backend: B, stream: BoxNodeStream<B, S<H>>) -> BoxNodeStream<B, Z>
     where
-        B: Backend<T, Node<Z>: Leaf<T>>,
-        T: Send + Sync + 'static,
+        B: Backend<Node<Z>: Leaf>,
     {
         let exploded = backend.clone();
-        let below: BoxNodeStream<B, T, H> = Box::pin(try_stream! {
+        let below: BoxNodeStream<B, H> = Box::pin(try_stream! {
             for await item in stream {
                 let (prefix, node) = item?;
                 for await child in exploded.clone().children::<H>(prefix, node) {
@@ -81,10 +76,9 @@ where
         H::explode(backend, below)
     }
 
-    fn assemble<B, T>(backend: B, leaves: BoxNodeStream<B, T, Z>) -> BoxNodeStream<B, T, S<H>>
+    fn assemble<B>(backend: B, leaves: BoxNodeStream<B, Z>) -> BoxNodeStream<B, S<H>>
     where
-        B: Backend<T, Node<Z>: Leaf<T>>,
-        T: Send + Sync + 'static,
+        B: Backend<Node<Z>: Leaf>,
     {
         let below = H::assemble(backend.clone(), leaves);
         let folded = fold_parents(backend, below);
@@ -101,24 +95,19 @@ where
 /// Reassemble an ascending child stream into its parent level, one complete
 /// radix group at a time: a group flushes when the prefix changes or the
 /// input ends.
-fn fold_parents<B, T, H>(
-    backend: B,
-    children: impl NodeStream<B, T, H>,
-) -> impl NodeStream<B, T, S<H>>
+fn fold_parents<B, H>(backend: B, children: impl NodeStream<B, H>) -> impl NodeStream<B, S<H>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     H: Height,
     S<H>: Height,
 {
     /// Flush a completed group, if any, into its parent.
-    async fn flush<B, T, H>(
+    async fn flush<B, H>(
         backend: &B,
         finished: Option<(Prefix<S<H>>, Vec<(u8, Option<B::Node<H>>)>)>,
     ) -> Result<Option<(Prefix<S<H>>, B::Node<S<H>>)>, B::Error>
     where
-        B: Backend<T, Node<Z>: Leaf<T>>,
-        T: Send + Sync + 'static,
+        B: Backend<Node<Z>: Leaf>,
         H: Height,
         S<H>: Height,
     {
diff --git a/src/tree/mirror/streaming/convert/tests.rs b/src/tree/mirror/streaming/convert/tests.rs
index e1d401fbe..3bf5e8cfb 100644
--- a/src/tree/mirror/streaming/convert/tests.rs
+++ b/src/tree/mirror/streaming/convert/tests.rs
@@ -43,7 +43,7 @@ fn parent_prefix(parent: u8) -> Prefix<S<Z>> {
 /// Build the expected parent of a radix group directly through the backend,
 /// bypassing the fold under test.
 fn parent_of(prefix: Prefix<S<Z>>, children: Vec<(u8, typed::Node<Z>)>) -> typed::Node<S<Z>> {
-    pollster::block_on(<Local as Backend<()>>::parent(
+    pollster::block_on(<Local as Backend>::parent(
         Local,
         prefix,
         children
@@ -58,7 +58,7 @@ fn parent_of(prefix: Prefix<S<Z>>, children: Vec<(u8, typed::Node<Z>)>) -> typed
 /// Drive the fold of an in-memory child stream to completion.
 fn fold(children: Vec<(Prefix<Z>, typed::Node<Z>)>) -> Vec<(Prefix<S<Z>>, Hash)> {
     pollster::block_on(
-        fold_parents::<Local, (), Z>(
+        fold_parents::<Local, Z>(
             Local,
             stream::iter(children.into_iter().map(Ok::<_, Infallible>)),
         )
diff --git a/src/tree/mirror/streaming/driver.rs b/src/tree/mirror/streaming/driver.rs
index 65902ec59..ba3d4e19f 100644
--- a/src/tree/mirror/streaming/driver.rs
+++ b/src/tree/mirror/streaming/driver.rs
@@ -149,15 +149,14 @@ macro_rules! mirror {
 }
 
 /// Drive the complete reconciliation schedule between two connected peers.
-pub(super) async fn mirror_connected<B, I, R, T>(
+pub(super) async fn mirror_connected<B, I, R>(
     i: I,
     r: R,
 ) -> Result<(I::Output, R::Output), Error<I::Error, R::Error>>
 where
-    T: Send + Sync + 'static,
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    I: Peer<B, T>,
-    R: Peer<B, T>,
+    B: Backend<Node<Z>: Leaf>,
+    I: Peer<B>,
+    R: Peer<B>,
 {
     mirror! {
         i.initiator;
@@ -177,13 +176,12 @@ where
 /// On error the stream parks rather than ending, because EOF means successful
 /// phase completion to its consumer. [`race_session`] observes the routed
 /// error and cancels the parked schedule.
-fn divert<B, T, H, E, D>(
-    messages: impl Responses<B, T, H, E>,
+fn divert<B, H, E, D>(
+    messages: impl Responses<B, H, E>,
     route: ErrorRoute<E, D>,
-) -> impl Requests<B, T, H>
+) -> impl Requests<B, H>
 where
-    T: Send + Sync + 'static,
-    B: Backend<T, Node<Z>: Leaf<T>>,
+    B: Backend<Node<Z>: Leaf>,
     H: Height,
     E: Send + 'static,
     D: Send + 'static,
diff --git a/src/tree/mirror/streaming/erased.rs b/src/tree/mirror/streaming/erased.rs
index 3fb93ec99..b59ff85d4 100644
--- a/src/tree/mirror/streaming/erased.rs
+++ b/src/tree/mirror/streaming/erased.rs
@@ -73,10 +73,9 @@ pub(crate) enum Reaction<E> {
 
 /// Erase one typed reply where a schedule-typed request stream enters a
 /// walk worker.
-pub(crate) fn erase_reply<B, T, H>(reply: message::Reply<B, T, H>) -> Reply<B::Erased>
+pub(crate) fn erase_reply<B, H>(reply: message::Reply<B, H>) -> Reply<B::Erased>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     H: Height,
 {
     Reply {
@@ -93,10 +92,9 @@ where
 }
 
 /// Re-tag one erased reply at the typed exit of [`reply_channel`].
-fn assume_reply<B, T, H>(reply: Reply<B::Erased>) -> message::Reply<B, T, H>
+fn assume_reply<B, H>(reply: Reply<B::Erased>) -> message::Reply<B, H>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     H: Height,
 {
     message::Reply {
@@ -115,24 +113,22 @@ where
 /// The typed exit of [`reply_channel`]: the erased receiver as a stream
 /// of schedule-typed replies. `Err` is the session's error type, passed
 /// through untouched.
-pub(crate) struct ReplyResultStream<B, T, H, Err>
+pub(crate) struct ReplyResultStream<B, H, Err>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     H: Height,
 {
     inner: ReceiverStreamOf<Result<Reply<B::Erased>, Err>>,
-    assume: fn(Result<Reply<B::Erased>, Err>) -> Result<message::Reply<B, T, H>, Err>,
+    assume: fn(Result<Reply<B::Erased>, Err>) -> Result<message::Reply<B, H>, Err>,
 }
 
-impl<B, T, H, Err> Stream for ReplyResultStream<B, T, H, Err>
+impl<B, H, Err> Stream for ReplyResultStream<B, H, Err>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     H: Height,
     Err: Send,
 {
-    type Item = Result<message::Reply<B, T, H>, Err>;
+    type Item = Result<message::Reply<B, H>, Err>;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         let this = self.get_mut();
@@ -169,16 +165,15 @@ fn receiver_stream<E: Send>(receiver: Receiver<E>) -> ReceiverStreamOf<E> {
 /// in, typed out — and therefore the outgoing half of the walk's typed
 /// boundary. Its height parameter fixes the exit's re-tag; the erased
 /// sender needs none.
-pub(crate) fn reply_channel<B, T, H, Err>(
+pub(crate) fn reply_channel<B, H, Err>(
     role: QueueRole,
     capacity: usize,
 ) -> (
     Sender<Result<Reply<B::Erased>, Err>>,
-    ReplyResultStream<B, T, H, Err>,
+    ReplyResultStream<B, H, Err>,
 )
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     H: Height,
     Err: Send,
 {
@@ -187,7 +182,7 @@ where
         sender,
         ReplyResultStream {
             inner: receiver_stream(receiver),
-            assume: |item| item.map(assume_reply::<B, T, H>),
+            assume: |item| item.map(assume_reply::<B, H>),
         },
     )
 }
@@ -248,18 +243,17 @@ pub(crate) mod ops {
     /// `prefix` is the node's own prefix; its length names the height the
     /// node is re-tagged at, so a walk cannot explode a node at any level
     /// other than the one its coordinate claims.
-    pub(crate) async fn children_of<B, T>(
+    pub(crate) async fn children_of<B>(
         backend: &B,
         prefix: ErasedPrefix,
         node: B::Erased,
     ) -> Result<Vec<(u8, B::Erased)>, B::Error>
     where
-        B: Backend<T, Node<Z>: Leaf<T>>,
-        T: Send + Sync + 'static,
+        B: Backend<Node<Z>: Leaf>,
     {
         at_parent_height!(prefix.height(), H => {
             let children =
-                children_of_typed::<B, T, <H as Pred>::Pred>(
+                children_of_typed::<B, <H as Pred>::Pred>(
                     backend,
                     prefix.assume::<H>(),
                     B::assume::<H>(node),
@@ -277,14 +271,13 @@ pub(crate) mod ops {
     ///
     /// `prefix` is the parent's own prefix, carrying the same
     /// length-is-height witness as [`children_of`].
-    pub(crate) async fn parent<B, T>(
+    pub(crate) async fn parent<B>(
         backend: B,
         prefix: ErasedPrefix,
         children: Vec<(u8, Option<B::Erased>)>,
     ) -> Result<Option<B::Erased>, B::Error>
     where
-        B: Backend<T, Node<Z>: Leaf<T>>,
-        T: Send + Sync + 'static,
+        B: Backend<Node<Z>: Leaf>,
     {
         at_parent_height!(prefix.height(), H => {
             let children = children
@@ -303,14 +296,13 @@ pub(crate) mod ops {
     ///
     /// The yielded leaves stay typed: `Z` is a single height, so nothing
     /// about a leaf ever needed erasing.
-    pub(crate) fn leaves<B, T>(
+    pub(crate) fn leaves<B>(
         backend: B,
         prefix: ErasedPrefix,
         node: B::Erased,
-    ) -> BoxNodeStream<'static, B, T, Z>
+    ) -> BoxNodeStream<'static, B, Z>
     where
-        B: Backend<T, Node<Z>: Leaf<T>>,
-        T: Send + Sync + 'static,
+        B: Backend<Node<Z>: Leaf>,
     {
         at_height!(prefix.height(), H => {
             Box::pin(backend.leaves::<H>(prefix.assume::<H>(), B::assume::<H>(node)))
@@ -324,14 +316,13 @@ pub(crate) mod ops {
     /// The one dispatch keyed by an explicit height rather than a prefix:
     /// its input is a whole leaf stream, and the target height is the
     /// consuming scope's — whose prefix length the caller derives it from.
-    pub(crate) fn assemble<B, T>(
+    pub(crate) fn assemble<B>(
         backend: B,
         height: usize,
-        leaves: BoxNodeStream<'static, B, T, Z>,
+        leaves: BoxNodeStream<'static, B, Z>,
     ) -> Pin<Box<dyn Stream<Item = Result<(ErasedPrefix, B::Erased), B::Error>> + Send>>
     where
-        B: Backend<T, Node<Z>: Leaf<T>>,
-        T: Send + Sync + 'static,
+        B: Backend<Node<Z>: Leaf>,
     {
         at_height!(height, H => {
             Box::pin(
diff --git a/src/tree/mirror/streaming/materialized.rs b/src/tree/mirror/streaming/materialized.rs
index c283c0aac..a3f75a633 100644
--- a/src/tree/mirror/streaming/materialized.rs
+++ b/src/tree/mirror/streaming/materialized.rs
@@ -299,10 +299,10 @@ pub enum Resolve<E> {
 /// [`responder`](protocol::Responder::responder). The session's outgoing
 /// messages carry `backend`'s own node types, which are the ones its
 /// counterparty reads.
-pub struct Handshaking<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, V> {
+pub struct Handshaking<B: Backend<Node<Z>: Leaf>, V> {
     backend: B,
     versions: V,
-    root: Root<B, T>,
+    root: Root<B>,
     /// The session's window choice, resolved against the exchanged set
     /// sizes; see [`window`](super::window).
     window: WindowConfig,
@@ -326,7 +326,7 @@ pub struct Start {
 /// Carries the root fan the greeting's listing was derived from, so the
 /// descent reuses it instead of asking the backend for the root's children a
 /// second time (the memory model's one-query-per-prefix rule).
-pub struct Connecting<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> {
+pub struct Connecting<B: Backend<Node<Z>: Leaf>> {
     our_version: Version,
     /// The root fan, already erased: everything downstream of the
     /// greeting — the descent's workers included — speaks the erased
@@ -338,7 +338,7 @@ pub struct Connecting<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>
 /// and can proceed with reconciliation.
 ///
 /// Like [`Connecting`], retains the greeting-time root fan for the descent.
-pub struct Connected<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> {
+pub struct Connected<B: Backend<Node<Z>: Leaf>> {
     our_version: Version,
     their_version: Version,
     /// The peer's live message count, from its greeting.
@@ -354,9 +354,9 @@ pub struct Connected<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>
     fan: Vec<(u8, B::Erased)>,
 }
 
-/// A mirror stage inside the descent, consuming [`Reply<B, T, H>`](Reply)
+/// A mirror stage inside the descent, consuming [`Reply<B, H>`](Reply)
 /// against a [`Query`] queue at the same height.
-pub struct Descending<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height>
+pub struct Descending<B: Backend<Node<Z>: Leaf>, H: Height>
 where
     S<H>: Height,
 {
@@ -388,9 +388,9 @@ where
     early_supplies: Option<oneshot::Receiver<Vec<(u8, Vec<(u8, B::Erased)>)>>>,
     /// The reassembly work accumulated so far; the terminals drive it to
     /// completion.
-    work: Work<B, T>,
+    work: Work<B>,
     /// Resolves to this side's reconciled root once the top return arrives.
-    finish: BoxFuture<'static, Result<Root<B, T>, Error<B::Error>>>,
+    finish: BoxFuture<'static, Result<Root<B>, Error<B::Error>>>,
     /// The stage's height, phantom.
     ///
     /// The payloads above are erased; this tag is what the schedule's
@@ -405,7 +405,7 @@ where
 /// This is not a [`Descending`] stage: its returns are the requested leaves
 /// themselves (height `Z`), not an assembled scope one height up, because
 /// nothing exists below a leaf to assemble from.
-pub struct Completing<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> {
+pub struct Completing<B: Backend<Node<Z>: Leaf>> {
     /// The peer's declared greeting version: the containment bound every
     /// supplied leaf is checked against
     /// ([`Violation::UncontainedSupply`]).
@@ -418,15 +418,15 @@ pub struct Completing<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>
     /// The requested leaves' resolutions, in request order.
     returns: Sender<Option<B::Erased>>,
     /// The accumulated work to drive the pipeline.
-    work: Work<B, T>,
+    work: Work<B>,
     /// The future result of the pipeline.
-    finish: BoxFuture<'static, Result<Root<B, T>, Error<B::Error>>>,
+    finish: BoxFuture<'static, Result<Root<B>, Error<B::Error>>>,
 }
 
-impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> Handshaking<B, T, Start> {
+impl<B: Backend<Node<Z>: Leaf>> Handshaking<B, Start> {
     /// Construct the session in its opening phase, at the default window
     /// and message-size target.
-    pub fn start(backend: B, root: Root<B, T>) -> Self {
+    pub fn start(backend: B, root: Root<B>) -> Self {
         Self {
             backend,
             versions: Start {
@@ -464,11 +464,9 @@ impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> Handshaking<B, T
     }
 }
 
-impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, V: Send> protocol::Protocol
-    for Handshaking<B, T, V>
-{
+impl<B: Backend<Node<Z>: Leaf>, V: Send> protocol::Protocol for Handshaking<B, V> {
     type Height = height::Root;
-    type Output = Root<B, T>;
+    type Output = Root<B>;
     type Error = Error<B::Error>;
 }
 
@@ -479,7 +477,7 @@ impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, V: Send> protoco
 /// (see [`Greeting`] for the trade). The fan itself is retained through
 /// [`Connecting`]/[`Connected`] so the descent never re-asks the backend for
 /// the root's children.
-pub(crate) async fn greeting_fan<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>(
+pub(crate) async fn greeting_fan<B: Backend<Node<Z>: Leaf>>(
     backend: &B,
     root: Option<B::Node<height::Root>>,
 ) -> Result<Vec<(u8, B::Erased)>, B::Error> {
@@ -505,10 +503,8 @@ pub(crate) fn fan_listing<E: ErasedNode>(fan: &[(u8, E)]) -> Vec<(u8, Hash)> {
         .collect()
 }
 
-impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> protocol::Connect<B, T>
-    for Handshaking<B, T, Start>
-{
-    type Next = Handshaking<B, T, Connecting<B, T>>;
+impl<B: Backend<Node<Z>: Leaf>> protocol::Connect<B> for Handshaking<B, Start> {
+    type Next = Handshaking<B, Connecting<B>>;
 
     async fn connect(self) -> Result<(Greeting, Self::Next), Self::Error> {
         let Start { our_version } = self.versions;
@@ -537,10 +533,8 @@ impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> protocol::Connec
     }
 }
 
-impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> protocol::CompleteConnect<B, T>
-    for Handshaking<B, T, Connecting<B, T>>
-{
-    type Next = Handshaking<B, T, Connected<B, T>>;
+impl<B: Backend<Node<Z>: Leaf>> protocol::CompleteConnect<B> for Handshaking<B, Connecting<B>> {
+    type Next = Handshaking<B, Connected<B>>;
 
     async fn complete_connect(self, theirs: Greeting) -> Result<Self::Next, Self::Error> {
         Ok(Handshaking {
@@ -561,10 +555,8 @@ impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> protocol::Comple
     }
 }
 
-impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> protocol::Accept<B, T>
-    for Handshaking<B, T, Start>
-{
-    type Next = Handshaking<B, T, Connected<B, T>>;
+impl<B: Backend<Node<Z>: Leaf>> protocol::Accept<B> for Handshaking<B, Start> {
+    type Next = Handshaking<B, Connected<B>>;
 
     async fn accept(self, request: Greeting) -> Result<(Greeting, Self::Next), Self::Error> {
         let Start { our_version } = self.versions;
@@ -600,20 +592,16 @@ impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> protocol::Accept
     }
 }
 
-impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> protocol::CompleteEqual<B, T>
-    for Handshaking<B, T, Connected<B, T>>
-{
-    async fn complete_equal(self) -> Result<Root<B, T>, Self::Error> {
+impl<B: Backend<Node<Z>: Leaf>> protocol::CompleteEqual<B> for Handshaking<B, Connected<B>> {
+    async fn complete_equal(self) -> Result<Root<B>, Self::Error> {
         Ok(self.root)
     }
 }
 
-impl<B: Backend<T, Node<Z>: Leaf<T>> + Sync, T: Send + Sync + 'static> protocol::Initiator<B, T>
-    for Handshaking<B, T, Connected<B, T>>
-{
-    type Next = Descending<B, T, UnderRoot>;
+impl<B: Backend<Node<Z>: Leaf> + Sync> protocol::Initiator<B> for Handshaking<B, Connected<B>> {
+    type Next = Descending<B, UnderRoot>;
 
-    fn initiator(self) -> (BoxResponses<B, T, UnderRoot, Self::Error>, Self::Next) {
+    fn initiator(self) -> (BoxResponses<B, UnderRoot, Self::Error>, Self::Next) {
         let Connected {
             our_version,
             their_version,
@@ -654,15 +642,13 @@ impl<B: Backend<T, Node<Z>: Leaf<T>> + Sync, T: Send + Sync + 'static> protocol:
     }
 }
 
-impl<B: Backend<T, Node<Z>: Leaf<T>> + Sync, T: Send + Sync + 'static> protocol::Responder<B, T>
-    for Handshaking<B, T, Connected<B, T>>
-{
-    type Next = Descending<B, T, UnderUnderRoot>;
+impl<B: Backend<Node<Z>: Leaf> + Sync> protocol::Responder<B> for Handshaking<B, Connected<B>> {
+    type Next = Descending<B, UnderUnderRoot>;
 
     fn responder(
         self,
-        requests: impl Requests<B, T, UnderRoot>,
-    ) -> (BoxResponses<B, T, UnderRoot, Self::Error>, Self::Next) {
+        requests: impl Requests<B, UnderRoot>,
+    ) -> (BoxResponses<B, UnderRoot, Self::Error>, Self::Next) {
         let Connected {
             our_version,
             their_version,
@@ -708,31 +694,29 @@ impl<B: Backend<T, Node<Z>: Leaf<T>> + Sync, T: Send + Sync + 'static> protocol:
     }
 }
 
-impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height> protocol::Protocol
-    for Descending<B, T, H>
+impl<B: Backend<Node<Z>: Leaf>, H: Height> protocol::Protocol for Descending<B, H>
 where
     S<H>: Height,
 {
     type Height = H;
-    type Output = Root<B, T>;
+    type Output = Root<B>;
     type Error = Error<B::Error>;
 }
 
-impl<B, T, H> protocol::Reply<B, T> for Descending<B, T, S<S<H>>>
+impl<B, H> protocol::Reply<B> for Descending<B, S<S<H>>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>> + Sync,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf> + Sync,
     H: Height,
     S<H>: Height,
     S<S<H>>: Height,
     S<S<S<H>>>: Height,
 {
-    type Next = Descending<B, T, H>;
+    type Next = Descending<B, H>;
 
     fn reply(
         mut self,
-        requests: impl Requests<B, T, S<S<H>>>,
-    ) -> (BoxResponses<B, T, S<H>, Self::Error>, Self::Next) {
+        requests: impl Requests<B, S<S<H>>>,
+    ) -> (BoxResponses<B, S<H>, Self::Error>, Self::Next) {
         let (responses, queries, upper, lower) = self.work.internal_level::<H>(
             self.their_version.clone(),
             self.ledger.clone(),
@@ -761,17 +745,16 @@ where
     }
 }
 
-impl<B, T> protocol::Reply<B, T> for Descending<B, T, S<Z>>
+impl<B> protocol::Reply<B> for Descending<B, S<Z>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>> + Sync,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf> + Sync,
 {
-    type Next = Completing<B, T>;
+    type Next = Completing<B>;
 
     fn reply(
         mut self,
-        requests: impl Requests<B, T, S<Z>>,
-    ) -> (BoxResponses<B, T, Z, Self::Error>, Self::Next) {
+        requests: impl Requests<B, S<Z>>,
+    ) -> (BoxResponses<B, Z, Self::Error>, Self::Next) {
         debug_assert!(
             self.early_survivors.is_none() && self.early_supplies.is_none(),
             "the opening hand-off is consumed by the first descending stage"
@@ -799,17 +782,16 @@ where
     }
 }
 
-impl<B, T> protocol::CompleteResponder<B, T> for Descending<B, T, Z>
+impl<B> protocol::CompleteResponder<B> for Descending<B, Z>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     fn complete_responder(
         mut self,
-        requests: impl Requests<B, T, Z>,
+        requests: impl Requests<B, Z>,
     ) -> (
-        BoxResponses<B, T, Z, Self::Error>,
-        impl Future<Output = Result<Root<B, T>, Self::Error>> + Send,
+        BoxResponses<B, Z, Self::Error>,
+        impl Future<Output = Result<Root<B>, Self::Error>> + Send,
     ) {
         let (responses, resolutions) =
             self.work
@@ -819,28 +801,25 @@ where
     }
 }
 
-impl<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static> protocol::Protocol
-    for Completing<B, T>
-{
+impl<B: Backend<Node<Z>: Leaf>> protocol::Protocol for Completing<B> {
     type Height = Z;
-    type Output = Root<B, T>;
+    type Output = Root<B>;
     type Error = Error<B::Error>;
 }
 
-impl<B, T> protocol::CompleteInitiator<B, T> for Completing<B, T>
+impl<B> protocol::CompleteInitiator<B> for Completing<B>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     async fn complete_initiator(
         self,
-        requests: impl Requests<B, T, Z>,
-    ) -> Result<Root<B, T>, Self::Error> {
+        requests: impl Requests<B, Z>,
+    ) -> Result<Root<B>, Self::Error> {
         let stats = self.work.stats();
-        let mut absorb = pin!(absorb::<B, T>(
+        let mut absorb = pin!(absorb::<B>(
             self.their_version,
             self.ledger,
-            requests.map(erased::erase_reply::<B, T, Z>),
+            requests.map(erased::erase_reply::<B, Z>),
             self.queries,
             self.returns,
             stats,
@@ -871,7 +850,7 @@ where
 /// Each absorbed leaf is content this replica just learned, credited as
 /// [`messages_gained`](crate::SessionStats::messages_gained) exactly like
 /// the resolver's supply arm.
-async fn absorb<B, T>(
+async fn absorb<B>(
     their_version: Version,
     ledger: SupplyLedger,
     requests: impl futures::Stream<Item = Reply<B::Erased>> + Send,
@@ -880,8 +859,7 @@ async fn absorb<B, T>(
     stats: Recorder,
 ) -> Result<(), Error<B::Error>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     let mut requests = pin!(requests);
     while let Some(prefix) = queries.recv().await {
diff --git a/src/tree/mirror/streaming/materialized/common.rs b/src/tree/mirror/streaming/materialized/common.rs
index 2f019607b..352504c88 100644
--- a/src/tree/mirror/streaming/materialized/common.rs
+++ b/src/tree/mirror/streaming/materialized/common.rs
@@ -15,14 +15,13 @@ use crate::tree::{
 use super::channel::{QueueRole, Receiver, Sender, channel};
 
 /// Collect one node's children, addressed by radix.
-pub async fn children_of<B, T, H>(
+pub async fn children_of<B, H>(
     backend: &B,
     prefix: Prefix<S<H>>,
     node: B::Node<S<H>>,
 ) -> Result<Vec<(u8, B::Node<H>)>, B::Error>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     H: Height,
     S<H>: Height,
 {
diff --git a/src/tree/mirror/streaming/materialized/tests.rs b/src/tree/mirror/streaming/materialized/tests.rs
index 6779f3a76..d989be73f 100644
--- a/src/tree/mirror/streaming/materialized/tests.rs
+++ b/src/tree/mirror/streaming/materialized/tests.rs
@@ -62,20 +62,17 @@ fn absorb_scripted(
     pollster::block_on(queries.send(Prefix::containing(&path))).expect("the loop is live");
     drop(queries);
 
-    let (returns, mut returns_rx) = channel::<Option<<Local as Backend<()>>::Erased>>(
+    let (returns, mut returns_rx) = channel::<Option<<Local as Backend>::Erased>>(
         QueueRole::new(QueueKind::TerminalLeafResolutions, Z::HEIGHT),
         1,
     );
 
     let leaf = typed::Node::leaf(leaf_version, Message::new(()));
     let requests = stream::iter(vec![erased::Reply {
-        replies: vec![erased::Reaction::Supply(
-            0,
-            <Local as Backend<()>>::erase(leaf),
-        )],
+        replies: vec![erased::Reaction::Supply(0, <Local as Backend>::erase(leaf))],
     }]);
 
-    let result = pollster::block_on(absorb::<Local, ()>(
+    let result = pollster::block_on(absorb::<Local>(
         declared,
         ledger,
         requests,
@@ -84,7 +81,7 @@ fn absorb_scripted(
         Recorder::default(),
     ));
     let returned = pollster::block_on(async move { returns_rx.recv().await })
-        .map(|leaf| leaf.map(<Local as Backend<()>>::assume::<Z>));
+        .map(|leaf| leaf.map(<Local as Backend>::assume::<Z>));
     (result, returned)
 }
 
diff --git a/src/tree/mirror/streaming/materialized/unknown.rs b/src/tree/mirror/streaming/materialized/unknown.rs
index 4a5f19d47..d90c419c0 100644
--- a/src/tree/mirror/streaming/materialized/unknown.rs
+++ b/src/tree/mirror/streaming/materialized/unknown.rs
@@ -74,7 +74,7 @@ fn knowledge(node: &impl ErasedNode, known: &Version) -> Dominance {
 /// [`messages_shed`](crate::SessionStats::messages_shed): one per dropped
 /// leaf, a whole subtree's exact leaf count when the cached version bounds
 /// prune it without descending.
-pub(super) fn unknown<'a, B, T>(
+pub(super) fn unknown<'a, B>(
     backend: &'a B,
     known: &'a Version,
     prefix: ErasedPrefix,
@@ -82,8 +82,7 @@ pub(super) fn unknown<'a, B, T>(
     stats: &'a Recorder,
 ) -> BoxFuture<'a, Result<Option<B::Erased>, B::Error>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>> + Sync,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf> + Sync,
 {
     async move {
         if prefix.height() == 0 {
@@ -130,7 +129,7 @@ where
 /// Reporting the children lets an answerer emit them as `Supply` reactions
 /// without re-querying the prefix it just explored (the one-query-per-prefix
 /// invariant; see [`super`]).
-pub(super) async fn unknown_providing<B, T>(
+pub(super) async fn unknown_providing<B>(
     backend: &B,
     known: &Version,
     prefix: ErasedPrefix,
@@ -138,8 +137,7 @@ pub(super) async fn unknown_providing<B, T>(
     stats: &Recorder,
 ) -> Result<(Option<B::Erased>, Vec<(u8, B::Erased)>), B::Error>
 where
-    B: Backend<T, Node<Z>: Leaf<T>> + Sync,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf> + Sync,
 {
     match knowledge(&node, known) {
         // Wholly unknown: the whole subtree travels.
diff --git a/src/tree/mirror/streaming/materialized/unknown/tests.rs b/src/tree/mirror/streaming/materialized/unknown/tests.rs
index cbef059d2..d70c5aafa 100644
--- a/src/tree/mirror/streaming/materialized/unknown/tests.rs
+++ b/src/tree/mirror/streaming/materialized/unknown/tests.rs
@@ -51,15 +51,15 @@ fn tree_and_known(flags_a: &[bool], flags_b: &[bool]) -> (Option<typed::node::Ro
 /// the future to completion with a trivial executor.
 fn stream_prune(root: Option<typed::node::Root>, known: &Version) -> Option<typed::node::Root> {
     root.and_then(|node| {
-        pollster::block_on(unknown::<Local, ()>(
+        pollster::block_on(unknown::<Local>(
             &Local,
             known,
             Prefix::new().erase(),
-            <Local as Backend<()>>::erase(node),
+            <Local as Backend>::erase(node),
             &Recorder::default(),
         ))
         .unwrap_or_else(|e| match e {})
-        .map(<Local as Backend<()>>::assume::<Root>)
+        .map(<Local as Backend>::assume::<Root>)
     })
 }
 
diff --git a/src/tree/mirror/streaming/materialized/work.rs b/src/tree/mirror/streaming/materialized/work.rs
index 0a41b15e2..638684153 100644
--- a/src/tree/mirror/streaming/materialized/work.rs
+++ b/src/tree/mirror/streaming/materialized/work.rs
@@ -40,10 +40,9 @@ use crate::tree::{
 use self::queues::outgoing_responses;
 
 /// Backend and independently runnable tasks retained across protocol phases.
-pub struct Work<B, T>
+pub struct Work<B>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     backend: B,
     /// Per-edge capacity for the recursive query and resolution queues.
@@ -56,10 +55,9 @@ where
     trace_id: usize,
 }
 
-impl<B, T> Work<B, T>
+impl<B> Work<B>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     /// Construct a new work context with the session's pipeline window and
     /// stats recorder.
@@ -90,8 +88,8 @@ where
     fn respond<H: Height>(
         &mut self,
         messages: impl Stream<Item = Result<erased::Reply<B::Erased>, Error<B::Error>>> + Send + 'static,
-    ) -> BoxResponses<B, T, H, Error<B::Error>> {
-        let (send, responses) = outgoing_responses::<B, T, H>();
+    ) -> BoxResponses<B, H, Error<B::Error>> {
+        let (send, responses) = outgoing_responses::<B, H>();
         self.tasks.push(Box::pin(pump(
             Box::pin(messages),
             send,
diff --git a/src/tree/mirror/streaming/materialized/work/answer.rs b/src/tree/mirror/streaming/materialized/work/answer.rs
index d3bdc5041..241b24283 100644
--- a/src/tree/mirror/streaming/materialized/work/answer.rs
+++ b/src/tree/mirror/streaming/materialized/work/answer.rs
@@ -29,7 +29,7 @@ use crate::{
 /// confirmation, not a dispute, and a one-sided join is a request being
 /// served.
 #[allow(clippy::type_complexity)]
-pub(super) async fn internal<B, T>(
+pub(super) async fn internal<B>(
     backend: &B,
     their_version: &Version,
     prefix: ErasedPrefix,
@@ -45,8 +45,7 @@ pub(super) async fn internal<B, T>(
     B::Error,
 >
 where
-    B: Backend<T, Node<Z>: Leaf<T>> + Sync,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf> + Sync,
 {
     let mut reactions = Vec::new();
     let mut asked = Vec::new();
diff --git a/src/tree/mirror/streaming/materialized/work/assembly.rs b/src/tree/mirror/streaming/materialized/work/assembly.rs
index c35113f2b..325e30927 100644
--- a/src/tree/mirror/streaming/materialized/work/assembly.rs
+++ b/src/tree/mirror/streaming/materialized/work/assembly.rs
@@ -17,10 +17,9 @@ use crate::tree::{
     typed::height::Z,
 };
 
-impl<B, T> Work<B, T>
+impl<B> Work<B>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     /// Assemble one level upward and return its lower-level sender.
     ///
@@ -36,7 +35,7 @@ where
         returns: Sender<Option<B::Erased>>,
         resolutions: impl Stream<Item = Result<Resolution<B::Erased>, Error<B::Error>>> + Send + 'static,
     ) -> Sender<Option<B::Erased>> {
-        let (level, level_rx) = assembly_level_returns::<B, T>(height);
+        let (level, level_rx) = assembly_level_returns::<B>(height);
         self.return_into(
             returns,
             assemble(self.backend.clone(), resolutions, level_rx),
@@ -62,14 +61,13 @@ where
 /// Pairing is positional: resolutions arrive in query order and `level`
 /// carries one item per `Pending` in that same order. An empty resolution
 /// reaches [`Backend::parent`] with an empty group and resolves to `None`.
-pub(super) fn assemble<B, T>(
+pub(super) fn assemble<B>(
     backend: B,
     resolutions: impl Stream<Item = Result<Resolution<B::Erased>, Error<B::Error>>> + Send,
     level: impl Stream<Item = Result<Option<B::Erased>, Error<B::Error>>> + Send,
 ) -> impl Stream<Item = Result<Option<B::Erased>, Error<B::Error>>> + Send
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     try_stream! {
         let mut level = pin!(level.fuse());
diff --git a/src/tree/mirror/streaming/materialized/work/levels.rs b/src/tree/mirror/streaming/materialized/work/levels.rs
index 2254aef58..be880f922 100644
--- a/src/tree/mirror/streaming/materialized/work/levels.rs
+++ b/src/tree/mirror/streaming/materialized/work/levels.rs
@@ -44,10 +44,9 @@ use crate::tree::{
 /// rather than once per concrete schedule stream.
 type Replies<E> = BoxStream<'static, Reply<E>>;
 
-impl<B, T> Work<B, T>
+impl<B> Work<B>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     /// Process the initiator level.
     ///
@@ -73,17 +72,17 @@ where
         fan: Vec<(u8, B::Erased)>,
         their_listing: Vec<(u8, Hash)>,
     ) -> (
-        BoxResponses<B, T, UnderRoot, Error<B::Error>>,
+        BoxResponses<B, UnderRoot, Error<B::Error>>,
         Receiver<Query<B::Erased>>,
         Sender<Option<B::Erased>>,
         oneshot::Receiver<Vec<(u8, Option<B::Erased>)>>,
-        BoxFuture<'static, Result<Root<B, T>, Error<B::Error>>>,
+        BoxFuture<'static, Result<Root<B>, Error<B::Error>>>,
     )
     where
         B: Sync,
     {
-        let (queries, queries_rx) = initiator_root_query::<B, T>();
-        let (returns, mut returns_rx) = initiator_root_return::<B, T>();
+        let (queries, queries_rx) = initiator_root_query::<B>();
+        let (returns, mut returns_rx) = initiator_root_return::<B>();
         let (early_tx, early_rx) = oneshot::channel();
         let backend = self.backend();
         let stats = self.stats.clone();
@@ -179,24 +178,24 @@ where
         ledger: SupplyLedger,
         ceiling: Version,
         fan: Vec<(u8, B::Erased)>,
-        requests: impl Requests<B, T, UnderRoot>,
+        requests: impl Requests<B, UnderRoot>,
     ) -> (
-        BoxResponses<B, T, UnderRoot, Error<B::Error>>,
+        BoxResponses<B, UnderRoot, Error<B::Error>>,
         Receiver<Query<B::Erased>>,
         Sender<Option<B::Erased>>,
         oneshot::Receiver<Vec<(u8, Vec<(u8, B::Erased)>)>>,
-        BoxFuture<'static, Result<Root<B, T>, Error<B::Error>>>,
+        BoxFuture<'static, Result<Root<B>, Error<B::Error>>>,
     )
     where
         B: Sync,
     {
         let requests: Replies<B::Erased> =
-            Box::pin(requests.map(erased::erase_reply::<B, T, UnderRoot>));
+            Box::pin(requests.map(erased::erase_reply::<B, UnderRoot>));
         let backend = self.backend();
         let stats = self.stats.clone();
         let (asked, asked_rx) =
-            responder_child_queries::<B, T>(self.window.capacity(UnderUnderRoot::HEIGHT));
-        let (resolution, resolution_rx) = responder_root_resolution::<B, T>();
+            responder_child_queries::<B>(self.window.capacity(UnderUnderRoot::HEIGHT));
+        let (resolution, resolution_rx) = responder_root_resolution::<B>();
         let (early_tx, early_rx) = oneshot::channel();
         let assembling = backend.clone();
         #[cfg(test)]
@@ -248,7 +247,7 @@ where
             );
         };
 
-        let (returns, returns_rx) = responder_root_returns::<B, T>();
+        let (returns, returns_rx) = responder_root_returns::<B>();
         let assembled = assemble(assembling, resolution_rx, returns_rx);
         let finish = Box::pin(async move {
             let mut assembled = pin!(assembled);
@@ -301,10 +300,10 @@ where
         ledger: SupplyLedger,
         early_survivors: Option<oneshot::Receiver<Vec<(u8, Option<B::Erased>)>>>,
         early_supplies: Option<oneshot::Receiver<Vec<(u8, Vec<(u8, B::Erased)>)>>>,
-        requests: impl Requests<B, T, S<S<H>>>,
+        requests: impl Requests<B, S<S<H>>>,
         queries: Receiver<Query<B::Erased>>,
     ) -> (
-        BoxResponses<B, T, S<H>, Error<B::Error>>,
+        BoxResponses<B, S<H>, Error<B::Error>>,
         Receiver<Query<B::Erased>>,
         OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
         OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
@@ -316,7 +315,7 @@ where
         S<S<H>>: Height,
     {
         let requests: Replies<B::Erased> =
-            Box::pin(requests.map(erased::erase_reply::<B, T, S<S<H>>>));
+            Box::pin(requests.map(erased::erase_reply::<B, S<S<H>>>));
         let (responses, asked_rx, upper_rx, lower_rx) = self.internal_walk(
             their_version,
             ledger,
@@ -350,7 +349,7 @@ where
         mut queries: Receiver<Query<B::Erased>>,
         asked_height: usize,
     ) -> (
-        impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>> + Send + 'static + use<B, T>,
+        impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>> + Send + 'static + use<B>,
         Receiver<Query<B::Erased>>,
         OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
         OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
@@ -361,12 +360,12 @@ where
         let backend = self.backend();
         let stats = self.stats.clone();
         let (asked, asked_rx) =
-            internal_child_queries::<B, T>(asked_height, self.window.capacity(asked_height));
-        let (upper, upper_rx) = internal_parent_resolutions::<B, T>(
+            internal_child_queries::<B>(asked_height, self.window.capacity(asked_height));
+        let (upper, upper_rx) = internal_parent_resolutions::<B>(
             asked_height + 2,
             self.window.capacity(asked_height + 2),
         );
-        let (lower, lower_rx) = internal_child_resolutions::<B, T>(
+        let (lower, lower_rx) = internal_child_resolutions::<B>(
             asked_height + 1,
             self.window.capacity(asked_height + 1),
         );
@@ -428,7 +427,7 @@ where
                 }
 
                 let mut resolver =
-                    Resolver::<B, T>::new(query, &their_version, &ledger, stats.clone());
+                    Resolver::<B>::new(query, &their_version, &ledger, stats.clone());
                 for reaction in replies {
                     let Some((prefix, radix, node, listing)) = resolver.react(reaction)? else {
                         continue;
@@ -519,10 +518,10 @@ where
         &mut self,
         their_version: Version,
         ledger: SupplyLedger,
-        requests: impl Requests<B, T, S<Z>>,
+        requests: impl Requests<B, S<Z>>,
         queries: Receiver<Query<B::Erased>>,
     ) -> (
-        BoxResponses<B, T, Z, Error<B::Error>>,
+        BoxResponses<B, Z, Error<B::Error>>,
         Receiver<Prefix<Z>>,
         OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
         OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
@@ -530,8 +529,7 @@ where
     where
         B: Sync,
     {
-        let requests: Replies<B::Erased> =
-            Box::pin(requests.map(erased::erase_reply::<B, T, S<Z>>));
+        let requests: Replies<B::Erased> = Box::pin(requests.map(erased::erase_reply::<B, S<Z>>));
         let (responses, asked_rx, upper_rx, lower_rx) =
             self.leaf_parent_walk(their_version, ledger, requests, queries);
         (self.respond::<Z>(responses), asked_rx, upper_rx, lower_rx)
@@ -546,7 +544,7 @@ where
         requests: Replies<B::Erased>,
         mut queries: Receiver<Query<B::Erased>>,
     ) -> (
-        impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>> + Send + 'static + use<B, T>,
+        impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>> + Send + 'static + use<B>,
         Receiver<Prefix<Z>>,
         OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
         OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
@@ -557,9 +555,8 @@ where
         let backend = self.backend();
         let stats = self.stats.clone();
         let (asked, asked_rx) = leaf_requests(self.window.capacity(Z::HEIGHT));
-        let (upper, upper_rx) =
-            leaf_parent_resolutions::<B, T>(self.window.capacity(<S<Z>>::HEIGHT));
-        let (lower, lower_rx) = leaf_child_resolutions::<B, T>(self.window.capacity(Z::HEIGHT));
+        let (upper, upper_rx) = leaf_parent_resolutions::<B>(self.window.capacity(<S<Z>>::HEIGHT));
+        let (lower, lower_rx) = leaf_child_resolutions::<B>(self.window.capacity(Z::HEIGHT));
         #[cfg(test)]
         let trace_id = self.trace_id;
 
@@ -571,7 +568,7 @@ where
                 };
 
                 let mut resolver =
-                    Resolver::<B, T>::new(query, &their_version, &ledger, stats.clone());
+                    Resolver::<B>::new(query, &their_version, &ledger, stats.clone());
                 for reaction in replies {
                     let Some((prefix, radix, node, listing)) = resolver.react(reaction)? else {
                         continue;
@@ -632,13 +629,13 @@ where
         &mut self,
         their_version: Version,
         ledger: SupplyLedger,
-        requests: impl Requests<B, T, Z>,
+        requests: impl Requests<B, Z>,
         queries: Receiver<Query<B::Erased>>,
     ) -> (
-        BoxResponses<B, T, Z, Error<B::Error>>,
+        BoxResponses<B, Z, Error<B::Error>>,
         OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
     ) {
-        let requests: Replies<B::Erased> = Box::pin(requests.map(erased::erase_reply::<B, T, Z>));
+        let requests: Replies<B::Erased> = Box::pin(requests.map(erased::erase_reply::<B, Z>));
         let (responses, upper_rx) = self.leaf_walk(their_version, ledger, requests, queries);
         (self.respond::<Z>(responses), upper_rx)
     }
@@ -652,10 +649,10 @@ where
         requests: Replies<B::Erased>,
         mut queries: Receiver<Query<B::Erased>>,
     ) -> (
-        impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>> + Send + 'static + use<B, T>,
+        impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>> + Send + 'static + use<B>,
         OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
     ) {
-        let (upper, upper_rx) = terminal_leaf_resolutions::<B, T>();
+        let (upper, upper_rx) = terminal_leaf_resolutions::<B>();
         let stats = self.stats.clone();
         #[cfg(test)]
         let trace_id = self.trace_id;
@@ -668,7 +665,7 @@ where
                 };
 
                 let mut resolver =
-                    Resolver::<B, T>::new(query, &their_version, &ledger, stats.clone());
+                    Resolver::<B>::new(query, &their_version, &ledger, stats.clone());
                 for reaction in replies {
                     let Some((prefix, radix, node, listing)) = resolver.react(reaction)? else {
                         continue;
diff --git a/src/tree/mirror/streaming/materialized/work/queues.rs b/src/tree/mirror/streaming/materialized/work/queues.rs
index fc1285e58..67a99cfbc 100644
--- a/src/tree/mirror/streaming/materialized/work/queues.rs
+++ b/src/tree/mirror/streaming/materialized/work/queues.rs
@@ -43,16 +43,15 @@ use crate::tree::{
 /// A blocked producer has already made one reply available to the counterparty,
 /// and consuming that reply is sufficient to release the producer. More slots
 /// retain whole messages without breaking another dependency.
-pub(super) fn outgoing_responses<B, T, H>() -> (
+pub(super) fn outgoing_responses<B, H>() -> (
     Sender<Result<Reply<B::Erased>, Error<B::Error>>>,
-    ReplyResultStream<B, T, H, Error<B::Error>>,
+    ReplyResultStream<B, H, Error<B::Error>>,
 )
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     H: Height,
 {
-    erased::reply_channel::<B, T, H, Error<B::Error>>(
+    erased::reply_channel::<B, H, Error<B::Error>>(
         QueueRole::new(QueueKind::OutgoingResponses, H::HEIGHT),
         1,
     )
@@ -82,15 +81,14 @@ where
 /// stall a session (`underbuffered_mirror_stalls` in the capacity tests
 /// demonstrates it), which is why the session window deliberately never
 /// reaches this constructor.
-pub(super) fn assembly_level_returns<B, T>(
+pub(super) fn assembly_level_returns<B>(
     height: usize,
 ) -> (
     Sender<Option<B::Erased>>,
     OkReceiverStream<Option<B::Erased>, Error<B::Error>>,
 )
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     ok_channel(QueueRole::new(QueueKind::AssemblyLevelReturns, height), FAN)
 }
@@ -99,10 +97,9 @@ where
 ///
 /// The opening emits exactly one query for the root scope, so a second slot
 /// can never be occupied.
-pub(super) fn initiator_root_query<B, T>() -> (Sender<Query<B::Erased>>, Receiver<Query<B::Erased>>)
+pub(super) fn initiator_root_query<B>() -> (Sender<Query<B::Erased>>, Receiver<Query<B::Erased>>)
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     channel(
         QueueRole::new(QueueKind::InitiatorRootQuery, UnderRoot::HEIGHT),
@@ -114,11 +111,9 @@ where
 ///
 /// Reconciliation produces exactly one root node and the terminal future
 /// consumes it directly.
-pub(super) fn initiator_root_return<B, T>()
--> (Sender<Option<B::Erased>>, Receiver<Option<B::Erased>>)
+pub(super) fn initiator_root_return<B>() -> (Sender<Option<B::Erased>>, Receiver<Option<B::Erased>>)
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     channel(
         QueueRole::new(QueueKind::InitiatorRootReturn, Root::HEIGHT),
@@ -133,12 +128,11 @@ where
 /// stage can hold a pipeline of disputed children in flight; each buffered
 /// [`Query`] may own a fan of node handles, which is priced by the window's
 /// node budget.
-pub(super) fn responder_child_queries<B, T>(
+pub(super) fn responder_child_queries<B>(
     capacity: usize,
 ) -> (Sender<Query<B::Erased>>, Receiver<Query<B::Erased>>)
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     channel(
         QueueRole::new(QueueKind::ResponderChildQueries, UnderUnderRoot::HEIGHT),
@@ -150,13 +144,12 @@ where
 ///
 /// The responder processes exactly one opening request and therefore
 /// publishes exactly one resolution for the root scope.
-pub(super) fn responder_root_resolution<B, T>() -> (
+pub(super) fn responder_root_resolution<B>() -> (
     Sender<Resolution<B::Erased>>,
     OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
 )
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     ok_channel(
         QueueRole::new(QueueKind::ResponderRootResolution, UnderRoot::HEIGHT),
@@ -169,13 +162,12 @@ where
 /// The root resolution is visible before its child queries are sent, so its
 /// assembler can consume each return as it arrives. No later return is needed
 /// to unlock the consumer of the buffered one.
-pub(super) fn responder_root_returns<B, T>() -> (
+pub(super) fn responder_root_returns<B>() -> (
     Sender<Option<B::Erased>>,
     OkReceiverStream<Option<B::Erased>, Error<B::Error>>,
 )
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     ok_channel(
         QueueRole::new(QueueKind::ResponderRootReturns, UnderRoot::HEIGHT),
@@ -192,13 +184,12 @@ where
 /// liveness floor. This queue is the in-flight question window itself: its
 /// occupancy is the number of disputed scopes awaiting wire replies at this
 /// height, so its capacity is what lets sibling scopes' round trips overlap.
-pub(super) fn internal_child_queries<B, T>(
+pub(super) fn internal_child_queries<B>(
     height: usize,
     capacity: usize,
 ) -> (Sender<Query<B::Erased>>, Receiver<Query<B::Erased>>)
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     channel(
         QueueRole::new(QueueKind::InternalChildQueries, height),
@@ -215,7 +206,7 @@ where
 /// `Pending` slots has been launched, so one slot is the liveness floor. But a
 /// resolution is consumed only as its subtree completes, so a one-slot edge
 /// stalls the walk two scopes in; the window lets it run ahead.
-pub(super) fn internal_parent_resolutions<B, T>(
+pub(super) fn internal_parent_resolutions<B>(
     height: usize,
     capacity: usize,
 ) -> (
@@ -223,8 +214,7 @@ pub(super) fn internal_parent_resolutions<B, T>(
     OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
 )
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     ok_channel(
         QueueRole::new(QueueKind::InternalParentResolutions, height),
@@ -240,7 +230,7 @@ where
 /// Each resolution is published before its corresponding child queries, so one
 /// slot is the liveness floor; the window lets the walk publish a pipeline of
 /// them while earlier subtrees are still reconciling.
-pub(super) fn internal_child_resolutions<B, T>(
+pub(super) fn internal_child_resolutions<B>(
     height: usize,
     capacity: usize,
 ) -> (
@@ -248,8 +238,7 @@ pub(super) fn internal_child_resolutions<B, T>(
     OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
 )
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     ok_channel(
         QueueRole::new(QueueKind::InternalChildResolutions, height),
@@ -272,15 +261,14 @@ pub(super) fn leaf_requests(capacity: usize) -> (Sender<Prefix<Z>>, Receiver<Pre
 /// All terminal work for a parent resolution has been launched before it is
 /// sent — the one-slot liveness floor; the window lets the walk run ahead while
 /// buffered resolutions wait on their leaf exchanges.
-pub(super) fn leaf_parent_resolutions<B, T>(
+pub(super) fn leaf_parent_resolutions<B>(
     capacity: usize,
 ) -> (
     Sender<Resolution<B::Erased>>,
     OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
 )
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     ok_channel(
         QueueRole::new(QueueKind::LeafParentResolutions, <S<Z>>::HEIGHT),
@@ -294,15 +282,14 @@ where
 /// Each resolution is published before its leaf requests — the one-slot
 /// liveness floor; the window keeps the walk publishing while earlier leaf
 /// scopes await their supplies.
-pub(super) fn leaf_child_resolutions<B, T>(
+pub(super) fn leaf_child_resolutions<B>(
     capacity: usize,
 ) -> (
     Sender<Resolution<B::Erased>>,
     OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
 )
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     ok_channel(
         QueueRole::new(QueueKind::LeafChildResolutions, Z::HEIGHT),
@@ -321,13 +308,12 @@ where
 /// scopes the memory model already charges, so no knob applies. (Contrast
 /// [`assembly_level_returns`], where one fan is a correctness floor rather
 /// than an amortization.)
-pub(super) fn terminal_leaf_resolutions<B, T>() -> (
+pub(super) fn terminal_leaf_resolutions<B>() -> (
     Sender<Resolution<B::Erased>>,
     OkReceiverStream<Resolution<B::Erased>, Error<B::Error>>,
 )
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     ok_channel(
         QueueRole::new(QueueKind::TerminalLeafResolutions, Z::HEIGHT),
diff --git a/src/tree/mirror/streaming/materialized/work/resolver.rs b/src/tree/mirror/streaming/materialized/work/resolver.rs
index a5359aa50..bd4a574e4 100644
--- a/src/tree/mirror/streaming/materialized/work/resolver.rs
+++ b/src/tree/mirror/streaming/materialized/work/resolver.rs
@@ -17,10 +17,9 @@ use crate::{
 /// One query's reaction loop: pairs the held children against the reply's
 /// reactions in order, accumulating the scope's [`Resolution`] and reporting
 /// each counterparty fault as its exact [`Violation`].
-pub struct Resolver<'v, B, T>
+pub struct Resolver<'v, B>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     prefix: ErasedPrefix,
     fan: Peekable<std::vec::IntoIter<(u8, B::Erased)>>,
@@ -39,10 +38,9 @@ where
     stats: Recorder,
 }
 
-impl<'v, B, T> Resolver<'v, B, T>
+impl<'v, B> Resolver<'v, B>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     pub fn new(
         Query { prefix, ours }: Query<B::Erased>,
diff --git a/src/tree/mirror/streaming/materialized/work/tests.rs b/src/tree/mirror/streaming/materialized/work/tests.rs
index 2b426af86..cd6539179 100644
--- a/src/tree/mirror/streaming/materialized/work/tests.rs
+++ b/src/tree/mirror/streaming/materialized/work/tests.rs
@@ -35,11 +35,11 @@ use crate::{
 
 /// The in-memory backend's erased node representation, which resolutions
 /// and level returns carry.
-type Erased = <Local as Backend<()>>::Erased;
+type Erased = <Local as Backend>::Erased;
 
 /// Erase one typed leaf the way the walk's payloads carry it.
 fn erased(node: typed::Node<Z>) -> Erased {
-    <Local as Backend<()>>::erase(node)
+    <Local as Backend>::erase(node)
 }
 
 /// A distinct leaf per call: the versions differ so hashes do.
@@ -67,7 +67,7 @@ fn parent_of(
     prefix: Prefix<S<Z>>,
     children: Vec<(u8, Option<typed::Node<Z>>)>,
 ) -> Option<typed::Node<S<Z>>> {
-    pollster::block_on(<Local as Backend<()>>::parent(Local, prefix, children))
+    pollster::block_on(<Local as Backend>::parent(Local, prefix, children))
         .unwrap_or_else(|e| match e {})
 }
 
@@ -77,7 +77,7 @@ type Level = Result<Option<Erased>, Error<Infallible>>;
 /// A work error cancels parked peers and retains its original error identity.
 #[test]
 fn work_failure_preempts_parked_tasks() {
-    let mut work: Work<Failing<Local>, ()> = Work::new(
+    let mut work: Work<Failing<Local>> = Work::new(
         Failing::after(Local, usize::MAX),
         Window::FLOOR,
         Recorder::default(),
@@ -108,7 +108,7 @@ fn assembled(
     level: Vec<Level>,
 ) -> Vec<Result<Option<Erased>, Error<Infallible>>> {
     pollster::block_on(
-        assemble::<Local, ()>(Local, stream::iter(resolutions), stream::iter(level))
+        assemble::<Local>(Local, stream::iter(resolutions), stream::iter(level))
             .collect::<Vec<_>>(),
     )
 }
@@ -215,17 +215,17 @@ fn chains_two_instances() {
         resolved: vec![(3, Resolve::Pending)],
     })];
 
-    let chained = assemble::<Local, ()>(
+    let chained = assemble::<Local>(
         Local,
         stream::iter(upper),
-        assemble::<Local, ()>(Local, stream::iter(lower), stream::empty()),
+        assemble::<Local>(Local, stream::iter(lower), stream::empty()),
     );
     let output =
         pollster::block_on(chained.try_collect::<Vec<_>>()).expect("no errors were fed in");
 
     let inner = parent_of(parent_prefix(3), vec![(1, Some(a)), (7, Some(b))])
         .expect("a non-empty all-real group constructs its parent");
-    let expected = pollster::block_on(<Local as Backend<()>>::parent(
+    let expected = pollster::block_on(<Local as Backend>::parent(
         Local,
         parent_prefix(3).pop().0,
         vec![(3, Some(inner))],
diff --git a/src/tree/mirror/streaming/materialized/work/tests/violations.rs b/src/tree/mirror/streaming/materialized/work/tests/violations.rs
index ff7d5d2ac..fa409eb76 100644
--- a/src/tree/mirror/streaming/materialized/work/tests/violations.rs
+++ b/src/tree/mirror/streaming/materialized/work/tests/violations.rs
@@ -28,7 +28,7 @@ use crate::{
 
 /// The in-memory backend's erased node representation, which the walk's
 /// query queues carry.
-type Erased = <Local as Backend<()>>::Erased;
+type Erased = <Local as Backend>::Erased;
 /// One deliberately malformed counterparty script and the exact violation it
 /// must surface.
 #[derive(Clone, Copy, Debug)]
@@ -102,7 +102,7 @@ fn violation_script<H>(
     injection: Injection,
     parent: u8,
     radixes: &BTreeSet<u8>,
-) -> (Option<Query<Erased>>, Vec<Reply<Local, (), H>>, Version)
+) -> (Option<Query<Erased>>, Vec<Reply<Local, H>>, Version)
 where
     H: TestHeight,
     S<H>: Height,
@@ -122,7 +122,7 @@ where
         prefix: prefix.erase(),
         ours: ours
             .iter()
-            .map(|(radix, node)| (*radix, <Local as Backend<()>>::erase(node.clone())))
+            .map(|(radix, node)| (*radix, <Local as Backend>::erase(node.clone())))
             .collect(),
     };
 
@@ -206,7 +206,7 @@ where
     H: Height,
     S<H>: Height,
 {
-    let (queries, queries_rx) = internal_child_queries::<Local, ()>(H::HEIGHT, 1);
+    let (queries, queries_rx) = internal_child_queries::<Local>(H::HEIGHT, 1);
     if let Some(query) = query {
         pollster::block_on(queries.send(query)).expect("the walk is live");
     }
@@ -216,8 +216,8 @@ where
 
 /// Drive a walk's response pump until it surfaces the injected violation.
 fn reported_violation<H: Height>(
-    work: Work<Local, ()>,
-    mut responses: BoxResponses<Local, (), H, Error<Infallible>>,
+    work: Work<Local>,
+    mut responses: BoxResponses<Local, H, Error<Infallible>>,
 ) -> Violation {
     let response = pollster::block_on(async move {
         let drive = work.execute(Box::pin(std::future::pending::<
diff --git a/src/tree/mirror/streaming/message.rs b/src/tree/mirror/streaming/message.rs
index 4f6e70706..5f7528026 100644
--- a/src/tree/mirror/streaming/message.rs
+++ b/src/tree/mirror/streaming/message.rs
@@ -144,9 +144,9 @@ pub(crate) fn initiates(
 }
 
 /// The sole stream message.
-pub struct Reply<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height> {
+pub struct Reply<B: Backend<Node<Z>: Leaf>, H: Height> {
     /// The reactions to a single previous query.
-    pub replies: Vec<Reaction<B, T, H>>,
+    pub replies: Vec<Reaction<B, H>>,
 }
 
 /// Reactions are positionally keyed against the corresponding
@@ -155,7 +155,7 @@ pub struct Reply<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: H
 /// The exception is [`Reaction::Supply`], which indicates its radix because
 /// it represents information that the counterparty could not have known to
 /// ask about.
-pub enum Reaction<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height> {
+pub enum Reaction<B: Backend<Node<Z>: Leaf>, H: Height> {
     /// Having inferred that the counterparty lacks this node through its
     /// absence in the counterparty's listing of hashes, we provide it, at
     /// this radix.
diff --git a/src/tree/mirror/streaming/protocol.rs b/src/tree/mirror/streaming/protocol.rs
index a1d67c7ba..88e8aa1b4 100644
--- a/src/tree/mirror/streaming/protocol.rs
+++ b/src/tree/mirror/streaming/protocol.rs
@@ -31,36 +31,30 @@ pub trait Protocol: Send {
 }
 
 /// Trait synonym: non-erroring message streams, the shape of incoming streams.
-pub trait Requests<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height>:
-    Stream<Item = message::Reply<B, T, H>> + Send + 'static
+pub trait Requests<B: Backend<Node<Z>: Leaf>, H: Height>:
+    Stream<Item = message::Reply<B, H>> + Send + 'static
 {
 }
-impl<X, B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height> Requests<B, T, H>
-    for X
-where
-    X: Stream<Item = message::Reply<B, T, H>> + Send + 'static,
+impl<X, B: Backend<Node<Z>: Leaf>, H: Height> Requests<B, H> for X where
+    X: Stream<Item = message::Reply<B, H>> + Send + 'static
 {
 }
 
 /// Trait synonym: fallible message streams, the shape of outgoing streams.
-pub trait Responses<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height, E>:
-    Stream<Item = Result<message::Reply<B, T, H>, E>> + Send + 'static
+pub trait Responses<B: Backend<Node<Z>: Leaf>, H: Height, E>:
+    Stream<Item = Result<message::Reply<B, H>, E>> + Send + 'static
 {
 }
-impl<X, B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static, H: Height, E>
-    Responses<B, T, H, E> for X
-where
-    X: Stream<Item = Result<message::Reply<B, T, H>, E>> + Send + 'static,
+impl<X, B: Backend<Node<Z>: Leaf>, H: Height, E> Responses<B, H, E> for X where
+    X: Stream<Item = Result<message::Reply<B, H>, E>> + Send + 'static
 {
 }
 
 /// A boxed [`Responses`] stream.
-pub type BoxResponses<B, T, H, E> = Pin<Box<dyn Responses<B, T, H, E>>>;
+pub type BoxResponses<B, H, E> = Pin<Box<dyn Responses<B, H, E>>>;
 
-pub trait Connect<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
-    Protocol<Height = Root> + Sized
-{
-    type Next: CompleteConnect<B, T>
+pub trait Connect<B: Backend<Node<Z>: Leaf>>: Protocol<Height = Root> + Sized {
+    type Next: CompleteConnect<B>
         + Protocol<Height = Root, Output = Self::Output, Error = Self::Error>;
 
     fn connect(
@@ -68,12 +62,10 @@ pub trait Connect<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
     ) -> impl Future<Output = Result<(message::Greeting, Self::Next), Self::Error>> + Send;
 }
 
-pub trait Accept<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
-    Protocol<Height = Root> + Sized
-{
-    type Next: CompleteEqual<B, T>
-        + Initiator<B, T>
-        + Responder<B, T>
+pub trait Accept<B: Backend<Node<Z>: Leaf>>: Protocol<Height = Root> + Sized {
+    type Next: CompleteEqual<B>
+        + Initiator<B>
+        + Responder<B>
         + Protocol<Height = Root, Output = Self::Output, Error = Self::Error>;
 
     fn accept(
@@ -82,12 +74,10 @@ pub trait Accept<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
     ) -> impl Future<Output = Result<(message::Greeting, Self::Next), Self::Error>> + Send;
 }
 
-pub trait CompleteConnect<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
-    Protocol<Height = Root> + Sized
-{
-    type Next: CompleteEqual<B, T>
-        + Initiator<B, T>
-        + Responder<B, T>
+pub trait CompleteConnect<B: Backend<Node<Z>: Leaf>>: Protocol<Height = Root> + Sized {
+    type Next: CompleteEqual<B>
+        + Initiator<B>
+        + Responder<B>
         + Protocol<Height = Root, Output = Self::Output, Error = Self::Error>;
 
     fn complete_connect(
@@ -102,9 +92,7 @@ pub trait CompleteConnect<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'sta
 /// must still be converted into its normal output. A materialized state returns
 /// the root it already holds; a remote proxy returns its transport halves so
 /// the caller can continue with trailing session frames.
-pub trait CompleteEqual<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
-    Protocol<Height = Root> + Sized
-{
+pub trait CompleteEqual<B: Backend<Node<Z>: Leaf>>: Protocol<Height = Root> + Sized {
     fn complete_equal(self) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send;
 }
 
@@ -119,9 +107,7 @@ pub trait CompleteEqual<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'stati
 /// wire that makes this stage free: the remote proxy replays the greeting's
 /// listing instead of spending a hop on a standalone opening frame, and only
 /// the in-process message below actually flows.
-pub trait Initiator<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
-    Protocol<Height = Root> + Sized
-{
+pub trait Initiator<B: Backend<Node<Z>: Leaf>>: Protocol<Height = Root> + Sized {
     type Next: Protocol<Height = UnderRoot, Output = Self::Output, Error = Self::Error>;
 
     fn initiator(
@@ -129,14 +115,12 @@ pub trait Initiator<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
     ) -> (
         // IMPORTANT: This must be boxed because otherwise `rustc` explodes on
         // an exponentially-sized type!
-        BoxResponses<B, T, UnderRoot, Self::Error>,
+        BoxResponses<B, UnderRoot, Self::Error>,
         Self::Next,
     );
 }
 
-pub trait Responder<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
-    Protocol<Height = Root> + Sized
-{
+pub trait Responder<B: Backend<Node<Z>: Leaf>>: Protocol<Height = Root> + Sized {
     // Like [`Initiator::Next`], this is left un-bounded by [`Reply`]: both
     // openings hand off to the descent, but only [`Peer`] spells the chain out.
     // Naming `Reply` here instead would make it a bound `Accept::Next` and
@@ -146,11 +130,11 @@ pub trait Responder<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
 
     fn responder(
         self,
-        requests: impl Requests<B, T, UnderRoot>,
+        requests: impl Requests<B, UnderRoot>,
     ) -> (
         // IMPORTANT: This must be boxed because otherwise `rustc` explodes on
         // an exponentially-sized type!
-        BoxResponses<B, T, UnderRoot, Self::Error>,
+        BoxResponses<B, UnderRoot, Self::Error>,
         Self::Next,
     );
 }
@@ -176,9 +160,7 @@ where
     type Next = H;
 }
 
-pub trait Reply<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
-    Protocol<Height: ReplyHeight> + Sized
-{
+pub trait Reply<B: Backend<Node<Z>: Leaf>>: Protocol<Height: ReplyHeight> + Sized {
     type Next: Protocol<
             Height = <Self::Height as ReplyHeight>::Next,
             Output = Self::Output,
@@ -187,11 +169,11 @@ pub trait Reply<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
 
     fn reply(
         self,
-        requests: impl Requests<B, T, Self::Height>,
+        requests: impl Requests<B, Self::Height>,
     ) -> (
         // IMPORTANT: This must be boxed because otherwise `rustc` explodes on
         // an exponentially-sized type!
-        BoxResponses<B, T, <Self::Height as ReplyHeight>::Output, Self::Error>,
+        BoxResponses<B, <Self::Height as ReplyHeight>::Output, Self::Error>,
         Self::Next,
     );
 }
@@ -201,25 +183,21 @@ pub trait Reply<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
 ///
 /// Each requested leaf is answered pruned against the initiator's version,
 /// so a leaf the initiator deleted drops here instead of shipping.
-pub trait CompleteResponder<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
-    Protocol<Height = Z> + Sized
-{
+pub trait CompleteResponder<B: Backend<Node<Z>: Leaf>>: Protocol<Height = Z> + Sized {
     fn complete_responder(
         self,
-        requests: impl Requests<B, T, Z>,
+        requests: impl Requests<B, Z>,
     ) -> (
-        BoxResponses<B, T, Z, Self::Error>,
+        BoxResponses<B, Z, Self::Error>,
         impl Future<Output = Result<Self::Output, Self::Error>> + Send,
     );
 }
 
 /// The initiator's terminal: absorb the responder's final leaf replies and
 /// resolve to the reconciled root.
-pub trait CompleteInitiator<B: Backend<T, Node<Z>: Leaf<T>>, T: Send + Sync + 'static>:
-    Protocol<Height = Z> + Sized
-{
+pub trait CompleteInitiator<B: Backend<Node<Z>: Leaf>>: Protocol<Height = Z> + Sized {
     fn complete_initiator(
         self,
-        requests: impl Requests<B, T, Z>,
+        requests: impl Requests<B, Z>,
     ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send;
 }
diff --git a/src/tree/mirror/streaming/protocol/peer.rs b/src/tree/mirror/streaming/protocol/peer.rs
index ed981f67d..3533d9328 100644
--- a/src/tree/mirror/streaming/protocol/peer.rs
+++ b/src/tree/mirror/streaming/protocol/peer.rs
@@ -18,8 +18,8 @@ macro_rules! define_peer {
         define_peer!(@step
             init: [$($init_count)*],
             resp: [$($resp_count)*],
-            init_chain: (Reply<I, T, Next: CompleteInitiator<I, T>>),
-            resp_chain: (Reply<I, T, Next: CompleteResponder<I, T>>),
+            init_chain: (Reply<I, Next: CompleteInitiator<I>>),
+            resp_chain: (Reply<I, Next: CompleteResponder<I>>),
         );
     };
 
@@ -32,7 +32,7 @@ macro_rules! define_peer {
         define_peer!(@step
             init: [$($init_rest)*],
             resp: [$($resp_count)*],
-            init_chain: (Reply<I, T, Next: $($init_chain)*>),
+            init_chain: (Reply<I, Next: $($init_chain)*>),
             resp_chain: ($($resp_chain)*),
         );
     };
@@ -47,7 +47,7 @@ macro_rules! define_peer {
             init: [],
             resp: [$($resp_rest)*],
             init_chain: ($($init_chain)*),
-            resp_chain: (Reply<I, T, Next: $($resp_chain)*>),
+            resp_chain: (Reply<I, Next: $($resp_chain)*>),
         );
     };
 
@@ -57,55 +57,49 @@ macro_rules! define_peer {
         init_chain: ($($init_chain:tt)*),
         resp_chain: ($($resp_chain:tt)*) $(,)?
     ) => {
-        pub trait Peer<I, T>:
-            CompleteEqual<I, T>
-            + Initiator<I, T, Next: $($init_chain)*>
-            + Responder<I, T, Next: $($resp_chain)*>
+        pub trait Peer<I>:
+            CompleteEqual<I>
+            + Initiator<I, Next: $($init_chain)*>
+            + Responder<I, Next: $($resp_chain)*>
         where
-            I: Backend<T, Node<Z>: Leaf<T>>,
-            T: Send + Sync + 'static,
-        {
+            I: Backend<Node<Z>: Leaf>,
+                    {
         }
 
-        impl<X, I, T> Peer<I, T> for X
+        impl<X, I> Peer<I> for X
         where
-            I: Backend<T, Node<Z>: Leaf<T>>,
-            T: Send + Sync + 'static,
-            X: CompleteEqual<I, T>
-                + Initiator<I, T, Next: $($init_chain)*>
-                + Responder<I, T, Next: $($resp_chain)*>,
+            I: Backend<Node<Z>: Leaf>,
+                        X: CompleteEqual<I>
+                + Initiator<I, Next: $($init_chain)*>
+                + Responder<I, Next: $($resp_chain)*>,
         {
         }
 
-        pub trait Server<I, T>:
-            Accept<I, T, Next: Initiator<I, T, Next: $($init_chain)*> + Responder<I, T, Next: $($resp_chain)*>>
+        pub trait Server<I>:
+            Accept<I, Next: Initiator<I, Next: $($init_chain)*> + Responder<I, Next: $($resp_chain)*>>
         where
-            I: Backend<T, Node<Z>: Leaf<T>>,
-            T: Send + Sync + 'static,
-        {
+            I: Backend<Node<Z>: Leaf>,
+                    {
         }
 
-        impl<X, I, T> Server<I, T> for X
+        impl<X, I> Server<I> for X
         where
-            I: Backend<T, Node<Z>: Leaf<T>>,
-            T: Send + Sync + 'static,
-            X: Accept<I, T, Next: Initiator<I, T, Next: $($init_chain)*> + Responder<I, T, Next: $($resp_chain)*>>,
+            I: Backend<Node<Z>: Leaf>,
+                        X: Accept<I, Next: Initiator<I, Next: $($init_chain)*> + Responder<I, Next: $($resp_chain)*>>,
         {
         }
 
-        pub trait Client<I, T>:
-            Connect<I, T, Next: CompleteConnect<I, T, Next: Initiator<I, T, Next: $($init_chain)*> + Responder<I, T, Next: $($resp_chain)*>>>
+        pub trait Client<I>:
+            Connect<I, Next: CompleteConnect<I, Next: Initiator<I, Next: $($init_chain)*> + Responder<I, Next: $($resp_chain)*>>>
         where
-            I: Backend<T, Node<Z>: Leaf<T>>,
-            T: Send + Sync + 'static,
-        {
+            I: Backend<Node<Z>: Leaf>,
+                    {
         }
 
-        impl<X, I, T> Client<I, T> for X
+        impl<X, I> Client<I> for X
         where
-            I: Backend<T, Node<Z>: Leaf<T>>,
-            T: Send + Sync + 'static,
-            X: Connect<I, T, Next: CompleteConnect<I, T, Next: Initiator<I, T, Next: $($init_chain)*> + Responder<I, T, Next: $($resp_chain)*>>>,
+            I: Backend<Node<Z>: Leaf>,
+                        X: Connect<I, Next: CompleteConnect<I, Next: Initiator<I, Next: $($init_chain)*> + Responder<I, Next: $($resp_chain)*>>>,
         {
         }
     };
diff --git a/src/tree/mirror/streaming/remote/adapter.rs b/src/tree/mirror/streaming/remote/adapter.rs
index 98297f47f..7b0ff35c7 100644
--- a/src/tree/mirror/streaming/remote/adapter.rs
+++ b/src/tree/mirror/streaming/remote/adapter.rs
@@ -9,8 +9,8 @@
 //! between them:
 //!
 //! ```text
-//! Reply<B, T, H> -- encode + explode --> Frame<T> leaves
-//! Reply<B, T, H> <-- decode + assemble -- Frame<T> leaves
+//! Reply<B, H> -- encode + explode --> Frame leaves
+//! Reply<B, H> <-- decode + assemble -- Frame leaves
 //! ```
 //!
 //! # Recovering omitted scope
diff --git a/src/tree/mirror/streaming/remote/adapter/decode.rs b/src/tree/mirror/streaming/remote/adapter/decode.rs
index 819e637af..a7b82e413 100644
--- a/src/tree/mirror/streaming/remote/adapter/decode.rs
+++ b/src/tree/mirror/streaming/remote/adapter/decode.rs
@@ -1,3 +1,4 @@
+use crate::message::PayloadDeserializer;
 use std::pin::pin;
 use std::task::Poll;
 
@@ -23,7 +24,6 @@ use super::{
     scope::Scope,
 };
 
-use serde::de::DeserializeOwned;
 /// One reconstructed reply and any questions it asks next.
 pub struct Decoded<E, Q> {
     pub reply: Reply<E>,
@@ -65,17 +65,17 @@ pub fn opening_reply<E>(listing: Vec<(u8, Hash)>) -> (Reply<E>, Scope) {
 /// [`DecodeError::OversizedVersion`] session violation. `ledger` is the
 /// session's declared-`set_len` allowance, charged per record before the
 /// payload takes custody ([`DecodeError::OverdrawnSupply`]).
-pub fn early_supplies<B, T, F>(
+pub fn early_supplies<B, F>(
     backend: B,
     version_bytes: u64,
     ledger: SupplyLedger,
     parent: ErasedPrefix,
     frames: F,
+    deserializer: PayloadDeserializer,
 ) -> impl Stream<Item = Result<(u8, B::Erased), DecodeError<B::Error>>> + Send
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
-    F: Stream<Item = Frame<T>> + Unpin + Send + 'static,
+    B: Backend<Node<Z>: Leaf>,
+    F: Stream<Item = Frame> + Unpin + Send + 'static,
 {
     try_stream! {
         // The same reader/assembler split as `decode`, driven jointly so
@@ -84,18 +84,19 @@ where
         let leaves = ReceiverStream::new(rx);
         #[cfg(test)]
         let leaves = leaves.inspect(|_| fan_probe::on_recv());
-        let leaves: BoxNodeStream<'static, B, T, Z> = Box::pin(leaves);
+        let leaves: BoxNodeStream<'static, B, Z> = Box::pin(leaves);
         let mut assembled = pin!(ops::assemble(
             backend.clone(),
             parent.height() - 1,
             leaves
         ));
-        let mut read = pin!(read_early::<B, T, _>(
+        let mut read = pin!(read_early::<B, _>(
             version_bytes,
             &ledger,
             parent,
             frames,
-            tx
+            tx,
+            deserializer,
         ));
         let mut read_result: Option<Result<(), DecodeError<B::Error>>> = None;
         loop {
@@ -132,17 +133,17 @@ where
 
 /// Read the opening-supply reply's frames — supplies only, one reply,
 /// nothing after it — streaming its leaves to assembly.
-async fn read_early<B, T, F>(
+async fn read_early<B, F>(
     version_bytes: u64,
     ledger: &SupplyLedger,
     parent: ErasedPrefix,
     mut frames: F,
     leaves: mpsc::Sender<Result<(Prefix<Z>, B::Node<Z>), B::Error>>,
+    deserializer: PayloadDeserializer,
 ) -> Result<(), DecodeError<B::Error>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
-    F: Stream<Item = Frame<T>> + Unpin,
+    B: Backend<Node<Z>: Leaf>,
+    F: Stream<Item = Frame> + Unpin,
 {
     let mut supplies = SupplyRuns::new(version_bytes);
     let mut any = false;
@@ -153,7 +154,7 @@ where
         let flow = match frame {
             Frame::Reaction(WireReaction::Supply(records), flow) => {
                 any = true;
-                for record in records.records() {
+                for record in records.records(deserializer) {
                     let (version, message) = record.map_err(DecodeError::Record)?;
                     let (leaf_prefix, _) = supplies.observe::<B::Error>(parent, &version)?;
                     // The set-length half of the greeting's priced
@@ -164,7 +165,7 @@ where
                     ledger
                         .charge(1)
                         .map_err(|declared| DecodeError::OverdrawnSupply { declared })?;
-                    let leaf = <B::Node<Z> as Leaf<T>>::leaf(version, message)
+                    let leaf = <B::Node<Z> as Leaf>::leaf(version, message)
                         .await
                         .map_err(DecodeError::Backend)?;
                     #[cfg(test)]
@@ -199,17 +200,17 @@ where
 }
 
 /// Decode one non-leaf reply and derive the lower questions it asks.
-pub async fn decode_reply<B, T, F>(
+pub async fn decode_reply<B, F>(
     backend: B,
     version_bytes: u64,
     ledger: SupplyLedger,
     scope: Scope,
     frames: &mut F,
+    deserializer: PayloadDeserializer,
 ) -> Result<Decoded<B::Erased, Vec<Scope>>, DecodeError<B::Error>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
-    F: Stream<Item = Frame<T>> + Unpin,
+    B: Backend<Node<Z>: Leaf>,
+    F: Stream<Item = Frame> + Unpin,
 {
     decode(
         backend,
@@ -221,22 +222,23 @@ where
             let (_, prefix) = scope.next().ok_or(ScopeError::UnpositionedQuery)?;
             Ok(Scope::new(prefix, listing))
         },
+        deserializer,
     )
     .await
 }
 
 /// Decode one leaf-height reply, where only an empty request for the leaf is valid.
-pub async fn decode_leaf_reply<B, T, F>(
+pub async fn decode_leaf_reply<B, F>(
     backend: B,
     version_bytes: u64,
     ledger: SupplyLedger,
     scope: Scope,
     frames: &mut F,
+    deserializer: PayloadDeserializer,
 ) -> Result<Decoded<B::Erased, Vec<Scope>>, DecodeError<B::Error>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
-    F: Stream<Item = Frame<T>> + Unpin,
+    B: Backend<Node<Z>: Leaf>,
+    F: Stream<Item = Frame> + Unpin,
 {
     decode(
         backend,
@@ -251,22 +253,23 @@ where
             let (_, prefix) = scope.next().ok_or(ScopeError::UnpositionedQuery)?;
             Ok(Scope::leaf(prefix))
         },
+        deserializer,
     )
     .await
 }
 
-async fn decode<B, T, F, Q, N>(
+async fn decode<B, F, Q, N>(
     backend: B,
     version_bytes: u64,
     ledger: SupplyLedger,
     scope: Scope,
     frames: &mut F,
     question: Q,
+    deserializer: PayloadDeserializer,
 ) -> Result<Decoded<B::Erased, Vec<N>>, DecodeError<B::Error>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
-    F: Stream<Item = Frame<T>> + Unpin,
+    B: Backend<Node<Z>: Leaf>,
+    F: Stream<Item = Frame> + Unpin,
     Q: FnMut(&mut Scope, &[(u8, Hash)]) -> Result<N, ScopeError>,
 {
     // The reply's supplied runs group into nodes one level under the
@@ -283,8 +286,16 @@ where
     // reader's hand per reply stream, at `node_bytes(0, version_bound)`
     // plus the slot itself (the window's supply-decode envelope).
     let (tx, rx) = mpsc::channel::<Result<(Prefix<Z>, B::Node<Z>), B::Error>>(FAN);
-    let read = read_reply::<B, T, _, _, _>(version_bytes, &ledger, scope, frames, question, tx);
-    let assemble = assemble_supplies::<B, T>(backend, children_height, rx);
+    let read = read_reply::<B, _, _, _>(
+        version_bytes,
+        &ledger,
+        scope,
+        frames,
+        question,
+        tx,
+        deserializer,
+    );
+    let assemble = assemble_supplies::<B>(backend, children_height, rx);
     let (read, assembled) = futures::future::join(read, assemble).await;
     let Some(ReadReply {
         skeleton,
@@ -300,18 +311,18 @@ where
 }
 
 /// Read and validate exactly one reply while streaming its leaves to assembly.
-async fn read_reply<B, T, F, Q, N>(
+async fn read_reply<B, F, Q, N>(
     version_bytes: u64,
     ledger: &SupplyLedger,
     mut scope: Scope,
     frames: &mut F,
     mut question: Q,
     leaves: mpsc::Sender<Result<(Prefix<Z>, B::Node<Z>), B::Error>>,
+    deserializer: PayloadDeserializer,
 ) -> Result<Option<ReadReply<N>>, DecodeError<B::Error>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
-    F: Stream<Item = Frame<T>> + Unpin,
+    B: Backend<Node<Z>: Leaf>,
+    F: Stream<Item = Frame> + Unpin,
     Q: FnMut(&mut Scope, &[(u8, Hash)]) -> Result<N, ScopeError>,
 {
     let mut read = ReadReply::new(version_bytes);
@@ -353,7 +364,7 @@ where
                 // Records leave the run one at a time and flow straight into
                 // assembly: the whole-run bound is its encoded bytes, never a
                 // decoded vector of leaves.
-                for record in records.records() {
+                for record in records.records(deserializer) {
                     let (version, message) = record.map_err(DecodeError::Record)?;
                     let (leaf_prefix, run) = read
                         .supplies
@@ -369,7 +380,7 @@ where
                     ledger
                         .charge(1)
                         .map_err(|declared| DecodeError::OverdrawnSupply { declared })?;
-                    let leaf = <B::Node<Z> as Leaf<T>>::leaf(version, message)
+                    let leaf = <B::Node<Z> as Leaf>::leaf(version, message)
                         .await
                         .map_err(DecodeError::Backend)?;
                     #[cfg(test)]
@@ -390,19 +401,18 @@ where
 
 /// Fold the reply's one-slot leaf stream into complete nodes at the
 /// scope's children height.
-async fn assemble_supplies<B, T>(
+async fn assemble_supplies<B>(
     backend: B,
     height: usize,
     leaves: mpsc::Receiver<Result<(Prefix<Z>, B::Node<Z>), B::Error>>,
 ) -> Result<Vec<(ErasedPrefix, B::Erased)>, DecodeError<B::Error>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     let leaves = ReceiverStream::new(leaves);
     #[cfg(test)]
     let leaves = leaves.inspect(|_| fan_probe::on_recv());
-    let leaves: BoxNodeStream<'static, B, T, Z> = Box::pin(leaves);
+    let leaves: BoxNodeStream<'static, B, Z> = Box::pin(leaves);
     let mut assembled = pin!(ops::assemble(backend, height, leaves));
     let mut nodes = Vec::new();
     while let Some(item) = assembled.next().await {
diff --git a/src/tree/mirror/streaming/remote/adapter/encode.rs b/src/tree/mirror/streaming/remote/adapter/encode.rs
index f966c1520..3301c7a1a 100644
--- a/src/tree/mirror/streaming/remote/adapter/encode.rs
+++ b/src/tree/mirror/streaming/remote/adapter/encode.rs
@@ -18,16 +18,16 @@ use super::{
 };
 
 /// A wire frame and the lower question it makes publishable once written.
-pub struct Encoded<T, Q> {
-    frame: Frame<T>,
+pub struct Encoded<Q> {
+    frame: Frame,
     question: Option<Q>,
 }
 
-impl<T, Q> Encoded<T, Q> {
+impl<Q> Encoded<Q> {
     /// Write this frame and release its question only after a successful write.
     pub async fn write_with<E, W, F>(self, write: W) -> Result<Option<Q>, E>
     where
-        W: FnOnce(Frame<T>) -> F,
+        W: FnOnce(Frame) -> F,
         F: Future<Output = Result<(), E>>,
     {
         let Self { frame, question } = self;
@@ -36,14 +36,13 @@ impl<T, Q> Encoded<T, Q> {
     }
 
     #[cfg(test)]
-    pub fn into_parts(self) -> (Frame<T>, Option<Q>) {
+    pub fn into_parts(self) -> (Frame, Option<Q>) {
         (self.frame, self.question)
     }
 }
 
 /// A fallible stream containing the wire frames of one protocol reply.
-pub type Frames<T, E, Q> =
-    Pin<Box<dyn Stream<Item = Result<Encoded<T, Q>, EncodeError<E>>> + Send>>;
+pub type Frames<E, Q> = Pin<Box<dyn Stream<Item = Result<Encoded<Q>, EncodeError<E>>> + Send>>;
 
 /// Validate the initiator's distinguished opening reply and split it into
 /// its question's listing and its early whole-subtree supplies.
@@ -78,15 +77,14 @@ pub fn opening_parts<E>(
 }
 
 /// Encode one non-leaf reply and derive the lower questions it asks.
-pub fn encode_reply<B, T>(
+pub fn encode_reply<B>(
     backend: B,
     budget: RunBudget,
     scope: Scope,
     reply: Reply<B::Erased>,
-) -> Frames<T, B::Error, Scope>
+) -> Frames<B::Error, Scope>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     render(
         backend,
@@ -110,15 +108,14 @@ where
 }
 
 /// Encode one leaf-height reply, where only an empty request for the leaf is valid.
-pub fn encode_leaf_reply<B, T>(
+pub fn encode_leaf_reply<B>(
     backend: B,
     budget: RunBudget,
     scope: Scope,
     reply: Reply<B::Erased>,
-) -> Frames<T, B::Error, Scope>
+) -> Frames<B::Error, Scope>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     render(
         backend,
@@ -144,16 +141,15 @@ where
     )
 }
 
-fn render<B, T, D>(
+fn render<B, D>(
     backend: B,
     budget: RunBudget,
     mut scope: Scope,
     reply: Reply<B::Erased>,
     mut derive: D,
-) -> Frames<T, B::Error, Scope>
+) -> Frames<B::Error, Scope>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     D: FnMut(&mut Scope, &ProtocolReaction<B::Erased>) -> Result<Option<Scope>, ScopeError>
         + Send
         + 'static,
@@ -210,7 +206,7 @@ where
                         let message = leaf.message();
                         if !run.is_empty()
                             && !budget
-                                .admits(run.encoded_len(), LeafRun::<T>::record_len(version, message))
+                                .admits(run.encoded_len(), LeafRun::record_len(version, message))
                         {
                             let full = mem::take(&mut run);
                             if let Some((ready, question)) =
diff --git a/src/tree/mirror/streaming/remote/adapter/tests.rs b/src/tree/mirror/streaming/remote/adapter/tests.rs
index 0e9251e8b..662fc575f 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests.rs
@@ -39,7 +39,7 @@ fn unbounded() -> SupplyLedger {
 }
 
 /// Build a supply run from borrowed leaf records, in the given order.
-fn leaf_run<T>(records: &[(&Version, &Message)]) -> LeafRun<T> {
+fn leaf_run(records: &[(&Version, &Message)]) -> LeafRun {
     let mut run = LeafRun::new();
     for (version, message) in records {
         run.push(version, message)
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/backend_errors.rs b/src/tree/mirror/streaming/remote/adapter/tests/backend_errors.rs
index 3cae2c57d..017244da9 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/backend_errors.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/backend_errors.rs
@@ -1,5 +1,6 @@
 //! Source-error propagation across every backend operation reachable by the adapter.
 
+use crate::message::Message;
 use std::convert::Infallible;
 
 use futures::{StreamExt, stream};
@@ -68,8 +69,7 @@ where
 
         for fail_after in 0..Self::HEIGHT {
             let backend = Failing::after(Local, fail_after);
-            let supply =
-                <Failing<Local> as Backend<u64>>::erase(FailingNode::new(Self::node(leaf)));
+            let supply = <Failing<Local> as Backend>::erase(FailingNode::new(Self::node(leaf)));
             let replies = if supply_radix < u8::MAX {
                 vec![
                     Reaction::Supply(supply_radix, supply),
@@ -81,7 +81,7 @@ where
                     Reaction::Supply(supply_radix, supply),
                 ]
             };
-            let mut encoded = encode_reply::<_, u64>(
+            let mut encoded = encode_reply(
                 backend.clone(),
                 RunBudget::default(),
                 Scope::new(parent.erase(), &listing),
@@ -130,12 +130,13 @@ where
                 sentinel.clone(),
             ]);
             let error = runtime
-                .block_on(decode_reply::<Failing<Local>, u64, _>(
+                .block_on(decode_reply::<Failing<Local>, _>(
                     backend.clone(),
                     u64::MAX,
                     unbounded(),
                     Scope::new(parent.erase(), &[]),
                     &mut frames,
+                    Message::deserializer::<u64>(),
                 ))
                 .err()
                 .expect("the injected decoding failure was not reached");
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/fan_occupancy.rs b/src/tree/mirror/streaming/remote/adapter/tests/fan_occupancy.rs
index f641abad5..2fb909aaa 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/fan_occupancy.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/fan_occupancy.rs
@@ -51,7 +51,7 @@ fn leaves(count: u64) -> Vec<(Version, Message)> {
 }
 
 /// Chunk leaves into supply frames of [`PER_FRAME`] records each.
-fn frames(leaves: &[(Version, Message)]) -> Vec<Frame<u64>> {
+fn frames(leaves: &[(Version, Message)]) -> Vec<Frame> {
     let chunks: Vec<&[(Version, Message)]> = leaves.chunks(PER_FRAME).collect();
     let count = chunks.len();
     chunks
@@ -75,16 +75,17 @@ fn frames(leaves: &[(Version, Message)]) -> Vec<Frame<u64>> {
 
 /// Decode one pure-supply reply from `input` over the instant in-memory
 /// backend, reporting the probe's peak resident record count.
-fn peak_occupancy(mut input: impl Stream<Item = Frame<u64>> + Unpin) -> usize {
+fn peak_occupancy(mut input: impl Stream<Item = Frame> + Unpin) -> usize {
     let runtime = super::runtime();
     fan_probe::reset();
     runtime.block_on(async {
-        decode_reply::<Local, u64, _>(
+        decode_reply::<Local, _>(
             Local,
             u64::MAX,
             unbounded(),
             Scope::opening(&[]),
             &mut input,
+            Message::deserializer::<u64>(),
         )
         .await
         .expect("ascending in-scope leaves assemble");
@@ -131,12 +132,13 @@ fn eager_early_supplies_ride_the_same_ceiling() {
     let runtime = super::runtime();
     fan_probe::reset();
     runtime.block_on(async {
-        let assembled: Vec<_> = early_supplies::<Local, u64, _>(
+        let assembled: Vec<_> = early_supplies::<Local, _>(
             Local,
             u64::MAX,
             unbounded(),
             Prefix::new().erase(),
             stream::iter(frames(&leaves)),
+            Message::deserializer::<u64>(),
         )
         .try_collect()
         .await
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs b/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs
index d8f5841e0..2337f049a 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/malformed.rs
@@ -33,7 +33,7 @@ use crate::tree::mirror::streaming::remote::codec::{
 fn bare_end_cannot_follow_reactions() {
     let path = Path::for_leaf(&Version::new());
     let parent = Prefix::<S<Z>>::containing(&path);
-    let frames: Vec<Frame<()>> = vec![
+    let frames: Vec<Frame> = vec![
         Frame::Reaction(WireReaction::Match, Flow::Continue),
         Frame::End(End::Reply),
     ];
@@ -46,6 +46,7 @@ fn bare_end_cannot_follow_reactions() {
             unbounded(),
             Scope::new(parent.erase(), &[(0, hash(0))]),
             &mut frames,
+            Message::deserializer::<u64>(),
         )
         .await
         .err()
@@ -59,7 +60,7 @@ fn bare_end_cannot_follow_reactions() {
 fn stream_exhaustion_before_a_boundary_is_truncation() {
     let path = Path::for_leaf(&Version::new());
     let parent = Prefix::<S<Z>>::containing(&path);
-    let mut frames = stream::iter([Frame::<()>::Reaction(WireReaction::Match, Flow::Continue)]);
+    let mut frames = stream::iter([Frame::Reaction(WireReaction::Match, Flow::Continue)]);
 
     let error = runtime().block_on(async {
         decode_leaf_reply(
@@ -68,6 +69,7 @@ fn stream_exhaustion_before_a_boundary_is_truncation() {
             unbounded(),
             Scope::new(parent.erase(), &[(0, hash(0))]),
             &mut frames,
+            Message::deserializer::<u64>(),
         )
         .await
         .err()
@@ -88,19 +90,20 @@ fn an_unpositioned_match_is_rejected_in_both_directions() {
     let parent = Prefix::<S<S<Z>>>::containing(&path);
     // One listed child admits one positional reaction; the second Match
     // must fail at its own frame with the reply still unterminated.
-    let frames: Vec<Frame<()>> = vec![
+    let frames: Vec<Frame> = vec![
         Frame::Reaction(WireReaction::Match, Flow::Continue),
         Frame::Reaction(WireReaction::Match, Flow::Continue),
     ];
 
     let decode_error = runtime().block_on(async {
         let mut frames = stream::iter(frames);
-        decode_reply::<Local, (), _>(
+        decode_reply::<Local, _>(
             Local,
             u64::MAX,
             unbounded(),
             Scope::new(parent.erase(), &[(1, hash(1))]),
             &mut frames,
+            Message::deserializer::<u64>(),
         )
         .await
         .err()
@@ -111,11 +114,11 @@ fn an_unpositioned_match_is_rejected_in_both_directions() {
         DecodeError::Scope(ScopeError::UnpositionedMatch)
     ));
 
-    let reply = Reply::<<Local as Backend<()>>::Erased> {
+    let reply = Reply::<<Local as Backend>::Erased> {
         replies: vec![Reaction::Match, Reaction::Match],
     };
     let encode_error = runtime().block_on(async {
-        encode_reply::<_, u64>(
+        encode_reply(
             Local,
             RunBudget::default(),
             Scope::new(parent.erase(), &[(1, hash(1))]),
@@ -138,19 +141,20 @@ fn an_unpositioned_query_is_rejected_in_both_directions() {
     let path = Path::for_leaf(&Version::new());
     let parent = Prefix::<S<S<Z>>>::containing(&path);
     let listing = vec![(1, hash(1))];
-    let frames: Vec<Frame<()>> = vec![Frame::Reaction(
+    let frames: Vec<Frame> = vec![Frame::Reaction(
         WireReaction::Query(listing.clone()),
         Flow::End,
     )];
 
     let decode_error = runtime().block_on(async {
         let mut frames = stream::iter(frames);
-        decode_reply::<Local, (), _>(
+        decode_reply::<Local, _>(
             Local,
             u64::MAX,
             unbounded(),
             Scope::new(parent.erase(), &[]),
             &mut frames,
+            Message::deserializer::<u64>(),
         )
         .await
         .err()
@@ -161,11 +165,11 @@ fn an_unpositioned_query_is_rejected_in_both_directions() {
         DecodeError::Scope(ScopeError::UnpositionedQuery)
     ));
 
-    let reply = Reply::<<Local as Backend<()>>::Erased> {
+    let reply = Reply::<<Local as Backend>::Erased> {
         replies: vec![Reaction::Query(listing)],
     };
     let encode_error = runtime().block_on(async {
-        encode_reply::<_, u64>(
+        encode_reply(
             Local,
             RunBudget::default(),
             Scope::new(parent.erase(), &[]),
@@ -209,10 +213,10 @@ fn leaf_query_matrix_is_exhaustive() {
             } else {
                 None
             };
-            let expected_frame: Frame<u64> =
+            let expected_frame: Frame =
                 Frame::Reaction(WireReaction::Query(query_listing.clone()), Flow::End);
 
-            let reply = Reply::<<Local as Backend<()>>::Erased> {
+            let reply = Reply::<<Local as Backend>::Erased> {
                 replies: vec![Reaction::Query(query_listing.clone())],
             };
             let encoded = runtime().block_on(async {
@@ -250,6 +254,7 @@ fn leaf_query_matrix_is_exhaustive() {
                     unbounded(),
                     Scope::new(parent.erase(), &scope_listing),
                     &mut frames,
+                    Message::deserializer::<u64>(),
                 )
                 .await
             });
@@ -281,7 +286,7 @@ fn leaf_query_matrix_is_exhaustive() {
 fn stream_end_is_not_a_protocol_reply() {
     let path = Path::for_leaf(&Version::new());
     let parent = Prefix::<S<Z>>::containing(&path);
-    let mut frames = stream::iter([Frame::<()>::End(End::Stream)]);
+    let mut frames = stream::iter([Frame::End(End::Stream)]);
 
     let error = runtime()
         .block_on(decode_leaf_reply(
@@ -290,6 +295,7 @@ fn stream_end_is_not_a_protocol_reply() {
             unbounded(),
             Scope::new(parent.erase(), &[]),
             &mut frames,
+            Message::deserializer::<u64>(),
         ))
         .err()
         .expect("stream control must be consumed below the adapter");
@@ -345,26 +351,32 @@ fn a_multi_leaf_run_is_one_supplied_subtree() {
 
     let reencoded = runtime().block_on(async {
         let mut input = stream::iter(frames.clone());
-        let decoded =
-            decode_reply::<Local, u64, _>(Local, u64::MAX, unbounded(), scope.clone(), &mut input)
-                .await
-                .expect("ascending in-scope leaves assemble");
+        let decoded = decode_reply::<Local, _>(
+            Local,
+            u64::MAX,
+            unbounded(),
+            scope.clone(),
+            &mut input,
+            Message::deserializer::<u64>(),
+        )
+        .await
+        .expect("ascending in-scope leaves assemble");
         assert_eq!(decoded.reply.replies.len(), 1);
         let [Reaction::Supply(_, node)] = decoded.reply.replies.as_slice() else {
             panic!("one leaf run must become one supplied node")
         };
         let supplied_prefix = Prefix::<UnderRoot>::containing(&leaves[0].2);
-        let rebuilt = <Local as Backend<u64>>::leaves(
+        let rebuilt = <Local as Backend>::leaves(
             Local,
             supplied_prefix,
-            <Local as Backend<u64>>::assume::<UnderRoot>(node.clone()),
+            <Local as Backend>::assume::<UnderRoot>(node.clone()),
         )
         .try_collect::<Vec<_>>()
         .await
         .expect("the local backend is infallible");
         assert_eq!(rebuilt.len(), 2);
 
-        encode_reply::<_, u64>(Local, RunBudget::default(), scope, decoded.reply)
+        encode_reply(Local, RunBudget::default(), scope, decoded.reply)
             .map_ok(|encoded| encoded.into_parts().0)
             .try_collect::<Vec<_>>()
             .await
@@ -401,12 +413,13 @@ fn leaf_order_is_enforced_within_one_run() {
 
     let error = runtime().block_on(async {
         let mut input = stream::iter(frames);
-        decode_reply::<Local, u64, _>(
+        decode_reply::<Local, _>(
             Local,
             u64::MAX,
             unbounded(),
             Scope::opening(&[]),
             &mut input,
+            Message::deserializer::<u64>(),
         )
         .await
         .err()
@@ -433,7 +446,7 @@ fn leaf_scope_is_enforced_within_one_run() {
         .find(|candidate| Prefix::<Z>::containing(&candidate.path()).pop().0 != parent)
         .expect("content paths do not all share one leaf parent");
     let frames = vec![Frame::Reaction(
-        WireReaction::Supply(leaf_run::<u64>(&[
+        WireReaction::Supply(leaf_run(&[
             (&inside.version, &inside.message),
             (&outside.version, &outside.message),
         ])),
@@ -448,6 +461,7 @@ fn leaf_scope_is_enforced_within_one_run() {
             unbounded(),
             Scope::new(parent.erase(), &[]),
             &mut input,
+            Message::deserializer::<u64>(),
         )
         .await
         .err()
@@ -471,19 +485,20 @@ const ZERO_LENGTH_RECORD_RUN: [u8; 4] = [0, 0, 0, 0];
 /// version decoder's `UnexpectedEof`.
 #[test]
 fn a_zero_length_record_fails_as_a_version_decode_error() {
-    let run = LeafRun::<u64>::from_encoded(ZERO_LENGTH_RECORD_RUN.to_vec())
+    let run = LeafRun::from_encoded(ZERO_LENGTH_RECORD_RUN.to_vec())
         .expect("a zero-length record header chains structurally");
     assert_eq!(run.record_count(), 1);
     let frames = vec![Frame::Reaction(WireReaction::Supply(run), Flow::End)];
 
     let error = runtime().block_on(async {
         let mut input = stream::iter(frames);
-        decode_reply::<Local, u64, _>(
+        decode_reply::<Local, _>(
             Local,
             u64::MAX,
             unbounded(),
             Scope::opening(&[]),
             &mut input,
+            Message::deserializer::<u64>(),
         )
         .await
         .err()
@@ -508,7 +523,7 @@ fn a_version_over_the_declared_bound_is_rejected() {
     let declared = leaf.version.as_bytes().len() as u64;
     let frames = || {
         vec![Frame::Reaction(
-            WireReaction::Supply(leaf_run::<u64>(&[(&leaf.version, &leaf.message)])),
+            WireReaction::Supply(leaf_run(&[(&leaf.version, &leaf.message)])),
             Flow::End,
         )]
     };
@@ -521,6 +536,7 @@ fn a_version_over_the_declared_bound_is_rejected() {
             unbounded(),
             Scope::new(parent.erase(), &[]),
             &mut input,
+            Message::deserializer::<u64>(),
         )
         .await
         .expect("a version exactly at the declared bound is admitted");
@@ -534,6 +550,7 @@ fn a_version_over_the_declared_bound_is_rejected() {
             unbounded(),
             Scope::new(parent.erase(), &[]),
             &mut input,
+            Message::deserializer::<u64>(),
         )
         .await
         .err()
@@ -563,7 +580,7 @@ fn ascending_leaves(count: u64) -> Vec<LeafCase> {
 
 /// One whole-root reply supplying every leaf in `cases`, as a single
 /// ascending run.
-fn whole_root_supply_reply(cases: &[LeafCase]) -> Vec<Frame<u64>> {
+fn whole_root_supply_reply(cases: &[LeafCase]) -> Vec<Frame> {
     let records: Vec<_> = cases
         .iter()
         .map(|case| (&case.version, &case.message))
@@ -607,12 +624,13 @@ fn a_reply_past_the_declared_set_len_fails_at_its_first_over_record() {
         let (live, _) = census::read();
         let decoded = runtime().block_on(async {
             let mut input = stream::iter(frames);
-            decode_reply::<Local, u64, _>(
+            decode_reply::<Local, _>(
                 Local,
                 u64::MAX,
                 SupplyLedger::new(declared),
                 Scope::opening(&[]),
                 &mut input,
+                Message::deserializer::<u64>(),
             )
             .await
         });
@@ -682,12 +700,13 @@ fn a_supply_run_cannot_resume_after_another_reaction() {
 
     let error = runtime().block_on(async {
         let mut input = stream::iter(frames);
-        decode_reply::<Local, u64, _>(
+        decode_reply::<Local, _>(
             Local,
             u64::MAX,
             unbounded(),
             Scope::opening(&[(1, hash(1))]),
             &mut input,
+            Message::deserializer::<u64>(),
         )
         .await
         .err()
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/opening.rs b/src/tree/mirror/streaming/remote/adapter/tests/opening.rs
index f7004d7bf..f020a5615 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/opening.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/opening.rs
@@ -26,8 +26,8 @@ use crate::tree::{
 };
 
 /// One erased opening node over the unit payload.
-fn erased(node: typed::Node<UnderRoot>) -> <Local as Backend<()>>::Erased {
-    <Local as Backend<()>>::erase(node)
+fn erased(node: typed::Node<UnderRoot>) -> <Local as Backend>::Erased {
+    <Local as Backend>::erase(node)
 }
 
 use super::{
@@ -59,7 +59,7 @@ where
 #[test]
 fn opening_listing_agrees_with_greeting_replay() {
     let listing = vec![(3, hash(1)), (9, hash(2))];
-    let reply = Reply::<<Local as Backend<()>>::Erased> {
+    let reply = Reply::<<Local as Backend>::Erased> {
         replies: vec![Reaction::Query(listing.clone())],
     };
 
@@ -68,8 +68,7 @@ fn opening_listing_agrees_with_greeting_replay() {
     assert!(supplies.is_empty(), "no supplies trailed the question");
     let scope = Scope::opening(&split);
 
-    let (replayed, replayed_scope) =
-        opening_reply::<<Local as Backend<()>>::Erased>(listing.clone());
+    let (replayed, replayed_scope) = opening_reply::<<Local as Backend>::Erased>(listing.clone());
     assert_eq!(replayed_scope, scope);
     let [Reaction::Query(replayed)] = replayed.replies.as_slice() else {
         panic!("the replayed opening must remain one query")
@@ -81,7 +80,7 @@ fn opening_listing_agrees_with_greeting_replay() {
 #[test]
 fn opening_supplies_split_off_the_question() {
     let listing = vec![(3, hash(1))];
-    let reply = Reply::<<Local as Backend<()>>::Erased> {
+    let reply = Reply::<<Local as Backend>::Erased> {
         replies: vec![
             Reaction::Query(listing.clone()),
             Reaction::Supply(5, erased(UnderRoot::node())),
@@ -105,7 +104,7 @@ fn opening_supplies_split_off_the_question() {
 /// scope holding no positional children.
 #[test]
 fn empty_listing_replays_the_empty_opening() {
-    let (replayed, mut scope) = opening_reply::<<Local as Backend<()>>::Erased>(Vec::new());
+    let (replayed, mut scope) = opening_reply::<<Local as Backend>::Erased>(Vec::new());
     let [Reaction::Query(listing)] = replayed.replies.as_slice() else {
         panic!("the replayed opening must be one query")
     };
@@ -134,7 +133,7 @@ fn opening_supplies_decode_by_radix_group() {
     }
     assert!(groups.len() >= 2, "the fixture must span two root children");
 
-    let mut frames: Vec<Frame<u64>> = groups
+    let mut frames: Vec<Frame> = groups
         .iter()
         .map(|group| {
             let records: Vec<_> = group
@@ -152,12 +151,13 @@ fn opening_supplies_decode_by_radix_group() {
 
     let decoded: Vec<(u8, _)> = runtime()
         .block_on(
-            early_supplies::<Local, u64, _>(
+            early_supplies::<Local, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
                 Prefix::new().erase(),
                 stream::iter(frames),
+                Message::deserializer::<u64>(),
             )
             .try_collect(),
         )
@@ -192,19 +192,20 @@ fn opening_supplies_past_the_declared_set_len_are_rejected() {
         .iter()
         .map(|case| (&case.version, &case.message))
         .collect();
-    let frames: Vec<Frame<u64>> = vec![Frame::Reaction(
+    let frames: Vec<Frame> = vec![Frame::Reaction(
         WireReaction::Supply(leaf_run(&records)),
         Flow::End,
     )];
 
     let error = runtime()
         .block_on(async {
-            early_supplies::<Local, u64, _>(
+            early_supplies::<Local, _>(
                 Local,
                 u64::MAX,
                 SupplyLedger::new(1),
                 Prefix::new().erase(),
                 stream::iter(frames),
+                Message::deserializer::<u64>(),
             )
             .try_collect::<Vec<_>>()
             .await
@@ -223,15 +224,16 @@ fn opening_supplies_past_the_declared_set_len_are_rejected() {
 /// decodes to no supplies at all.
 #[test]
 fn empty_opening_supply_reply_decodes_to_nothing() {
-    let frames: Vec<Frame<u64>> = vec![Frame::End(End::Reply)];
+    let frames: Vec<Frame> = vec![Frame::End(End::Reply)];
     let decoded: Vec<(u8, _)> = runtime()
         .block_on(
-            early_supplies::<Local, u64, _>(
+            early_supplies::<Local, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
                 Prefix::new().erase(),
                 stream::iter(frames),
+                Message::deserializer::<u64>(),
             )
             .try_collect(),
         )
@@ -243,15 +245,16 @@ fn empty_opening_supply_reply_decodes_to_nothing() {
 /// end are rejected, not absorbed into a phantom second reply.
 #[test]
 fn second_opening_supply_reply_is_rejected() {
-    let frames: Vec<Frame<u64>> = vec![Frame::End(End::Reply), Frame::End(End::Reply)];
+    let frames: Vec<Frame> = vec![Frame::End(End::Reply), Frame::End(End::Reply)];
     let error = runtime()
         .block_on(async {
-            early_supplies::<Local, u64, _>(
+            early_supplies::<Local, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
                 Prefix::new().erase(),
                 stream::iter(frames),
+                Message::deserializer::<u64>(),
             )
             .try_collect::<Vec<_>>()
             .await
@@ -264,15 +267,16 @@ fn second_opening_supply_reply_is_rejected() {
 /// an in-process one is rejected as unpositioned.
 #[test]
 fn positional_reaction_in_opening_supplies_is_rejected() {
-    let frames: Vec<Frame<u64>> = vec![Frame::Reaction(WireReaction::Match, Flow::End)];
+    let frames: Vec<Frame> = vec![Frame::Reaction(WireReaction::Match, Flow::End)];
     let error = runtime()
         .block_on(async {
-            early_supplies::<Local, u64, _>(
+            early_supplies::<Local, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
                 Prefix::new().erase(),
                 stream::iter(frames),
+                Message::deserializer::<u64>(),
             )
             .try_collect::<Vec<_>>()
             .await
@@ -288,26 +292,26 @@ fn positional_reaction_in_opening_supplies_is_rejected() {
 /// form or its exact typed rejection.
 #[test]
 fn opening_rejections_are_exhaustive() {
-    let empty = Reply::<<Local as Backend<()>>::Erased> {
+    let empty = Reply::<<Local as Backend>::Erased> {
         replies: Vec::new(),
     };
     assert_eq!(opening_parts(empty).err(), Some(OpeningError::Empty));
 
     for count in 1..=3 {
-        let reply = Reply::<<Local as Backend<()>>::Erased> {
+        let reply = Reply::<<Local as Backend>::Erased> {
             replies: (0..count).map(|_| Reaction::Match).collect(),
         };
         assert_eq!(opening_parts(reply).err(), Some(OpeningError::NotQuery));
     }
 
-    let supplied = Reply::<<Local as Backend<()>>::Erased> {
+    let supplied = Reply::<<Local as Backend>::Erased> {
         replies: vec![Reaction::Supply(0, erased(UnderRoot::node()))],
     };
     assert_eq!(opening_parts(supplied).err(), Some(OpeningError::NotQuery));
 
     // A non-supply reaction anywhere behind the question is rejected at
     // its whole-reply position.
-    let trailing = Reply::<<Local as Backend<()>>::Erased> {
+    let trailing = Reply::<<Local as Backend>::Erased> {
         replies: vec![
             Reaction::Query(vec![(3, hash(1))]),
             Reaction::Supply(5, erased(UnderRoot::node())),
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/parking.rs b/src/tree/mirror/streaming/remote/adapter/tests/parking.rs
index 93207530f..ec94abcd4 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/parking.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/parking.rs
@@ -105,7 +105,7 @@ fn parked_supply_reply_holds_handles_not_subtrees() {
     let reply = Reply {
         replies: children
             .into_iter()
-            .map(|(radix, node)| Reaction::Supply(radix, <Local as Backend<u64>>::erase(node)))
+            .map(|(radix, node)| Reaction::Supply(radix, <Local as Backend>::erase(node)))
             .collect(),
     };
     let runtime = runtime();
@@ -120,12 +120,13 @@ fn parked_supply_reply_holds_handles_not_subtrees() {
 
     let mut frames = stream::iter(frames);
     let decoded = runtime
-        .block_on(decode_reply::<Local, u64, _>(
+        .block_on(decode_reply::<Local, _>(
             Local,
             u64::MAX,
             unbounded(),
             scope,
             &mut frames,
+            Message::deserializer::<u64>(),
         ))
         .expect("a canonical supplied fan decodes");
 
@@ -162,7 +163,7 @@ fn maximally_disputed_reply_parks_bounded_skeleton() {
     let listing: Vec<(u8, Hash)> = (0..FAN)
         .map(|radix| (radix as u8, hash(radix as u8)))
         .collect();
-    let reply = Reply::<<Local as Backend<u64>>::Erased> {
+    let reply = Reply::<<Local as Backend>::Erased> {
         replies: (0..FAN).map(|_| Reaction::Query(listing.clone())).collect(),
     };
 
@@ -207,12 +208,13 @@ fn maximally_disputed_reply_parks_bounded_skeleton() {
 
     let mut frames = stream::iter(frames);
     let decoded = runtime
-        .block_on(decode_reply::<Local, u64, _>(
+        .block_on(decode_reply::<Local, _>(
             Local,
             u64::MAX,
             unbounded(),
             Scope::opening(&listing),
             &mut frames,
+            Message::deserializer::<u64>(),
         ))
         .expect("a canonical maximally disputed reply decodes");
 
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/properties.rs b/src/tree/mirror/streaming/remote/adapter/tests/properties.rs
index 3ad4eaba1..c542cabcb 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/properties.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/properties.rs
@@ -1,5 +1,6 @@
 //! Laws which hold uniformly across the adapter's type-level height ladder.
 
+use crate::message::Message;
 use std::convert::Infallible;
 
 use futures::{StreamExt, TryStreamExt, stream};
@@ -18,8 +19,8 @@ use crate::tree::{
 };
 
 /// The in-memory backend's erased node representations, per payload.
-type ErasedUnit = <Local as Backend<()>>::Erased;
-type ErasedU64 = <Local as Backend<u64>>::Erased;
+type ErasedUnit = <Local as Backend>::Erased;
+type ErasedU64 = <Local as Backend>::Erased;
 
 use super::{
     super::{DecodeError, Scope, decode_leaf_reply, decode_reply, encode_leaf_reply, encode_reply},
@@ -114,6 +115,7 @@ impl AdapterHeight for Z {
                 unbounded(),
                 scope.clone(),
                 &mut frames,
+                Message::deserializer::<u64>(),
             ))
             .expect("an in-scope leaf decodes");
 
@@ -163,6 +165,7 @@ impl AdapterHeight for Z {
                 unbounded(),
                 scope,
                 &mut frames,
+                Message::deserializer::<u64>(),
             ))
             .expect("canonical matches decode");
         prop_assert!(decoded.questions.is_empty(), "height 0");
@@ -240,6 +243,7 @@ impl AdapterHeight for Z {
                 unbounded(),
                 scope,
                 &mut frames,
+                Message::deserializer::<u64>(),
             ))
             .expect("canonical leaf reactions decode");
         prop_assert_eq!(&decoded.questions, &expected_questions, "height 0");
@@ -291,6 +295,7 @@ impl AdapterHeight for Z {
                 unbounded(),
                 scope,
                 &mut frames,
+                Message::deserializer::<u64>(),
             ))
             .expect("canonical mixed leaf reactions decode");
         prop_assert_eq!(&decoded.questions, &expected_questions, "height 0");
@@ -320,6 +325,7 @@ impl AdapterHeight for Z {
                 unbounded(),
                 Scope::new(parent.erase(), &[]),
                 &mut frames,
+                Message::deserializer::<u64>(),
             ))
             .err()
             .expect("duplicate leaves are not strictly ascending");
@@ -340,6 +346,7 @@ impl AdapterHeight for Z {
                 unbounded(),
                 Scope::new(foreign.erase(), &[]),
                 &mut frames,
+                Message::deserializer::<u64>(),
             ))
             .err()
             .expect("a leaf outside the retained scope must fail");
@@ -367,12 +374,13 @@ where
         let frame = supplied_frame(leaf, Flow::End);
         let mut frames = stream::iter([frame.clone()]);
         let decoded = runtime
-            .block_on(decode_reply::<Local, u64, _>(
+            .block_on(decode_reply::<Local, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
                 scope.clone(),
                 &mut frames,
+                Message::deserializer::<u64>(),
             ))
             .expect("an in-scope leaf decodes");
 
@@ -416,12 +424,13 @@ where
                 .chain([sentinel.clone()]),
         );
         let decoded = runtime
-            .block_on(decode_reply::<Local, (), _>(
+            .block_on(decode_reply::<Local, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
                 scope,
                 &mut frames,
+                Message::deserializer::<u64>(),
             ))
             .expect("canonical matches decode");
         prop_assert!(decoded.questions.is_empty(), "height {}", Self::HEIGHT);
@@ -499,12 +508,13 @@ where
 
         let mut frames = stream::iter(actual_frames);
         let decoded = runtime
-            .block_on(decode_reply::<Local, (), _>(
+            .block_on(decode_reply::<Local, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
                 scope,
                 &mut frames,
+                Message::deserializer::<u64>(),
             ))
             .expect("canonical positional reactions decode");
         prop_assert_eq!(
@@ -566,12 +576,13 @@ where
         let sentinel = Frame::End(End::Reply);
         let mut frames = stream::iter(actual_frames.into_iter().chain([sentinel.clone()]));
         let decoded = runtime
-            .block_on(decode_reply::<Local, u64, _>(
+            .block_on(decode_reply::<Local, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
                 scope,
                 &mut frames,
+                Message::deserializer::<u64>(),
             ))
             .expect("canonical mixed reactions decode");
         prop_assert_eq!(
@@ -605,12 +616,13 @@ where
         let parent = Prefix::<Self>::containing(&leaf.path()).pop().0;
         let mut frames = stream::iter(duplicate_frames(leaf));
         let error = runtime
-            .block_on(decode_reply::<Local, u64, _>(
+            .block_on(decode_reply::<Local, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
                 Scope::new(parent.erase(), &[]),
                 &mut frames,
+                Message::deserializer::<u64>(),
             ))
             .err()
             .expect("duplicate leaves are not strictly ascending");
@@ -631,12 +643,13 @@ where
         let foreign = foreign_parent::<Self>(leaf, actual);
         let mut frames = stream::iter([supplied_frame(leaf, Flow::End)]);
         let error = runtime
-            .block_on(decode_reply::<Local, u64, _>(
+            .block_on(decode_reply::<Local, _>(
                 Local,
                 u64::MAX,
                 unbounded(),
                 Scope::new(foreign.erase(), &[]),
                 &mut frames,
+                Message::deserializer::<u64>(),
             ))
             .err()
             .expect("a leaf outside the retained scope must fail");
@@ -644,14 +657,14 @@ where
     }
 }
 
-fn supplied_frame(leaf: &LeafCase, flow: Flow) -> Frame<u64> {
+fn supplied_frame(leaf: &LeafCase, flow: Flow) -> Frame {
     Frame::Reaction(
         WireReaction::Supply(leaf_run(&[(&leaf.version, &leaf.message)])),
         flow,
     )
 }
 
-fn duplicate_frames(leaf: &LeafCase) -> [Frame<u64>; 2] {
+fn duplicate_frames(leaf: &LeafCase) -> [Frame; 2] {
     [
         supplied_frame(leaf, Flow::Continue),
         supplied_frame(leaf, Flow::End),
@@ -669,7 +682,7 @@ fn mixed_reply<H: Height>(
     supply_radix: u8,
     supply: typed::Node<H>,
 ) -> Reply<ErasedU64> {
-    let mut supply = Some(<Local as Backend<u64>>::erase(supply));
+    let mut supply = Some(<Local as Backend>::erase(supply));
     let mut replies = Vec::with_capacity(case.radixes.len() + 1);
     for position in 0..=case.radixes.len() {
         if position == supply_at {
@@ -694,7 +707,7 @@ fn expected_mixed_frames(
     query_listing: &[(u8, Hash)],
     supply_at: usize,
     leaf: &LeafCase,
-) -> Vec<Frame<u64>> {
+) -> Vec<Frame> {
     let mut reactions = Vec::with_capacity(case.radixes.len() + 1);
     for position in 0..=case.radixes.len() {
         if position == supply_at {
@@ -820,14 +833,10 @@ where
 {
     let prefix = Prefix::<H>::containing(&expected_leaf.path());
     let leaves = runtime.block_on(async {
-        <Local as Backend<u64>>::leaves(
-            Local,
-            prefix,
-            <Local as Backend<u64>>::assume::<H>(node.clone()),
-        )
-        .try_collect::<Vec<_>>()
-        .await
-        .expect("the local backend is infallible")
+        <Local as Backend>::leaves(Local, prefix, <Local as Backend>::assume::<H>(node.clone()))
+            .try_collect::<Vec<_>>()
+            .await
+            .expect("the local backend is infallible")
     });
     prop_assert_eq!(leaves.len(), 1, "height {}", H::HEIGHT);
     let (actual_prefix, actual_leaf) = &leaves[0];
@@ -844,7 +853,7 @@ where
 }
 
 fn assert_match_encoding<Q>(
-    encoded: &[(Frame<()>, Option<Q>)],
+    encoded: &[(Frame, Option<Q>)],
     count: usize,
     height: usize,
 ) -> TestCaseResult {
@@ -886,7 +895,7 @@ fn assert_matches(reply: &Reply<ErasedUnit>, count: usize, height: usize) -> Tes
     Ok(())
 }
 
-fn expected_positional_frames(case: &PositionalCase) -> Vec<Frame<()>> {
+fn expected_positional_frames(case: &PositionalCase) -> Vec<Frame> {
     if case.radixes.is_empty() {
         return vec![Frame::End(End::Reply)];
     }
diff --git a/src/tree/mirror/streaming/remote/adapter/tests/runs.rs b/src/tree/mirror/streaming/remote/adapter/tests/runs.rs
index 07885eaed..9b012fe0c 100644
--- a/src/tree/mirror/streaming/remote/adapter/tests/runs.rs
+++ b/src/tree/mirror/streaming/remote/adapter/tests/runs.rs
@@ -83,7 +83,7 @@ fn separated_leaves() -> [LeafCase; 2] {
 }
 
 /// One single-record supply frame per leaf: the least-batched wire form.
-fn unbatched_frames(leaves: &[LeafCase]) -> Vec<Frame<u64>> {
+fn unbatched_frames(leaves: &[LeafCase]) -> Vec<Frame> {
     let count = leaves.len();
     leaves
         .iter()
@@ -104,16 +104,17 @@ fn unbatched_frames(leaves: &[LeafCase]) -> Vec<Frame<u64>> {
 
 /// Decode `frames` as one reply to the opening scope, then re-encode it
 /// under `budget`, returning the emitted wire frames.
-fn recode(frames: Vec<Frame<u64>>, budget: RunBudget) -> Vec<Frame<u64>> {
+fn recode(frames: Vec<Frame>, budget: RunBudget) -> Vec<Frame> {
     let runtime = runtime();
     runtime.block_on(async {
         let mut input = stream::iter(frames);
-        let decoded = decode_reply::<Local, u64, _>(
+        let decoded = decode_reply::<Local, _>(
             Local,
             u64::MAX,
             unbounded(),
             Scope::opening(&[]),
             &mut input,
+            Message::deserializer::<u64>(),
         )
         .await
         .expect("ascending in-scope leaves assemble");
@@ -126,7 +127,7 @@ fn recode(frames: Vec<Frame<u64>>, budget: RunBudget) -> Vec<Frame<u64>> {
 }
 
 /// Split every emitted frame into its supply run, requiring supplies only.
-fn runs_of(frames: &[Frame<u64>]) -> Vec<&LeafRun<u64>> {
+fn runs_of(frames: &[Frame]) -> Vec<&LeafRun> {
     frames
         .iter()
         .map(|frame| match frame {
@@ -137,10 +138,10 @@ fn runs_of(frames: &[Frame<u64>]) -> Vec<&LeafRun<u64>> {
 }
 
 /// The decoded records of `runs`, flattened in wire order.
-fn records_of(runs: &[&LeafRun<u64>]) -> Vec<(Version, Message)> {
+fn records_of(runs: &[&LeafRun]) -> Vec<(Version, Message)> {
     runs.iter()
         .flat_map(|run| {
-            run.records()
+            run.records(Message::deserializer::<u64>())
                 .collect::<Result<Vec<_>, _>>()
                 .expect("an encoder-produced run holds canonical records")
         })
@@ -190,14 +191,14 @@ proptest! {
             // would have pushed its frame past the budget.
             if position + 1 < runs.len() {
                 let (version, message) = runs[position + 1]
-                    .records()
+                    .records(Message::deserializer::<u64>())
                     .next()
                     .expect("a nonempty run yields a first record")
                     .expect("an encoder-produced run holds canonical records");
                 prop_assert!(
                     SUPPLY_FRAME_OVERHEAD
                         + run.encoded_len()
-                        + LeafRun::<u64>::record_len(&version, &message)
+                        + LeafRun::record_len(&version, &message)
                         > budget,
                     "run {position} flushed although the next record fit"
                 );
@@ -264,12 +265,13 @@ fn a_batched_run_round_trips_the_reply() {
     let runtime = runtime();
     let reply = runtime.block_on(async {
         let mut input = stream::iter(frames);
-        decode_reply::<Local, u64, _>(
+        decode_reply::<Local, _>(
             Local,
             u64::MAX,
             unbounded(),
             Scope::opening(&[]),
             &mut input,
+            Message::deserializer::<u64>(),
         )
         .await
         .expect("the batched frame decodes")
@@ -280,10 +282,10 @@ fn a_batched_run_round_trips_the_reply() {
     };
     let prefix = Prefix::<UnderRoot>::containing(&leaves[0].path());
     let rebuilt = runtime.block_on(async {
-        <Local as Backend<u64>>::leaves(
+        <Local as Backend>::leaves(
             Local,
             prefix,
-            <Local as Backend<u64>>::assume::<UnderRoot>(node.clone()),
+            <Local as Backend>::assume::<UnderRoot>(node.clone()),
         )
         .try_collect::<Vec<_>>()
         .await
diff --git a/src/tree/mirror/streaming/remote/codec.rs b/src/tree/mirror/streaming/remote/codec.rs
index 0ebd53460..69a4dd5b3 100644
--- a/src/tree/mirror/streaming/remote/codec.rs
+++ b/src/tree/mirror/streaming/remote/codec.rs
@@ -100,7 +100,7 @@ pub(crate) async fn decode_frame_discarded(
     budget: RunBudget,
 ) -> Result<(), DecodeError> {
     let mut read = FrameRead::new(Speaker::Initiator, budget, read);
-    read.frame::<u64>().await.map(|_| ())
+    read.frame().await.map(|_| ())
 }
 
 #[cfg(test)]
diff --git a/src/tree/mirror/streaming/remote/codec/capture.rs b/src/tree/mirror/streaming/remote/codec/capture.rs
index 4f9c2547c..503f288fc 100644
--- a/src/tree/mirror/streaming/remote/codec/capture.rs
+++ b/src/tree/mirror/streaming/remote/codec/capture.rs
@@ -324,7 +324,7 @@ fn query_lines(children: &[u8]) -> Vec<String> {
 /// whose record framing or version encoding does not decode renders the
 /// failure explicitly.
 fn supply_lines(run: Vec<u8>) -> Vec<String> {
-    let run = match LeafRun::<()>::from_encoded(run) {
+    let run = match LeafRun::from_encoded(run) {
         Ok(run) => run,
         Err(err) => {
             return vec![format!(
diff --git a/src/tree/mirror/streaming/remote/codec/capture/tests.rs b/src/tree/mirror/streaming/remote/codec/capture/tests.rs
index 2cf597d2c..35b2fb32b 100644
--- a/src/tree/mirror/streaming/remote/codec/capture/tests.rs
+++ b/src/tree/mirror/streaming/remote/codec/capture/tests.rs
@@ -38,7 +38,7 @@ fn supply_decode_names_the_field_that_moved() {
     high.tick(&party);
 
     let render = |version: &Version| {
-        let mut run = LeafRun::<u64>::new();
+        let mut run = LeafRun::new();
         run.push(version, &Message::new(7_u64))
             .expect("one small record fits any run");
         supply_lines(run.as_bytes().to_vec())
diff --git a/src/tree/mirror/streaming/remote/codec/decode.rs b/src/tree/mirror/streaming/remote/codec/decode.rs
index f6ae3ea1e..9b1b94fc8 100644
--- a/src/tree/mirror/streaming/remote/codec/decode.rs
+++ b/src/tree/mirror/streaming/remote/codec/decode.rs
@@ -26,26 +26,23 @@ use super::{
     signal::{Signal, Speaker, Stream, WireSignal},
 };
 
-#[cfg(test)]
-use serde::de::DeserializeOwned;
-
 /// Decode one frame from `read`, leaving subsequent bytes untouched.
 #[cfg(test)]
-pub fn decode<T: DeserializeOwned>(
+pub fn decode(
     speaker: Speaker,
     budget: RunBudget,
     read: &mut impl Read,
-) -> Result<WireFrame<T>, DecodeError> {
+) -> Result<WireFrame, DecodeError> {
     FrameDecoder::new(speaker, budget, read).decode()
 }
 
 /// Decode exactly one frame from a slice, rejecting bytes after it.
 #[cfg(test)]
-pub fn decode_exact<T: DeserializeOwned>(
+pub fn decode_exact(
     speaker: Speaker,
     budget: RunBudget,
     input: &[u8],
-) -> Result<WireFrame<T>, DecodeError> {
+) -> Result<WireFrame, DecodeError> {
     let mut rest = input;
     let (stream, frame) = decode(speaker, budget, &mut rest)?;
     if rest.is_empty() {
@@ -78,7 +75,7 @@ impl<'a, R: Read> FrameDecoder<'a, R> {
         }
     }
 
-    fn decode<T: DeserializeOwned>(mut self) -> Result<WireFrame<T>, DecodeError> {
+    fn decode(mut self) -> Result<WireFrame, DecodeError> {
         let (stream, signal) = self.signal()?;
         let frame = self
             .body(signal)
@@ -93,7 +90,7 @@ impl<'a, R: Read> FrameDecoder<'a, R> {
         decode_signal(self.speaker, byte)
     }
 
-    fn body<T: DeserializeOwned>(&mut self, signal: Signal) -> Result<Frame<T>, DecodeErrorKind> {
+    fn body(&mut self, signal: Signal) -> Result<Frame, DecodeErrorKind> {
         let frame = match signal {
             Signal::Match(flow) => Frame::Reaction(Reaction::Match, flow),
             Signal::QueryEmpty(flow) => Frame::Reaction(Reaction::Query(Vec::new()), flow),
@@ -113,7 +110,7 @@ impl<'a, R: Read> FrameDecoder<'a, R> {
         parse_query(&listing)
     }
 
-    fn supply<T>(&mut self) -> Result<LeafRun<T>, DecodeErrorKind> {
+    fn supply(&mut self) -> Result<LeafRun, DecodeErrorKind> {
         let mut header = [0; LENGTH_HEADER_LEN];
         self.read_exact(&mut header, FramePart::SupplyLength)?;
         let len = u32::from_be_bytes(header) as usize;
diff --git a/src/tree/mirror/streaming/remote/codec/decode/async_io.rs b/src/tree/mirror/streaming/remote/codec/decode/async_io.rs
index 4a8866228..a490a0025 100644
--- a/src/tree/mirror/streaming/remote/codec/decode/async_io.rs
+++ b/src/tree/mirror/streaming/remote/codec/decode/async_io.rs
@@ -17,7 +17,6 @@ use crate::tree::{
     typed::Hash,
 };
 
-use serde::de::DeserializeOwned;
 /// Async frame reader over one speaker's transport direction.
 ///
 /// EOF before a signal is a clean direction close and returns `None`. Once a
@@ -63,9 +62,7 @@ impl<R: AsyncRead + Unpin> FrameRead<R> {
     /// as a signal. Either retain the in-flight future across polls until
     /// it resolves, or read nothing further from this direction after a
     /// cancellation.
-    pub async fn frame<T: DeserializeOwned>(
-        &mut self,
-    ) -> Result<Option<WireFrame<T>>, DecodeError> {
+    pub async fn frame(&mut self) -> Result<Option<WireFrame>, DecodeError> {
         let Some((stream, signal)) = read_signal(self.speaker, &mut self.read).await? else {
             return Ok(None);
         };
@@ -108,10 +105,7 @@ impl<'a, R: AsyncRead + Unpin> AsyncFrameDecoder<'a, R> {
         Self { read, budget }
     }
 
-    async fn body<T: DeserializeOwned>(
-        &mut self,
-        signal: Signal,
-    ) -> Result<Frame<T>, DecodeErrorKind> {
+    async fn body(&mut self, signal: Signal) -> Result<Frame, DecodeErrorKind> {
         let frame = match signal {
             Signal::Match(flow) => Frame::Reaction(Reaction::Match, flow),
             Signal::QueryEmpty(flow) => Frame::Reaction(Reaction::Query(Vec::new()), flow),
@@ -130,7 +124,7 @@ impl<'a, R: AsyncRead + Unpin> AsyncFrameDecoder<'a, R> {
         parse_query(&listing)
     }
 
-    async fn supply<T>(&mut self) -> Result<LeafRun<T>, DecodeErrorKind> {
+    async fn supply(&mut self) -> Result<LeafRun, DecodeErrorKind> {
         let mut header = [0; LENGTH_HEADER_LEN];
         self.read_exact(&mut header, FramePart::SupplyLength)
             .await?;
diff --git a/src/tree/mirror/streaming/remote/codec/decode/tests.rs b/src/tree/mirror/streaming/remote/codec/decode/tests.rs
index b2bdb3e52..e5df2a9a9 100644
--- a/src/tree/mirror/streaming/remote/codec/decode/tests.rs
+++ b/src/tree/mirror/streaming/remote/codec/decode/tests.rs
@@ -68,7 +68,7 @@ fn invalid_signals_are_rejected() {
             let DecodeSignalError::Reserved(reserved) = invalid else {
                 panic!("unexpected signal error")
             };
-            let error = decode_exact::<u64>(speaker, RunBudget::default(), &[byte]).unwrap_err();
+            let error = decode_exact(speaker, RunBudget::default(), &[byte]).unwrap_err();
             assert_eq!(error.origin, Origin::stream(speaker, reserved.stream()));
             let DecodeErrorKind::InvalidSignal(DecodeSignalError::Reserved(source)) = error.kind
             else {
@@ -115,7 +115,7 @@ fn truncated_bodies_are_rejected() {
             ),
         ];
         for (encoded, missing, origin) in cases {
-            let error = decode_exact::<u64>(speaker, RunBudget::default(), &encoded).unwrap_err();
+            let error = decode_exact(speaker, RunBudget::default(), &encoded).unwrap_err();
             assert_eq!(error.origin, origin);
             let DecodeErrorKind::Truncated {
                 missing: actual,
@@ -149,7 +149,7 @@ proptest! {
 
         let expected = LeafRun::from_encoded(body).unwrap();
         prop_assert_eq!(
-            decode_exact::<u64>(speaker, RunBudget::default(), &encoded).unwrap(),
+            decode_exact(speaker, RunBudget::default(), &encoded).unwrap(),
             (stream, Frame::Reaction(Reaction::Supply(expected), flow))
         );
     }
@@ -164,7 +164,7 @@ fn malformed_run_structure_is_typed() {
 
     let stream = stream(8);
     for speaker in SPEAKERS {
-        let empty = decode_exact::<u64>(
+        let empty = decode_exact(
             speaker,
             RunBudget::default(),
             &supply(stream, Flow::Continue, &[]),
@@ -176,7 +176,7 @@ fn malformed_run_structure_is_typed() {
             DecodeErrorKind::InvalidRun(LeafRunError::Empty)
         ));
 
-        let short_header = decode_exact::<u64>(
+        let short_header = decode_exact(
             speaker,
             RunBudget::default(),
             &supply(stream, Flow::Continue, &[0, 0]),
@@ -190,7 +190,7 @@ fn malformed_run_structure_is_typed() {
 
         let mut overrun = 2_u32.to_be_bytes().to_vec();
         overrun.push(0);
-        let short_record = decode_exact::<u64>(
+        let short_record = decode_exact(
             speaker,
             RunBudget::default(),
             &supply(stream, Flow::Continue, &overrun),
@@ -219,13 +219,17 @@ fn a_zero_length_record_is_structurally_valid() {
     let encoded = supply(stream, Flow::End, &[0, 0, 0, 0]);
     for speaker in SPEAKERS {
         let (decoded_stream, frame) =
-            decode_exact::<u64>(speaker, RunBudget::default(), &encoded).unwrap();
+            decode_exact(speaker, RunBudget::default(), &encoded).unwrap();
         assert_eq!(decoded_stream, stream);
         let Frame::Reaction(Reaction::Supply(run), Flow::End) = frame else {
             panic!("a structurally valid run decodes as a supply reaction");
         };
         assert_eq!(run.record_count(), 1);
-        let error = run.records().next().unwrap().unwrap_err();
+        let error = run
+            .records(Message::deserializer::<u64>())
+            .next()
+            .unwrap()
+            .unwrap_err();
         let DecodeLeafError::Version(source) = error else {
             panic!("unexpected record error");
         };
@@ -239,8 +243,12 @@ fn a_zero_length_record_is_structurally_valid() {
 fn supplied_record_errors_are_typed() {
     let mut truncated_version = (TRUNCATED_VERSION.len() as u32).to_be_bytes().to_vec();
     truncated_version.extend_from_slice(TRUNCATED_VERSION);
-    let run = LeafRun::<u64>::from_encoded(truncated_version).unwrap();
-    let error = run.records().next().unwrap().unwrap_err();
+    let run = LeafRun::from_encoded(truncated_version).unwrap();
+    let error = run
+        .records(Message::deserializer::<u64>())
+        .next()
+        .unwrap()
+        .unwrap_err();
     let DecodeLeafError::Version(source) = error else {
         panic!("unexpected record error");
     };
@@ -250,20 +258,34 @@ fn supplied_record_errors_are_typed() {
     ciborium::ser::into_writer(&Version::new(), &mut version).unwrap();
     let mut missing_message = (version.len() as u32).to_be_bytes().to_vec();
     missing_message.extend_from_slice(&version);
-    let run = LeafRun::<u64>::from_encoded(missing_message).unwrap();
-    let error = run.records().next().unwrap().unwrap_err();
+    let run = LeafRun::from_encoded(missing_message).unwrap();
+    let error = run
+        .records(Message::deserializer::<u64>())
+        .next()
+        .unwrap()
+        .unwrap_err();
     let DecodeLeafError::Message(source) = error else {
         panic!("unexpected record error");
     };
     assert_eq!(source.kind(), std::io::ErrorKind::UnexpectedEof);
 
+    // Bytes past the canonical pair make the payload malformed: the
+    // payload runs to the record's end, so the deserializer's
+    // exactly-one-value check is what rejects the excess.
     ciborium::ser::into_writer(&0_u64, &mut version).unwrap();
     version.push(u8::MIN);
     let mut trailing = (version.len() as u32).to_be_bytes().to_vec();
     trailing.extend_from_slice(&version);
-    let run = LeafRun::<u64>::from_encoded(trailing).unwrap();
-    let error = run.records().next().unwrap().unwrap_err();
-    assert!(matches!(error, DecodeLeafError::TrailingBytes { count: 1 }));
+    let run = LeafRun::from_encoded(trailing).unwrap();
+    let error = run
+        .records(Message::deserializer::<u64>())
+        .next()
+        .unwrap()
+        .unwrap_err();
+    let DecodeLeafError::Message(source) = error else {
+        panic!("unexpected record error");
+    };
+    assert_eq!(source.kind(), std::io::ErrorKind::InvalidData);
 }
 
 proptest! {
@@ -288,7 +310,7 @@ proptest! {
             encoded.push(*radix);
             encoded.extend_from_slice(hash.as_bytes());
         }
-        let error = decode_exact::<u64>(speaker, RunBudget::default(), &encoded).unwrap_err();
+        let error = decode_exact(speaker, RunBudget::default(), &encoded).unwrap_err();
         prop_assert_eq!(error.origin, Origin::stream(speaker, stream));
         let correct = matches!(
             error.kind,
@@ -309,7 +331,7 @@ fn exact_decode_rejects_trailing_frame() {
     let second = signal(stream, Signal::End(End::Reply));
     let encoded = [first, second];
     for speaker in SPEAKERS {
-        let error = decode_exact::<u64>(speaker, RunBudget::default(), &encoded).unwrap_err();
+        let error = decode_exact(speaker, RunBudget::default(), &encoded).unwrap_err();
         assert_eq!(error.origin, Origin::stream(speaker, stream));
         assert!(matches!(
             error.kind,
@@ -319,7 +341,7 @@ fn exact_decode_rejects_trailing_frame() {
         ));
 
         let mut rest = encoded.as_slice();
-        let frame = decode::<u64>(speaker, RunBudget::default(), &mut rest).unwrap();
+        let frame = decode(speaker, RunBudget::default(), &mut rest).unwrap();
         assert_eq!(
             frame,
             (stream, Frame::Reaction(Reaction::Match, Flow::Continue))
@@ -335,7 +357,7 @@ fn async_eof_distinguishes_close_from_truncation() {
     let stream = stream(4);
     for speaker in SPEAKERS {
         let mut closed = FrameRead::new(speaker, RunBudget::default(), &[][..]);
-        assert_eq!(pollster::block_on(closed.frame::<u64>()).unwrap(), None);
+        assert_eq!(pollster::block_on(closed.frame()).unwrap(), None);
 
         let cases = [
             (
@@ -361,7 +383,7 @@ fn async_eof_distinguishes_close_from_truncation() {
         ];
         for (encoded, missing) in cases {
             let mut reader = FrameRead::new(speaker, RunBudget::default(), encoded.as_slice());
-            let error = pollster::block_on(reader.frame::<u64>()).unwrap_err();
+            let error = pollster::block_on(reader.frame()).unwrap_err();
             assert_eq!(error.origin, Origin::stream(speaker, stream));
             assert!(matches!(
                 error.kind,
@@ -404,14 +426,14 @@ fn async_invalid_signal_does_not_consume_a_body() {
         let bytes = [invalid, valid];
         let mut reader = FrameRead::new(speaker, RunBudget::default(), bytes.as_slice());
 
-        let error = pollster::block_on(reader.frame::<u64>()).unwrap_err();
+        let error = pollster::block_on(reader.frame()).unwrap_err();
         assert_eq!(error.origin, Origin::stream(speaker, stream));
         assert!(matches!(
             error.kind,
             DecodeErrorKind::InvalidSignal(DecodeSignalError::Placement(_))
         ));
         assert_eq!(
-            pollster::block_on(reader.frame::<u64>()).unwrap(),
+            pollster::block_on(reader.frame()).unwrap(),
             Some((stream, valid_frame)),
         );
     }
@@ -429,7 +451,7 @@ impl std::io::Read for FailingReader {
 #[test]
 fn reader_errors_are_contextual() {
     for speaker in SPEAKERS {
-        let error = decode::<()>(speaker, RunBudget::default(), &mut FailingReader).unwrap_err();
+        let error = decode(speaker, RunBudget::default(), &mut FailingReader).unwrap_err();
         assert_eq!(error.origin, Origin::direction(speaker));
         assert!(matches!(
             error.kind,
@@ -459,7 +481,7 @@ fn supply_truncation_at_chunk_boundaries_is_typed() {
             encoded.extend_from_slice(&u32::try_from(declared).unwrap().to_be_bytes());
             encoded.extend(vec![0xA5; delivered]);
             let mut reader = FrameRead::new(speaker, RunBudget::default(), encoded.as_slice());
-            let error = pollster::block_on(reader.frame::<u64>()).unwrap_err();
+            let error = pollster::block_on(reader.frame()).unwrap_err();
             assert_eq!(error.origin, Origin::stream(speaker, stream));
             assert!(
                 matches!(
@@ -498,12 +520,12 @@ fn decode_both(
     speaker: Speaker,
     budget: RunBudget,
     bytes: &[u8],
-) -> Result<WireFrame<u64>, DecodeError> {
+) -> Result<WireFrame, DecodeError> {
     let mut reader = FrameRead::new(speaker, budget, bytes);
-    let from_async = pollster::block_on(reader.frame::<u64>())
+    let from_async = pollster::block_on(reader.frame())
         .map(|frame| frame.expect("a nonempty byte stream is not a clean close"));
     let mut rest = bytes;
-    let from_sync = decode::<u64>(speaker, budget, &mut rest);
+    let from_sync = decode(speaker, budget, &mut rest);
     match (from_async, from_sync) {
         (Ok(a), Ok(s)) => {
             assert_eq!(a, s, "the two decoders accept different frames");
diff --git a/src/tree/mirror/streaming/remote/codec/encode.rs b/src/tree/mirror/streaming/remote/codec/encode.rs
index 8bc985404..f62bf7326 100644
--- a/src/tree/mirror/streaming/remote/codec/encode.rs
+++ b/src/tree/mirror/streaming/remote/codec/encode.rs
@@ -26,9 +26,9 @@ use super::{
 
 /// Append `wire`'s canonical representation to `out`.
 #[cfg(test)]
-pub fn encode<T, W: Write>(
+pub fn encode<W: Write>(
     speaker: Speaker,
-    wire: &WireFrame<T>,
+    wire: &WireFrame,
     out: &mut W,
 ) -> Result<(), EncodeError> {
     let (stream, frame) = wire;
@@ -43,12 +43,12 @@ pub fn encode<T, W: Write>(
 /// run record framing are guaranteed by its callers and checked only when
 /// bytes enter from the wire. Construction performs only the
 /// representational checks needed before any byte can be emitted.
-struct FrameEncoding<'a, T> {
+struct FrameEncoding<'a> {
     signal: [u8; WireSignal::ENCODED_LEN],
-    body: BodyEncoding<'a, T>,
+    body: BodyEncoding<'a>,
 }
 
-enum BodyEncoding<'a, T> {
+enum BodyEncoding<'a> {
     Empty,
     Query {
         count: [u8; 1],
@@ -56,12 +56,12 @@ enum BodyEncoding<'a, T> {
     },
     Supply {
         header: [u8; LENGTH_HEADER_LEN],
-        run: &'a LeafRun<T>,
+        run: &'a LeafRun,
     },
 }
 
-impl<'a, T> FrameEncoding<'a, T> {
-    fn new(stream: Stream, frame: &'a Frame<T>) -> Result<Self, EncodeErrorKind> {
+impl<'a> FrameEncoding<'a> {
+    fn new(stream: Stream, frame: &'a Frame) -> Result<Self, EncodeErrorKind> {
         let (signal, body) = match frame {
             Frame::Reaction(Reaction::Match, flow) => (Signal::Match(*flow), BodyEncoding::Empty),
             Frame::Reaction(Reaction::Query(children), flow) if children.is_empty() => {
diff --git a/src/tree/mirror/streaming/remote/codec/encode/async_io.rs b/src/tree/mirror/streaming/remote/codec/encode/async_io.rs
index f8c5dc4da..fa834f2bc 100644
--- a/src/tree/mirror/streaming/remote/codec/encode/async_io.rs
+++ b/src/tree/mirror/streaming/remote/codec/encode/async_io.rs
@@ -43,7 +43,7 @@ impl<W: AsyncWrite + Unpin> FrameWrite<W> {
     /// reader. Either retain the in-flight future across polls until it
     /// resolves, or write nothing further on this direction after a
     /// cancellation.
-    pub async fn frame<T>(&mut self, wire: &WireFrame<T>) -> Result<(), EncodeError> {
+    pub async fn frame(&mut self, wire: &WireFrame) -> Result<(), EncodeError> {
         let (stream, frame) = wire;
         let result = async {
             let encoding = FrameEncoding::new(*stream, frame)?;
@@ -55,9 +55,9 @@ impl<W: AsyncWrite + Unpin> FrameWrite<W> {
     }
 }
 
-async fn write_encoding<T>(
+async fn write_encoding(
     out: &mut (impl AsyncWrite + Unpin),
-    encoding: &FrameEncoding<'_, T>,
+    encoding: &FrameEncoding<'_>,
 ) -> Result<(), EncodeErrorKind> {
     write(out, FramePart::Signal, &encoding.signal).await?;
     match &encoding.body {
diff --git a/src/tree/mirror/streaming/remote/codec/encode/tests.rs b/src/tree/mirror/streaming/remote/codec/encode/tests.rs
index 848f62baa..4be2237e7 100644
--- a/src/tree/mirror/streaming/remote/codec/encode/tests.rs
+++ b/src/tree/mirror/streaming/remote/codec/encode/tests.rs
@@ -53,7 +53,7 @@ fn query_count_covers_every_fan_and_flow() {
             })
             .collect::<Vec<_>>();
         for flow in FLOWS {
-            let frame: WireFrame<u64> = (
+            let frame: WireFrame = (
                 stream,
                 Frame::Reaction(Reaction::Query(children.clone()), flow),
             );
@@ -79,7 +79,7 @@ fn query_count_covers_every_fan_and_flow() {
 #[test]
 fn one_byte_frames_are_exhaustive() {
     let stream = stream(4);
-    let cases: Vec<(WireFrame<u64>, u8)> = vec![
+    let cases: Vec<(WireFrame, u8)> = vec![
         (
             (stream, Frame::Reaction(Reaction::Match, Flow::Continue)),
             signal(stream, Signal::Match(Flow::Continue)),
@@ -118,7 +118,7 @@ proptest! {
         records in proptest::collection::vec((arb_version(), any::<u64>()), 1..=4),
     ) {
         let stream = stream(index);
-        let mut run = super::LeafRun::<u64>::new();
+        let mut run = super::LeafRun::new();
         let mut body = Vec::new();
         for (version, value) in &records {
             let message = Message::new(*value);
@@ -157,7 +157,7 @@ impl std::io::Write for FailingWriter {
 #[test]
 fn writer_errors_are_contextual() {
     let stream = stream(12);
-    let frame: WireFrame<()> = (stream, Frame::End(End::Reply));
+    let frame: WireFrame = (stream, Frame::End(End::Reply));
     for speaker in SPEAKERS {
         let error = encode(speaker, &frame, &mut FailingWriter).unwrap_err();
         assert_eq!(error.origin, Origin::stream(speaker, stream));
@@ -207,7 +207,7 @@ impl AsyncWrite for FailingAsyncWriter {
 #[test]
 fn async_writer_errors_are_contextual() {
     let stream = stream(12);
-    let frame: WireFrame<()> = (stream, Frame::End(End::Reply));
+    let frame: WireFrame = (stream, Frame::End(End::Reply));
     for speaker in SPEAKERS {
         let mut writer = FrameWrite::new(speaker, FailingAsyncWriter(AsyncFailure::Write));
         let error = pollster::block_on(writer.frame(&frame)).unwrap_err();
diff --git a/src/tree/mirror/streaming/remote/codec/error.rs b/src/tree/mirror/streaming/remote/codec/error.rs
index 71f281492..68405f945 100644
--- a/src/tree/mirror/streaming/remote/codec/error.rs
+++ b/src/tree/mirror/streaming/remote/codec/error.rs
@@ -106,8 +106,6 @@ pub enum DecodeLeafError {
     Version(#[source] std::io::Error),
     #[error("supplied Message could not be decoded")]
     Message(#[source] std::io::Error),
-    #[error("{count} trailing bytes follow the supplied Version and Message")]
-    TrailingBytes { count: usize },
 }
 
 /// Why an incoming frame could not be decoded.
diff --git a/src/tree/mirror/streaming/remote/codec/frame.rs b/src/tree/mirror/streaming/remote/codec/frame.rs
index dcbb3fc2f..9b21f0b2f 100644
--- a/src/tree/mirror/streaming/remote/codec/frame.rs
+++ b/src/tree/mirror/streaming/remote/codec/frame.rs
@@ -1,10 +1,8 @@
 //! Semantic wire frames after signal decoding.
 
-use std::marker::PhantomData;
-
 use crate::{
     Version,
-    message::Message,
+    message::{Message, PayloadDeserializer},
     tree::{
         mirror::framing::{LENGTH_HEADER_LEN, LengthOverflow, length_header},
         typed::{Hash, hash::MERKLE_HASH_LEN},
@@ -14,7 +12,6 @@ use crate::{
 use super::error::{DecodeLeafError, QueryOrderError};
 use super::signal::{End, Flow, Stream};
 
-use serde::de::DeserializeOwned;
 /// The count byte stores one less than the nonempty query's actual fan.
 pub const QUERY_COUNT_BIAS: usize = 1;
 
@@ -32,23 +29,23 @@ const ADJACENT_CHILD_COUNT: usize = 2;
 
 /// The body of one complete reaction frame.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Reaction<T> {
+pub enum Reaction {
     Match,
     Query(Vec<(u8, Hash)>),
-    Supply(LeafRun<T>),
+    Supply(LeafRun),
 }
 
 /// A protocol reaction frame or a boundary-only frame.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Frame<T> {
+pub enum Frame {
     /// A reaction and whether another follows in its reply.
-    Reaction(Reaction<T>, Flow),
+    Reaction(Reaction, Flow),
     /// An empty reply or a transport-level stream-end control.
     End(End),
 }
 
 /// A frame paired with the logical stream named by its signal byte.
-pub type WireFrame<T> = (Stream, Frame<T>);
+pub type WireFrame = (Stream, Frame);
 
 /// One supply frame's run of leaf records, held in encoded form.
 ///
@@ -72,35 +69,33 @@ pub type WireFrame<T> = (Stream, Frame<T>);
 ///
 /// [`push`]: Self::push
 /// [`records`]: Self::records
-pub struct LeafRun<T> {
+pub struct LeafRun {
     bytes: Vec<u8>,
-    marker: PhantomData<fn() -> T>,
 }
 
-impl<T> Default for LeafRun<T> {
+impl Default for LeafRun {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl<T> Clone for LeafRun<T> {
+impl Clone for LeafRun {
     fn clone(&self) -> Self {
         Self {
             bytes: self.bytes.clone(),
-            marker: PhantomData,
         }
     }
 }
 
-impl<T> PartialEq for LeafRun<T> {
+impl PartialEq for LeafRun {
     fn eq(&self, other: &Self) -> bool {
         self.bytes == other.bytes
     }
 }
 
-impl<T> Eq for LeafRun<T> {}
+impl Eq for LeafRun {}
 
-impl<T> std::fmt::Debug for LeafRun<T> {
+impl std::fmt::Debug for LeafRun {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("LeafRun")
             .field("records", &self.record_count())
@@ -109,14 +104,11 @@ impl<T> std::fmt::Debug for LeafRun<T> {
     }
 }
 
-impl<T> LeafRun<T> {
+impl LeafRun {
     /// Start an empty run; at least one record must be pushed before it may
     /// become a frame.
     pub fn new() -> Self {
-        Self {
-            bytes: Vec::new(),
-            marker: PhantomData,
-        }
+        Self { bytes: Vec::new() }
     }
 
     /// Whether no record has been pushed yet.
@@ -194,10 +186,7 @@ impl<T> LeafRun<T> {
             }
             rest = &body[len..];
         }
-        Ok(Self {
-            bytes,
-            marker: PhantomData,
-        })
+        Ok(Self { bytes })
     }
 
     /// The number of records in this run.
@@ -206,11 +195,12 @@ impl<T> LeafRun<T> {
     }
 
     /// Iterate the run's records, decoding each into its canonical pair.
-    pub fn records(&self) -> impl Iterator<Item = Result<(Version, Message), DecodeLeafError>>
-    where
-        T: DeserializeOwned + Send + Sync + 'static,
-    {
-        self.record_slices().map(parse_record::<T>)
+    pub fn records(
+        &self,
+        deserializer: PayloadDeserializer,
+    ) -> impl Iterator<Item = Result<(Version, Message), DecodeLeafError>> {
+        self.record_slices()
+            .map(move |record| parse_record(record, deserializer))
     }
 
     /// Split the validated run back into its exact record slices.
@@ -263,8 +253,9 @@ fn record_header(header: &[u8]) -> usize {
 }
 
 /// Decode one exact record body into its canonical pair.
-fn parse_record<T: DeserializeOwned + Send + Sync + 'static>(
+fn parse_record(
     record: &[u8],
+    deserializer: PayloadDeserializer,
 ) -> Result<(Version, Message), DecodeLeafError> {
     // Both fields are self-delimiting CBOR values, so the exact record
     // body parses without retrying, and whatever the payload's parse does
@@ -278,13 +269,12 @@ fn parse_record<T: DeserializeOwned + Send + Sync + 'static>(
     let mut input = record;
     let version: Version =
         ciborium::de::from_reader(&mut input).map_err(|e| DecodeLeafError::Version(de_error(e)))?;
-    let payload = input;
-    let message: T =
-        ciborium::de::from_reader(&mut input).map_err(|e| DecodeLeafError::Message(de_error(e)))?;
-    if !input.is_empty() {
-        return Err(DecodeLeafError::TrailingBytes { count: input.len() });
-    }
-    let message = Message::from_decoded(message, bytes::Bytes::copy_from_slice(payload));
+    // The deserializer owns the payload parse, including the
+    // exactly-one-value check the record framing otherwise cannot make
+    // (the payload runs to the record's end), so trailing bytes surface
+    // as its InvalidData.
+    let message = Message::from_wire(bytes::Bytes::copy_from_slice(input), deserializer)
+        .map_err(DecodeLeafError::Message)?;
     Ok((version, message))
 }
 
diff --git a/src/tree/mirror/streaming/remote/codec/frame/tests.rs b/src/tree/mirror/streaming/remote/codec/frame/tests.rs
index 4394f4900..f21de3348 100644
--- a/src/tree/mirror/streaming/remote/codec/frame/tests.rs
+++ b/src/tree/mirror/streaming/remote/codec/frame/tests.rs
@@ -59,11 +59,11 @@ fn record_len_matches_an_actual_push() {
         }
         checked_regimes.insert(super::cbor_bytes_header_len(version.as_bytes().len()));
         for message in [Message::new(0u64), Message::new(u64::MAX)] {
-            let mut run = LeafRun::<u64>::new();
+            let mut run = LeafRun::new();
             run.push(&version, &message).expect("test records fit");
             assert_eq!(
                 run.encoded_len(),
-                LeafRun::<u64>::record_len(&version, &message),
+                LeafRun::record_len(&version, &message),
                 "record_len must price exactly one pushed record",
             );
             // The version atom `push` writes is byte-identical to the
diff --git a/src/tree/mirror/streaming/remote/codec/tests.rs b/src/tree/mirror/streaming/remote/codec/tests.rs
index 7adb6b03f..cfda12463 100644
--- a/src/tree/mirror/streaming/remote/codec/tests.rs
+++ b/src/tree/mirror/streaming/remote/codec/tests.rs
@@ -67,7 +67,7 @@ const MAX_ARBITRARY_SUFFIX_LEN: usize = 32;
 const MAX_ARBITRARY_RUN_RECORDS: usize = 4;
 
 /// Build a supply run from decoded leaf records.
-fn leaf_run<T: Serialize + Clone + Send + Sync + 'static>(records: &[(Version, T)]) -> LeafRun<T> {
+fn leaf_run<T: Serialize + Clone + Send + Sync + 'static>(records: &[(Version, T)]) -> LeafRun {
     let mut run = LeafRun::new();
     for (version, value) in records {
         run.push(version, &Message::new(value.clone()))
@@ -93,7 +93,7 @@ fn arb_flow() -> impl Strategy<Value = Flow> {
     prop_oneof![Just(Flow::Continue), Just(Flow::End)]
 }
 
-fn arb_frame() -> impl Strategy<Value = WireFrame<u64>> {
+fn arb_frame() -> impl Strategy<Value = WireFrame> {
     prop_oneof![
         (arb_stream(), arb_flow())
             .prop_map(|(stream, flow)| (stream, Frame::Reaction(Reaction::Match, flow))),
@@ -135,7 +135,7 @@ proptest! {
         encoded.extend_from_slice(&suffix);
 
         let mut rest = encoded.as_slice();
-        let decoded = decode::<u64>(speaker, RunBudget::default(), &mut rest).unwrap();
+        let decoded = decode(speaker, RunBudget::default(), &mut rest).unwrap();
         prop_assert_eq!(&decoded, &frame);
         prop_assert_eq!(rest, suffix.as_slice());
 
@@ -166,9 +166,9 @@ proptest! {
         prop_assert_eq!(&written.bytes, &canonical);
 
         let mut reader = FrameRead::new(speaker, RunBudget::default(), written.bytes.as_slice());
-        let decoded = pollster::block_on(reader.frame::<u64>()).unwrap();
+        let decoded = pollster::block_on(reader.frame()).unwrap();
         prop_assert_eq!(decoded, Some(frame));
-        prop_assert_eq!(pollster::block_on(reader.frame::<u64>()).unwrap(), None);
+        prop_assert_eq!(pollster::block_on(reader.frame()).unwrap(), None);
     }
 }
 
@@ -233,9 +233,9 @@ async fn async_duplex_preserves_adjacent_frame_boundaries() {
         };
         let receiving = async {
             let mut reader = FrameRead::new(speaker, RunBudget::default(), receive);
-            assert_eq!(reader.frame::<u64>().await.unwrap(), Some(first));
-            assert_eq!(reader.frame::<u64>().await.unwrap(), Some(second));
-            assert_eq!(reader.frame::<u64>().await.unwrap(), None);
+            assert_eq!(reader.frame().await.unwrap(), Some(first));
+            assert_eq!(reader.frame().await.unwrap(), Some(second));
+            assert_eq!(reader.frame().await.unwrap(), None);
         };
         futures::join!(sending, receiving);
     }
@@ -258,7 +258,7 @@ fn canonical_frame_atlas_snapshot() {
                         encode(speaker, &(stream, frame.clone()), &mut encoded).unwrap();
                         assert_eq!(encoded.first(), Some(&wire.to_byte()));
                         assert_eq!(
-                            decode_exact::<()>(speaker, RunBudget::default(), &encoded).unwrap(),
+                            decode_exact(speaker, RunBudget::default(), &encoded).unwrap(),
                             (stream, frame)
                         );
                         write!(atlas, "    {signal:?}: accepted len {} hex ", encoded.len())
@@ -267,9 +267,8 @@ fn canonical_frame_atlas_snapshot() {
                         atlas.push('\n');
                     }
                     Err(invalid) => {
-                        let error =
-                            decode_exact::<()>(speaker, RunBudget::default(), &[invalid.byte()])
-                                .unwrap_err();
+                        let error = decode_exact(speaker, RunBudget::default(), &[invalid.byte()])
+                            .unwrap_err();
                         assert_eq!(error.origin, Origin::stream(speaker, stream));
                         assert!(matches!(
                             error.kind,
@@ -297,7 +296,7 @@ fn write_hex(out: &mut impl Write, bytes: &[u8]) {
     }
 }
 
-fn representative_frame(signal: Signal) -> Frame<()> {
+fn representative_frame(signal: Signal) -> Frame {
     match signal {
         Signal::Match(flow) => Frame::Reaction(Reaction::Match, flow),
         Signal::QueryEmpty(flow) => Frame::Reaction(Reaction::Query(Vec::new()), flow),
@@ -442,7 +441,7 @@ fn enumerate_queries(
     }
 }
 
-fn check_both(frame: WireFrame<()>, accepted: &mut [usize; 2], buckets: &mut [CorpusBucket]) {
+fn check_both(frame: WireFrame, accepted: &mut [usize; 2], buckets: &mut [CorpusBucket]) {
     let signal = frame_signal(&frame.1);
     let signal_index = SIGNALS
         .iter()
@@ -459,7 +458,7 @@ fn check_both(frame: WireFrame<()>, accepted: &mut [usize; 2], buckets: &mut [Co
                 encode(speaker, &frame, &mut encoded).unwrap();
                 accepted[direction] += 1;
                 assert_eq!(
-                    decode_exact::<()>(speaker, RunBudget::default(), &encoded).unwrap(),
+                    decode_exact(speaker, RunBudget::default(), &encoded).unwrap(),
                     frame
                 );
                 bucket.accept(&encoded);
@@ -469,7 +468,7 @@ fn check_both(frame: WireFrame<()>, accepted: &mut [usize; 2], buckets: &mut [Co
     }
 }
 
-fn frame_signal<T>(frame: &Frame<T>) -> Signal {
+fn frame_signal(frame: &Frame) -> Signal {
     match frame {
         Frame::Reaction(Reaction::Match, flow) => Signal::Match(*flow),
         Frame::Reaction(Reaction::Query(children), flow) if children.is_empty() => {
@@ -499,7 +498,7 @@ fn generic_io_preserves_frame_boundaries() {
 
     let mut reader = Cursor::new(writer.into_inner());
     assert_eq!(
-        decode::<()>(Speaker::Initiator, RunBudget::default(), &mut reader).unwrap(),
+        decode(Speaker::Initiator, RunBudget::default(), &mut reader).unwrap(),
         frame
     );
     assert_eq!(reader.position(), frame_len);
diff --git a/src/tree/mirror/streaming/remote/codec/tests/error_atlas.rs b/src/tree/mirror/streaming/remote/codec/tests/error_atlas.rs
index a8b261f60..eaf44cc30 100644
--- a/src/tree/mirror/streaming/remote/codec/tests/error_atlas.rs
+++ b/src/tree/mirror/streaming/remote/codec/tests/error_atlas.rs
@@ -55,7 +55,6 @@ const WITNESS_MARKERS: &[&str] = &[
     // DecodeLeafError (describe_leaf_kind).
     "kind: Record::Version(io=",
     "kind: Record::Message(io=",
-    "kind: Record::TrailingBytes(count=",
     // FramePart: every frame component must fail somewhere. These ride the
     // encode Write witnesses; FramePart has no exhaustive match here, so a
     // new component's marker must be added by hand alongside its witnesses.
@@ -82,7 +81,7 @@ const INTERIOR_STREAM: u8 = 8;
 const FIRST_RESERVED_SIGNAL: u8 = WireSignal::BYTE_COUNT;
 
 /// Build a supply run holding one leaf record.
-fn one_record_run<T: Serialize + Send + Sync + 'static>(version: Version, value: T) -> LeafRun<T> {
+fn one_record_run<T: Serialize + Send + Sync + 'static>(version: Version, value: T) -> LeafRun {
     let mut run = LeafRun::new();
     run.push(&version, &Message::new(value))
         .expect("an atlas record fits the run framing");
@@ -127,14 +126,14 @@ fn build_atlas() -> String {
 fn encode_errors(atlas: &mut String) {
     writeln!(atlas, "ENCODE").unwrap();
     let stream = Stream::new(INTERIOR_STREAM).unwrap();
-    let query: WireFrame<u8> = (
+    let query: WireFrame = (
         stream,
         Frame::Reaction(
             Reaction::Query(vec![(1, Hash::default()), (2, Hash::default())]),
             Flow::Continue,
         ),
     );
-    let supply: WireFrame<u8> = (
+    let supply: WireFrame = (
         stream,
         Frame::Reaction(
             Reaction::Supply(one_record_run(Version::new(), 7)),
@@ -167,7 +166,7 @@ fn decode_errors(atlas: &mut String) {
         Speaker::Initiator,
         (
             stream,
-            Frame::<u8>::Reaction(
+            Frame::Reaction(
                 Reaction::Query(vec![(1, Hash::default()), (2, Hash::default())]),
                 Flow::Continue,
             ),
@@ -185,14 +184,11 @@ fn decode_errors(atlas: &mut String) {
     );
     let matched = encoded(
         Speaker::Initiator,
-        (
-            stream,
-            Frame::<u8>::Reaction(Reaction::Match, Flow::Continue),
-        ),
+        (stream, Frame::Reaction(Reaction::Match, Flow::Continue)),
     );
 
     for speaker in [Speaker::Initiator, Speaker::Responder] {
-        let error = decode::<u8>(
+        let error = decode(
             speaker,
             RunBudget::default(),
             &mut FailAfterReader::new(matched.clone(), 0),
@@ -201,7 +197,7 @@ fn decode_errors(atlas: &mut String) {
         record_decode(atlas, &format!("{speaker:?}/read/signal"), &error);
 
         for (label, offset) in [("query-count", 1), ("query-children", 2)] {
-            let error = decode::<u8>(
+            let error = decode(
                 speaker,
                 RunBudget::default(),
                 &mut FailAfterReader::new(query.clone(), offset),
@@ -210,7 +206,7 @@ fn decode_errors(atlas: &mut String) {
             record_decode(atlas, &format!("{speaker:?}/read/{label}"), &error);
         }
         for (label, offset) in [("supply-length", 1), ("supply-run", 5)] {
-            let error = decode::<u8>(
+            let error = decode(
                 speaker,
                 RunBudget::default(),
                 &mut FailAfterReader::new(supply.clone(), offset),
@@ -226,21 +222,21 @@ fn decode_errors(atlas: &mut String) {
             ("supply-length", &supply[..1]),
             ("supply-run", &supply[..5]),
         ] {
-            let error = decode_exact::<u8>(speaker, RunBudget::default(), bytes).unwrap_err();
+            let error = decode_exact(speaker, RunBudget::default(), bytes).unwrap_err();
             record_decode(atlas, &format!("{speaker:?}/truncated/{label}"), &error);
         }
 
-        let error = decode_exact::<u8>(speaker, RunBudget::default(), &[FIRST_RESERVED_SIGNAL])
-            .unwrap_err();
+        let error =
+            decode_exact(speaker, RunBudget::default(), &[FIRST_RESERVED_SIGNAL]).unwrap_err();
         record_decode(atlas, &format!("{speaker:?}/reserved-signal"), &error);
 
         let mut unordered = query.clone();
         unordered[2] = 2;
         unordered[2 + QUERY_CHILD_LEN] = 1;
-        let error = decode_exact::<u8>(speaker, RunBudget::default(), &unordered).unwrap_err();
+        let error = decode_exact(speaker, RunBudget::default(), &unordered).unwrap_err();
         record_decode(atlas, &format!("{speaker:?}/query-out-of-order"), &error);
 
-        let error = decode_exact::<u64>(
+        let error = decode_exact(
             speaker,
             RunBudget::default(),
             &raw_supply(stream, Flow::Continue, &[]),
@@ -248,7 +244,7 @@ fn decode_errors(atlas: &mut String) {
         .unwrap_err();
         record_decode(atlas, &format!("{speaker:?}/run/empty"), &error);
 
-        let error = decode_exact::<u64>(
+        let error = decode_exact(
             speaker,
             RunBudget::default(),
             &raw_supply(stream, Flow::Continue, &[0, 0]),
@@ -258,7 +254,7 @@ fn decode_errors(atlas: &mut String) {
 
         let mut overrun = 2_u32.to_be_bytes().to_vec();
         overrun.push(0);
-        let error = decode_exact::<u64>(
+        let error = decode_exact(
             speaker,
             RunBudget::default(),
             &raw_supply(stream, Flow::Continue, &overrun),
@@ -281,20 +277,19 @@ fn decode_errors(atlas: &mut String) {
             &mut batched,
         )
         .unwrap();
-        let error = decode_exact::<u8>(speaker, RunBudget::from_bytes(0), &batched).unwrap_err();
+        let error = decode_exact(speaker, RunBudget::from_bytes(0), &batched).unwrap_err();
         record_decode(atlas, &format!("{speaker:?}/run/overbatched"), &error);
 
         let mut trailing = matched.clone();
         trailing.push(0);
-        let error = decode_exact::<u8>(speaker, RunBudget::default(), &trailing).unwrap_err();
+        let error = decode_exact(speaker, RunBudget::default(), &trailing).unwrap_err();
         record_decode(atlas, &format!("{speaker:?}/frame/trailing"), &error);
     }
 
     for (label, speaker, stream, frame) in placement_witnesses() {
         let signal = frame_signal(&frame);
         let invalid = WireSignal::new(speaker, stream, signal).unwrap_err();
-        let error =
-            decode_exact::<u8>(speaker, RunBudget::default(), &[invalid.byte()]).unwrap_err();
+        let error = decode_exact(speaker, RunBudget::default(), &[invalid.byte()]).unwrap_err();
         record_decode(atlas, &format!("{label}/decode"), &error);
     }
 }
@@ -309,20 +304,21 @@ fn record_errors(atlas: &mut String) {
 
     // A zero-length record is structurally valid; its empty body fails
     // at the version decoder.
-    let run = LeafRun::<u64>::from_encoded(framed_record(&[])).unwrap();
+    let run = LeafRun::from_encoded(framed_record(&[])).unwrap();
     record_leaf(atlas, "record/version", &next_record_error(&run));
 
     // A record ending after its version fails at the message decoder.
     let mut version = Vec::new();
     ciborium::ser::into_writer(&Version::new(), &mut version).unwrap();
-    let run = LeafRun::<u64>::from_encoded(framed_record(&version)).unwrap();
+    let run = LeafRun::from_encoded(framed_record(&version)).unwrap();
     record_leaf(atlas, "record/message", &next_record_error(&run));
 
-    // Bytes past the canonical pair are trailing.
+    // Bytes past the canonical pair are a malformed payload: the payload
+    // runs to the record's end, so the deserializer rejects the excess.
     let mut padded = version.clone();
     ciborium::ser::into_writer(&0_u64, &mut padded).unwrap();
     padded.push(u8::MIN);
-    let run = LeafRun::<u64>::from_encoded(framed_record(&padded)).unwrap();
+    let run = LeafRun::from_encoded(framed_record(&padded)).unwrap();
     record_leaf(atlas, "record/trailing", &next_record_error(&run));
 }
 
@@ -334,8 +330,8 @@ fn framed_record(record: &[u8]) -> Vec<u8> {
 }
 
 /// The first record's decode failure from a structurally valid run.
-fn next_record_error(run: &LeafRun<u64>) -> DecodeLeafError {
-    run.records()
+fn next_record_error(run: &LeafRun) -> DecodeLeafError {
+    run.records(Message::deserializer::<u64>())
         .next()
         .expect("the run holds one record")
         .unwrap_err()
@@ -361,13 +357,10 @@ fn describe_leaf_kind(out: &mut String, kind: &DecodeLeafError) {
         DecodeLeafError::Message(source) => {
             write!(out, "Record::Message(io={:?})", source.kind()).unwrap()
         }
-        DecodeLeafError::TrailingBytes { count } => {
-            write!(out, "Record::TrailingBytes(count={count})").unwrap()
-        }
     }
 }
 
-fn placement_witnesses() -> [(&'static str, Speaker, Stream, Frame<u8>); 3] {
+fn placement_witnesses() -> [(&'static str, Speaker, Stream, Frame); 3] {
     [
         (
             "placement/opening-supplies",
@@ -390,7 +383,7 @@ fn placement_witnesses() -> [(&'static str, Speaker, Stream, Frame<u8>); 3] {
     ]
 }
 
-fn encoded<T>(speaker: Speaker, frame: WireFrame<T>) -> Vec<u8> {
+fn encoded(speaker: Speaker, frame: WireFrame) -> Vec<u8> {
     let mut bytes = Vec::new();
     encode(speaker, &frame, &mut bytes).unwrap();
     bytes
@@ -406,7 +399,7 @@ fn raw_supply(stream: Stream, flow: Flow, body: &[u8]) -> Vec<u8> {
     encoded
 }
 
-fn frame_signal<T>(frame: &Frame<T>) -> Signal {
+fn frame_signal(frame: &Frame) -> Signal {
     match frame {
         Frame::Reaction(Reaction::Match, flow) => Signal::Match(*flow),
         Frame::Reaction(Reaction::Query(children), flow) if children.is_empty() => {
diff --git a/src/tree/mirror/streaming/remote/codec/tests/snapshots/rumors__tree__mirror__streaming__remote__codec__tests__error_atlas__codec_error_atlas_snapshot.snap b/src/tree/mirror/streaming/remote/codec/tests/snapshots/rumors__tree__mirror__streaming__remote__codec__tests__error_atlas__codec_error_atlas_snapshot.snap
index 0b652e48f..299c92125 100644
--- a/src/tree/mirror/streaming/remote/codec/tests/snapshots/rumors__tree__mirror__streaming__remote__codec__tests__error_atlas__codec_error_atlas_snapshot.snap
+++ b/src/tree/mirror/streaming/remote/codec/tests/snapshots/rumors__tree__mirror__streaming__remote__codec__tests__error_atlas__codec_error_atlas_snapshot.snap
@@ -293,5 +293,6 @@ RECORD
     kind: Record::Message(io=UnexpectedEof)
     source[0]: Io(UnexpectedEof)
   record/trailing
-    display: 1 trailing bytes follow the supplied Version and Message
-    kind: Record::TrailingBytes(count=1)
+    display: supplied Message could not be decoded
+    kind: Record::Message(io=InvalidData)
+    source[0]: Io(InvalidData)
diff --git a/src/tree/mirror/streaming/remote/proxy/start.rs b/src/tree/mirror/streaming/remote/proxy/start.rs
index ec4868000..bf5b4f2b3 100644
--- a/src/tree/mirror/streaming/remote/proxy/start.rs
+++ b/src/tree/mirror/streaming/remote/proxy/start.rs
@@ -1,7 +1,7 @@
 //! The wire participant's protocol handshake states.
 
+use crate::message::PayloadDeserializer;
 use std::io;
-use std::marker::PhantomData;
 
 use tokio::io::{AsyncRead, AsyncWrite};
 
@@ -35,17 +35,15 @@ use crate::{
     },
 };
 
-use serde::de::DeserializeOwned;
 /// A wire-bound protocol participant ready for the version handshake.
 ///
 /// Consumes a [`Link`] carrier for one session: the control halves host the
 /// causal-version handshake (and are the session's output), the connector
 /// and acceptor supply the descent's data streams, and the carrier's epoch
 /// labels every stream this session opens.
-pub struct Handshaking<B, T, R, W, C, A, V = Start>
+pub struct Handshaking<B, R, W, C, A, V = Start>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     backend: B,
     link: Link<R, W, C, A>,
@@ -57,23 +55,28 @@ where
     /// The session's stats recorder: every stream this session binds
     /// counts its codec bytes through it.
     stats: Recorder,
-    marker: PhantomData<fn() -> T>,
+    /// The peer's payload deserializer: the typed ingress every supplied
+    /// leaf record decodes through (see
+    /// [`Message::deserializer`](crate::message::Message::deserializer)).
+    deserializer: PayloadDeserializer,
 }
 
-impl<B, T, R, W, C, A> Handshaking<B, T, R, W, C, A>
+impl<B, R, W, C, A> Handshaking<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     /// Bind one session's link carrier before exchanging causal versions.
-    pub fn start(backend: B, link: Link<R, W, C, A>) -> Self {
+    ///
+    /// `deserializer` is the peer's payload deserializer: every leaf
+    /// record this session decodes builds its payload through it.
+    pub fn start(backend: B, link: Link<R, W, C, A>, deserializer: PayloadDeserializer) -> Self {
         Self {
             backend,
             link,
             versions: Start,
             window: WindowConfig::default(),
             stats: Recorder::default(),
-            marker: PhantomData,
+            deserializer,
         }
     }
 
@@ -103,10 +106,9 @@ pub struct Connecting {
     remote: Greeting,
 }
 
-impl<B, T, R, W, C, A, V> protocol::Protocol for Handshaking<B, T, R, W, C, A, V>
+impl<B, R, W, C, A, V> protocol::Protocol for Handshaking<B, R, W, C, A, V>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: Send,
     W: Send,
     C: Send,
@@ -118,16 +120,15 @@ where
     type Output = (R, W);
 }
 
-impl<B, T, R, W, C, A> Connect<B, T> for Handshaking<B, T, R, W, C, A>
+impl<B, R, W, C, A> Connect<B> for Handshaking<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
     C: Connector,
     A: Acceptor,
 {
-    type Next = Handshaking<B, T, R, W, C, A, Connecting>;
+    type Next = Handshaking<B, R, W, C, A, Connecting>;
 
     /// Receive the remote greeting before asking the local server to answer it.
     async fn connect(mut self) -> Result<(Greeting, Self::Next), Self::Error> {
@@ -139,22 +140,21 @@ where
             versions: Connecting { remote },
             window: self.window,
             stats: self.stats,
-            marker: PhantomData,
+            deserializer: self.deserializer,
         };
         Ok((greeting, next))
     }
 }
 
-impl<B, T, R, W, C, A> CompleteConnect<B, T> for Handshaking<B, T, R, W, C, A, Connecting>
+impl<B, R, W, C, A> CompleteConnect<B> for Handshaking<B, R, W, C, A, Connecting>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
     C: Connector,
     A: Acceptor,
 {
-    type Next = Connected<B, T, R, W, C, A>;
+    type Next = Connected<B, R, W, C, A>;
 
     /// Send the local server's greeting, then open only if versions differ.
     async fn complete_connect(mut self, theirs: Greeting) -> Result<Self::Next, Self::Error> {
@@ -175,20 +175,20 @@ where
             self.versions.remote,
             self.link,
             self.stats,
+            self.deserializer,
         ))
     }
 }
 
-impl<B, T, R, W, C, A> Accept<B, T> for Handshaking<B, T, R, W, C, A>
+impl<B, R, W, C, A> Accept<B> for Handshaking<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: AsyncRead + Unpin + Send,
     W: AsyncWrite + Unpin + Send,
     C: Connector,
     A: Acceptor,
 {
-    type Next = Connected<B, T, R, W, C, A>;
+    type Next = Connected<B, R, W, C, A>;
 
     /// Exchange greetings concurrently, then open only if versions differ.
     async fn accept(mut self, request: Greeting) -> Result<(Greeting, Self::Next), Self::Error> {
@@ -212,6 +212,7 @@ where
             remote,
             self.link,
             self.stats,
+            self.deserializer,
         );
         Ok((greeting, next))
     }
@@ -312,7 +313,9 @@ where
 ///
 /// On equality both carried listings are dropped unused — the documented
 /// price of carrying them unconditionally.
-fn connected<B, T, R, W, C, A>(
+#[allow(clippy::too_many_arguments)] // The argument list is the handshake's
+// dataflow into the elected session, one premise per argument.
+fn connected<B, R, W, C, A>(
     backend: B,
     window: Window,
     budget: RunBudget,
@@ -320,10 +323,10 @@ fn connected<B, T, R, W, C, A>(
     remote: Greeting,
     link: Link<R, W, C, A>,
     stats: Recorder,
-) -> Connected<B, T, R, W, C, A>
+    deserializer: PayloadDeserializer,
+) -> Connected<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     C: Connector,
     A: Acceptor,
 {
@@ -352,6 +355,7 @@ where
         remote.listing,
         link,
         stats,
+        deserializer,
     )
 }
 
@@ -365,7 +369,7 @@ where
 /// version the remote supplies; `peer_set_len` is its declared set
 /// length, which the session charges per supplied record at ingress.
 #[allow(clippy::too_many_arguments)]
-fn open<B, T, R, W, C, A>(
+fn open<B, R, W, C, A>(
     backend: B,
     window: Window,
     budget: RunBudget,
@@ -375,10 +379,10 @@ fn open<B, T, R, W, C, A>(
     peer_listing: Vec<(u8, Hash)>,
     link: Link<R, W, C, A>,
     stats: Recorder,
-) -> Connected<B, T, R, W, C, A>
+    deserializer: PayloadDeserializer,
+) -> Connected<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     C: Connector,
     A: Acceptor,
 {
@@ -408,6 +412,7 @@ where
             accept,
             errors,
         },
+        deserializer,
     );
     Connected::new(remote, epoch, connector, claims, route, budget, stats, work)
 }
diff --git a/src/tree/mirror/streaming/remote/proxy/state.rs b/src/tree/mirror/streaming/remote/proxy/state.rs
index 39554ef92..7d51a6601 100644
--- a/src/tree/mirror/streaming/remote/proxy/state.rs
+++ b/src/tree/mirror/streaming/remote/proxy/state.rs
@@ -26,12 +26,10 @@ use crate::tree::{
     typed::height::{Height, Root, S, UnderRoot, UnderUnderRoot, Z},
 };
 
-use serde::de::DeserializeOwned;
 /// Session endpoints and backend shared by every state in one proxy chain.
-struct Session<B, T, R, W, C, A>
+struct Session<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     A: Acceptor,
 {
     remote: Speaker,
@@ -46,18 +44,17 @@ where
     /// The session's stats recorder, handed to every stream this session
     /// binds so the codec seam's byte counts accumulate in one place.
     stats: Recorder,
-    work: Work<B, T, R, W, A>,
+    work: Work<B, R, W, A>,
 }
 
-impl<B, T, R, W, C, A> Session<B, T, R, W, C, A>
+impl<B, R, W, C, A> Session<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     C: Connector,
     A: Acceptor,
 {
     /// Bind the incoming logical stream spoken by the remote at `height`.
-    fn incoming<H: Height>(&mut self) -> StreamReceiver<A::Rx, T> {
+    fn incoming<H: Height>(&mut self) -> StreamReceiver<A::Rx> {
         let stream = stream_at::<H>(self.remote);
         StreamReceiver::new(
             self.claims.take(stream),
@@ -70,7 +67,7 @@ where
     }
 
     /// Bind the outgoing logical stream spoken locally at `height`.
-    fn outgoing<H: Height>(&mut self) -> StreamSender<C, T> {
+    fn outgoing<H: Height>(&mut self) -> StreamSender<C> {
         let local = self.remote.other();
         StreamSender::new(
             self.connector.clone(),
@@ -88,30 +85,27 @@ fn stream_at<H: Height>(speaker: Speaker) -> Stream {
 }
 
 /// A proxy after the version exchange but before its elected role is known.
-pub struct Connected<B, T, R, W, C, A>
+pub struct Connected<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     A: Acceptor,
 {
-    state: ConnectedState<B, T, R, W, C, A>,
+    state: ConnectedState<B, R, W, C, A>,
 }
 
 /// Equal versions need no data streams; divergent versions own a session.
-enum ConnectedState<B, T, R, W, C, A>
+enum ConnectedState<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     A: Acceptor,
 {
     Equal(R, W),
-    Diverged(Box<Session<B, T, R, W, C, A>>),
+    Diverged(Box<Session<B, R, W, C, A>>),
 }
 
-impl<B, T, R, W, C, A> Connected<B, T, R, W, C, A>
+impl<B, R, W, C, A> Connected<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     C: Connector,
     A: Acceptor,
 {
@@ -125,7 +119,7 @@ where
         route: ErrorRoute,
         budget: RunBudget,
         stats: Recorder,
-        work: Work<B, T, R, W, A>,
+        work: Work<B, R, W, A>,
     ) -> Self {
         Self {
             state: ConnectedState::Diverged(Box::new(Session {
@@ -149,7 +143,7 @@ where
     }
 
     /// Extract the session guaranteed by the driver's divergent-version path.
-    fn diverged(self) -> Session<B, T, R, W, C, A> {
+    fn diverged(self) -> Session<B, R, W, C, A> {
         match self.state {
             ConnectedState::Diverged(session) => *session,
             ConnectedState::Equal(..) => unreachable!("descent opened for equal versions"),
@@ -157,10 +151,9 @@ where
     }
 }
 
-impl<B, T, R, W, C, A> protocol::Protocol for Connected<B, T, R, W, C, A>
+impl<B, R, W, C, A> protocol::Protocol for Connected<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: Send,
     W: Send,
     C: Send,
@@ -172,15 +165,14 @@ where
 }
 
 /// A proxy inside the descent with scopes for the next local reply stream.
-pub struct Descending<B, T, H, R, W, C, A>
+pub struct Descending<B, H, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     H: Height,
     S<H>: Height,
     A: Acceptor,
 {
-    session: Session<B, T, R, W, C, A>,
+    session: Session<B, R, W, C, A>,
     /// The next local reply's scopes, erased: the typestate's `H` is what
     /// pins this queue to the stage that consumes it at the right height,
     /// and every scope's parent prefix carries the runtime witness.
@@ -190,27 +182,25 @@ where
     ///
     /// The receiver claims its transport stream on first read, so a
     /// session without early supplies never touches it.
-    early: Option<StreamReceiver<A::Rx, T>>,
+    early: Option<StreamReceiver<A::Rx>>,
     /// The stage's height, phantom (`fn() -> H` for the auto-trait
     /// shortcut; see [`typed::Node`](crate::tree::typed::Node)).
     height: PhantomData<fn() -> H>,
 }
 
 /// The initiator proxy's leaf terminal and accumulated transport work.
-pub struct Completing<B, T, R, W, C, A>
+pub struct Completing<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     A: Acceptor,
 {
-    session: Session<B, T, R, W, C, A>,
+    session: Session<B, R, W, C, A>,
     scopes: Receiver<Scope>,
 }
 
-impl<B, T, H, R, W, C, A> protocol::Protocol for Descending<B, T, H, R, W, C, A>
+impl<B, H, R, W, C, A> protocol::Protocol for Descending<B, H, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: Send,
     W: Send,
     C: Send,
@@ -223,10 +213,9 @@ where
     type Output = (R, W);
 }
 
-impl<B, T, R, W, C, A> protocol::Protocol for Completing<B, T, R, W, C, A>
+impl<B, R, W, C, A> protocol::Protocol for Completing<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: Send,
     W: Send,
     C: Send,
@@ -237,10 +226,9 @@ where
     type Output = (R, W);
 }
 
-impl<B, T, R, W, C, A> protocol::CompleteEqual<B, T> for Connected<B, T, R, W, C, A>
+impl<B, R, W, C, A> protocol::CompleteEqual<B> for Connected<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: Send,
     W: Send,
     C: Connector,
@@ -255,16 +243,15 @@ where
     }
 }
 
-impl<B, T, R, W, C, A> protocol::Initiator<B, T> for Connected<B, T, R, W, C, A>
+impl<B, R, W, C, A> protocol::Initiator<B> for Connected<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: Send,
     W: Send,
     C: Connector,
     A: Acceptor,
 {
-    type Next = Descending<B, T, UnderRoot, R, W, C, A>;
+    type Next = Descending<B, UnderRoot, R, W, C, A>;
 
     /// Replay the remote initiator's opening question from its greeting.
     ///
@@ -273,7 +260,7 @@ where
     /// stream carries the remote's early supplies instead: its receiver is
     /// bound now and handed to the next stage, which reads (and thereby
     /// claims) it only when a root-level request needs an opening supply.
-    fn initiator(self) -> (BoxResponses<B, T, UnderRoot, Self::Error>, Self::Next) {
+    fn initiator(self) -> (BoxResponses<B, UnderRoot, Self::Error>, Self::Next) {
         let mut session = self.diverged();
         debug_assert_eq!(session.remote, Speaker::Initiator);
         let early = session.incoming::<UnderRoot>();
@@ -288,16 +275,15 @@ where
     }
 }
 
-impl<B, T, R, W, C, A> protocol::Responder<B, T> for Connected<B, T, R, W, C, A>
+impl<B, R, W, C, A> protocol::Responder<B> for Connected<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: Send,
     W: Send,
     C: Connector,
     A: Acceptor,
 {
-    type Next = Descending<B, T, UnderUnderRoot, R, W, C, A>;
+    type Next = Descending<B, UnderUnderRoot, R, W, C, A>;
 
     /// Proxy the opening: consume the local question, write the early
     /// supplies, decode the remote's top-level reply.
@@ -310,8 +296,8 @@ where
     /// root children.
     fn responder(
         self,
-        requests: impl Requests<B, T, UnderRoot>,
-    ) -> (BoxResponses<B, T, UnderRoot, Self::Error>, Self::Next) {
+        requests: impl Requests<B, UnderRoot>,
+    ) -> (BoxResponses<B, UnderRoot, Self::Error>, Self::Next) {
         let mut session = self.diverged();
         debug_assert_eq!(session.remote, Speaker::Responder);
         let incoming = session.incoming::<UnderRoot>();
@@ -327,10 +313,9 @@ where
     }
 }
 
-impl<B, T, H, R, W, C, A> protocol::Reply<B, T> for Descending<B, T, S<S<H>>, R, W, C, A>
+impl<B, H, R, W, C, A> protocol::Reply<B> for Descending<B, S<S<H>>, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: Send,
     W: Send,
     C: Connector,
@@ -340,13 +325,13 @@ where
     S<S<H>>: Height,
     S<S<S<H>>>: Height,
 {
-    type Next = Descending<B, T, H, R, W, C, A>;
+    type Next = Descending<B, H, R, W, C, A>;
 
     /// Proxy one ordinary two-height descent transition.
     fn reply(
         mut self,
-        requests: impl Requests<B, T, S<S<H>>>,
-    ) -> (BoxResponses<B, T, S<H>, Self::Error>, Self::Next) {
+        requests: impl Requests<B, S<S<H>>>,
+    ) -> (BoxResponses<B, S<H>, Self::Error>, Self::Next) {
         let incoming = self.session.incoming::<S<H>>();
         let outgoing = self.session.outgoing::<S<S<H>>>();
         let early = self.early.take();
@@ -364,22 +349,21 @@ where
     }
 }
 
-impl<B, T, R, W, C, A> protocol::Reply<B, T> for Descending<B, T, S<Z>, R, W, C, A>
+impl<B, R, W, C, A> protocol::Reply<B> for Descending<B, S<Z>, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: Send,
     W: Send,
     C: Connector,
     A: Acceptor,
 {
-    type Next = Completing<B, T, R, W, C, A>;
+    type Next = Completing<B, R, W, C, A>;
 
     /// Proxy the leaf-parent transition into the role-specific terminal.
     fn reply(
         mut self,
-        requests: impl Requests<B, T, S<Z>>,
-    ) -> (BoxResponses<B, T, Z, Self::Error>, Self::Next) {
+        requests: impl Requests<B, S<Z>>,
+    ) -> (BoxResponses<B, Z, Self::Error>, Self::Next) {
         debug_assert!(
             self.early.is_none(),
             "the opening-supply stream is consumed by the first descending stage"
@@ -398,10 +382,9 @@ where
     }
 }
 
-impl<B, T, R, W, C, A> protocol::CompleteInitiator<B, T> for Completing<B, T, R, W, C, A>
+impl<B, R, W, C, A> protocol::CompleteInitiator<B> for Completing<B, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: Send,
     W: Send,
     C: Connector,
@@ -410,7 +393,7 @@ where
     /// Encode the local responder's final leaf answers and close its stream.
     async fn complete_initiator(
         mut self,
-        requests: impl Requests<B, T, Z>,
+        requests: impl Requests<B, Z>,
     ) -> Result<(R, W), Self::Error> {
         debug_assert_eq!(self.session.remote, Speaker::Initiator);
         let outgoing = self.session.outgoing::<Z>();
@@ -421,10 +404,9 @@ where
     }
 }
 
-impl<B, T, R, W, C, A> protocol::CompleteResponder<B, T> for Descending<B, T, Z, R, W, C, A>
+impl<B, R, W, C, A> protocol::CompleteResponder<B> for Descending<B, Z, R, W, C, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: Send,
     W: Send,
     C: Connector,
@@ -433,9 +415,9 @@ where
     /// Proxy the final bidirectional leaf exchange to clean completion.
     fn complete_responder(
         mut self,
-        requests: impl Requests<B, T, Z>,
+        requests: impl Requests<B, Z>,
     ) -> (
-        BoxResponses<B, T, Z, Self::Error>,
+        BoxResponses<B, Z, Self::Error>,
         impl Future<Output = Result<(R, W), Self::Error>> + Send,
     ) {
         debug_assert_eq!(self.session.remote, Speaker::Responder);
diff --git a/src/tree/mirror/streaming/remote/proxy/tests.rs b/src/tree/mirror/streaming/remote/proxy/tests.rs
index ea56d609c..ec4dc5f0d 100644
--- a/src/tree/mirror/streaming/remote/proxy/tests.rs
+++ b/src/tree/mirror/streaming/remote/proxy/tests.rs
@@ -1,5 +1,6 @@
 //! End-to-end sessions between materialized peers and protocol-start proxies.
 
+use serde::de::DeserializeOwned;
 use std::convert::Infallible;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -32,7 +33,6 @@ use crate::tree::{
 };
 use crate::{Version, message::Message, tree::mirror::Error as MirrorError};
 
-use serde::de::DeserializeOwned;
 type BackendFailure = Failure<Infallible>;
 type LocalFailure = MaterializedError<BackendFailure>;
 type ProxyFailure = RemoteError<BackendFailure>;
@@ -52,12 +52,14 @@ const TRANSPORT_CAPACITY: usize = 37;
 
 /// Drive two local starts, each paired directly with its remote protocol start.
 async fn reconcile(a: TreeRoot, b: TreeRoot) -> (TreeRoot, TreeRoot) {
-    let a = Handshaking::start(Local, Root::<Local, ()>::from(a)).window(WindowConfig::FLOOR);
-    let b = Handshaking::start(Local, Root::<Local, ()>::from(b)).window(WindowConfig::FLOOR);
+    let a = Handshaking::start(Local, Root::<Local>::from(a)).window(WindowConfig::FLOOR);
+    let b = Handshaking::start(Local, Root::<Local>::from(b)).window(WindowConfig::FLOOR);
 
     let (a_link, b_link) = memory_with_capacity(TRANSPORT_CAPACITY);
-    let remote_b = RemoteHandshaking::start(Local, a_link).window(WindowConfig::FLOOR);
-    let remote_a = RemoteHandshaking::start(Local, b_link).window(WindowConfig::FLOOR);
+    let remote_b = RemoteHandshaking::start(Local, a_link, Message::deserializer::<()>())
+        .window(WindowConfig::FLOOR);
+    let remote_a = RemoteHandshaking::start(Local, b_link, Message::deserializer::<()>())
+        .window(WindowConfig::FLOOR);
 
     let (a, b) = join!(Box::pin(mirror(a, remote_b)), Box::pin(mirror(remote_a, b)));
     let (a, _control) = a.expect("endpoint A should reconcile through its proxy");
@@ -75,11 +77,13 @@ async fn reconcile_symmetric_accepts<T>(
 where
     T: DeserializeOwned + Send + Sync + 'static,
 {
-    let a = Handshaking::start(Local, Root::<Local, T>::from(a)).window(WindowConfig::FLOOR);
-    let b = Handshaking::start(Local, Root::<Local, T>::from(b)).window(WindowConfig::FLOOR);
+    let a = Handshaking::start(Local, Root::<Local>::from(a)).window(WindowConfig::FLOOR);
+    let b = Handshaking::start(Local, Root::<Local>::from(b)).window(WindowConfig::FLOOR);
     let (a_link, b_link) = memory_with_capacity(transport_capacity);
-    let remote_b = RemoteHandshaking::start(Local, a_link).window(WindowConfig::FLOOR);
-    let remote_a = RemoteHandshaking::start(Local, b_link).window(WindowConfig::FLOOR);
+    let remote_b = RemoteHandshaking::start(Local, a_link, Message::deserializer::<T>())
+        .window(WindowConfig::FLOOR);
+    let remote_a = RemoteHandshaking::start(Local, b_link, Message::deserializer::<T>())
+        .window(WindowConfig::FLOOR);
 
     let (a, b) = join!(Box::pin(mirror(a, remote_b)), Box::pin(mirror(b, remote_a)),);
     let (a, _control) = a.expect("endpoint A should reconcile through its proxy");
@@ -106,13 +110,15 @@ async fn reconcile_symmetric_accepts_reordered<T>(
 where
     T: DeserializeOwned + Send + Sync + 'static,
 {
-    let a = Handshaking::start(Local, Root::<Local, T>::from(a)).window(WindowConfig::FLOOR);
-    let b = Handshaking::start(Local, Root::<Local, T>::from(b)).window(WindowConfig::FLOOR);
+    let a = Handshaking::start(Local, Root::<Local>::from(a)).window(WindowConfig::FLOOR);
+    let b = Handshaking::start(Local, Root::<Local>::from(b)).window(WindowConfig::FLOOR);
     let (a_link, b_link) = memory_with_capacity(transport_capacity);
     let a_link = reorder_accepts(a_link, REORDER_BATCH, reordered.clone());
     let b_link = reorder_accepts(b_link, REORDER_BATCH, reordered);
-    let remote_b = RemoteHandshaking::start(Local, a_link).window(WindowConfig::FLOOR);
-    let remote_a = RemoteHandshaking::start(Local, b_link).window(WindowConfig::FLOOR);
+    let remote_b = RemoteHandshaking::start(Local, a_link, Message::deserializer::<T>())
+        .window(WindowConfig::FLOOR);
+    let remote_a = RemoteHandshaking::start(Local, b_link, Message::deserializer::<T>())
+        .window(WindowConfig::FLOOR);
 
     let (a, b) = join!(Box::pin(mirror(a, remote_b)), Box::pin(mirror(b, remote_a)),);
     let (a, _control) = a.expect("endpoint A should reconcile through its proxy");
@@ -126,8 +132,8 @@ async fn reconcile_after_preamble<T>(a: TreeRoot, b: TreeRoot) -> (TreeRoot, Tre
 where
     T: DeserializeOwned + Send + Sync + 'static,
 {
-    let a = Handshaking::start(Local, Root::<Local, T>::from(a)).window(WindowConfig::FLOOR);
-    let b = Handshaking::start(Local, Root::<Local, T>::from(b)).window(WindowConfig::FLOOR);
+    let a = Handshaking::start(Local, Root::<Local>::from(a)).window(WindowConfig::FLOOR);
+    let b = Handshaking::start(Local, Root::<Local>::from(b)).window(WindowConfig::FLOOR);
     let (mut a_link, mut b_link) = memory_with_capacity(64 * 1024);
     let network = crate::Network::from_bytes([1; 16]);
     let mut a_staged = handshake::Staged::new();
@@ -153,8 +159,10 @@ where
     seen_a.expect("A preamble");
     seen_b.expect("B preamble");
 
-    let remote_b = RemoteHandshaking::start(Local, a_link).window(WindowConfig::FLOOR);
-    let remote_a = RemoteHandshaking::start(Local, b_link).window(WindowConfig::FLOOR);
+    let remote_b = RemoteHandshaking::start(Local, a_link, Message::deserializer::<T>())
+        .window(WindowConfig::FLOOR);
+    let remote_a = RemoteHandshaking::start(Local, b_link, Message::deserializer::<T>())
+        .window(WindowConfig::FLOOR);
     let (a, b) = join!(Box::pin(mirror(a, remote_b)), Box::pin(mirror(b, remote_a)),);
     let (a, _control) = a.expect("endpoint A should reconcile through its proxy");
     let (b, _control) = b.expect("endpoint B should reconcile through its proxy");
@@ -163,8 +171,8 @@ where
 
 /// Reconcile the same pair entirely in process as the behavioral oracle.
 async fn reconcile_locally(a: TreeRoot, b: TreeRoot) -> (TreeRoot, TreeRoot) {
-    let a = Handshaking::start(Local, Root::<Local, ()>::from(a)).window(WindowConfig::FLOOR);
-    let b = Handshaking::start(Local, Root::<Local, ()>::from(b)).window(WindowConfig::FLOOR);
+    let a = Handshaking::start(Local, Root::<Local>::from(a)).window(WindowConfig::FLOOR);
+    let b = Handshaking::start(Local, Root::<Local>::from(b)).window(WindowConfig::FLOOR);
     let (a, b) = Box::pin(mirror(a, b))
         .await
         .expect("two honest local participants should reconcile");
@@ -172,7 +180,7 @@ async fn reconcile_locally(a: TreeRoot, b: TreeRoot) -> (TreeRoot, TreeRoot) {
 }
 
 /// Translate a local root into the composable failing backend's node type.
-fn failing_root(root: TreeRoot) -> Root<Failing<Local>, ()> {
+fn failing_root(root: TreeRoot) -> Root<Failing<Local>> {
     Root {
         ceiling: root.ceiling,
         root: root.root.map(FailingNode::new),
@@ -236,8 +244,10 @@ async fn reconcile_with_stacked_failures(
     } else {
         failing
     };
-    let remote_b = RemoteHandshaking::start(left_backend, a_link).window(WindowConfig::FLOOR);
-    let remote_a = RemoteHandshaking::start(right_backend, b_link).window(WindowConfig::FLOOR);
+    let remote_b = RemoteHandshaking::start(left_backend, a_link, Message::deserializer::<()>())
+        .window(WindowConfig::FLOOR);
+    let remote_a = RemoteHandshaking::start(right_backend, b_link, Message::deserializer::<()>())
+        .window(WindowConfig::FLOOR);
 
     let (left, right) = join!(Box::pin(mirror(a, remote_b)), Box::pin(mirror(remote_a, b)));
     (
diff --git a/src/tree/mirror/streaming/remote/proxy/tests/containment.rs b/src/tree/mirror/streaming/remote/proxy/tests/containment.rs
index c1788708d..3cce0da4c 100644
--- a/src/tree/mirror/streaming/remote/proxy/tests/containment.rs
+++ b/src/tree/mirror/streaming/remote/proxy/tests/containment.rs
@@ -1,5 +1,6 @@
 //! Version-containment enforcement over the full wire stack.
 
+use crate::message::Message;
 use futures::join;
 
 use crate::link::memory_with_capacity;
@@ -28,12 +29,14 @@ async fn reconcile_results(
     a: TreeRoot,
     b: TreeRoot,
 ) -> (Result<TreeRoot, LeftError>, Result<TreeRoot, RightError>) {
-    let a = Handshaking::start(Local, Root::<Local, ()>::from(a)).window(WindowConfig::FLOOR);
-    let b = Handshaking::start(Local, Root::<Local, ()>::from(b)).window(WindowConfig::FLOOR);
+    let a = Handshaking::start(Local, Root::<Local>::from(a)).window(WindowConfig::FLOOR);
+    let b = Handshaking::start(Local, Root::<Local>::from(b)).window(WindowConfig::FLOOR);
 
     let (a_link, b_link) = memory_with_capacity(TRANSPORT_CAPACITY);
-    let remote_b = RemoteHandshaking::start(Local, a_link).window(WindowConfig::FLOOR);
-    let remote_a = RemoteHandshaking::start(Local, b_link).window(WindowConfig::FLOOR);
+    let remote_b = RemoteHandshaking::start(Local, a_link, Message::deserializer::<()>())
+        .window(WindowConfig::FLOOR);
+    let remote_a = RemoteHandshaking::start(Local, b_link, Message::deserializer::<()>())
+        .window(WindowConfig::FLOOR);
 
     let (a, b) = join!(Box::pin(mirror(a, remote_b)), Box::pin(mirror(remote_a, b)));
     (
diff --git a/src/tree/mirror/streaming/remote/proxy/tests/harness.rs b/src/tree/mirror/streaming/remote/proxy/tests/harness.rs
index 19576413b..b77a3a611 100644
--- a/src/tree/mirror/streaming/remote/proxy/tests/harness.rs
+++ b/src/tree/mirror/streaming/remote/proxy/tests/harness.rs
@@ -1,5 +1,6 @@
 //! Reusable two-proxy session harness for transport-adversity properties.
 
+use crate::message::Message;
 use std::{
     convert::Infallible,
     io,
@@ -490,10 +491,12 @@ where
     RC: Connector,
     RA: Acceptor,
 {
-    let left = Handshaking::start(Local, Root::<Local, ()>::from(left)).window(window);
-    let right = Handshaking::start(Local, Root::<Local, ()>::from(right)).window(window);
-    let remote_right = RemoteHandshaking::start(Local, left_link).window(window);
-    let remote_left = RemoteHandshaking::start(Local, right_link).window(window);
+    let left = Handshaking::start(Local, Root::<Local>::from(left)).window(window);
+    let right = Handshaking::start(Local, Root::<Local>::from(right)).window(window);
+    let remote_right =
+        RemoteHandshaking::start(Local, left_link, Message::deserializer::<()>()).window(window);
+    let remote_left =
+        RemoteHandshaking::start(Local, right_link, Message::deserializer::<()>()).window(window);
     let (left, right) = join!(
         Box::pin(mirror(left, remote_right)),
         Box::pin(mirror(remote_left, right)),
diff --git a/src/tree/mirror/streaming/remote/proxy/work.rs b/src/tree/mirror/streaming/remote/proxy/work.rs
index fe9a35f78..596d1b9c0 100644
--- a/src/tree/mirror/streaming/remote/proxy/work.rs
+++ b/src/tree/mirror/streaming/remote/proxy/work.rs
@@ -5,6 +5,7 @@
 //! protocol operation concurrently drives the stored pumps, its own terminal
 //! work, the session's accept driver, and the incoming-stream error route.
 
+use crate::message::PayloadDeserializer;
 use std::pin::{Pin, pin};
 
 use futures::{Stream, StreamExt, future::BoxFuture};
@@ -34,17 +35,15 @@ use crate::tree::{
 
 use self::progress::Progress;
 
-use serde::de::DeserializeOwned;
 mod encode;
 pub(super) mod progress;
 mod pump;
 mod queues;
 
 /// Deferred reply pumps and the physical session which drives them.
-pub struct Work<B, T, R, W, A>
+pub struct Work<B, R, W, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     A: Acceptor,
 {
     backend: B,
@@ -59,6 +58,11 @@ where
     /// supply allowance: every leaf record this session decodes charges
     /// it before the payload takes backend custody.
     peer_supplies: SupplyLedger,
+    /// The peer's payload deserializer: the typed ingress every supplied
+    /// leaf record decodes through (see [`Message::deserializer`]).
+    ///
+    /// [`Message::deserializer`]: crate::message::Message::deserializer
+    deserializer: PayloadDeserializer,
     /// The remote greeting's root-fan listing, consumed by whichever role
     /// the election assigns.
     ///
@@ -88,13 +92,14 @@ where
     pub errors: FirstStreamError,
 }
 
-impl<B, T, R, W, A> Work<B, T, R, W, A>
+impl<B, R, W, A> Work<B, R, W, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     A: Acceptor,
 {
     /// Begin accumulating work around an elected physical session.
+    #[allow(clippy::too_many_arguments)] // The argument list is the session's
+    // greeting-derived configuration, one premise per argument.
     pub fn new(
         backend: B,
         window: Window,
@@ -103,6 +108,7 @@ where
         peer_set_len: u64,
         peer_listing: Vec<(u8, Hash)>,
         physical: Physical<R, W, A>,
+        deserializer: PayloadDeserializer,
     ) -> Self {
         Self {
             backend,
@@ -114,6 +120,7 @@ where
             physical,
             tasks: Vec::new(),
             progress: Progress::new(),
+            deserializer,
         }
     }
 
@@ -133,7 +140,7 @@ where
     fn respond<H>(
         &mut self,
         messages: impl Stream<Item = Result<erased::Reply<B::Erased>, Error<B::Error>>> + Send + 'static,
-    ) -> BoxResponses<B, T, H, Error<B::Error>>
+    ) -> BoxResponses<B, H, Error<B::Error>>
     where
         H: Height,
     {
@@ -141,7 +148,7 @@ where
         // that response is already available to advance the counterparty
         // and release the slot. Buffering a fan would retain whole
         // protocol messages without breaking any additional dependency.
-        let (send, responses) = erased::reply_channel::<B, T, H, Error<B::Error>>(
+        let (send, responses) = erased::reply_channel::<B, H, Error<B::Error>>(
             QueueRole::new(QueueKind::ProxyResponses, H::HEIGHT),
             1,
         );
diff --git a/src/tree/mirror/streaming/remote/proxy/work/encode.rs b/src/tree/mirror/streaming/remote/proxy/work/encode.rs
index 2ad2ebf88..cd308a3f3 100644
--- a/src/tree/mirror/streaming/remote/proxy/work/encode.rs
+++ b/src/tree/mirror/streaming/remote/proxy/work/encode.rs
@@ -38,18 +38,17 @@ use super::progress::Progress;
 pub type Replies<E> = Pin<Box<dyn Stream<Item = Reply<E>> + Send>>;
 
 /// Encode local leaf replies, optionally publishing the leaf questions they ask.
-pub async fn terminal<B, T, C>(
+pub async fn terminal<B, C>(
     backend: B,
     budget: RunBudget,
     requests: Replies<B::Erased>,
     mut scopes: Receiver<Scope>,
-    mut outgoing: StreamSender<C, T>,
+    mut outgoing: StreamSender<C>,
     questions: Option<Sender<Scope>>,
     progress: Progress,
 ) -> Result<(), Error<B::Error>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     C: Connector,
 {
     let mut requests = requests;
@@ -78,19 +77,18 @@ where
 // The argument list is the stage's dataflow, one edge per argument;
 // bundling edges into a struct would only rename the arity.
 #[allow(clippy::too_many_arguments)]
-pub async fn replies<B, T, C>(
+pub async fn replies<B, C>(
     backend: B,
     budget: RunBudget,
     requests: Replies<B::Erased>,
     mut scopes: Receiver<Scope>,
-    mut outgoing: StreamSender<C, T>,
+    mut outgoing: StreamSender<C>,
     questions: Sender<Scope>,
     progress: Progress,
     question_height: usize,
 ) -> Result<(), Error<B::Error>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     C: Connector,
 {
     let mut requests = requests;
@@ -124,18 +122,17 @@ where
 /// pruned away" from an empty reply rather than wait on a stream that
 /// never opens, and a session without initiator exclusives keeps today's
 /// streamless opening.
-pub async fn opening<B, T, C>(
+pub async fn opening<B, C>(
     backend: B,
     budget: RunBudget,
     requests: Replies<B::Erased>,
     questions: Sender<Scope>,
-    mut outgoing: StreamSender<C, T>,
+    mut outgoing: StreamSender<C>,
     peer_listing: Vec<(u8, Hash)>,
     progress: Progress,
 ) -> Result<(), Error<B::Error>>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     C: Connector,
 {
     let mut requests = requests;
@@ -176,9 +173,9 @@ where
 }
 
 /// Flush every frame in one reply and retain its acknowledged questions.
-async fn write_reply<T, C, Q, E>(
-    outgoing: &mut StreamSender<C, T>,
-    encoded: &mut (impl futures::Stream<Item = Result<Encoded<T, Q>, adapter::EncodeError<E>>> + Unpin),
+async fn write_reply<C, Q, E>(
+    outgoing: &mut StreamSender<C>,
+    encoded: &mut (impl futures::Stream<Item = Result<Encoded<Q>, adapter::EncodeError<E>>> + Unpin),
 ) -> Result<Vec<Q>, Error<E>>
 where
     C: Connector,
@@ -201,9 +198,9 @@ async fn publish(questions: &Sender<Scope>, batch: Vec<Scope>, progress: Progres
 }
 
 /// Reject unclaimed local replies, then close the outgoing logical stream.
-async fn finish<T, C, R, E>(
+async fn finish<C, R, E>(
     mut requests: Pin<Box<R>>,
-    outgoing: StreamSender<C, T>,
+    outgoing: StreamSender<C>,
 ) -> Result<(), Error<E>>
 where
     C: Connector,
@@ -217,9 +214,9 @@ where
 }
 
 /// Flush one adapter frame and release its optional question afterward.
-async fn write_encoded<T, C, Q, E>(
-    outgoing: &mut StreamSender<C, T>,
-    encoded: Encoded<T, Q>,
+async fn write_encoded<C, Q, E>(
+    outgoing: &mut StreamSender<C>,
+    encoded: Encoded<Q>,
 ) -> Result<Option<Q>, Error<E>>
 where
     C: Connector,
diff --git a/src/tree/mirror/streaming/remote/proxy/work/pump.rs b/src/tree/mirror/streaming/remote/proxy/work/pump.rs
index 59d86bc68..dc45210b6 100644
--- a/src/tree/mirror/streaming/remote/proxy/work/pump.rs
+++ b/src/tree/mirror/streaming/remote/proxy/work/pump.rs
@@ -24,6 +24,7 @@
 //! precedes its dependent scopes. Each edge's capacity rationale lives at
 //! its constructor in [`queues`].
 
+use crate::message::PayloadDeserializer;
 use std::pin::Pin;
 
 use async_stream::try_stream;
@@ -55,11 +56,9 @@ use crate::tree::{
 
 use super::{encode, queues};
 
-use serde::de::DeserializeOwned;
-impl<B, T, R, W, A> Work<B, T, R, W, A>
+impl<B, R, W, A> Work<B, R, W, A>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     R: Send,
     W: Send,
     A: Acceptor,
@@ -73,12 +72,7 @@ where
     /// early supplies instead; the first descending transition claims and
     /// decodes it against the root-level requests it answers, so the root
     /// merge-join below never waits on the supply bulk.
-    pub fn initiator(
-        &mut self,
-    ) -> (
-        BoxResponses<B, T, UnderRoot, Error<B::Error>>,
-        Receiver<Scope>,
-    ) {
+    pub fn initiator(&mut self) -> (BoxResponses<B, UnderRoot, Error<B::Error>>, Receiver<Scope>) {
         let (next_scopes, scopes) =
             queues::next_scopes(UnderRoot::HEIGHT, self.window.capacity(UnderRoot::HEIGHT));
         let progress = self.progress;
@@ -97,15 +91,12 @@ where
     /// Proxy the responder opening and return its lower scope queue.
     pub fn opening_responder<C: Connector>(
         &mut self,
-        requests: impl Requests<B, T, UnderRoot>,
-        incoming: StreamReceiver<A::Rx, T>,
-        outgoing: StreamSender<C, T>,
-    ) -> (
-        BoxResponses<B, T, UnderRoot, Error<B::Error>>,
-        Receiver<Scope>,
-    ) {
+        requests: impl Requests<B, UnderRoot>,
+        incoming: StreamReceiver<A::Rx>,
+        outgoing: StreamSender<C>,
+    ) -> (BoxResponses<B, UnderRoot, Error<B::Error>>, Receiver<Scope>) {
         let requests: encode::Replies<B::Erased> =
-            Box::pin(requests.map(erased::erase_reply::<B, T, UnderRoot>));
+            Box::pin(requests.map(erased::erase_reply::<B, UnderRoot>));
         let (local_questions, questions) =
             queues::local_questions(UnderRoot::HEIGHT, self.window.capacity(UnderRoot::HEIGHT));
         let peer_listing = std::mem::take(&mut self.peer_listing);
@@ -142,19 +133,19 @@ where
     /// wire-borne answer would have carried.
     pub fn internal_replies<C: Connector, H>(
         &mut self,
-        requests: impl Requests<B, T, S<S<H>>>,
+        requests: impl Requests<B, S<S<H>>>,
         scopes: Receiver<Scope>,
-        incoming: StreamReceiver<A::Rx, T>,
-        outgoing: StreamSender<C, T>,
-        early: Option<StreamReceiver<A::Rx, T>>,
-    ) -> (BoxResponses<B, T, S<H>, Error<B::Error>>, Receiver<Scope>)
+        incoming: StreamReceiver<A::Rx>,
+        outgoing: StreamSender<C>,
+        early: Option<StreamReceiver<A::Rx>>,
+    ) -> (BoxResponses<B, S<H>, Error<B::Error>>, Receiver<Scope>)
     where
         H: Height,
         S<H>: Height,
         S<S<H>>: Height,
     {
         let requests: encode::Replies<B::Erased> =
-            Box::pin(requests.map(erased::erase_reply::<B, T, S<S<H>>>));
+            Box::pin(requests.map(erased::erase_reply::<B, S<S<H>>>));
         let (local_questions, questions) =
             queues::local_questions(<S<H>>::HEIGHT, self.window.capacity(<S<H>>::HEIGHT));
         self.spawn(encode::replies(
@@ -183,20 +174,20 @@ where
     fn decode_pump(
         &mut self,
         mut questions: Receiver<Scope>,
-        mut incoming: StreamReceiver<A::Rx, T>,
+        mut incoming: StreamReceiver<A::Rx>,
         next_scopes: crate::tree::mirror::streaming::channel::Sender<Scope>,
-        early: Option<StreamReceiver<A::Rx, T>>,
+        early: Option<StreamReceiver<A::Rx>>,
         height: usize,
-    ) -> impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>>
-    + Send
-    + 'static
-    + use<B, T, R, W, A> {
+    ) -> impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>> + Send + 'static + use<B, R, W, A>
+    {
         let progress = self.progress;
         let backend = self.backend();
         let version_bytes = self.peer_version_bytes;
         let ledger = self.peer_supplies.clone();
+        let deserializer = self.deserializer;
         try_stream! {
-            let mut early = Early::<B, T, A::Rx>::new(version_bytes, ledger.clone(), early);
+            let mut early =
+                Early::<B, A::Rx>::new(version_bytes, ledger.clone(), early, deserializer);
             while let Some(scope) = questions.recv().await {
                 if early.armed() && scope.is_request() {
                     // A root-level request: its content crossed at the
@@ -204,9 +195,15 @@ where
                     // the early stream carries the node — or neither does,
                     // when pruning removed the whole subtree.
                     let parent = scope.parent();
-                    let Decoded { reply, questions: asked } = decode_reply::<B, T, _>(
-                        backend.clone(), version_bytes, ledger.clone(), scope, &mut incoming,
-                    ).await?;
+                    let Decoded { reply, questions: asked } = decode_reply::<B, _>(
+                        backend.clone(),
+                        version_bytes,
+                        ledger.clone(),
+                        scope,
+                        &mut incoming,
+                        deserializer,
+                    )
+                    .await?;
                     debug_assert!(asked.is_empty(), "an empty request opens no lower scope");
                     let (root, radix) = parent.pop();
                     let mut replies = reply.replies;
@@ -227,9 +224,15 @@ where
                     );
                     continue;
                 }
-                let Decoded { reply, questions } = decode_reply::<B, T, _>(
-                    backend.clone(), version_bytes, ledger.clone(), scope, &mut incoming,
-                ).await?;
+                let Decoded { reply, questions } = decode_reply::<B, _>(
+                    backend.clone(),
+                    version_bytes,
+                    ledger.clone(),
+                    scope,
+                    &mut incoming,
+                    deserializer,
+                )
+                .await?;
                 yield_reply_scopes!(
                     progress, height, questions.len();
                     yield reply;
@@ -244,13 +247,13 @@ where
     /// Proxy the leaf-parent transition and return its terminal leaf scopes.
     pub fn leaf_replies<C: Connector>(
         &mut self,
-        requests: impl Requests<B, T, S<Z>>,
+        requests: impl Requests<B, S<Z>>,
         scopes: Receiver<Scope>,
-        incoming: StreamReceiver<A::Rx, T>,
-        outgoing: StreamSender<C, T>,
-    ) -> (BoxResponses<B, T, Z, Error<B::Error>>, Receiver<Scope>) {
+        incoming: StreamReceiver<A::Rx>,
+        outgoing: StreamSender<C>,
+    ) -> (BoxResponses<B, Z, Error<B::Error>>, Receiver<Scope>) {
         let requests: encode::Replies<B::Erased> =
-            Box::pin(requests.map(erased::erase_reply::<B, T, S<Z>>));
+            Box::pin(requests.map(erased::erase_reply::<B, S<Z>>));
         let (local_questions, questions) =
             queues::local_questions(Z::HEIGHT, self.window.capacity(Z::HEIGHT));
         self.spawn(encode::replies(
@@ -273,21 +276,26 @@ where
     fn leaf_decode_pump(
         &mut self,
         mut questions: Receiver<Scope>,
-        mut incoming: StreamReceiver<A::Rx, T>,
+        mut incoming: StreamReceiver<A::Rx>,
         next_scopes: crate::tree::mirror::streaming::channel::Sender<Scope>,
-    ) -> impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>>
-    + Send
-    + 'static
-    + use<B, T, R, W, A> {
+    ) -> impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>> + Send + 'static + use<B, R, W, A>
+    {
         let progress = self.progress;
         let backend = self.backend();
         let version_bytes = self.peer_version_bytes;
         let ledger = self.peer_supplies.clone();
+        let deserializer = self.deserializer;
         try_stream! {
             while let Some(scope) = questions.recv().await {
                 let Decoded { reply, questions } = decode_leaf_reply(
-                    backend.clone(), version_bytes, ledger.clone(), scope, &mut incoming,
-                ).await?;
+                    backend.clone(),
+                    version_bytes,
+                    ledger.clone(),
+                    scope,
+                    &mut incoming,
+                    deserializer,
+                )
+                .await?;
                 yield_reply_scopes!(
                     progress, Z::HEIGHT, questions.len();
                     yield reply;
@@ -301,12 +309,12 @@ where
     /// Drive the final local answers for a remote initiator to completion.
     pub async fn complete_initiator<C: Connector>(
         self,
-        requests: impl Requests<B, T, Z>,
+        requests: impl Requests<B, Z>,
         scopes: Receiver<Scope>,
-        outgoing: StreamSender<C, T>,
+        outgoing: StreamSender<C>,
     ) -> Result<(R, W), Error<B::Error>> {
         let requests: encode::Replies<B::Erased> =
-            Box::pin(requests.map(erased::erase_reply::<B, T, Z>));
+            Box::pin(requests.map(erased::erase_reply::<B, Z>));
         let finish = encode::terminal(
             self.backend(),
             self.budget,
@@ -323,12 +331,12 @@ where
     /// Drive the responder's final bidirectional leaf exchange.
     pub fn complete_responder<C: Connector>(
         mut self,
-        requests: impl Requests<B, T, Z>,
+        requests: impl Requests<B, Z>,
         scopes: Receiver<Scope>,
-        incoming: StreamReceiver<A::Rx, T>,
-        outgoing: StreamSender<C, T>,
+        incoming: StreamReceiver<A::Rx>,
+        outgoing: StreamSender<C>,
     ) -> (
-        BoxResponses<B, T, Z, Error<B::Error>>,
+        BoxResponses<B, Z, Error<B::Error>>,
         impl Future<Output = Result<(R, W), Error<B::Error>>> + Send,
     )
     where
@@ -337,7 +345,7 @@ where
         A: Send,
     {
         let requests: encode::Replies<B::Erased> =
-            Box::pin(requests.map(erased::erase_reply::<B, T, Z>));
+            Box::pin(requests.map(erased::erase_reply::<B, Z>));
         let (local_questions, questions) =
             queues::local_questions(Z::HEIGHT, self.window.capacity(Z::HEIGHT));
         self.spawn(encode::terminal(
@@ -363,20 +371,25 @@ where
     fn terminal_decode_pump(
         &mut self,
         mut questions: Receiver<Scope>,
-        mut incoming: StreamReceiver<A::Rx, T>,
-    ) -> impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>>
-    + Send
-    + 'static
-    + use<B, T, R, W, A> {
+        mut incoming: StreamReceiver<A::Rx>,
+    ) -> impl Stream<Item = Result<Reply<B::Erased>, Error<B::Error>>> + Send + 'static + use<B, R, W, A>
+    {
         let progress = self.progress;
         let backend = self.backend();
         let version_bytes = self.peer_version_bytes;
         let ledger = self.peer_supplies.clone();
+        let deserializer = self.deserializer;
         try_stream! {
             while let Some(scope) = questions.recv().await {
                 let Decoded { reply, questions } = decode_leaf_reply(
-                    backend.clone(), version_bytes, ledger.clone(), scope, &mut incoming,
-                ).await?;
+                    backend.clone(),
+                    version_bytes,
+                    ledger.clone(),
+                    scope,
+                    &mut incoming,
+                    deserializer,
+                )
+                .await?;
                 if !questions.is_empty() {
                     Err(Error::TerminalQuery)?;
                 }
@@ -397,10 +410,9 @@ where
 /// session. An armed cursor whose stage sees no request never polls the
 /// receiver, so the transport stream is never claimed — the lazy-claim
 /// discipline every level follows.
-struct Early<B, T, Rx>
+struct Early<B, Rx>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     /// The peer's greeting-declared `max_version_bytes`, enforced on
     /// every supplied version the opening stream decodes.
@@ -408,17 +420,19 @@ where
     /// The session's declared-`set_len` allowance, charged per record
     /// the opening stream decodes.
     ledger: SupplyLedger,
-    receiver: Option<StreamReceiver<Rx, T>>,
+    receiver: Option<StreamReceiver<Rx>>,
     supplies:
         Option<Pin<Box<dyn Stream<Item = Result<(u8, B::Erased), DecodeError<B::Error>>> + Send>>>,
     lookahead: Option<(u8, B::Erased)>,
     exhausted: bool,
+    /// The peer's payload deserializer, handed to the opening-supply
+    /// stream when the cursor arms it.
+    deserializer: PayloadDeserializer,
 }
 
-impl<B, T, Rx> Early<B, T, Rx>
+impl<B, Rx> Early<B, Rx>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: DeserializeOwned + Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
     Rx: tokio::io::AsyncRead + Unpin + Send + 'static,
 {
     /// Arm the cursor with the opening-supply stream's receiver, if this
@@ -426,7 +440,8 @@ where
     fn new(
         version_bytes: u64,
         ledger: SupplyLedger,
-        receiver: Option<StreamReceiver<Rx, T>>,
+        receiver: Option<StreamReceiver<Rx>>,
+        deserializer: PayloadDeserializer,
     ) -> Self {
         Self {
             version_bytes,
@@ -435,6 +450,7 @@ where
             supplies: None,
             lookahead: None,
             exhausted: false,
+            deserializer,
         }
     }
 
@@ -474,14 +490,14 @@ where
                         .receiver
                         .take()
                         .expect("an unarmed cursor resolves no request");
-                    self.supplies
-                        .get_or_insert(Box::pin(early_supplies::<B, T, _>(
-                            backend.clone(),
-                            self.version_bytes,
-                            self.ledger.clone(),
-                            root,
-                            receiver,
-                        )))
+                    self.supplies.get_or_insert(Box::pin(early_supplies::<B, _>(
+                        backend.clone(),
+                        self.version_bytes,
+                        self.ledger.clone(),
+                        root,
+                        receiver,
+                        self.deserializer,
+                    )))
                 }
             };
             match supplies.next().await {
@@ -511,10 +527,9 @@ where
 /// A stream that was never claimed — its level asked no question — is
 /// finished vacuously; a claimed stream must have delivered its end control
 /// with no reply to spare.
-async fn reject_extra<Rx, T, E>(incoming: &mut StreamReceiver<Rx, T>) -> Result<(), Error<E>>
+async fn reject_extra<Rx, E>(incoming: &mut StreamReceiver<Rx>) -> Result<(), Error<E>>
 where
     Rx: tokio::io::AsyncRead + Unpin + Send + 'static,
-    T: DeserializeOwned + Send + Sync + 'static,
 {
     match incoming.finish().await {
         ReceiverFinish::Clean => Ok(()),
diff --git a/src/tree/mirror/streaming/remote/proxy/work/tests.rs b/src/tree/mirror/streaming/remote/proxy/work/tests.rs
index e30182b32..a4745ee5c 100644
--- a/src/tree/mirror/streaming/remote/proxy/work/tests.rs
+++ b/src/tree/mirror/streaming/remote/proxy/work/tests.rs
@@ -1,5 +1,6 @@
 use std::future;
 
+use crate::message::Message;
 use futures::StreamExt;
 use tokio::io::DuplexStream;
 use tokio::sync::oneshot;
@@ -25,7 +26,7 @@ use crate::tree::mirror::streaming::{
 /// A parked session's `Work` executor over a fresh in-memory link, wired
 /// the way the session wires it, with everything the tests must keep alive.
 struct ParkedSession {
-    work: Work<Failing<Local>, (), DuplexStream, DuplexStream, MemoryAcceptor>,
+    work: Work<Failing<Local>, DuplexStream, DuplexStream, MemoryAcceptor>,
     /// The claim table the protocol owns in production. Keeping it alive
     /// ensures no stream-layer closure can accidentally win the error race.
     claims: Claims<DuplexStream>,
@@ -62,6 +63,7 @@ fn parked_session() -> ParkedSession {
             accept,
             errors,
         },
+        Message::deserializer::<u64>(),
     );
     ParkedSession {
         work,
@@ -235,7 +237,7 @@ fn queued_supply_closed_outranks_a_selected_consequence_at_stream_granularity()
     let (claim_send, claim_receive) =
         oneshot::channel::<(DuplexStream, crate::link::Done<DuplexStream>)>();
     drop(claim_send);
-    let mut receiver: StreamReceiver<DuplexStream, ()> = StreamReceiver::new(
+    let mut receiver: StreamReceiver<DuplexStream> = StreamReceiver::new(
         claim_receive,
         Speaker::Initiator,
         Stream::new(3).expect("stream index 3 exists"),
@@ -301,7 +303,7 @@ fn published_stream_error_preempts_a_parked_protocol() {
     let (claim_send, claim_receive) =
         oneshot::channel::<(DuplexStream, crate::link::Done<DuplexStream>)>();
     drop(claim_send);
-    let mut receiver: StreamReceiver<DuplexStream, ()> = StreamReceiver::new(
+    let mut receiver: StreamReceiver<DuplexStream> = StreamReceiver::new(
         claim_receive,
         Speaker::Initiator,
         Stream::new(0).expect("stream index 0 exists"),
diff --git a/src/tree/mirror/streaming/remote/streams.rs b/src/tree/mirror/streaming/remote/streams.rs
index 75b73c0ab..297cb6f31 100644
--- a/src/tree/mirror/streaming/remote/streams.rs
+++ b/src/tree/mirror/streaming/remote/streams.rs
@@ -35,7 +35,6 @@
 //! observes the route (the same publish-then-park discipline the response
 //! streams use).
 
-use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
@@ -54,7 +53,6 @@ use super::codec::{
     DecodeError, EncodeError, End, Frame, FrameRead, FrameWrite, Origin, RunBudget, Speaker, Stream,
 };
 
-use serde::de::DeserializeOwned;
 /// Bytes of the label a sender writes before its first frame.
 ///
 /// The canonical definition of the wire label's width: the capture
@@ -74,13 +72,13 @@ const STREAM_COUNT: usize = Stream::COUNT as usize;
 /// Stream end is a lifecycle event owned by [`StreamSender::finish`]; a
 /// producer cannot smuggle one into the middle of its replies.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ReplyFrame<T>(Frame<T>);
+pub struct ReplyFrame(Frame);
 
-impl<T> TryFrom<Frame<T>> for ReplyFrame<T> {
+impl TryFrom<Frame> for ReplyFrame {
     type Error = ReplyFrameError;
 
     /// Check that a general wire frame belongs to a protocol reply.
-    fn try_from(frame: Frame<T>) -> Result<Self, Self::Error> {
+    fn try_from(frame: Frame) -> Result<Self, Self::Error> {
         if matches!(frame, Frame::End(End::Stream)) {
             Err(ReplyFrameError::StreamEnd)
         } else {
@@ -89,9 +87,9 @@ impl<T> TryFrom<Frame<T>> for ReplyFrame<T> {
     }
 }
 
-impl<T> From<ReplyFrame<T>> for Frame<T> {
+impl From<ReplyFrame> for Frame {
     /// Recover the general wire frame for transport encoding.
-    fn from(frame: ReplyFrame<T>) -> Self {
+    fn from(frame: ReplyFrame) -> Self {
         frame.0
     }
 }
@@ -110,7 +108,7 @@ pub enum ReplyFrameError {
 /// label, and flushes the frame behind it; a sender that never carries a
 /// frame never opens a stream. [`finish`](Self::finish) closes an opened
 /// stream with an explicit end control and skips silently otherwise.
-pub struct StreamSender<C: Connector, T> {
+pub struct StreamSender<C: Connector> {
     connector: C,
     epoch: u8,
     /// The local role whose direction this stream carries.
@@ -121,7 +119,6 @@ pub struct StreamSender<C: Connector, T> {
     /// label excluded (it is written before the counted wrapper wraps).
     stats: Recorder,
     state: SendState<C::Tx>,
-    marker: PhantomData<fn(T)>,
 }
 
 enum SendState<Tx> {
@@ -129,7 +126,7 @@ enum SendState<Tx> {
     Open(FrameWrite<CountedWrite<Tx>>, Done<Tx>),
 }
 
-impl<C: Connector, T> StreamSender<C, T> {
+impl<C: Connector> StreamSender<C> {
     /// Bind one outgoing logical stream to a link's stream supply.
     pub fn new(connector: C, epoch: u8, speaker: Speaker, stream: Stream, stats: Recorder) -> Self {
         Self {
@@ -139,7 +136,6 @@ impl<C: Connector, T> StreamSender<C, T> {
             stream,
             stats,
             state: SendState::Unopened,
-            marker: PhantomData,
         }
     }
 
@@ -155,7 +151,7 @@ impl<C: Connector, T> StreamSender<C, T> {
     /// session-wide severance misattributed to the supply rather than to
     /// the cancellation. Retain the future until it resolves, or treat the
     /// session as severed after cancelling it.
-    pub async fn frame(&mut self, frame: ReplyFrame<T>) -> Result<(), SendError> {
+    pub async fn frame(&mut self, frame: ReplyFrame) -> Result<(), SendError> {
         self.write(frame.into()).await
     }
 
@@ -182,7 +178,7 @@ impl<C: Connector, T> StreamSender<C, T> {
     }
 
     /// Write one frame through the open transport stream, opening it first.
-    async fn write(&mut self, frame: Frame<T>) -> Result<(), SendError> {
+    async fn write(&mut self, frame: Frame) -> Result<(), SendError> {
         let stream = self.stream;
         let write = match &mut self.state {
             SendState::Open(write, _) => write,
@@ -285,13 +281,13 @@ pub enum StreamError {
 /// yields `None` — when the peer's explicit end control arrives, and it
 /// consumes that control rather than exposing it. On any failure it reports
 /// through the session error route and parks.
-pub struct StreamReceiver<Rx, T> {
+pub struct StreamReceiver<Rx> {
     /// The claim and identity, consumed to build `frames` on first poll.
     start: Option<ReceiverStart<Rx>>,
     /// `Some` exactly once the stream has been claimed: the first poll
     /// builds it, and [`finish`](Self::finish) reads its absence as "this
     /// level was never needed".
-    frames: Option<BoxStream<'static, Frame<T>>>,
+    frames: Option<BoxStream<'static, Frame>>,
 }
 
 struct ReceiverStart<Rx> {
@@ -310,10 +306,9 @@ struct ReceiverStart<Rx> {
     stats: Recorder,
 }
 
-impl<Rx, T> StreamReceiver<Rx, T>
+impl<Rx> StreamReceiver<Rx>
 where
     Rx: tokio::io::AsyncRead + Unpin + Send + 'static,
-    T: DeserializeOwned + Send + Sync + 'static,
 {
     /// Bind one incoming logical stream to its claim slot.
     pub fn new(
@@ -354,7 +349,7 @@ where
     }
 
     /// Build the claimed frame stream on first use.
-    fn frames(&mut self) -> &mut BoxStream<'static, Frame<T>> {
+    fn frames(&mut self) -> &mut BoxStream<'static, Frame> {
         let start = &mut self.start;
         self.frames.get_or_insert_with(|| {
             let ReceiverStart {
@@ -381,12 +376,11 @@ pub enum ReceiverFinish {
     ExtraReply,
 }
 
-impl<Rx, T> futures::Stream for StreamReceiver<Rx, T>
+impl<Rx> futures::Stream for StreamReceiver<Rx>
 where
     Rx: tokio::io::AsyncRead + Unpin + Send + 'static,
-    T: DeserializeOwned + Send + Sync + 'static,
 {
-    type Item = Frame<T>;
+    type Item = Frame;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         self.get_mut().frames().as_mut().poll_next(cx)
@@ -397,17 +391,16 @@ where
 ///
 /// Every failure path publishes to the session error route and parks: the
 /// consumer never observes a truncated stream as a clean end.
-fn read_frames<Rx, T>(
+fn read_frames<Rx>(
     claim: oneshot::Receiver<(Rx, Done<Rx>)>,
     speaker: Speaker,
     stream: Stream,
     budget: RunBudget,
     route: ErrorRoute,
     stats: Recorder,
-) -> impl futures::Stream<Item = Frame<T>> + Send
+) -> impl futures::Stream<Item = Frame> + Send
 where
     Rx: tokio::io::AsyncRead + Unpin + Send + 'static,
-    T: DeserializeOwned + Send + Sync + 'static,
 {
     stream! {
         let Ok((rx, done)) = claim.await else {
@@ -428,7 +421,7 @@ where
         };
         let mut read = FrameRead::new(speaker, budget, CountedRead::new(rx, stats));
         loop {
-            let frame = match read.frame::<T>().await {
+            let frame = match read.frame().await {
                 Ok(Some((framed, frame))) if framed == stream => frame,
                 Ok(Some((framed, _))) => {
                     route.report(StreamError::Mislabeled {
diff --git a/src/tree/mirror/streaming/remote/streams/tests.rs b/src/tree/mirror/streaming/remote/streams/tests.rs
index 0614e6cf7..58fad8926 100644
--- a/src/tree/mirror/streaming/remote/streams/tests.rs
+++ b/src/tree/mirror/streaming/remote/streams/tests.rs
@@ -18,9 +18,6 @@ use super::{
 /// Session epoch shared by the violation tests; its value is arbitrary.
 const EPOCH: u8 = 0;
 
-/// A payload-free frame type for stream-layer tests.
-type Unit = ();
-
 /// The label is exactly two bytes: the session epoch then the stream index.
 #[test]
 fn label_is_epoch_then_stream() {
@@ -35,7 +32,7 @@ fn label_is_epoch_then_stream() {
 fn unopened_sender_finishes_without_connecting() {
     let (a, mut b) = memory();
     run_to_quiescence(async {
-        let sender: StreamSender<_, Unit> = StreamSender::new(
+        let sender: StreamSender<_> = StreamSender::new(
             a.connector.clone(),
             0,
             Speaker::Initiator,
@@ -62,7 +59,7 @@ fn frames_flow_sender_to_claimed_receiver() {
     let stream = Stream::new(2).expect("stream 2 exists");
     run_to_quiescence(async {
         let send = async {
-            let mut sender: StreamSender<_, Unit> = StreamSender::new(
+            let mut sender: StreamSender<_> = StreamSender::new(
                 a.connector.clone(),
                 9,
                 Speaker::Initiator,
@@ -83,7 +80,7 @@ fn frames_flow_sender_to_claimed_receiver() {
             let (route, _errors) = error_route();
             let driver =
                 AcceptDriver::new(&mut b.acceptor, 9, Speaker::Initiator, slots, route.clone());
-            let mut receiver: StreamReceiver<_, Unit> = StreamReceiver::new(
+            let mut receiver: StreamReceiver<_> = StreamReceiver::new(
                 claims.take(stream),
                 Speaker::Initiator,
                 stream,
@@ -118,7 +115,7 @@ fn unpolled_receiver_finishes_vacuously() {
     let (slots, mut claims) = claims::<tokio::io::DuplexStream>();
     let stream = Stream::new(0).expect("stream 0 exists");
     let (route, _errors) = error_route();
-    let mut receiver: StreamReceiver<_, Unit> = StreamReceiver::new(
+    let mut receiver: StreamReceiver<_> = StreamReceiver::new(
         claims.take(stream),
         Speaker::Responder,
         stream,
@@ -139,7 +136,7 @@ fn accept_driver_rejects_wrong_epoch() {
     let (a, mut b) = memory();
     run_to_quiescence(async {
         let send = async {
-            let mut sender: StreamSender<_, Unit> = StreamSender::new(
+            let mut sender: StreamSender<_> = StreamSender::new(
                 a.connector.clone(),
                 4,
                 Speaker::Initiator,
@@ -183,7 +180,7 @@ fn accept_driver_rejects_unclaimed_delivery() {
     let stream = Stream::new(6).expect("stream 6 exists");
     run_to_quiescence(async {
         let send = async {
-            let mut sender: StreamSender<_, Unit> = StreamSender::new(
+            let mut sender: StreamSender<_> = StreamSender::new(
                 a.connector.clone(),
                 0,
                 Speaker::Initiator,
@@ -243,12 +240,12 @@ async fn raw_labeled(
 async fn first_reported_error(
     acceptor: &mut crate::link::MemoryAcceptor,
     stream: Stream,
-    leading: &[Frame<Unit>],
+    leading: &[Frame],
 ) -> (StreamError, FirstStreamError) {
     let (slots, mut claims) = claims();
     let (route, mut errors) = error_route();
     let driver = AcceptDriver::new(acceptor, EPOCH, Speaker::Initiator, slots, route.clone());
-    let mut receiver: StreamReceiver<_, Unit> = StreamReceiver::new(
+    let mut receiver: StreamReceiver<_> = StreamReceiver::new(
         claims.take(stream),
         Speaker::Initiator,
         stream,
@@ -299,7 +296,7 @@ fn mislabeled_frame_is_reported_not_yielded() {
             // stream, the frame's signal byte another.
             let mut write = raw_labeled(&a.connector, labeled).await;
             write
-                .frame(&(framed, Frame::<Unit>::End(End::Reply)))
+                .frame(&(framed, Frame::End(End::Reply)))
                 .await
                 .expect("the miswired frame writes");
         };
@@ -329,7 +326,7 @@ fn truncated_stream_is_reported_not_ended() {
     let stream = Stream::new(4).expect("stream 4 exists");
     let error = run_to_quiescence(async {
         let send = async {
-            let mut sender: StreamSender<_, Unit> = StreamSender::new(
+            let mut sender: StreamSender<_> = StreamSender::new(
                 a.connector.clone(),
                 EPOCH,
                 Speaker::Initiator,
@@ -491,7 +488,7 @@ fn supply_failure_after_delivery_lets_the_session_finish() {
     let stream = Stream::new(7).expect("stream 7 exists");
     run_to_quiescence(async {
         let send = async {
-            let mut sender: StreamSender<_, Unit> = StreamSender::new(
+            let mut sender: StreamSender<_> = StreamSender::new(
                 a.connector.clone(),
                 EPOCH,
                 Speaker::Initiator,
@@ -520,7 +517,7 @@ fn supply_failure_after_delivery_lets_the_session_finish() {
                 slots,
                 route.clone(),
             );
-            let mut receiver: StreamReceiver<_, Unit> = StreamReceiver::new(
+            let mut receiver: StreamReceiver<_> = StreamReceiver::new(
                 claims.take(stream),
                 Speaker::Initiator,
                 stream,
@@ -552,12 +549,12 @@ fn supply_failure_after_delivery_lets_the_session_finish() {
 }
 
 /// Wrap a frame the type-level exclusion admits.
-fn reply_frame(frame: Frame<Unit>) -> ReplyFrame<Unit> {
+fn reply_frame(frame: Frame) -> ReplyFrame {
     ReplyFrame::try_from(frame).expect("not a stream-end control")
 }
 
 /// Stream-end control is excluded from reply frames at the type level.
 #[test]
 fn stream_end_is_not_a_reply_frame() {
-    assert!(ReplyFrame::<Unit>::try_from(Frame::End(End::Stream)).is_err());
+    assert!(ReplyFrame::try_from(Frame::End(End::Stream)).is_err());
 }
diff --git a/src/tree/mirror/streaming/testing/failing.rs b/src/tree/mirror/streaming/testing/failing.rs
index 36a6f5dec..ae67818db 100644
--- a/src/tree/mirror/streaming/testing/failing.rs
+++ b/src/tree/mirror/streaming/testing/failing.rs
@@ -136,10 +136,9 @@ impl<N> FailingNode<N> {
     }
 }
 
-impl<T, N> Node<T> for FailingNode<N>
+impl<N> Node for FailingNode<N>
 where
-    T: Send + Sync + 'static,
-    N: Node<T> + Clone + Send + 'static,
+    N: Node + Clone + Send + 'static,
 {
     type Backend = Failing<N::Backend>;
     type Height = N::Height;
@@ -175,10 +174,9 @@ impl<E: ErasedNode> ErasedNode for FailingNode<E> {
     }
 }
 
-impl<T, N> Leaf<T> for FailingNode<N>
+impl<N> Leaf for FailingNode<N>
 where
-    T: Send + Sync + 'static,
-    N: Leaf<T> + Clone + Send + 'static,
+    N: Leaf + Clone + Send + 'static,
 {
     fn message(&self) -> &Message {
         self.0.message()
@@ -189,7 +187,7 @@ where
     async fn leaf(
         version: Version,
         message: Message,
-    ) -> Result<Self, Failure<<N::Backend as Backend<T>>::Error>> {
+    ) -> Result<Self, Failure<<N::Backend as Backend>::Error>> {
         N::leaf(version, message)
             .await
             .map(Self)
@@ -197,10 +195,9 @@ where
     }
 }
 
-impl<B, T> Backend<T> for Failing<B>
+impl<B> Backend for Failing<B>
 where
-    B: Backend<T, Node<Z>: Leaf<T>>,
-    T: Send + Sync + 'static,
+    B: Backend<Node<Z>: Leaf>,
 {
     type Node<H: Height> = FailingNode<B::Node<H>>;
     // Erasure passes through the wrapper: fault injection targets the
@@ -245,11 +242,7 @@ where
             .map_err(Failure::Inner)
     }
 
-    fn children<H>(
-        self,
-        prefix: Prefix<S<H>>,
-        parent: Self::Node<S<H>>,
-    ) -> impl NodeStream<Self, T, H>
+    fn children<H>(self, prefix: Prefix<S<H>>, parent: Self::Node<S<H>>) -> impl NodeStream<Self, H>
     where
         H: Height,
         S<H>: Height,
@@ -283,11 +276,7 @@ mod tests {
         let outer = Failing::after(inner.clone(), 1);
         let prefix = Prefix::<S<Z>>::containing(&Path::from([0; 32]));
 
-        let first = pollster::block_on(Backend::<()>::parent::<Z>(
-            outer.clone(),
-            prefix,
-            Vec::new(),
-        ));
+        let first = pollster::block_on(Backend::parent::<Z>(outer.clone(), prefix, Vec::new()));
         assert!(matches!(
             first,
             Err(Failure::Inner(Failure::Injected(Operation::Parent {
@@ -295,11 +284,7 @@ mod tests {
             })))
         ));
 
-        let second = pollster::block_on(Backend::<()>::parent::<Z>(
-            outer.clone(),
-            prefix,
-            Vec::new(),
-        ));
+        let second = pollster::block_on(Backend::parent::<Z>(outer.clone(), prefix, Vec::new()));
         assert!(matches!(
             second,
             Err(Failure::Injected(Operation::Parent { height: 1 }))
diff --git a/src/tree/mirror/streaming/testing/faulting.rs b/src/tree/mirror/streaming/testing/faulting.rs
index 35b5ba660..ee9a6447e 100644
--- a/src/tree/mirror/streaming/testing/faulting.rs
+++ b/src/tree/mirror/streaming/testing/faulting.rs
@@ -134,7 +134,7 @@ trait FaultHeight: height::Height + Sized {
 }
 
 /// A backend whose test node handles can wrap the canonical local fixture.
-trait FaultBackend: Backend<(), Node<Z>: Leaf<()>> {
+trait FaultBackend: Backend<Node<Z>: Leaf> {
     fn node<H: FaultHeight>() -> Self::Node<H>;
 
     /// A node whose version no fixture's declared ceiling contains.
@@ -181,11 +181,11 @@ where
 fn malformed_responses<B, H, R>(
     responses: R,
     violation: Violation,
-) -> BoxResponses<B, (), H, MaterializedError<B::Error>>
+) -> BoxResponses<B, H, MaterializedError<B::Error>>
 where
     B: FaultBackend,
     H: FaultHeight,
-    R: Responses<B, (), H, MaterializedError<B::Error>>,
+    R: Responses<B, H, MaterializedError<B::Error>>,
 {
     Box::pin(async_stream::stream! {
         let mut responses = Box::pin(responses);
@@ -250,14 +250,11 @@ fn fault_phase<B, H, R, N>(
     next: N,
     remaining: usize,
     fault: Option<Fault>,
-) -> (
-    BoxResponses<B, (), H, MaterializedError<B::Error>>,
-    Faulting<N>,
-)
+) -> (BoxResponses<B, H, MaterializedError<B::Error>>, Faulting<N>)
 where
     B: FaultBackend,
     H: FaultHeight,
-    R: Responses<B, (), H, MaterializedError<B::Error>>,
+    R: Responses<B, H, MaterializedError<B::Error>>,
 {
     if let (0, Some(Fault::Reply(violation))) = (remaining, fault) {
         (
@@ -281,10 +278,10 @@ where
     type Output = P::Output;
 }
 
-impl<B, P> Connect<B, ()> for Faulting<P>
+impl<B, P> Connect<B> for Faulting<P>
 where
     B: FaultBackend,
-    P: Connect<B, ()> + protocol::Protocol<Error = MaterializedError<B::Error>>,
+    P: Connect<B> + protocol::Protocol<Error = MaterializedError<B::Error>>,
 {
     type Next = Faulting<P::Next>;
 
@@ -302,10 +299,10 @@ where
     }
 }
 
-impl<B, P> CompleteConnect<B, ()> for Faulting<P>
+impl<B, P> CompleteConnect<B> for Faulting<P>
 where
     B: FaultBackend,
-    P: CompleteConnect<B, ()> + protocol::Protocol<Error = MaterializedError<B::Error>>,
+    P: CompleteConnect<B> + protocol::Protocol<Error = MaterializedError<B::Error>>,
 {
     type Next = Faulting<P::Next>;
 
@@ -320,10 +317,10 @@ where
     }
 }
 
-impl<B, P> protocol::Accept<B, ()> for Faulting<P>
+impl<B, P> protocol::Accept<B> for Faulting<P>
 where
     B: FaultBackend,
-    P: protocol::Accept<B, ()> + protocol::Protocol<Error = MaterializedError<B::Error>>,
+    P: protocol::Accept<B> + protocol::Protocol<Error = MaterializedError<B::Error>>,
 {
     type Next = Faulting<P::Next>;
 
@@ -344,66 +341,58 @@ where
     }
 }
 
-impl<B, P> CompleteEqual<B, ()> for Faulting<P>
+impl<B, P> CompleteEqual<B> for Faulting<P>
 where
     B: FaultBackend,
-    P: CompleteEqual<B, ()> + protocol::Protocol<Error = MaterializedError<B::Error>>,
+    P: CompleteEqual<B> + protocol::Protocol<Error = MaterializedError<B::Error>>,
 {
     async fn complete_equal(self) -> Result<Self::Output, Self::Error> {
         self.inner.complete_equal().await
     }
 }
 
-impl<B, P> Initiator<B, ()> for Faulting<P>
+impl<B, P> Initiator<B> for Faulting<P>
 where
     B: FaultBackend,
-    P: Initiator<B, ()> + protocol::Protocol<Error = MaterializedError<B::Error>>,
+    P: Initiator<B> + protocol::Protocol<Error = MaterializedError<B::Error>>,
 {
     type Next = Faulting<P::Next>;
 
-    fn initiator(
-        self,
-    ) -> (
-        BoxResponses<B, (), height::UnderRoot, Self::Error>,
-        Self::Next,
-    ) {
+    fn initiator(self) -> (BoxResponses<B, height::UnderRoot, Self::Error>, Self::Next) {
         let (responses, next) = self.inner.initiator();
         fault_phase(responses, next, self.remaining, self.fault)
     }
 }
 
-impl<B, P> Responder<B, ()> for Faulting<P>
+impl<B, P> Responder<B> for Faulting<P>
 where
     B: FaultBackend,
-    P: Responder<B, ()> + protocol::Protocol<Error = MaterializedError<B::Error>>,
+    P: Responder<B> + protocol::Protocol<Error = MaterializedError<B::Error>>,
 {
     type Next = Faulting<P::Next>;
 
     fn responder(
         self,
-        requests: impl Requests<B, (), height::UnderRoot>,
-    ) -> (
-        BoxResponses<B, (), height::UnderRoot, Self::Error>,
-        Self::Next,
-    ) {
+        requests: impl Requests<B, height::UnderRoot>,
+    ) -> (BoxResponses<B, height::UnderRoot, Self::Error>, Self::Next) {
         let (responses, next) = self.inner.responder(requests);
         fault_phase(responses, next, self.remaining, self.fault)
     }
 }
 
-impl<B, P> Reply<B, ()> for Faulting<P>
+impl<B, P> Reply<B> for Faulting<P>
 where
     B: FaultBackend,
-    P: Reply<B, ()> + protocol::Protocol<Error = MaterializedError<B::Error>>,
+    P: Reply<B> + protocol::Protocol<Error = MaterializedError<B::Error>>,
     <P::Height as protocol::ReplyHeight>::Output: FaultHeight,
 {
     type Next = Faulting<P::Next>;
 
     fn reply(
         self,
-        requests: impl Requests<B, (), Self::Height>,
+        requests: impl Requests<B, Self::Height>,
     ) -> (
-        BoxResponses<B, (), <Self::Height as protocol::ReplyHeight>::Output, Self::Error>,
+        BoxResponses<B, <Self::Height as protocol::ReplyHeight>::Output, Self::Error>,
         Self::Next,
     ) {
         let (responses, next) = self.inner.reply(requests);
@@ -411,16 +400,16 @@ where
     }
 }
 
-impl<B, P> CompleteResponder<B, ()> for Faulting<P>
+impl<B, P> CompleteResponder<B> for Faulting<P>
 where
     B: FaultBackend,
-    P: CompleteResponder<B, ()> + protocol::Protocol<Error = MaterializedError<B::Error>>,
+    P: CompleteResponder<B> + protocol::Protocol<Error = MaterializedError<B::Error>>,
 {
     fn complete_responder(
         self,
-        requests: impl Requests<B, (), height::Z>,
+        requests: impl Requests<B, height::Z>,
     ) -> (
-        BoxResponses<B, (), height::Z, Self::Error>,
+        BoxResponses<B, height::Z, Self::Error>,
         impl Future<Output = Result<Self::Output, Self::Error>> + Send,
     ) {
         let (responses, output) = self.inner.complete_responder(requests);
@@ -433,14 +422,14 @@ where
     }
 }
 
-impl<B, P> CompleteInitiator<B, ()> for Faulting<P>
+impl<B, P> CompleteInitiator<B> for Faulting<P>
 where
     B: FaultBackend,
-    P: CompleteInitiator<B, ()> + protocol::Protocol<Error = MaterializedError<B::Error>>,
+    P: CompleteInitiator<B> + protocol::Protocol<Error = MaterializedError<B::Error>>,
 {
     async fn complete_initiator(
         self,
-        requests: impl Requests<B, (), height::Z>,
+        requests: impl Requests<B, height::Z>,
     ) -> Result<Self::Output, Self::Error> {
         self.inner.complete_initiator(requests).await
     }
diff --git a/src/tree/mirror/streaming/tests.rs b/src/tree/mirror/streaming/tests.rs
index c0eb8b10f..8bef7633b 100644
--- a/src/tree/mirror/streaming/tests.rs
+++ b/src/tree/mirror/streaming/tests.rs
@@ -78,7 +78,7 @@ fn streaming_mirror_sides_with_schedules(
     channel_schedule: Vec<u8>,
     backend_schedule: Vec<u8>,
 ) -> (Root, Root) {
-    let (a, b): (StreamingRoot<Local, ()>, StreamingRoot<Local, ()>) = (a.into(), b.into());
+    let (a, b): (StreamingRoot<Local>, StreamingRoot<Local>) = (a.into(), b.into());
     let client = Handshaking::start(Local, a.clone()).window(WindowConfig::FLOOR);
     let server = Handshaking::start(Local, b.clone()).window(WindowConfig::FLOOR);
     let (result, trace) = with_trace(|| {
@@ -103,11 +103,8 @@ fn streaming_mirror_sides_with_schedules(
 /// The skeleton-bridge harness ([`skeleton`]): generic over the payload type
 /// so payload-perturbation twins (same paths, different contents) can run
 /// through the identical machinery.
-fn transcribed_mirror_sides<T: Send + Sync + 'static>(
-    a: Root,
-    b: Root,
-) -> (Root, Root, Trace, Transcript) {
-    let (a, b): (StreamingRoot<Local, T>, StreamingRoot<Local, T>) = (a.into(), b.into());
+fn transcribed_mirror_sides(a: Root, b: Root) -> (Root, Root, Trace, Transcript) {
+    let (a, b): (StreamingRoot<Local>, StreamingRoot<Local>) = (a.into(), b.into());
     let client = Handshaking::start(Local, a).window(WindowConfig::FLOOR);
     let server = Handshaking::start(Local, b).window(WindowConfig::FLOOR);
     let ((result, trace), transcript) =
@@ -161,7 +158,7 @@ fn alternating_mirror_sides(a: Root, b: Root) -> (Root, Root) {
     pollster::block_on(async {
         let local_a = alternating::local::Exchange::start(a);
         let local_b = alternating::local::Exchange::start(b);
-        alternating::mirror::<_, _, ()>(local_a, local_b)
+        alternating::mirror(local_a, local_b)
             .await
             .expect("two honest oracle endpoints speak no violations")
     })
@@ -247,7 +244,7 @@ fn uncontained_supply_is_rejected_by_streaming() {
     use crate::tree::mirror::streaming::materialized::{Error, Violation};
 
     let (receiver, poisoned, _, _) = uncontained_supply_pair();
-    let (receiver, poisoned): (StreamingRoot<Local, ()>, StreamingRoot<Local, ()>) =
+    let (receiver, poisoned): (StreamingRoot<Local>, StreamingRoot<Local>) =
         (receiver.into(), poisoned.into());
     let client = Handshaking::start(Local, receiver).window(WindowConfig::FLOOR);
     let server = Handshaking::start(Local, poisoned).window(WindowConfig::FLOOR);
diff --git a/src/tree/mirror/streaming/tests/announced.rs b/src/tree/mirror/streaming/tests/announced.rs
index 27c6d048e..1266af6b6 100644
--- a/src/tree/mirror/streaming/tests/announced.rs
+++ b/src/tree/mirror/streaming/tests/announced.rs
@@ -52,7 +52,7 @@ proptest! {
     fn announced_skeleton_reconstructs_the_session(spec in arb_divergence()) {
         let run = |value: u64| {
             let (local, remote, _) = spec.trees(&value);
-            transcribed_mirror_sides::<()>(local, remote)
+            transcribed_mirror_sides(local, remote)
         };
 
         let (ours, theirs, trace, transcript) = run(0);
diff --git a/src/tree/mirror/streaming/tests/capacity.rs b/src/tree/mirror/streaming/tests/capacity.rs
index 2f7af8c32..047ad6272 100644
--- a/src/tree/mirror/streaming/tests/capacity.rs
+++ b/src/tree/mirror/streaming/tests/capacity.rs
@@ -24,7 +24,7 @@ use crate::tree::{
 
 /// Whether the session stalls at a selected capacity for the fan return queue.
 fn underbuffered_mirror_stalls(a: Root, b: Root, capacity: usize) -> bool {
-    let (a, b): (StreamingRoot<Local, ()>, StreamingRoot<Local, ()>) = (a.into(), b.into());
+    let (a, b): (StreamingRoot<Local>, StreamingRoot<Local>) = (a.into(), b.into());
     let client = Handshaking::start(Local, a).window(WindowConfig::FLOOR);
     let server = Handshaking::start(Local, b).window(WindowConfig::FLOOR);
     with_kind_capacity(QueueKind::AssemblyLevelReturns, capacity, || {
@@ -201,7 +201,7 @@ fn shape_stalls(
     channel_schedule: Vec<u8>,
     backend_schedule: Vec<u8>,
 ) -> bool {
-    let (a, b): (StreamingRoot<Local, ()>, StreamingRoot<Local, ()>) =
+    let (a, b): (StreamingRoot<Local>, StreamingRoot<Local>) =
         (pair.0.clone().into(), pair.1.clone().into());
     let client = Handshaking::start(Local, a).window(WindowConfig::FLOOR);
     let server = Handshaking::start(Local, b).window(WindowConfig::FLOOR);
diff --git a/src/tree/mirror/streaming/tests/faults.rs b/src/tree/mirror/streaming/tests/faults.rs
index d6ca7c5a8..ec6f9b344 100644
--- a/src/tree/mirror/streaming/tests/faults.rs
+++ b/src/tree/mirror/streaming/tests/faults.rs
@@ -21,7 +21,7 @@ use crate::tree::mirror::{
     },
 };
 
-fn failing_root(root: crate::tree::Root) -> StreamingRoot<Failing<Local>, ()> {
+fn failing_root(root: crate::tree::Root) -> StreamingRoot<Failing<Local>> {
     StreamingRoot {
         ceiling: root.ceiling,
         root: root.root.map(FailingNode::new),
diff --git a/src/tree/mirror/streaming/tests/local_eq.rs b/src/tree/mirror/streaming/tests/local_eq.rs
index a921b32dc..5d53e054f 100644
--- a/src/tree/mirror/streaming/tests/local_eq.rs
+++ b/src/tree/mirror/streaming/tests/local_eq.rs
@@ -110,8 +110,8 @@ proptest! {
         );
 
         let local_paths = spec.local_path_set();
-        let (_, _, trace_0, _) = transcribed_mirror_sides::<()>(local.clone(), remote_0);
-        let (_, _, trace_1, _) = transcribed_mirror_sides::<()>(local, remote_1);
+        let (_, _, trace_0, _) = transcribed_mirror_sides(local.clone(), remote_0);
+        let (_, _, trace_1, _) = transcribed_mirror_sides(local, remote_1);
         let decoded_0 = decode(&trace_0);
         let decoded_1 = decode(&trace_1);
 
@@ -223,8 +223,8 @@ fn free_insertions_are_invisible_to_the_local_view() {
         let remote_0 = rooted_at(remote_plus(shallow), join.clone());
         let remote_1 = rooted_at(remote_plus(deep), join);
 
-        let (_, _, trace_0, _) = transcribed_mirror_sides::<()>(local.clone(), remote_0);
-        let (_, _, trace_1, _) = transcribed_mirror_sides::<()>(local, remote_1);
+        let (_, _, trace_0, _) = transcribed_mirror_sides(local.clone(), remote_0);
+        let (_, _, trace_1, _) = transcribed_mirror_sides(local, remote_1);
         let decoded_0 = decode(&trace_0);
         let decoded_1 = decode(&trace_1);
 
@@ -302,8 +302,8 @@ fn leaf_requests_are_erased_from_the_view() {
         local_paths: &BTreeSet<[u8; 32]>,
         p: Party,
     ) {
-        let (_, _, trace_0, _) = transcribed_mirror_sides::<()>(local.clone(), remote_0);
-        let (_, _, trace_1, _) = transcribed_mirror_sides::<()>(local, remote_1);
+        let (_, _, trace_0, _) = transcribed_mirror_sides(local.clone(), remote_0);
+        let (_, _, trace_1, _) = transcribed_mirror_sides(local, remote_1);
         let decoded_0 = decode(&trace_0);
         let decoded_1 = decode(&trace_1);
         assert_view_sound(&decoded_0, p, local_paths);
diff --git a/src/tree/mirror/streaming/tests/stats.rs b/src/tree/mirror/streaming/tests/stats.rs
index 6fae69aac..43fa9f0fb 100644
--- a/src/tree/mirror/streaming/tests/stats.rs
+++ b/src/tree/mirror/streaming/tests/stats.rs
@@ -39,11 +39,8 @@ use super::fixtures::LeafOrder;
 /// No wire is involved, so the byte counters stay zero here; this
 /// harness pins the walk's counters (disputes, gains, sheds) and the
 /// window grant.
-fn mirror_with_stats<T: Send + Sync + 'static>(
-    a: Root,
-    b: Root,
-) -> (Root, Root, SessionStats, SessionStats) {
-    let (a, b): (StreamingRoot<Local, T>, StreamingRoot<Local, T>) = (a.into(), b.into());
+fn mirror_with_stats(a: Root, b: Root) -> (Root, Root, SessionStats, SessionStats) {
+    let (a, b): (StreamingRoot<Local>, StreamingRoot<Local>) = (a.into(), b.into());
     let a_recorder = Recorder::default();
     let b_recorder = Recorder::default();
     let client = Handshaking::start(Local, a)
@@ -65,7 +62,7 @@ fn mirror_with_stats<T: Send + Sync + 'static>(
 
 /// The live-leaf count of a tree root, for conservation checks.
 fn live(root: &Root) -> u64 {
-    let root: StreamingRoot<Local, ()> = root.clone().into();
+    let root: StreamingRoot<Local> = root.clone().into();
     root.len()
 }
 
@@ -73,8 +70,7 @@ fn live(root: &Root) -> u64 {
 /// session's role election (the smaller exchanged set initiates,
 /// canonical version bytes break ties).
 fn a_initiates(a: &Root, b: &Root) -> bool {
-    let (a, b): (StreamingRoot<Local, ()>, StreamingRoot<Local, ()>) =
-        (a.clone().into(), b.clone().into());
+    let (a, b): (StreamingRoot<Local>, StreamingRoot<Local>) = (a.clone().into(), b.clone().into());
     initiates(a.len(), &a.ceiling, b.len(), &b.ceiling)
 }
 
@@ -139,7 +135,7 @@ fn arb_cells() -> impl Strategy<Value = Vec<Vec<u8>>> {
 fn equal_trees_report_zero_stats() {
     let node = grown(None, 0, 1, &(), &[path_at(&[0x11]), path_at(&[0x22])]);
     let (a, b) = (rooted(node.clone()), rooted(node));
-    let (ours, theirs, a_stats, b_stats) = mirror_with_stats::<()>(a, b);
+    let (ours, theirs, a_stats, b_stats) = mirror_with_stats(a, b);
     assert_eq!(ours, theirs, "equal endpoints stay equal");
     assert_eq!(a_stats, SessionStats::default());
     assert_eq!(b_stats, SessionStats::default());
@@ -160,7 +156,7 @@ fn pyramid_disputes_match_the_prefix_closure() {
     let b_before = live(&b);
     let a_leads = a_initiates(&a, &b);
 
-    let (ours, theirs, a_stats, b_stats) = mirror_with_stats::<()>(a, b);
+    let (ours, theirs, a_stats, b_stats) = mirror_with_stats(a, b);
     assert_eq!(ours, theirs, "endpoints converge");
 
     let by_depth = expected_disputes_by_depth(&cells);
@@ -202,7 +198,7 @@ fn pyramid_disputes_match_the_prefix_closure() {
 #[test]
 fn honored_redaction_counts_as_shed() {
     let (a, b, expected) = leaf_parent_redaction_pair();
-    let (ours, theirs, a_stats, b_stats) = mirror_with_stats::<()>(a, b);
+    let (ours, theirs, a_stats, b_stats) = mirror_with_stats(a, b);
     assert_eq!(ours, expected, "the redacted leaf survives nowhere");
     assert_eq!(theirs, expected);
 
@@ -239,7 +235,7 @@ proptest! {
         let equal = a_before == 0 && b_before == 0;
         let a_leads = !equal && a_initiates(&a, &b);
 
-        let (ours, theirs, a_stats, b_stats) = mirror_with_stats::<()>(a, b);
+        let (ours, theirs, a_stats, b_stats) = mirror_with_stats(a, b);
         prop_assert_eq!(&ours, &theirs);
 
         let by_depth = expected_disputes_by_depth(&cells);
diff --git a/src/tree/mirror/streaming/tests/wedge.rs b/src/tree/mirror/streaming/tests/wedge.rs
index f32179027..f91be941f 100644
--- a/src/tree/mirror/streaming/tests/wedge.rs
+++ b/src/tree/mirror/streaming/tests/wedge.rs
@@ -132,7 +132,7 @@ fn session_realizes_the_wedge_shape() {
          if tree construction changes"
     );
 
-    let (ours, theirs, trace, _) = transcribed_mirror_sides::<()>(wall, chain);
+    let (ours, theirs, trace, _) = transcribed_mirror_sides(wall, chain);
     assert_eq!(ours, theirs, "sanity: the session converges");
 
     let decoded = decode(&trace);
diff --git a/src/tree/mirror/streaming/window.rs b/src/tree/mirror/streaming/window.rs
index 846823a24..417392105 100644
--- a/src/tree/mirror/streaming/window.rs
+++ b/src/tree/mirror/streaming/window.rs
@@ -152,7 +152,7 @@ const KEY_DEPTH: usize = 32;
 /// layout pads the real slots beyond this constant and owes that padding
 /// to its own `node_bytes` price.
 const REFERENCE_SLOT_BYTES: usize = std::mem::size_of::<(u8, typed::Node<Z>)>()
-    + std::mem::size_of::<(u8, Resolve<<Local as Backend<()>>::Erased>)>()
+    + std::mem::size_of::<(u8, Resolve<<Local as Backend>::Erased>)>()
     + std::mem::size_of::<(u8, typed::Hash)>();
 
 /// Fixed in-memory bytes per buffered scope beyond its per-child slots:
diff --git a/src/tree/traverse/join/tests.rs b/src/tree/traverse/join/tests.rs
index 32a08e79c..e2ad706aa 100644
--- a/src/tree/traverse/join/tests.rs
+++ b/src/tree/traverse/join/tests.rs
@@ -16,7 +16,7 @@ fn mirror_merge(a: Root, b: Root) -> Root {
     pollster::block_on(async {
         let l = local::Exchange::start(a);
         let r = local::Exchange::start(b);
-        match mirror::<_, _, ()>(l, r).await {
+        match mirror(l, r).await {
             Ok((merged, _)) => merged,
             Err(e) => panic!("honest oracle endpoints speak no violations: {e}"),
         }
diff --git a/src/tree/typed/node.rs b/src/tree/typed/node.rs
index d87de8f2e..2c8b139d3 100644
--- a/src/tree/typed/node.rs
+++ b/src/tree/typed/node.rs
@@ -2,6 +2,8 @@ use std::{fmt::Debug, iter::Map, marker::PhantomData};
 
 use before::{Dominance, Span};
 
+#[cfg(any(test, feature = "protocol-v1"))]
+use crate::message::PayloadDeserializer;
 use crate::{Version, causally, message::Message};
 
 use super::hash::Hash;
@@ -16,9 +18,6 @@ use crate::tree::wire;
 use crate::tree::wire::Decode;
 use untyped::fan::{self, Fan};
 
-#[cfg(any(test, feature = "protocol-v1"))]
-use serde::de::DeserializeOwned;
-
 /// The typed node with a height of 32; the root of the tree.
 pub type Root = Node<height::Root>;
 
@@ -482,24 +481,25 @@ where
 #[cfg(any(test, feature = "protocol-v1"))]
 /// The typed-payload decode of the node wire shape, per height.
 ///
-/// The node itself is erased, but a leaf's payload decodes as a concrete
-/// `T` (the alternating protocol's typed ingress: malformed payloads fail
-/// here, at the wire boundary), so the decoder is a generic method rather
-/// than a [`wire::Decode`] impl — the height trait carries the same
-/// one-step-down recursion as the batch-apply walk
-/// ([`Act`](crate::tree::traverse::act::Act)).
+/// The node itself is erased; a leaf's payload decodes through the
+/// peer's deserializer (the alternating protocol's typed ingress:
+/// malformed payloads fail here, at the wire boundary), so the decoder
+/// takes that extra argument rather than implementing [`wire::Decode`] —
+/// the height trait carries the same one-step-down recursion as the
+/// batch-apply walk ([`Act`](crate::tree::traverse::act::Act)).
 pub trait DecodeNode: Height {
-    fn read_node<T, R>(reader: &mut R) -> std::io::Result<Node<Self>>
+    fn read_node<R>(
+        reader: &mut R,
+        deserializer: PayloadDeserializer,
+    ) -> std::io::Result<Node<Self>>
     where
-        T: DeserializeOwned + Send + Sync + 'static,
         R: std::io::Read;
 }
 
 #[cfg(any(test, feature = "protocol-v1"))]
 impl DecodeNode for Z {
-    fn read_node<T, R>(reader: &mut R) -> std::io::Result<Node<Z>>
+    fn read_node<R>(reader: &mut R, deserializer: PayloadDeserializer) -> std::io::Result<Node<Z>>
     where
-        T: DeserializeOwned + Send + Sync + 'static,
         R: std::io::Read,
     {
         let prefix_len = u8::read_wire(reader)?;
@@ -507,7 +507,7 @@ impl DecodeNode for Z {
             return Err(wire::invalid("leaf height cannot carry a prefix"));
         }
         let version = Version::read_wire(reader)?;
-        let message = Message::from_reader::<T, _>(reader)?;
+        let message = Message::from_reader(reader, deserializer)?;
         Ok(Node::leaf(version, message))
     }
 }
@@ -518,9 +518,11 @@ where
     H: DecodeNode,
     S<H>: Height,
 {
-    fn read_node<T, R>(reader: &mut R) -> std::io::Result<Node<S<H>>>
+    fn read_node<R>(
+        reader: &mut R,
+        deserializer: PayloadDeserializer,
+    ) -> std::io::Result<Node<S<H>>>
     where
-        T: DeserializeOwned + Send + Sync + 'static,
         R: std::io::Read,
     {
         let prefix_len = u8::read_wire(reader)?;
@@ -543,7 +545,7 @@ where
                     return Err(wire::invalid("branch radices not strictly ascending"));
                 }
                 prev = Some(radix);
-                let child = H::read_node::<T, R>(reader)?;
+                let child = H::read_node(reader, deserializer)?;
                 children.insert(radix, child);
             }
             Node::branch(children).ok_or_else(|| wire::invalid("branch could not be reconstructed"))
@@ -555,7 +557,7 @@ where
             // dispatch layer.
             let synthesized = [prefix_len - 1];
             let mut chained = std::io::Read::chain(synthesized.as_slice(), &mut *reader);
-            let inner = H::read_node::<T, _>(&mut chained)?;
+            let inner = H::read_node(&mut chained, deserializer)?;
             Ok(Node::beneath(inner, head))
         }
     }
diff --git a/src/tree/wire.rs b/src/tree/wire.rs
index 2b179c038..e75d963df 100644
--- a/src/tree/wire.rs
+++ b/src/tree/wire.rs
@@ -243,13 +243,14 @@ mod tests {
 
         let m = Message::new(());
         let enc = to_vec(&m).unwrap();
-        let back = Message::from_reader::<(), _>(&mut enc.as_slice()).unwrap();
+        let back =
+            Message::from_reader(&mut enc.as_slice(), Message::deserializer::<()>()).unwrap();
         assert_eq!(back.as_slice(), m.as_slice());
 
         let leaf: Node<Z> = Node::leaf(version.clone(), Message::new(()));
         let enc = to_vec(&leaf).unwrap();
         let mut input = enc.as_slice();
-        let back = Z::read_node::<(), _>(&mut input).unwrap();
+        let back = Z::read_node(&mut input, Message::deserializer::<()>()).unwrap();
         assert!(
             input.is_empty(),
             "the node decode consumes exactly its bytes"
diff --git a/tests/bootstrap_snapshot.rs b/tests/bootstrap_snapshot.rs
index 1e9b93c89..cde1bdb2b 100644
--- a/tests/bootstrap_snapshot.rs
+++ b/tests/bootstrap_snapshot.rs
@@ -40,7 +40,7 @@ use serde::de::DeserializeOwned;
 /// deterministic and these captures stay reproducible.
 ///
 /// Mirrors `gossip_snapshot::seeded`.
-fn seeded<T>() -> Rumors<T> {
+fn seeded<T: serde::de::DeserializeOwned + Send + Sync + 'static>() -> Rumors<T> {
     Peer::seed_rng(&mut SmallRng::seed_from_u64(0))
         .sync_window_floor()
         .into_rumors()
diff --git a/tests/gossip_snapshot.rs b/tests/gossip_snapshot.rs
index 8ae731f0a..22372909c 100644
--- a/tests/gossip_snapshot.rs
+++ b/tests/gossip_snapshot.rs
@@ -35,7 +35,7 @@ use crate::common::wire::{block_on, bootstrap_fork, bootstrap_fork_async};
 /// A peer seeded from a fixed RNG, so the [`rumors::Network`] id carried in
 /// the preamble is deterministic and these byte-level captures stay
 /// reproducible across runs.
-fn seeded<T>() -> Rumors<T> {
+fn seeded<T: serde::de::DeserializeOwned + Send + Sync + 'static>() -> Rumors<T> {
     Peer::seed_rng(&mut SmallRng::seed_from_u64(0))
         .sync_window_floor()
         .into_rumors()
diff --git a/tests/network.rs b/tests/network.rs
index f9adbbf8c..46dfadf60 100644
--- a/tests/network.rs
+++ b/tests/network.rs
@@ -15,7 +15,7 @@ use crate::common::wire::{assert_control_drained, block_on};
 
 /// A peer seeded deterministically, so two seeds with distinct stream ids get
 /// distinct (but reproducible) networks.
-fn seeded<T>(stream: u64) -> Peer<T> {
+fn seeded<T: serde::de::DeserializeOwned + Send + Sync + 'static>(stream: u64) -> Peer<T> {
     Peer::seed_rng(&mut SmallRng::seed_from_u64(stream)).sync_window_floor()
 }
 
diff --git a/tests/opening_supply.rs b/tests/opening_supply.rs
index ac8b4261e..26e051470 100644
--- a/tests/opening_supply.rs
+++ b/tests/opening_supply.rs
@@ -21,7 +21,7 @@ use crate::common::shape::{ballast_avoiding, keep_only, path_radix, pool, send_p
 use crate::common::wire::{block_on, bootstrap_fork_async};
 
 /// A peer seeded from a fixed RNG so the capture is deterministic.
-fn seeded<T>() -> Rumors<T> {
+fn seeded<T: serde::de::DeserializeOwned + Send + Sync + 'static>() -> Rumors<T> {
     Peer::seed_rng(&mut SmallRng::seed_from_u64(0)).into_rumors()
 }
 
diff --git a/tests/single_peer.rs b/tests/single_peer.rs
index 45220466d..e88bd3c9a 100644
--- a/tests/single_peer.rs
+++ b/tests/single_peer.rs
@@ -164,6 +164,17 @@ impl Serialize for Explosive {
     }
 }
 
+// Peer construction mints the payload deserializer up front, so even this
+// send-only payload type states how its wire form reads back.
+impl<'de> serde::Deserialize<'de> for Explosive {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        Ok(Explosive {
+            value: u64::deserialize(deserializer)?,
+            fail: false,
+        })
+    }
+}
+
 /// A batch interrupted by a panic between its sends commits nothing.
 ///
 /// [`Batch`](rumors::Batch) documents that a batch dropped by a panic's

From 442174f06944128baee654f37773969bbe7edcf7 Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Thu, 20 Aug 2026 01:20:09 -0400
Subject: [PATCH 14/18] peer: seal the session funnels behind boxed non-generic
 reconciliations (part II stage 4)

The reconcile arms of gossip_inner and bootstrap_erased move into
non-generic bodies -- Reconciliation::{v2,v1} and bootstrap_{v2,v1} --
that return their futures boxed. Extraction alone moves nothing: an
async fn body is a closure item codegen'd into whichever crate polls
the future, so a bare non-generic async fn hands the protocol state
machine right back to the consumer crate. The dyn coercion inside this
crate is the seal -- vtable, poll, and everything the body awaits
codegen here -- and #[inline(never)] on the small shells keeps
optimized builds' automatic cross-crate MIR inlining from moving the
coercion back out.

Measured (cargo llvm-lines, debug): pairwise 719,377 -> 207,278 lines
(-71% this stage; -80% across part II); the lib 354,431 -> 867,372,
the towers' once-paid residence. A minimal one-gossip-call downstream
binary: 3,401,418 lines against pre-erasure rumors, 1,095,377 against
the height-erased tree, 34,699 fully erased. Runtime pin:
gossip_fixed_bidir_insertions/V2/5000 at 15.67ms -> 15.62ms,
overlapping confidence intervals (same-machine back-to-back A/B).
---
 design/item-erasure.md |  27 +++
 src/peer/gossip.rs     | 407 ++++++++++++++++++++++++++++-------------
 2 files changed, 302 insertions(+), 132 deletions(-)

diff --git a/design/item-erasure.md b/design/item-erasure.md
index d1ce2a755..347c1c117 100644
--- a/design/item-erasure.md
+++ b/design/item-erasure.md
@@ -223,3 +223,30 @@ security-relevant: payload validation stays exactly where it is
    unchanged). The new meter lands here: IR lines of a minimal
    downstream binary (one `gossip` call) — the "what the next consumer
    pays" number. Measure; bench pin at the end.
+   *Measured*: `pairwise` falls 719,377 → 207,278 lines (30,252 →
+   8,299 copies) — −71% in this stage, −80% across part II — and the
+   lib grows 354,431 → 867,372: the towers' once-paid residence, the
+   +513k there mirroring the −512k every consumer stops re-buying.
+   What remains in a consumer of `rumors`'s code is ~11k lines of
+   thin generic shells (the largest single item: `gossip_inner`'s
+   bookkeeping at ~1.5k). The headline meter, a minimal
+   one-`gossip`-call binary: 3,401,418 lines (102,771 copies) against
+   pre-erasure `rumors`, 1,095,377 (34,116) against the height-erased
+   tree, 34,699 (1,161) fully erased — −96.8% for part II alone,
+   −99.0% across both erasures. The sealing mechanism is subtler than
+   "extract non-generic functions", which alone moved *nothing*: an
+   `async fn` body is a closure item codegen'd into whichever crate
+   polls the future, so a bare non-generic `async fn` hands the state
+   machine right back to its caller's crate. What seals is returning
+   the future boxed — the `dyn` coercion inside this crate pins the
+   vtable, the poll function, and everything the body awaits into this
+   crate's object code — plus `#[inline(never)]` on the small shells,
+   without which optimized builds' automatic cross-crate MIR inlining
+   would move the coercion (and the tower behind it) back into the
+   consumer.
+   *Runtime pin*: `gossip_fixed_bidir_insertions/V2/5000` at 15.67 ms
+   against the height-erased tree vs 15.62 ms fully erased —
+   identical within the confidence intervals (both sides back-to-back
+   on the same machine under the same background load; a shared-host
+   run, so a coarse regression check rather than a precise
+   measurement, and it shows no movement to explain).
diff --git a/src/peer/gossip.rs b/src/peer/gossip.rs
index 153063407..1194055ef 100644
--- a/src/peer/gossip.rs
+++ b/src/peer/gossip.rs
@@ -8,7 +8,7 @@
 use std::pin::Pin;
 use std::sync::Arc;
 
-use before::Party;
+use before::{Party, Ticks};
 use futures::{Stream, future::BoxFuture};
 use futures_util::StreamExt;
 use tokio::{
@@ -20,7 +20,7 @@ use crate::link::{
     Acceptor, Connector, Link, SessionState,
     erased::{DynAcceptor, DynConnector},
 };
-use crate::message::Message;
+use crate::message::{Message, PayloadDeserializer};
 #[cfg(any(test, feature = "protocol-v1"))]
 use crate::tree::mirror::{
     alternating::{self, local as alternating_local, remote as alternating_remote},
@@ -34,8 +34,10 @@ use crate::{
         handshake::{self, Intent},
         party,
         streaming::{
-            self, Local, materialized, remote as streaming_remote,
+            self, Local, materialized,
+            remote::{self as streaming_remote, RunBudget},
             stats::{Recorder, SessionStats},
+            window::WindowConfig,
         },
     },
 };
@@ -66,7 +68,9 @@ const EPILOGUE_MARKER: u8 = b'.';
 /// instantiation would otherwise re-instantiate both towers — and, because
 /// generic code monomorphizes in the crate that supplies the concrete types,
 /// it would do so once per downstream binary per instantiation. Erasing here
-/// caps that at one instantiation per payload type. The price is one vtable
+/// — with the protocol bodies behind the non-generic [`Reconciliation`] and
+/// bootstrap drivers — caps that at one instantiation, compiled once into
+/// this crate. The price is one vtable
 /// call per stream open/accept and per `poll_read`/`poll_write` beneath the
 /// framing layers, which buffer whole frames on both sides.
 type DynRead<'a> = &'a mut (dyn AsyncRead + Unpin + Send + 'a);
@@ -268,73 +272,20 @@ impl<T> Peer<T, NoBookmark> {
             // Reconcile from an empty tree using the selected wire protocol. Both
             // branches return the same lifecycle boundary: a materialized root and
             // the raw control halves positioned at the trailing party frame.
-            // `BoxFuture` is the compile-time boundary: `Box::pin` alone would
-            // allocate the state while still exposing its enormous concrete type.
-            #[allow(clippy::type_complexity)]
-            let reconcile: BoxFuture<
-                '_,
-                Result<Option<(tree::Root, DynRead<'a>, DynWrite<'a>)>, Error>,
-            > = match config.protocol {
-                Protocol::V2 => Box::pin(async move {
-                    let local_root: streaming::Root<Local> = tree::Root::default().into();
-                    // The window choice is passed for uniformity with gossip,
-                    // but no choice can widen this session: disputes require
-                    // joint occupancy and this side's replica is empty, so
-                    // every derived capacity floors at one slot regardless.
-                    // The message-size target is the operative knob: the
-                    // greeting advertises it, and the provider's supply runs
-                    // are built at the exchanged minimum.
-                    let local = materialized::Handshaking::start(Local, local_root)
-                        .window(config.window)
-                        .target_message_size(config.run_budget.bytes() as u64);
-                    let carrier = Link::for_session(read, write, connector, acceptor, epoch);
-                    let proxy = streaming_remote::Handshaking::start(Local, carrier, deserializer)
-                        .window(config.window);
-                    let handshaken = streaming::handshake(local, proxy)
-                        .await
-                        .map_err(streaming_error)?;
-                    // A counterparty that is itself bootstrapping has nothing
-                    // to hand us, but the session still ends with the
-                    // epilogue. Both trees are empty, so the versions are
-                    // equal and `reconcile` resolves to the untouched control
-                    // halves without opening a data stream; the marker
-                    // exchange then certifies the mutual bail to both sides.
-                    // The equal-version resolution is itself guarded: a
-                    // fellow claimant must be as newborn as we are.
-                    let both_bootstrapping = remote.network.is_bootstrap();
-                    if both_bootstrapping {
-                        bootstrap_claimant_is_newborn(&handshaken.peer().version)?;
-                    }
-                    let descent: BoxFuture<'_, _> = Box::pin(handshaken.reconcile());
-                    let (root, (mut read, mut write)) = descent.await.map_err(streaming_error)?;
-                    if both_bootstrapping {
-                        epilogue(&mut read, &mut write).await?;
-                        return Ok(None);
-                    }
-                    Ok(Some((root.into(), read, write)))
-                }),
+            // The protocol bodies are the non-generic [`bootstrap_v2`] and
+            // [`bootstrap_v1`], which return their futures boxed; see
+            // [`Reconciliation::v2`] for the boxing and inlining discipline.
+            let both_bootstrapping = remote.network.is_bootstrap();
+            let reconcile = match config.protocol {
+                Protocol::V2 => bootstrap_v2(
+                    (read, write, connector, acceptor, epoch),
+                    deserializer,
+                    config.window,
+                    config.run_budget,
+                    both_bootstrapping,
+                ),
                 #[cfg(any(test, feature = "protocol-v1"))]
-                Protocol::V1 => Box::pin(async move {
-                    let local = alternating_local::Exchange::start(tree::Root::default());
-                    let proxy = alternating_remote::Exchange::start(
-                        FrameRead::new(read),
-                        FrameWrite::new(write),
-                        deserializer,
-                    );
-                    let handshaken = alternating::handshake(local, proxy)
-                        .await
-                        .map_err(alternating_error)?;
-                    // The frozen V1 wire has no epilogue: a mutual bootstrap
-                    // bails right here, exactly as V1 always has — once the
-                    // fellow claimant proves as newborn as we are.
-                    if remote.network.is_bootstrap() {
-                        bootstrap_claimant_is_newborn(&handshaken.peer().version)?;
-                        return Ok(None);
-                    }
-                    let descent: BoxFuture<'_, _> = Box::pin(handshaken.reconcile());
-                    let (root, (read, write)) = descent.await.map_err(alternating_error)?;
-                    Ok(Some((root, read.into_inner(), write.into_inner())))
-                }),
+                Protocol::V1 => bootstrap_v1(read, write, deserializer, both_bootstrapping),
             };
             let Some((root, mut read, mut write)) = reconcile.await? else {
                 return Ok(None);
@@ -615,9 +566,10 @@ impl<T, B: Persist> Peer<T, B> {
     ///
     /// [`gossip_when`]: crate::Rumors::gossip_when
     ///
-    /// Takes the link pre-erased ([`DynLinkParts`]): every generic caller funnels
-    /// through here, so the protocol towers this drives instantiate once per
-    /// payload type, not once per link instantiation.
+    /// Takes the link pre-erased ([`DynLinkParts`]): every generic caller
+    /// funnels through here, and the reconciliation itself runs behind the
+    /// non-generic [`Reconciliation`], so the protocol towers it drives
+    /// codegen exactly once, in this crate.
     async fn gossip_inner<'a>(
         &self,
         intent: Intent,
@@ -742,66 +694,26 @@ impl<T, B: Persist> Peer<T, B> {
         // Reconcile using this peer's selected protocol. Both branches meet at
         // the lifecycle boundary the surrounding transaction needs: a local
         // root plus raw transport halves positioned after reconciliation.
-        // The explicit `BoxFuture` coercion prevents either concrete protocol
-        // state machine from becoming part of this outer session future.
-        let network = self.network;
-        let window = self.window;
-        let run_budget = self.run_budget;
-        let session_stats = stats.clone();
-        #[allow(clippy::type_complexity)]
-        let reconcile: BoxFuture<
-            '_,
-            Result<(tree::Root, DynRead<'a>, DynWrite<'a>), Error>,
-        > = match self.protocol {
-            Protocol::V2 => Box::pin(async move {
-                let local = materialized::Handshaking::<_, _>::start(Local, prior_tree.root.into())
-                    .window(window)
-                    .target_message_size(run_budget.bytes() as u64)
-                    .stats(session_stats.clone());
-                let carrier = Link::for_session(read, write, connector, acceptor, epoch);
-                let proxy = streaming_remote::Handshaking::start(Local, carrier, deserializer)
-                    .window(window)
-                    .stats(session_stats);
-                let handshaken = streaming::handshake(local, proxy)
-                    .await
-                    .map_err(streaming_error)?;
-                if peer_bootstrapping {
-                    bootstrap_claimant_is_newborn(&handshaken.peer().version)?;
-                } else if remote.network != network {
-                    return Err(Error::NetworkMismatch {
-                        remote_network: remote.network,
-                        remote_min_events: handshaken.peer().version.min_ticks(),
-                        local_min_events,
-                    });
-                }
-                let descent: BoxFuture<'_, _> = Box::pin(handshaken.reconcile());
-                let (root, (read, write)) = descent.await.map_err(streaming_error)?;
-                Ok((root.into(), read, write))
-            }),
+        // The protocol bodies live behind the non-generic [`Reconciliation`],
+        // whose methods return their futures boxed: neither concrete
+        // protocol state machine becomes part of this outer session future,
+        // or of the consumer crate that instantiates it.
+        let reconciliation = Reconciliation {
+            root: prior_tree.root,
+            link: (read, write, connector, acceptor, epoch),
+            deserializer,
+            window: self.window,
+            run_budget: self.run_budget,
+            stats: stats.clone(),
+            peer_bootstrapping,
+            remote_network: remote.network,
+            network: self.network,
+            local_min_events,
+        };
+        let reconcile = match self.protocol {
+            Protocol::V2 => reconciliation.v2(),
             #[cfg(any(test, feature = "protocol-v1"))]
-            Protocol::V1 => Box::pin(async move {
-                let local = alternating_local::Exchange::start(prior_tree.root);
-                let proxy = alternating_remote::Exchange::start(
-                    FrameRead::new(read),
-                    FrameWrite::new(write),
-                    deserializer,
-                );
-                let handshaken = alternating::handshake(local, proxy)
-                    .await
-                    .map_err(alternating_error)?;
-                if peer_bootstrapping {
-                    bootstrap_claimant_is_newborn(&handshaken.peer().version)?;
-                } else if remote.network != network {
-                    return Err(Error::NetworkMismatch {
-                        remote_network: remote.network,
-                        remote_min_events: handshaken.peer().version.min_ticks(),
-                        local_min_events,
-                    });
-                }
-                let descent: BoxFuture<'_, _> = Box::pin(handshaken.reconcile());
-                let (root, (read, write)) = descent.await.map_err(alternating_error)?;
-                Ok((root, read.into_inner(), write.into_inner()))
-            }),
+            Protocol::V1 => reconciliation.v1(),
         };
         let (root, read, write) = match reconcile.await {
             Ok(reconciled) => reconciled,
@@ -1120,6 +1032,237 @@ impl<T, B: Bookmark> Peer<T, B> {
     }
 }
 
+/// One gossip reconciliation's inputs, fully erased.
+///
+/// [`Peer::gossip_inner`] assembles this and immediately consumes it through
+/// [`v2`](Self::v2) or [`v1`](Self::v1). The struct exists so those bodies
+/// are non-generic: `gossip_inner` is generic over the payload and bookmark
+/// types, and a reconciliation written inline there would monomorphize the
+/// entire protocol tower it drives into every consumer crate, once per
+/// instantiation. Behind this boundary the towers codegen exactly once, into
+/// this crate's own object code.
+struct Reconciliation<'a> {
+    /// The local replica's root, snapshotted inside the session transaction's
+    /// critical section: exactly what the local participant reconciles from.
+    root: tree::Root,
+    /// The session's erased link.
+    link: DynLinkParts<'a>,
+    /// The peer's payload deserializer, applied at wire ingress.
+    deserializer: PayloadDeserializer,
+    /// The window policy the V2 session negotiates under.
+    window: WindowConfig,
+    /// The V2 supply-run sizing budget; its byte target rides the greeting.
+    run_budget: RunBudget,
+    /// The session's stats recorder, shared by both V2 participants.
+    stats: Recorder,
+    /// Whether the remote's preamble declared it a bootstrap claimant.
+    peer_bootstrapping: bool,
+    /// The network the remote's preamble declared.
+    remote_network: Network,
+    /// The local network, which a non-bootstrapping remote must match.
+    network: Network,
+    /// The local greeting frontier's event floor, for the mismatch report.
+    local_min_events: Ticks,
+}
+
+impl<'a> Reconciliation<'a> {
+    /// Drive one V2 (streaming) reconciliation to the lifecycle boundary the
+    /// session transaction resumes from: the reconciled local root plus the
+    /// raw control halves, positioned after the descent.
+    ///
+    /// Returns the future boxed: an `async fn` body is codegen'd into
+    /// whichever crate polls it, so a bare future here would hand the whole
+    /// protocol state machine right back to every consumer. The `dyn`
+    /// coercion pins it — vtable, poll, and everything the body awaits — in
+    /// this crate's own object code. `inline(never)` guards the same
+    /// boundary in optimized builds: the shell is small enough for rustc's
+    /// automatic cross-crate MIR inlining, which would move the coercion —
+    /// and the tower behind it — back into the consumer.
+    #[inline(never)]
+    fn v2(self) -> BoxFuture<'a, Result<(tree::Root, DynRead<'a>, DynWrite<'a>), Error>> {
+        Box::pin(async move {
+            let Self {
+                root,
+                link,
+                deserializer,
+                window,
+                run_budget,
+                stats,
+                peer_bootstrapping,
+                remote_network,
+                network,
+                local_min_events,
+            } = self;
+            let (read, write, connector, acceptor, epoch) = link;
+            let local = materialized::Handshaking::<_, _>::start(Local, root.into())
+                .window(window)
+                .target_message_size(run_budget.bytes() as u64)
+                .stats(stats.clone());
+            let carrier = Link::for_session(read, write, connector, acceptor, epoch);
+            let proxy = streaming_remote::Handshaking::start(Local, carrier, deserializer)
+                .window(window)
+                .stats(stats);
+            let handshaken = streaming::handshake(local, proxy)
+                .await
+                .map_err(streaming_error)?;
+            if peer_bootstrapping {
+                bootstrap_claimant_is_newborn(&handshaken.peer().version)?;
+            } else if remote_network != network {
+                return Err(Error::NetworkMismatch {
+                    remote_network,
+                    remote_min_events: handshaken.peer().version.min_ticks(),
+                    local_min_events,
+                });
+            }
+            let descent: BoxFuture<'_, _> = Box::pin(handshaken.reconcile());
+            let (root, (read, write)) = descent.await.map_err(streaming_error)?;
+            Ok((root.into(), read, write))
+        })
+    }
+
+    /// Drive one V1 (alternating) reconciliation to the same lifecycle
+    /// boundary as [`v2`](Self::v2), boxed and `inline(never)` for the same
+    /// reasons.
+    ///
+    /// The frozen V1 wire has no window, budget, or stats vocabulary, and
+    /// its proxy runs on the control halves alone, so those inputs are
+    /// dropped unread.
+    #[cfg(any(test, feature = "protocol-v1"))]
+    #[inline(never)]
+    fn v1(self) -> BoxFuture<'a, Result<(tree::Root, DynRead<'a>, DynWrite<'a>), Error>> {
+        Box::pin(async move {
+            let Self {
+                root,
+                link,
+                deserializer,
+                peer_bootstrapping,
+                remote_network,
+                network,
+                local_min_events,
+                ..
+            } = self;
+            let (read, write, ..) = link;
+            let local = alternating_local::Exchange::start(root);
+            let proxy = alternating_remote::Exchange::start(
+                FrameRead::new(read),
+                FrameWrite::new(write),
+                deserializer,
+            );
+            let handshaken = alternating::handshake(local, proxy)
+                .await
+                .map_err(alternating_error)?;
+            if peer_bootstrapping {
+                bootstrap_claimant_is_newborn(&handshaken.peer().version)?;
+            } else if remote_network != network {
+                return Err(Error::NetworkMismatch {
+                    remote_network,
+                    remote_min_events: handshaken.peer().version.min_ticks(),
+                    local_min_events,
+                });
+            }
+            let descent: BoxFuture<'_, _> = Box::pin(handshaken.reconcile());
+            let (root, (read, write)) = descent.await.map_err(alternating_error)?;
+            Ok((root, read.into_inner(), write.into_inner()))
+        })
+    }
+}
+
+/// Drive one V2 bootstrap reconciliation from an empty local replica.
+///
+/// Free and non-generic for the same reason [`Reconciliation`] is: the
+/// generic [`Peer::bootstrap_erased`] shell funnels through here, so the
+/// protocol tower codegens once, in this crate.
+///
+/// `Ok(None)` is the mutual-bootstrap bail: the counterparty is itself
+/// bootstrapping, so there is no donation to receive, and the epilogue has
+/// already been exchanged. `Ok(Some(..))` hands back the reconciled root and
+/// the control halves positioned at the trailing party frame.
+///
+/// Boxed and `inline(never)` for [`Reconciliation::v2`]'s reasons: the `dyn`
+/// coercion is what pins the protocol state machine in this crate.
+#[inline(never)]
+#[allow(clippy::type_complexity)]
+fn bootstrap_v2<'a>(
+    link: DynLinkParts<'a>,
+    deserializer: PayloadDeserializer,
+    window: WindowConfig,
+    run_budget: RunBudget,
+    both_bootstrapping: bool,
+) -> BoxFuture<'a, Result<Option<(tree::Root, DynRead<'a>, DynWrite<'a>)>, Error>> {
+    Box::pin(async move {
+        let (read, write, connector, acceptor, epoch) = link;
+        let local_root: streaming::Root<Local> = tree::Root::default().into();
+        // The window choice is passed for uniformity with gossip, but no
+        // choice can widen this session: disputes require joint occupancy
+        // and this side's replica is empty, so every derived capacity floors
+        // at one slot regardless. The message-size target is the operative
+        // knob: the greeting advertises it, and the provider's supply runs
+        // are built at the exchanged minimum.
+        let local = materialized::Handshaking::start(Local, local_root)
+            .window(window)
+            .target_message_size(run_budget.bytes() as u64);
+        let carrier = Link::for_session(read, write, connector, acceptor, epoch);
+        let proxy =
+            streaming_remote::Handshaking::start(Local, carrier, deserializer).window(window);
+        let handshaken = streaming::handshake(local, proxy)
+            .await
+            .map_err(streaming_error)?;
+        // A counterparty that is itself bootstrapping has nothing to hand
+        // us, but the session still ends with the epilogue. Both trees are
+        // empty, so the versions are equal and `reconcile` resolves to the
+        // untouched control halves without opening a data stream; the marker
+        // exchange then certifies the mutual bail to both sides. The
+        // equal-version resolution is itself guarded: a fellow claimant must
+        // be as newborn as we are.
+        if both_bootstrapping {
+            bootstrap_claimant_is_newborn(&handshaken.peer().version)?;
+        }
+        let descent: BoxFuture<'_, _> = Box::pin(handshaken.reconcile());
+        let (root, (mut read, mut write)) = descent.await.map_err(streaming_error)?;
+        if both_bootstrapping {
+            epilogue(&mut read, &mut write).await?;
+            return Ok(None);
+        }
+        Ok(Some((root.into(), read, write)))
+    })
+}
+
+/// Drive one V1 bootstrap reconciliation from an empty local replica; see
+/// [`bootstrap_v2`] for the lifecycle boundary and the boxing and inlining
+/// discipline.
+///
+/// The frozen V1 wire has no epilogue: a mutual bootstrap (`Ok(None)`)
+/// bails right after the handshake, exactly as V1 always has — once the
+/// fellow claimant proves as newborn as we are.
+#[cfg(any(test, feature = "protocol-v1"))]
+#[inline(never)]
+#[allow(clippy::type_complexity)]
+fn bootstrap_v1<'a>(
+    read: DynRead<'a>,
+    write: DynWrite<'a>,
+    deserializer: PayloadDeserializer,
+    both_bootstrapping: bool,
+) -> BoxFuture<'a, Result<Option<(tree::Root, DynRead<'a>, DynWrite<'a>)>, Error>> {
+    Box::pin(async move {
+        let local = alternating_local::Exchange::start(tree::Root::default());
+        let proxy = alternating_remote::Exchange::start(
+            FrameRead::new(read),
+            FrameWrite::new(write),
+            deserializer,
+        );
+        let handshaken = alternating::handshake(local, proxy)
+            .await
+            .map_err(alternating_error)?;
+        if both_bootstrapping {
+            bootstrap_claimant_is_newborn(&handshaken.peer().version)?;
+            return Ok(None);
+        }
+        let descent: BoxFuture<'_, _> = Box::pin(handshaken.reconcile());
+        let (root, (read, write)) = descent.await.map_err(alternating_error)?;
+        Ok(Some((root, read.into_inner(), write.into_inner())))
+    })
+}
+
 /// Erase a caller's link into one session's [`DynLinkParts`], opening the
 /// session on the link's [`SessionState`]: each call is exactly one session.
 ///

From c9e36a9ab2b725097a8f2ca97fafac5dd0f8dca0 Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Thu, 20 Aug 2026 01:22:20 -0400
Subject: [PATCH 15/18] item-erasure: mark the design implemented, awaiting the
 merge ruling

---
 design/item-erasure.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/design/item-erasure.md b/design/item-erasure.md
index 347c1c117..97838258d 100644
--- a/design/item-erasure.md
+++ b/design/item-erasure.md
@@ -1,9 +1,9 @@
 # Item-type erasure at the leaf boundary (part II sketch)
 
-Status: accepted (option B, with the rulings below); implementation in
-progress on the `height-erasure` branch. Numbers marked *measured* come
-from `cargo llvm-lines --test pairwise` (debug, default features) on
-the height-erased tree.
+Status: accepted (option B, with the rulings below); implemented on the
+`height-erasure` branch, all four stages measured, awaiting the owner's
+merge ruling. Numbers marked *measured* come from `cargo llvm-lines
+--test pairwise` (debug, default features) on the height-erased tree.
 
 ## The problem, precisely
 

From 0ac1872cf200a43befd3914633976944456d972a Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Thu, 20 Aug 2026 01:49:09 -0400
Subject: [PATCH 16/18] message: dissolve the unused typed borrow; pin the
 cross-type ingress family

Message::message (the &T borrow) had no production caller -- every typed
read goes through arc -- so the unexercised downcast face dissolves; its
panic contract and the provenance argument move onto arc, and the tests
exercising it re-target arc.

The complement of the payload-evolution suite lands beside it: payload
bytes that do not decode as the receiving type fail the session as a
clean decode error at the receiver's own ingress -- never a panic,
moving nothing into its set. Ingress decodes through the receiving
peer's own deserializer, so no wire input can reach the typed-read
downcast with a foreign payload; the new tests are the committed
demonstration of that claim (an undecodable bootstrap, and an
established cross-typed pair failing at the first out-of-range value).
---
 src/message.rs                 | 23 +++--------
 src/message/tests.rs           |  7 ++--
 src/tree/typed/untyped/iter.rs |  2 +-
 tests/cbor_evolution.rs        | 74 ++++++++++++++++++++++++++++++++++
 4 files changed, 84 insertions(+), 22 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index 423cbccf9..dec9a7e07 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -18,8 +18,8 @@ use serde::de::DeserializeOwned;
 /// they compile once, and only the thin typed facades at the crate's API
 /// boundary name `T`. Construction goes through the typed constructors
 /// ([`new`](Self::new), [`from_slice`](Self::from_slice), ...); reads at
-/// the typed boundary go through the checked downcasts
-/// ([`message`](Self::message), [`arc`](Self::arc)).
+/// the typed boundary go through the checked downcast
+/// ([`arc`](Self::arc)).
 ///
 /// The cache avoids repeated roundtrips through serialization: a `Message`
 /// always carries the exact CBOR bytes its payload was encoded to or
@@ -46,8 +46,8 @@ use serde::de::DeserializeOwned;
 /// example `std::path::PathBuf`, which errors on non-UTF-8 paths) violate
 /// that obligation and must not be used as message types.
 ///
-/// The typed reads panic on a payload type mismatch; see
-/// [`message`](Self::message).
+/// The typed read panics on a payload type mismatch; see
+/// [`arc`](Self::arc).
 #[derive(Clone)]
 pub struct Message {
     message: Arc<dyn Any + Send + Sync>,
@@ -221,7 +221,8 @@ impl Message {
         Self::from_wire(Bytes::from(bytes), deserializer)
     }
 
-    /// Borrows the payload as its concrete type.
+    /// Clones out an owned handle to the payload: a reference bump on the
+    /// same shared allocation.
     ///
     /// # Panics
     ///
@@ -230,18 +231,6 @@ impl Message {
     /// constructed with that facade's payload type — local sends through
     /// the same `Peer`'s type, wire ingress through its typed decode —
     /// so no gossip input can place a differently-typed payload here.
-    pub fn message<T: 'static>(&self) -> &T {
-        self.message
-            .downcast_ref::<T>()
-            .expect("a message's payload type matches its tree's")
-    }
-
-    /// Clones out an owned handle to the payload: a reference bump on the
-    /// same shared allocation.
-    ///
-    /// # Panics
-    ///
-    /// If the payload is not a `T` (see [`message`](Self::message)).
     pub fn arc<T: Send + Sync + 'static>(&self) -> Arc<T> {
         self.message
             .clone()
diff --git a/src/message/tests.rs b/src/message/tests.rs
index b6ca22eb3..c857eb242 100644
--- a/src/message/tests.rs
+++ b/src/message/tests.rs
@@ -41,13 +41,12 @@ fn cbor_vec<T: Serialize>(value: &T) -> Vec<u8> {
 
 proptest! {
     /// After construction via `new`, the cached serialized bytes are exactly
-    /// the value's CBOR encoding, and the typed reads recover the value.
+    /// the value's CBOR encoding, and the typed read recovers the value.
     #[test]
     fn new_caches_cbor_serialization(p in payload()) {
         let m = Message::new(p.clone());
         let direct = cbor_vec(&p);
         prop_assert_eq!(m.bytes(), direct.as_slice());
-        prop_assert_eq!(m.message::<Payload>(), &p);
         prop_assert_eq!(&*m.arc::<Payload>(), &p);
     }
 
@@ -57,7 +56,7 @@ proptest! {
     fn from_slice_roundtrips(p in payload()) {
         let bytes = cbor_vec(&p);
         let m = Message::from_slice::<Payload>(&bytes).unwrap();
-        prop_assert_eq!(m.message::<Payload>(), &p);
+        prop_assert_eq!(&*m.arc::<Payload>(), &p);
         prop_assert_eq!(m.bytes(), bytes.as_slice());
     }
 
@@ -153,5 +152,5 @@ proptest! {
 #[should_panic(expected = "payload type matches")]
 fn mismatched_downcast_panics() {
     let m = Message::new(0u64);
-    let _ = m.message::<String>();
+    let _ = m.arc::<String>();
 }
diff --git a/src/tree/typed/untyped/iter.rs b/src/tree/typed/untyped/iter.rs
index ddc927333..446981ca2 100644
--- a/src/tree/typed/untyped/iter.rs
+++ b/src/tree/typed/untyped/iter.rs
@@ -334,7 +334,7 @@ impl Leaf {
     ///
     /// # Panics
     ///
-    /// If the payload is not a `T` (see [`Message::message`]).
+    /// If the payload is not a `T` (see [`Message::arc`]).
     pub fn value<T: Send + Sync + 'static>(&self) -> std::sync::Arc<T> {
         self.0
             .as_leaf()
diff --git a/tests/cbor_evolution.rs b/tests/cbor_evolution.rs
index 82cbadf42..ac00f1041 100644
--- a/tests/cbor_evolution.rs
+++ b/tests/cbor_evolution.rs
@@ -12,6 +12,14 @@
 //! The evolution rules the crate documents ride the same mechanism and are
 //! pinned beside it: unknown fields are skipped, and missing fields error
 //! unless the field carries `#[serde(default)]`.
+//!
+//! The complement is pinned here too: payload bytes that do *not* decode
+//! as the receiving type fail the session cleanly — a decode error at the
+//! receiver's wire ingress, never a panic, moving nothing into its set.
+//! Ingress decodes every payload through the receiving peer's own
+//! deserializer, so no wire input can reach the typed-read downcast with
+//! a foreign payload; these tests are the committed demonstration of that
+//! claim.
 
 use serde::{Deserialize, Serialize};
 
@@ -139,6 +147,72 @@ async fn unknown_fields_are_skipped() {
     assert_eq!(narrow, Narrow { id: 42 });
 }
 
+/// A payload that does not decode as the receiving type fails the session
+/// cleanly: bootstrapping a `Peer<u64>` from a `String`-payload donor
+/// returns an error — never a panic, and never a misconstructed peer.
+#[tokio::test]
+async fn undecodable_payload_fails_bootstrap_cleanly() {
+    let sender = Peer::<String>::seed().into_rumors();
+    sender.send("not a number".to_string());
+
+    let (mut near, mut far) = rumors::link::memory();
+    let serve = sender.clone();
+    let server = tokio::spawn(async move { serve.gossip(&mut far).await });
+
+    let joined = Peer::<u64>::bootstrap().join(&mut near).await;
+    assert!(joined.is_err(), "a String payload must not decode as u64");
+
+    // Drop the failed side's link so the donor sees the transport close
+    // (a peer that errored out of a session hangs up); its session then
+    // fails too — but only ever as an error, never a panic.
+    drop(near);
+    let _ = server.await.expect("the serving task must not panic");
+}
+
+/// An established cross-typed pair degrades cleanly at the first
+/// undecodable value: the receiving session fails as an error, never a
+/// panic, moving nothing into the receiver's set.
+///
+/// `u64` payloads that fit `u32` interoperate (the bootstrap here rides
+/// one); the first value that does not fit is the one that must fail.
+#[tokio::test]
+async fn out_of_range_payload_fails_gossip_cleanly() {
+    let sender = Peer::<u64>::seed().into_rumors();
+    sender.send(7u64);
+
+    let (mut near, mut far) = rumors::link::memory();
+    let serve = sender.clone();
+    let server = tokio::spawn(async move { serve.gossip(&mut far).await });
+    let receiver = Peer::<u32>::bootstrap()
+        .join(&mut near)
+        .await
+        .expect("in-range values decode across the pair")
+        .expect("the sender is established")
+        .into_rumors();
+    server
+        .await
+        .expect("the serving task must not panic")
+        .expect("the in-range session succeeds");
+
+    // A value only `u64` can hold: the next session must fail at the
+    // receiver's ingress. The sender's half fails too (its counterparty
+    // aborted), but only ever as an error.
+    sender.send(u64::MAX);
+    let (mut near, mut far) = rumors::link::memory();
+    let serve = sender.clone();
+    let server = tokio::spawn(async move { serve.gossip(&mut far).await });
+    let gossiped = receiver.gossip(&mut near).await;
+    assert!(gossiped.is_err(), "u64::MAX must not decode as u32");
+    // Hang up the failed side so the sender's half sees the transport
+    // close rather than blocking on an unread stream.
+    drop(near);
+    let _ = server.await.expect("the serving task must not panic");
+
+    let snapshot = receiver.snapshot();
+    let values: Vec<u32> = snapshot.iter().map(|(_, m)| *m).collect();
+    assert_eq!(values, vec![7u32], "a failed session moves nothing");
+}
+
 /// A missing field errors without `#[serde(default)]` and fills with it:
 /// the documented boundary between tolerated and rejected evolution.
 #[test]

From 5a61b90f10d0574677ec99677ac5bf75d10b6aed Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Thu, 20 Aug 2026 02:32:05 -0400
Subject: [PATCH 17/18] item-erasure: record the wall-clock gate measurement

---
 design/item-erasure.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/design/item-erasure.md b/design/item-erasure.md
index 97838258d..d44f60cee 100644
--- a/design/item-erasure.md
+++ b/design/item-erasure.md
@@ -250,3 +250,13 @@ security-relevant: payload validation stays exactly where it is
    on the same machine under the same background load; a shared-host
    run, so a coarse regression check rather than a precise
    measurement, and it shows no movement to explain).
+   *Wall-clock corroboration*, measured across the whole branch (main
+   vs fully erased, back-to-back on one machine, kache replaced by a
+   pass-through `RUSTC_WRAPPER` in every phase so the numbers are pure
+   rustc): the warm-except-`rumors` gate — dependencies built, the
+   `rumors` package `cargo clean -p`'d, the developer's
+   edit-and-gate cost — runs 249 s on main and 140 s fully erased
+   (−44%); the from-scratch build-and-gate runs 370 s vs 239 s
+   (−35%). Since a fully warm gate runs ~130 s (the tests and checks
+   themselves), the `rumors` codegen share of the inner loop fell
+   from ~120 s to ~10 s.

From 58a2b2db50bdb5316122a3d38649ae881f6c66b2 Mon Sep 17 00:00:00 2001
From: finch <finch@oxidecomputer.com>
Date: Thu, 20 Aug 2026 02:39:27 -0400
Subject: [PATCH 18/18] item-erasure: retire the design doc into its agent-note
 record

---
 .../2026-08-19-height-erasure/README.md       | 11 +++++-----
 .../2026-08-20-item-erasure/README.md         | 22 +++++++++++++++++++
 .../2026-08-20-item-erasure}/item-erasure.md  | 14 +++++++-----
 3 files changed, 37 insertions(+), 10 deletions(-)
 create mode 100644 .agent-notes/2026-08-20-item-erasure/README.md
 rename {design => .agent-notes/2026-08-20-item-erasure}/item-erasure.md (95%)

diff --git a/.agent-notes/2026-08-19-height-erasure/README.md b/.agent-notes/2026-08-19-height-erasure/README.md
index 8438b1118..262c16b44 100644
--- a/.agent-notes/2026-08-19-height-erasure/README.md
+++ b/.agent-notes/2026-08-19-height-erasure/README.md
@@ -124,9 +124,10 @@ mispairing: wire prefixes decode through height-typed readers.
   The durable fix named then was this height erasure, which shrank every
   tower from the inside.
 
-## What remains: the T axis
+## What followed: the T axis
 
-Height erasure deliberately kept the payload axis. The follow-on design
-(`design/item-erasure.md`) sketches erasing `T` at the leaf conversion
-boundary so the subsystem compiles once into the rlib; height erasure
-shrank what that phase must move.
+Height erasure deliberately kept the payload axis. The follow-on work
+erased `T` at the leaf conversion boundary so the subsystem compiles
+once into the rlib — its record is
+[`2026-08-20-item-erasure`](../2026-08-20-item-erasure/README.md) —
+and height erasure shrank what that phase had to move.
diff --git a/.agent-notes/2026-08-20-item-erasure/README.md b/.agent-notes/2026-08-20-item-erasure/README.md
new file mode 100644
index 000000000..944ba2a1c
--- /dev/null
+++ b/.agent-notes/2026-08-20-item-erasure/README.md
@@ -0,0 +1,22 @@
+# Item-type erasure: `T` leaves the tree and session (part II)
+
+The payload type erased behind `Arc<dyn Any>`: the tree and both mirror
+protocols compile once into the rlib, with thin typed facades
+downcasting at the crate's API boundary. Headline numbers: a minimal
+one-`gossip`-call consumer pays 34,699 IR lines instead of 1,095,377
+(height-erased) or 3,401,418 (pre-erasure); the warm-except-`rumors`
+gate falls 249 s → 140 s; the runtime pin does not move. The sealing
+lesson is recorded inside: extracting non-generic functions alone moves
+nothing, because an `async fn` body codegens into whichever crate polls
+it — the seal is returning the future boxed (the `dyn` coercion pins
+the tower in the defining crate) plus `#[inline(never)]` against
+cross-crate MIR inlining.
+
+- [`item-erasure.md`](item-erasure.md) — the problem, the design
+  options, the owner rulings, the staged implementation with per-stage
+  measurements, and the acceptance numbers.
+
+---
+
+Retired from `design/item-erasure.md` with part II complete; the body is
+the design document as it finished, already record-shaped.
diff --git a/design/item-erasure.md b/.agent-notes/2026-08-20-item-erasure/item-erasure.md
similarity index 95%
rename from design/item-erasure.md
rename to .agent-notes/2026-08-20-item-erasure/item-erasure.md
index d44f60cee..866a94a9d 100644
--- a/design/item-erasure.md
+++ b/.agent-notes/2026-08-20-item-erasure/item-erasure.md
@@ -1,9 +1,13 @@
-# Item-type erasure at the leaf boundary (part II sketch)
+# Item-type erasure at the leaf boundary: the record
 
-Status: accepted (option B, with the rulings below); implemented on the
-`height-erasure` branch, all four stages measured, awaiting the owner's
-merge ruling. Numbers marked *measured* come from `cargo llvm-lines
---test pairwise` (debug, default features) on the height-erased tree.
+Status: implemented (option B, with the rulings below), the four staged
+commits gate-clean on the `height-erasure` branch; this note is the
+decision and measurement record. The mechanism's documentation of record
+is the rustdoc — start at `Message`'s type docs and `peer::gossip`'s
+`Reconciliation`. Part I of the erasure arc has its own record in
+[`2026-08-19-height-erasure`](../2026-08-19-height-erasure/README.md).
+Numbers marked *measured* come from `cargo llvm-lines --test pairwise`
+(debug, default features) on the height-erased tree.
 
 ## The problem, precisely