Method drain_pending

native/shared/src/renderer/hot_reload.rs:136–169

Drain pending file-change events. Returns the unique set of (handle, descriptor) pairs that need recompilation this frame. `notify` fires multiple events per save; we coalesce within a 120 ms window.

(&self)

    /// `notify` fires multiple events per save; we coalesce within a
    /// 120 ms window.
    pub fn drain_pending(&self) -> Vec<(u32, FileMaterialDesc)> {
        let mut paths: Vec<PathBuf> = Vec::new();
        if let Ok(rx) = self.rx.lock() {
            while let Ok(p) = rx.try_recv() {
                paths.push(p);
            }
        }
        if paths.is_empty() { return Vec::new(); }

        let now = Instant::now();
        let mut last = self.last_event.lock().expect("hot_reload poisoned");
        let mut out: Vec<(u32, FileMaterialDesc)> = Vec::new();
        let mut seen: HashSet<u32> = HashSet::new();
        for raw in paths {
            // Resolve canonically so the keys we matched on register
            // line up with the events. notify on macOS sometimes
            // returns the realpath, sometimes the symlink path.
            let p = std::fs::canonicalize(&raw).unwrap_or(raw);
            if let Some(t) = last.get(&p) {
                if now.duration_since(*t) < DEBOUNCE_WINDOW { continue; }
            }
            last.insert(p.clone(), now);
            if let Some(handles) = self.by_path.get(&p) {
                for h in handles {
                    if seen.insert(*h) {
                        if let Some(d) = self.descriptors.get(h) {
                            out.push((*h, d.clone()));
                        }
                    }
                }
            }
        }
        out
    }

    /// Test-only: push a path through the channel as if `notify` had
    /// fired a Modify event. Lets unit tests exercise the drain +