Struct EffectManager 

pub struct EffectManager { /* private fields */ }

Implementations

impl EffectManager

pub fn new( registry: Arc<EffectRegistry>, rt_ctx: RuntimeContext, test_span: SpanId, ) -> Self

pub fn instantiate<'a>( &'a self, starts: &'a [IrEffectStart], caller_vars: &'a VarScope, caller_env: &'a Arc<LayeredEnv>, parent_span: SpanId, caller_captures: &'a HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<Vec<(ExportedEffect, EffectGuard)>, ExecError>> + Send + 'a>>

Acquire all starts, honoring the wait-set edges enrichment derived from each start’s overlay (IrEffectStart::deps()). caller_vars contains the caller’s accumulated variable scope, allowing overlay expressions to reference the caller’s let bindings. caller_env is the layered environment visible to the caller. Returns one (ExportedEffect, EffectGuard) per start declaration, in input order.

Scheduling: each start runs as its own future. A start whose deps() is non-empty first awaits those sibling starts’ completion signals (published over per-start watch channels); the ready deps’ EXPOSED VARS are injected into the start’s scope under Alias.var keys BEFORE its overlay is evaluated, so the overlay’s QualifiedVar refs resolve. Independent starts (empty deps()) still bootstrap concurrently, exactly as before. Enrichment proved the dep graph acyclic, so the wait-set awaits cannot deadlock.

The slot lock in acquire (see registry::EffectSlot) serialises bootstrap-vs-reuse for the same dedup key, so parallel acquires of overlapping keys are safe - one bootstraps, the others wait on the slot’s Notify. Independent effects (different keys) bootstrap truly in parallel. Overlay evaluation runs inside each start’s future (concurrently): a start’s scope is fully materialized (caller scope + resolved dep vars) BEFORE its pure overlay eval runs, and pure eval has no cross-start side effects, so concurrent evaluation cannot change any overlay’s value or its derived dedup key.

Rollback stays all-or-nothing, generalized along dep edges: a failed dep fails its dependents (recorded as DepFailed), and on ANY failure every successful acquire is released concurrently before the first root error propagates.

pub async fn instantiate_top_level( &self, starts: &[IrEffectStart], caller_vars: &VarScope, caller_env: &Arc<LayeredEnv>, caller_captures: &HashMap<String, String>, ) -> Result<Vec<ExportedEffect>, ExecError>

Public top-level entry point used by the test runner. Acquires every start in starts, stashes the resulting guards on the EffectManager so cleanup_all can drain them, and returns the shells/vars exports for the caller’s shell map.

pub async fn cleanup_all(&self) -> Vec<Warning>

Drain the test’s top-level guards and release each concurrently. The slot mutex + refcount guarantee that for each dedup’d slot, exactly one releaser sees refcount == 0 and runs the cleanup body; other releasers return None and short-circuit.

Every EffectCleanup span opened here is parented under self.test_span. Cleanups are operationally test-level activity (scheduled at test teardown), and the EffectSetup span has long since closed.