feat(server): add Recorder — the runtime Handler used by vite_task

Recorder is a generic `Handler` impl parameterized by an env-lookup
closure. It records:
- ignored inputs / outputs (FxHashSet<Arc<AbsolutePath>>)
- cache_disabled flag
- env_records: name -> (tracked, resolved value), with `tracked`
  monotonically OR-ed across repeated get_env calls (once true, stays true)

The runtime caller (vite_task in step 5) constructs `Recorder::new(|name| ...)`
with a lookup closure over its own env source; after the driver resolves,
`recorder.into_reports()` yields the `Reports` for the cache-update phase.

Tests swap the ad-hoc `RecordingHandler` for `Recorder` — exercising
the same code path runtime code will use.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: wan9chi

crates/vite_task_server/Cargo.toml

@@ -10,22 +10,21 @@ rust-version.workspace = true
 futures = { workspace = true }
 interprocess = { workspace = true, features = ["tokio"] }
 native_str = { workspace = true }
+rustc-hash = { workspace = true }
 tempfile = { workspace = true }
 tokio = { workspace = true, features = ["io-util", "net", "rt", "macros"] }
 tokio-util = { workspace = true }
 tracing = { workspace = true }
 vite_path = { workspace = true }
+vite_str = { workspace = true }
 vite_task_ipc_shared = { workspace = true }
 wincode = { workspace = true, features = ["derive"] }
 
 [target.'cfg(windows)'.dependencies]
 uuid = { workspace = true, features = ["v4"] }
-vite_str = { workspace = true }
 
 [dev-dependencies]
-rustc-hash = { workspace = true }
 tokio = { workspace = true, features = ["io-util", "net", "rt", "macros", "time"] }
-vite_str = { workspace = true }
 vite_task_client = { workspace = true }
 
 [lints]

crates/vite_task_server/src/lib.rs

