Function with_executor 

pub fn with_executor<R>(ex: &Rc<RefCell<Executor>>, f: impl FnOnce() -> R) -> R

Run f with ex set as the current executor.

Signal callbacks and spawn_global calls inside f will be routed to ex instead of the global thread-local executor. Restores the previous executor afterward.

Signal routing constraints

Auralis uses a single global schedule hook (installed once by the first call to init_flush_scheduler) that decides where signal notifications land by checking the current executor at the time the notification fires, not at the time Signal::set is called.

This design implies two hard requirements for multi-instance users:

1. init_flush_scheduler must be called at least once — without it, Signal::set falls back to synchronous callback execution, which breaks the deferred-notification model and can cause re-entrant borrow panics.
2. The instance executor must still be “current” when the flush runs — if with_executor has already exited, deferred callbacks from signals set inside f will be routed to the global executor (or synchronously if no global hook is installed).

For the typical single-threaded case (Wasm, game loop, CLI), both requirements are satisfied trivially: call init_flush_scheduler once at startup and never use with_executor. For SSR / multi-tenant servers, ensure that with_executor wraps the entire request lifecycle — from signal creation through the final flush.

Example

use auralis_task::Executor;

let ex = Executor::new_instance();
Executor::install_flush_scheduler(&ex, my_scheduler);
auralis_task::with_executor(&ex, || {
    // Signal notifications and task spawns here go to `ex`.
});

Examples found in repository

examples/multi_instance_isolated.rs (lines 53-57)

fn handle_request(request_id: u32) -> String {
    let ex = Executor::new_instance();
    Executor::install_flush_scheduler(&ex, Rc::new(SyncScheduler));

    let scope = TaskScope::with_executor(&ex);
    let data = Signal::new(String::new());

    // "route handler" spawns a reactive effect
    let d = data.clone();
    scope.spawn(async move {
        loop {
            d.changed().await;
            let val = d.read();
            if val == "done" {
                break;
            }
        }
    });

    // "middleware" sets up cleanup
    let cleanup_called = Rc::new(Cell::new(false));
    let cc = Rc::clone(&cleanup_called);
    scope.on_cleanup(move || cc.set(true));

    // "business logic" — would be I/O in real app
    let result = auralis_task::with_executor(&ex, || {
        data.set(format!("request {request_id}: processing"));
        data.set(format!("request {request_id}: done"));
        data.read()
    });

    // Drop scope → cancels effect, runs cleanup.
    drop(scope);

    assert!(cleanup_called.get());
    result
}

fn main() {
    // ---- Pattern 1: sequential requests (same thread, isolated) ----------
    println!("=== 1. Sequential request isolation ===");
    let r1 = handle_request(1);
    let r2 = handle_request(2);
    println!("  {r1}");
    println!("  {r2}");
    assert_eq!(r1, "request 1: done");
    assert_eq!(r2, "request 2: done");

    // ---- Pattern 2: same-signal isolation test (different executors) -----
    println!("\n=== 2. Cross-executor signal isolation ===");
    {
        let ex_a = Executor::new_instance();
        Executor::install_flush_scheduler(&ex_a, Rc::new(SyncScheduler));
        let ex_b = Executor::new_instance();
        Executor::install_flush_scheduler(&ex_b, Rc::new(SyncScheduler));

        let sig_a1 = Signal::new(0i32);
        let sig_b1 = Signal::new(0i32);

        // Scope on executor A sets sig_a and reads sig_b.
        let scope_a = TaskScope::with_executor(&ex_a);
        let a_val = Rc::new(RefCell::new(Vec::new()));
        let av = Rc::clone(&a_val);
        {
            let s = sig_a1.clone();
            scope_a.spawn(async move {
                s.set(42);
                av.borrow_mut().push(s.read());
            });
        }
        drop(scope_a);

        // Scope on executor B sets sig_b and reads sig_a.
        let scope_b = TaskScope::with_executor(&ex_b);
        let b_val = Rc::new(RefCell::new(Vec::new()));
        let bv = Rc::clone(&b_val);
        {
            let s = sig_b1.clone();
            scope_b.spawn(async move {
                s.set(99);
                bv.borrow_mut().push(s.read());
            });
        }
        drop(scope_b);

        // Each executor only sees its own signal changes.
        assert_eq!(*a_val.borrow(), vec![42]);
        assert_eq!(*b_val.borrow(), vec![99]);
        assert_eq!(sig_a1.read(), 42);
        assert_eq!(sig_b1.read(), 99);
    }

    // ---- Pattern 3: the SSR mental model (one request = one executor) ----
    println!("\n=== 3. SSR mental model ===");
    for i in 0..3 {
        let ex = Executor::new_instance();
        Executor::install_flush_scheduler(&ex, Rc::new(SyncScheduler));
        let counter = Signal::new(0i32);

        let scope = TaskScope::with_executor(&ex);
        let c = counter.clone();
        let results = Rc::new(RefCell::new(Vec::new()));
        let res = Rc::clone(&results);

        scope.spawn(async move {
            loop {
                c.changed().await;
                let v = c.read();
                res.borrow_mut().push(v);
                if v >= 3 {
                    break;
                }
            }
        });

        auralis_task::with_executor(&ex, || {
            counter.set(1);
            counter.set(2);
            counter.set(3);
        });

        drop(scope);
        assert_eq!(*results.borrow(), vec![1, 2, 3]);
        println!("  request {i}: signals {:?}", results.borrow());
    }

    println!("\nAll patterns completed — zero cross-request leakage.");
}