Method top_loop

compiler/src/modules/vm/builtins/async_ops.rs:320–379

Single scheduler driver: picks a Ready coro and steps it; on no Ready, classifies the wait-state and yields to the host (PendingTimer / PendingFrame / PendingHostCall / PendingEvent) or returns Ok when nothing alive remains. */

(&mut self)

    /* Single scheduler driver: picks a Ready coro and steps it; on no Ready, classifies the wait-state and yields to the host (PendingTimer / PendingFrame / PendingHostCall / PendingEvent) or returns Ok when nothing alive remains. */
    pub(crate) fn top_loop(&mut self) -> Result<(), VmErr> {
        loop {
            // Charge the full scheduler scan so accumulating coroutines stay bounded.
            self.charge_steps(self.scheduler.len().max(1))?;
            self.wake_waiting_outers();
            let mut next_ready: Option<usize> = None;
            let mut min_wake: Option<u64> = None;
            let mut any_frame = false;
            let mut any_event = false;
            let mut any_host_call = false;
            let mut alive = false;
            for (i, h) in self.scheduler.iter().enumerate() {
                match &h.state {
                    CoroState::Ready | CoroState::CancelPending => { next_ready = Some(i); alive = true; break; }
                    CoroState::Sleeping(w) => {
                        alive = true;
                        if min_wake.is_none_or(|m| *w < m) { min_wake = Some(*w); }
                    }
                    CoroState::WaitingForChildren { kind: WaitKind::Timeout { deadline_ns, .. }, .. } => {
                        alive = true;
                        if min_wake.is_none_or(|m| *deadline_ns < m) { min_wake = Some(*deadline_ns); }
                    }
                    CoroState::WaitingFrame => { any_frame = true; alive = true; }
                    CoroState::WaitingEvent => { any_event = true; alive = true; }
                    CoroState::WaitingHostCall(_) => { any_host_call = true; alive = true; }
                    CoroState::WaitingForChildren { .. } => { alive = true; }
                    CoroState::Done(_) | CoroState::Errored(_) | CoroState::Cancelled => {}
                }
            }
            if !alive { return Ok(()); }
            if let Some(i) = next_ready {
                self.scheduler_step(i)?;
                continue;
            }
            // Yield priority: frame tick > sleep/timeout deadline > host call > event.
            if any_frame { return Err(VmErr::HostYield(SchedulerStatus::PendingFrame)); }
            match min_wake {
                Some(w) => {
                    let now = self.now_ns();
                    if w > now {
                        if self.time_hook.is_some() {
                            return Err(VmErr::HostYield(SchedulerStatus::PendingTimer(w)));
                        }
                        self.virtual_clock_ns = w;
                    }
                    let now = self.now_ns();
                    for h in self.scheduler.iter_mut() {
                        if let CoroState::Sleeping(w) = h.state && w <= now {
                            h.state = CoroState::Ready;
                        }
                    }
                }
                None => {
                    if any_host_call { return Err(VmErr::HostYield(SchedulerStatus::PendingHostCall)); }
                    if any_event { return Err(VmErr::HostYield(SchedulerStatus::PendingEvent)); }
                    return Ok(());
                }
            }