@@ -1,4 +1,5 @@
 use std::{
+    cell::{Cell, RefCell},
     ffi::{OsStr, OsString},
     io,
     sync::Arc,
@@ -10,9 +11,11 @@ use interprocess::local_socket::{
     tokio::{Listener, Stream, prelude::*},
 };
 use native_str::NativeStr;
+use rustc_hash::{FxHashMap, FxHashSet};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio_util::sync::CancellationToken;
 use vite_path::AbsolutePath;
+use vite_str::Str;
 use vite_task_ipc_shared::{IPC_ENV_NAME, Request, Response, ResponseBody};
 
 pub trait Handler {
@@ -22,6 +25,92 @@ pub trait Handler {
     fn get_env(&self, name: &str, tracked: bool) -> Option<Arc<OsStr>>;
 }
 
+/// A [`Handler`] that records every report and resolves `get_env` via a
+/// user-provided lookup closure.
+///
+/// Call [`Recorder::into_reports`] after the driver future completes to
+/// recover the collected [`Reports`].
+pub struct Recorder<F> {
+    ignored_inputs: RefCell<FxHashSet<Arc<AbsolutePath>>>,
+    ignored_outputs: RefCell<FxHashSet<Arc<AbsolutePath>>>,
+    cache_disabled: Cell<bool>,
+    env_records: RefCell<FxHashMap<Str, EnvRecord>>,
+    env_lookup: F,
+}
+
+/// A record of an env value requested via `get_env`.
+///
+/// `tracked` is the monotonic OR of every `tracked` flag sent for this name
+/// — once `true`, it stays `true`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct EnvRecord {
+    pub tracked: bool,
+    pub value: Option<Arc<OsStr>>,
+}
+
+/// The data collected by a [`Recorder`] over the server's lifetime.
+#[derive(Debug, Default)]
+pub struct Reports {
+    pub ignored_inputs: FxHashSet<Arc<AbsolutePath>>,
+    pub ignored_outputs: FxHashSet<Arc<AbsolutePath>>,
+    pub cache_disabled: bool,
+    pub env_records: FxHashMap<Str, EnvRecord>,
+}
+
+impl<F> Recorder<F>
+where
+    F: Fn(&str) -> Option<Arc<OsStr>>,
+{
+    pub fn new(env_lookup: F) -> Self {
+        Self {
+            ignored_inputs: RefCell::default(),
+            ignored_outputs: RefCell::default(),
+            cache_disabled: Cell::new(false),
+            env_records: RefCell::default(),
+            env_lookup,
+        }
+    }
+
+    #[must_use]
+    pub fn into_reports(self) -> Reports {
+        Reports {
+            ignored_inputs: self.ignored_inputs.into_inner(),
+            ignored_outputs: self.ignored_outputs.into_inner(),
+            cache_disabled: self.cache_disabled.get(),
+            env_records: self.env_records.into_inner(),
+        }
+    }
+}
+
+impl<F> Handler for Recorder<F>
+where
+    F: Fn(&str) -> Option<Arc<OsStr>>,
+{
+    fn ignore_input(&self, path: &Arc<AbsolutePath>) {
+        self.ignored_inputs.borrow_mut().insert(Arc::clone(path));
+    }
+
+    fn ignore_output(&self, path: &Arc<AbsolutePath>) {
+        self.ignored_outputs.borrow_mut().insert(Arc::clone(path));
+    }
+
+    fn disable_cache(&self) {
+        self.cache_disabled.set(true);
+    }
+
+    fn get_env(&self, name: &str, tracked: bool) -> Option<Arc<OsStr>> {
+        if let Some(existing) = self.env_records.borrow_mut().get_mut(name) {
+            existing.tracked |= tracked;
+            return existing.value.clone();
+        }
+        let value = (self.env_lookup)(name);
+        self.env_records
+            .borrow_mut()
+            .insert(name.into(), EnvRecord { tracked, value: value.clone() });
+        value
+    }
+}
+
 /// Handle to a running IPC server.
 ///
 /// `driver` must be polled to accept clients and handle messages. It resolves

crates/vite_task_server/tests/integration.rs

@@ -1,56 +1,30 @@
 use std::{
-    cell::RefCell,
     ffi::{OsStr, OsString},
     sync::Arc,
     thread,
 };
 
 use rustc_hash::FxHashMap;
 use tokio::runtime::Builder;
-use vite_path::{AbsolutePath, AbsolutePathBuf};
-use vite_str::Str;
+use vite_path::AbsolutePathBuf;
 use vite_task_client::Client;
-use vite_task_server::{Handler, ServerHandle, serve};
-
-#[derive(Default)]
-struct RecordingHandler {
-    ignore_inputs: RefCell<Vec<Arc<AbsolutePath>>>,
-    ignore_outputs: RefCell<Vec<Arc<AbsolutePath>>>,
-    disable_cache_count: RefCell<u32>,
-    env_calls: RefCell<Vec<(Str, bool)>>,
-    env_map: FxHashMap<&'static str, &'static str>,
-}
-
-impl Handler for RecordingHandler {
-    fn ignore_input(&self, path: &Arc<AbsolutePath>) {
-        self.ignore_inputs.borrow_mut().push(Arc::clone(path));
-    }
-
-    fn ignore_output(&self, path: &Arc<AbsolutePath>) {
-        self.ignore_outputs.borrow_mut().push(Arc::clone(path));
-    }
-
-    fn disable_cache(&self) {
-        *self.disable_cache_count.borrow_mut() += 1;
-    }
-
-    fn get_env(&self, name: &str, tracked: bool) -> Option<Arc<OsStr>> {
-        self.env_calls.borrow_mut().push((name.into(), tracked));
-        self.env_map.get(name).map(|value| Arc::<OsStr>::from(OsStr::new(value)))
-    }
-}
+use vite_task_server::{Recorder, Reports, ServerHandle, serve};
 
 fn abs(path: &str) -> AbsolutePathBuf {
     AbsolutePathBuf::new(path.into()).expect("absolute path literal")
 }
 
-fn run_with_server<F>(handler: RecordingHandler, client_work: F) -> RecordingHandler
+fn run_with_server<F>(env_map: FxHashMap<&'static str, &'static str>, client_work: F) -> Reports
 where
     F: FnOnce(OsString) + Send + 'static,
 {
+    let recorder = Recorder::new(move |name: &str| {
+        env_map.get(name).map(|value| Arc::<OsStr>::from(OsStr::new(value)))
+    });
+
     let rt = Builder::new_current_thread().enable_all().build().unwrap();
     rt.block_on(async move {
-        let (envs, ServerHandle { driver, stop_accepting }) = serve(handler).expect("bind server");
+        let (envs, ServerHandle { driver, stop_accepting }) = serve(recorder).expect("bind server");
         let name = envs.into_iter().next().expect("serve should yield an IPC env").1;
 
         let client = async move {
@@ -61,55 +35,73 @@ where
         };
 
         let (recorder, ()) = tokio::join!(driver, client);
-        recorder
+        recorder.into_reports()
     })
 }
 
 #[test]
 fn single_client_fire_and_forget() {
-    let h = run_with_server(RecordingHandler::default(), |name| {
+    let reports = run_with_server(FxHashMap::default(), |name| {
         let mut client = Client::from_name(&name).expect("connect");
         client.ignore_input(abs("/tmp/in.txt").as_absolute_path()).unwrap();
         client.ignore_output(abs("/tmp/out.txt").as_absolute_path()).unwrap();
         client.disable_cache().unwrap();
     });
 
-    let inputs = h.ignore_inputs.into_inner();
-    let outputs = h.ignore_outputs.into_inner();
-    assert_eq!(inputs.len(), 1);
-    assert_eq!(inputs[0].as_path().as_os_str(), OsStr::new("/tmp/in.txt"));
-    assert_eq!(outputs.len(), 1);
-    assert_eq!(outputs[0].as_path().as_os_str(), OsStr::new("/tmp/out.txt"));
-    assert_eq!(h.disable_cache_count.into_inner(), 1);
+    let inputs: Vec<_> = reports.ignored_inputs.iter().map(|p| p.as_path().as_os_str()).collect();
+    let outputs: Vec<_> = reports.ignored_outputs.iter().map(|p| p.as_path().as_os_str()).collect();
+    assert_eq!(inputs, vec![OsStr::new("/tmp/in.txt")]);
+    assert_eq!(outputs, vec![OsStr::new("/tmp/out.txt")]);
+    assert!(reports.cache_disabled);
 }
 
 #[test]
 fn get_env_found_and_not_found() {
-    let mut handler = RecordingHandler::default();
-    handler.env_map.insert("NODE_ENV", "production");
+    let mut env_map = FxHashMap::default();
+    env_map.insert("NODE_ENV", "production");
 
-    let h = run_with_server(handler, |name| {
+    let reports = run_with_server(env_map, |name| {
         let mut client = Client::from_name(&name).expect("connect");
         let present = client.get_env("NODE_ENV", true).unwrap();
         assert_eq!(present.as_deref(), Some(OsStr::new("production")));
         let missing = client.get_env("MISSING", false).unwrap();
         assert!(missing.is_none());
     });
 
-    let calls = h.env_calls.into_inner();
-    assert_eq!(calls.len(), 2);
-    assert_eq!(calls[0].0.as_str(), "NODE_ENV");
-    assert!(calls[0].1);
-    assert_eq!(calls[1].0.as_str(), "MISSING");
-    assert!(!calls[1].1);
+    let node = reports.env_records.get("NODE_ENV").expect("NODE_ENV recorded");
+    assert!(node.tracked);
+    assert_eq!(node.value.as_deref(), Some(OsStr::new("production")));
+
+    let missing = reports.env_records.get("MISSING").expect("MISSING recorded");
+    assert!(!missing.tracked);
+    assert!(missing.value.is_none());
+}
+
+#[test]
+fn get_env_tracked_upgrade_is_monotonic() {
+    let mut env_map = FxHashMap::default();
+    env_map.insert("NODE_ENV", "production");
+
+    let reports = run_with_server(env_map, |name| {
+        let mut client = Client::from_name(&name).expect("connect");
+        let a = client.get_env("NODE_ENV", false).unwrap();
+        let b = client.get_env("NODE_ENV", true).unwrap();
+        let c = client.get_env("NODE_ENV", false).unwrap();
+        for v in [a, b, c] {
+            assert_eq!(v.as_deref(), Some(OsStr::new("production")));
+        }
+    });
+
+    let node = reports.env_records.get("NODE_ENV").expect("recorded");
+    assert!(node.tracked, "tracked must remain true once set");
 }
 
 #[test]
 fn concurrent_clients() {
-    let mut handler = RecordingHandler::default();
-    handler.env_map.insert("SHARED", "value");
+    let mut env_map = FxHashMap::default();
+    env_map.insert("SHARED", "value");
 
-    let h = run_with_server(handler, |name| {
+    let reports = run_with_server(env_map, |name| {
         let threads: Vec<_> = (0..4)
             .map(|i| {
                 let name = name.clone();
@@ -127,6 +119,8 @@ fn concurrent_clients() {
         }
     });
 
-    assert_eq!(h.ignore_inputs.into_inner().len(), 4);
-    assert_eq!(h.env_calls.into_inner().len(), 4);
+    assert_eq!(reports.ignored_inputs.len(), 4);
+    let shared = reports.env_records.get("SHARED").expect("recorded");
+    assert!(shared.tracked);
+    assert_eq!(shared.value.as_deref(), Some(OsStr::new("value")));
 }