StreamMux

Return the transformer that contributed key to the projection.

Wire the sync pull callback onto every projection in this mux.

Records the pump on the mux so child mini-muxes built by _make_child can inherit it. Propagates to:

• the main event log (self._events)
• every projection StreamChannel in extensions
• any registered transformer that exposes _bind_pump (e.g. MessagesTransformer so ChatModelStream instances drive the shared pump from their cursors)

Async counterpart to bind_pump.

Route an event through all transformers, then append to the main log.

Each transformer's process() is called in registration order. If any transformer returns False, the event is suppressed from the main log, but transformers that already saw it keep their side effects.

On the root mux, seq is assigned right before an event enters the main log, not before the transformer pipeline runs. This ensures that events auto-forwarded from StreamChannels during process() get earlier seq numbers than the original event, preserving monotonic ordering in the root log. Child muxes do not assign seq, so subgraph forwarding can share event objects without mutating their envelopes.

Finalize all transformers, close all projections and the main log.

StreamChannels discovered in transformer projections are auto-closed after finalize() runs — transformers don't need to close them manually. If any transformer's finalize() raises, the remaining transformers, projections, and the main log are still closed; the first error is re-raised after cleanup completes.

Fail all transformers, projections, and the main log.

StreamChannels discovered in transformer projections are auto-failed — transformers don't need to fail them manually. If any transformer's fail() raises, the remaining transformers, projections, and the main log are still failed.

Dispatch an event on the async lane.

Awaits each transformer's aprocess in registration order before appending to the main log. A slow aprocess serializes the pipeline by design — that's the guarantee that lets a later transformer (or a synchronous consumer) see the result of the async work. For decoupled work, use schedule() from inside process / aprocess instead.

The main log append is a non-blocking push — matching v1's put_nowait shape. The root mux assigns seq; child muxes do not, so forwarded subgraph events can be shared without copying. Memory is bounded by caller pace via the caller-driven pump; see StreamChannel for the full tradeoff story.

Finalize on the async lane.

Awaits every task started via StreamTransformer.schedule() across all transformers, then calls afinalize() on each, then auto-closes channels and the main event log.

If any scheduled task raised under on_error="raise", or any transformer's afinalize raises, the exception propagates. The caller (the pump) handles it by routing into afail.

Fail on the async lane.

Cancels every scheduled task across all transformers, awaits them to completion, then runs each transformer's afail hook and auto-fails channels and the main event log.