Struct TypedChain 

Typed, effect-only serial Graph with 1..8 sealed concrete stages.

Record-Vec payload is checked against 4MiB before/after reservation; existing Graph allocations and arbitrary processor-owned storage have separate limits. The internal graph drops before the stable cells, including during unwind. Readonly and stopped-exclusive getters derive from the same cell provenance as callbacks. No references are retained across callback/getter boundaries. Bypass freezes a child but retains its declared latency/tail: audible bypass is not latency compensated. Generated output events and auxiliary buses are rejected; accepted input events use canonical Graph broadcast.

§Audio sessions: prefer the guard

The inherent start_audio() returns a non-Send guard that stops the owner on drop (reverse stage order) on the starting thread. Prefer it. A forgotten guard (mem::forget, a leak) is misuse, not valid use: it leaves the audio owner live exactly like an unpaired manual start (see below), and the guard that would have stopped it no longer exists.

§Manual Processor hooks are a caller obligation

Processor::start_audio on this chain is the canonical manual hook; it returns no guard. The caller must pair it with Processor::stop_audio on the thread that started it before transfer to another thread, deactivate, into_stages or drop. Unlike the guard, nothing stops a manual owner automatically: the facade adds no owner-thread cleanup, no thread check at process, and a manually started chain is Send. While a manual owner (or a forgotten guard) is live:

• prepare and stage_mut_stopped refuse with AudioSessionActive;
• deactivate (inherent and Processor), into_stages and Drop do not refuse: they panic through the canonical Graph assertion;
• Processor::stop_audio called on another thread panics and leaves the owner live, so it can still be stopped on the owning thread afterwards;
• process, reset, getters and bypass flags keep working.

Unwind caveats, with no safeguard claimed. A caught deactivate panic happens before any state change: the chain stays prepared with the owner live, and the owner thread can still stop_audio. A panic from into_stages or Drop destroys the facade while unwinding: the Graph is dropped, then each stage is dropped exactly once by field drop glue, without stop_audio or deactivate, and no owners are returned. If that panic happens while the thread is already unwinding, the second panic aborts the process; the facade does not prevent that.

§Compile-time exclusions

Unsupported static index:

use ravet_graph::TypedChain;
use ravet_gain::GainProcessor;
let chain = TypedChain::<f32,_>::new((GainProcessor::new(0.).unwrap(),),1,64,0).ok().unwrap();
chain.stage::<1>(); // tuple1 has index0 only

Positive companion (valid index):

use ravet_graph::TypedChain;
use ravet_gain::GainProcessor;
let chain = TypedChain::<f32,_>::new((GainProcessor::new(0.).unwrap(),),1,64,0).ok().unwrap();
let _ = chain.stage::<0>();

A readonly stage borrow excludes set_bypassed:

use ravet_graph::{StageAt,TypedChain};
use ravet_foundation::Processor;
fn overlap<T: StageAt<f32,0>>(chain:&mut TypedChain<f32,T>) {
    let stage=chain.stage::<0>();
    chain.set_bypassed::<0>(true);
    let _=stage.latency_samples();
}

A readonly stage borrow excludes process:

use ravet_graph::{StageAt,TypedChain};
use ravet_foundation::{ProcessBlock,Processor};
fn overlap<T: StageAt<f32,0>>(chain:&mut TypedChain<f32,T>, block:&mut ProcessBlock<'_,'_,'_,f32>) {
    let stage=chain.stage::<0>();
    let _=chain.process(block);
    let _=stage.latency_samples();
}

Positive companion: finish the readonly borrow before mutating or rendering.

use ravet_graph::{StageAt,TypedChain};
use ravet_foundation::{ProcessBlock,Processor};
fn ordered<T: StageAt<f32,0>>(chain:&mut TypedChain<f32,T>, block:&mut ProcessBlock<'_,'_,'_,f32>) {
    let latency=chain.stage::<0>().latency_samples();
    chain.set_bypassed::<0>(true);
    let _=chain.process(block);
    let _=latency;
}

A live audio session excludes the stopped mutable getter:

use ravet_graph::{StageAt,TypedChain};
use ravet_foundation::Processor;
fn overlap<T: StageAt<f32,0>>(chain:&mut TypedChain<f32,T>) {
    let session=chain.start_audio().ok().unwrap();
    let _=chain.stage_mut_stopped::<0>();
    drop(session);
}

Positive companion: drop the session first.

use ravet_graph::{StageAt,TypedChain};
fn ordered<T: StageAt<f32,0>>(chain:&mut TypedChain<f32,T>) {
    let session=chain.start_audio().ok().unwrap();
    drop(session);
    let _=chain.stage_mut_stopped::<0>();
}

A live &mut P from the stopped getter excludes process:

use ravet_graph::{StageAt,TypedChain};
use ravet_foundation::{ProcessBlock,Processor};
fn overlap<T: StageAt<f32,0>>(chain:&mut TypedChain<f32,T>, block:&mut ProcessBlock<'_,'_,'_,f32>) {
    let stage=chain.stage_mut_stopped::<0>().ok().unwrap();
    let _=chain.process(block);
    let _=stage.latency_samples();
}

… excludes a second stage borrow:

use ravet_graph::{StageAt,TypedChain};
use ravet_foundation::Processor;
fn overlap<T: StageAt<f32,0>>(chain:&mut TypedChain<f32,T>) {
    let stage=chain.stage_mut_stopped::<0>().ok().unwrap();
    let _=chain.stage::<0>();
    let _=stage.latency_samples();
}

… and excludes prepare:

use ravet_graph::{StageAt,TypedChain};
use ravet_foundation::{ProcessConfig,Processor};
fn overlap<T: StageAt<f32,0>>(chain:&mut TypedChain<f32,T>, config:ProcessConfig) {
    let stage=chain.stage_mut_stopped::<0>().ok().unwrap();
    let _=chain.prepare(config);
    let _=stage.latency_samples();
}

Positive companion: use the exclusive stage, then prepare.

use ravet_graph::{StageAt,TypedChain};
use ravet_foundation::{ProcessConfig,Processor};
fn ordered<T: StageAt<f32,0>>(chain:&mut TypedChain<f32,T>, config:ProcessConfig) {
    let stage=chain.stage_mut_stopped::<0>().ok().unwrap();
    let _=stage.latency_samples();
    let _=chain.prepare(config);
}

The chain is Send (for Send stages) but not Sync:

use ravet_graph::TypedChain;
use ravet_gain::GainProcessor;
fn sync<T:Sync>() {}
sync::<TypedChain<f32,(GainProcessor,)>>();

use ravet_graph::TypedChain;
use ravet_gain::GainProcessor;
fn send<T:Send>() {}
send::<TypedChain<f32,(GainProcessor,)>>();