refactor(ipc): drop id correlation; use NativeStr/OsStr for env names

- Drop the `id: u32` field from `Request::GetEnv` and the `Response`
  wrapper. Each IPC connection is request-response sequential with a
  single in-flight reply, so correlation adds no value. `Response` +
  `ResponseBody` collapse into a single `GetEnvResponse { env_value }`.
- Switch env-var names in requests from `&str` to `&NativeStr`, and
  `Handler::get_env` / `Client::get_env` to `&OsStr`. Handles non-UTF-8
  env names correctly on both platforms.
- `Client::get_env` returns `Arc<OsStr>` (was `OsString`); `Client::recv`
  is now generic over `T: SchemaRead` so future response types plug in
  without touching the framing layer.
- `Recorder` keys `env_map` / `env_records` by `Arc<OsStr>` (was `Str`).
- Windows socket name: build via `format!` directly (name always exceeds
  `Str` inline capacity, so the extra machinery provided no benefit).
- Drop `vite_str` dep from `vite_task_server`.

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

Author: wan9chi

Cargo.lock

@@ -1,16 +1,17 @@
 use std::{
-    ffi::{OsStr, OsString},
+    ffi::OsStr,
     io::{self, Read, Write},
+    sync::Arc,
 };
 
 use interprocess::local_socket::{Stream, prelude::*};
 use native_str::NativeStr;
 use vite_path::AbsolutePath;
-use vite_task_ipc_shared::{IPC_ENV_NAME, Request, Response, ResponseBody};
+use vite_task_ipc_shared::{GetEnvResponse, IPC_ENV_NAME, Request};
+use wincode::{SchemaRead, config::DefaultConfig};
 
 pub struct Client {
     stream: Stream,
-    next_id: u32,
     scratch: Vec<u8>,
 }
 
@@ -30,7 +31,7 @@ impl Client {
         for (name, value) in envs {
             if name.as_ref() == IPC_ENV_NAME {
                 let stream = Stream::connect(resolve_name(value.as_ref())?)?;
-                return Ok(Some(Self { stream, next_id: 0, scratch: Vec::new() }));
+                return Ok(Some(Self { stream, scratch: Vec::new() }));
             }
         }
         Ok(None)
@@ -43,7 +44,7 @@ impl Client {
     /// Returns an error if the connection cannot be established.
     pub fn from_name(name: &OsStr) -> io::Result<Self> {
         let stream = Stream::connect(resolve_name(name)?)?;
-        Ok(Self { stream, next_id: 0, scratch: Vec::new() })
+        Ok(Self { stream, scratch: Vec::new() })
     }
 
     /// `path` can be a file or a directory; for a directory, all files inside it are ignored.
@@ -79,20 +80,15 @@ impl Client {
     /// # Errors
     ///
     /// Returns an error if the request or response fails, or the response id mismatches.
-    pub fn get_env(&mut self, name: &str, tracked: bool) -> io::Result<Option<OsString>> {
-        let id = self.next_id;
-        self.next_id = self.next_id.wrapping_add(1);
+    pub fn get_env(&mut self, name: &OsStr, tracked: bool) -> io::Result<Option<Arc<OsStr>>> {
+        let name = Box::<NativeStr>::from(name);
 
-        self.send(&Request::GetEnv { id, name, tracked })?;
-        self.recv()?;
+        self.send(&Request::GetEnv { name: &name, tracked })?;
+        let get_env_response = self.recv::<GetEnvResponse>()?;
 
-        let response: Response<'_> = wincode::deserialize_exact(&self.scratch)
-            .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
-        if response.id != id {
-            return Err(io::Error::new(io::ErrorKind::InvalidData, "response id mismatch"));
-        }
-        let ResponseBody::Env(value) = response.body;
-        Ok(value.map(native_str_to_os_string))
+        Ok(get_env_response
+            .env_value
+            .map(|env_value| Arc::<OsStr>::from(env_value.to_cow_os_str().as_ref())))
     }
 
     fn send(&mut self, request: &Request<'_>) -> io::Result<()> {
@@ -106,14 +102,15 @@ impl Client {
         Ok(())
     }
 
-    fn recv(&mut self) -> io::Result<()> {
+    fn recv<'a, T: SchemaRead<'a, DefaultConfig, Dst = T>>(&'a mut self) -> io::Result<T> {
         let mut len_bytes = [0u8; 4];
         self.stream.read_exact(&mut len_bytes)?;
         let len = u32::from_le_bytes(len_bytes) as usize;
         self.scratch.clear();
         self.scratch.resize(len, 0);
         self.stream.read_exact(&mut self.scratch)?;
-        Ok(())
+        wincode::deserialize_exact(&self.scratch)
+            .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))
     }
 }
 
@@ -132,7 +129,3 @@ fn resolve_name(name: &OsStr) -> io::Result<interprocess::local_socket::Name<'_>
 fn path_to_native_str(path: &AbsolutePath) -> Box<NativeStr> {
     Box::<NativeStr>::from(path.as_path().as_os_str())
 }
-
-fn native_str_to_os_string(ns: &NativeStr) -> OsString {
-    ns.to_cow_os_str().into_owned()
-}

crates/vite_task_client/src/lib.rs

@@ -7,17 +7,11 @@ pub const IPC_ENV_NAME: &str = "VITE_TASK_IPC_NAME";
 pub enum Request<'a> {
     IgnoreInput(&'a NativeStr),
     IgnoreOutput(&'a NativeStr),
-    GetEnv { id: u32, name: &'a str, tracked: bool },
+    GetEnv { name: &'a NativeStr, tracked: bool },
     DisableCache,
 }
 
 #[derive(Debug, SchemaWrite, SchemaRead)]
-pub struct Response<'a> {
-    pub id: u32,
-    pub body: ResponseBody<'a>,
-}
-
-#[derive(Debug, SchemaWrite, SchemaRead)]
-pub enum ResponseBody<'a> {
-    Env(Option<&'a NativeStr>),
+pub struct GetEnvResponse<'a> {
+    pub env_value: Option<&'a NativeStr>,
 }

crates/vite_task_ipc_shared/src/lib.rs

@@ -16,7 +16,6 @@ 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"] }
 

crates/vite_task_server/Cargo.toml

@@ -15,14 +15,14 @@ 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};
+use vite_task_ipc_shared::{GetEnvResponse, IPC_ENV_NAME, Request};
+use wincode::{SchemaWrite, config::DefaultConfig};
 
 pub trait Handler {
     fn ignore_input(&mut self, path: &Arc<AbsolutePath>);
     fn ignore_output(&mut self, path: &Arc<AbsolutePath>);
     fn disable_cache(&mut self);
-    fn get_env(&mut self, name: &str, tracked: bool) -> Option<Arc<OsStr>>;
+    fn get_env(&mut self, name: &OsStr, tracked: bool) -> Option<Arc<OsStr>>;
 }
 
 /// A [`Handler`] that records every report and resolves `get_env` against
@@ -34,8 +34,8 @@ pub struct Recorder {
     ignored_inputs: FxHashSet<Arc<AbsolutePath>>,
     ignored_outputs: FxHashSet<Arc<AbsolutePath>>,
     cache_disabled: bool,
-    env_records: FxHashMap<Str, EnvRecord>,
-    env_map: FxHashMap<Str, Arc<OsStr>>,
+    env_records: FxHashMap<Arc<OsStr>, EnvRecord>,
+    env_map: FxHashMap<Arc<OsStr>, Arc<OsStr>>,
 }
 
 /// A record of an env value requested via `get_env`.
@@ -54,12 +54,12 @@ 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>,
+    pub env_records: FxHashMap<Arc<OsStr>, EnvRecord>,
 }
 
 impl Recorder {
     #[must_use]
-    pub fn new(env_map: FxHashMap<Str, Arc<OsStr>>) -> Self {
+    pub fn new(env_map: FxHashMap<Arc<OsStr>, Arc<OsStr>>) -> Self {
         Self {
             ignored_inputs: FxHashSet::default(),
             ignored_outputs: FxHashSet::default(),
@@ -93,7 +93,7 @@ impl Handler for Recorder {
         self.cache_disabled = true;
     }
 
-    fn get_env(&mut self, name: &str, tracked: bool) -> Option<Arc<OsStr>> {
+    fn get_env(&mut self, name: &OsStr, tracked: bool) -> Option<Arc<OsStr>> {
         if let Some(existing) = self.env_records.get_mut(name) {
             existing.tracked |= tracked;
             return existing.value.clone();
@@ -187,10 +187,15 @@ fn bind_listener() -> io::Result<(OsString, Bound)> {
 fn bind_listener() -> io::Result<(OsString, Bound)> {
     use interprocess::local_socket::{GenericNamespaced, ToNsName};
 
-    let name_str = vite_str::format!("vite_task_ipc_{}", uuid::Uuid::new_v4());
-    let name = name_str.as_str().to_ns_name::<GenericNamespaced>()?;
-    let listener = ListenerOptions::new().name(name).create_tokio()?;
-    Ok((OsString::from(name_str.as_str()), listener))
+    #[expect(
+        clippy::disallowed_macros,
+        reason = "socket name always exceeds Str inline capacity; format! is the simplest construction"
+    )]
+    let name = OsString::from(format!("vite_task_ipc_{}", uuid::Uuid::new_v4()));
+
+    let ns_name = name.as_os_str().to_ns_name::<GenericNamespaced>()?;
+    let listener = ListenerOptions::new().name(ns_name).create_tokio()?;
+    Ok((name, listener))
 }
 
 #[cfg(unix)]
@@ -265,11 +270,10 @@ async fn handle_client<H: Handler>(mut stream: Stream, handler: &RefCell<H>) {
                 }
             }
             Request::DisableCache => handler.borrow_mut().disable_cache(),
-            Request::GetEnv { id, name, tracked } => {
-                let value = handler.borrow_mut().get_env(name, tracked);
+            Request::GetEnv { name, tracked } => {
+                let value = handler.borrow_mut().get_env(name.to_cow_os_str().as_ref(), tracked);
                 let boxed: Option<Box<NativeStr>> = value.as_deref().map(Into::into);
-                let body = ResponseBody::Env(boxed.as_deref());
-                let response = Response { id, body };
+                let response = GetEnvResponse { env_value: boxed.as_deref() };
                 if let Err(err) = write_response(&mut stream, &response).await {
                     tracing::warn!(?err, "vite_task_server: write response failed");
                     return;
@@ -303,7 +307,10 @@ async fn read_frame(stream: &mut Stream, buf: &mut Vec<u8>) -> io::Result<()> {
     Ok(())
 }
 
-async fn write_response(stream: &mut Stream, response: &Response<'_>) -> io::Result<()> {
+async fn write_response<T>(stream: &mut Stream, response: &T) -> io::Result<()>
+where
+    T: SchemaWrite<DefaultConfig, Src = T> + ?Sized,
+{
     let bytes = wincode::serialize(response)
         .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
     let len = u32::try_from(bytes.len())

crates/vite_task_server/src/lib.rs

@@ -7,19 +7,21 @@ use std::{
 use rustc_hash::FxHashMap;
 use tokio::runtime::Builder;
 use vite_path::AbsolutePathBuf;
-use vite_str::Str;
 use vite_task_client::Client;
 use vite_task_server::{Recorder, Reports, ServerHandle, serve};
 
 fn abs(path: &str) -> AbsolutePathBuf {
     AbsolutePathBuf::new(path.into()).expect("absolute path literal")
 }
 
-fn env_map(pairs: &[(&str, &str)]) -> FxHashMap<Str, Arc<OsStr>> {
-    pairs.iter().map(|(k, v)| (Str::from(*k), Arc::<OsStr>::from(OsStr::new(v)))).collect()
+fn env_map(pairs: &[(&str, &str)]) -> FxHashMap<Arc<OsStr>, Arc<OsStr>> {
+    pairs
+        .iter()
+        .map(|(k, v)| (Arc::<OsStr>::from(OsStr::new(k)), Arc::<OsStr>::from(OsStr::new(v))))
+        .collect()
 }
 
-fn run_with_server<F>(envs: FxHashMap<Str, Arc<OsStr>>, client_work: F) -> Reports
+fn run_with_server<F>(envs: FxHashMap<Arc<OsStr>, Arc<OsStr>>, client_work: F) -> Reports
 where
     F: FnOnce(OsString) + Send + 'static,
 {
@@ -62,17 +64,17 @@ fn single_client_fire_and_forget() {
 fn get_env_found_and_not_found() {
     let reports = run_with_server(env_map(&[("NODE_ENV", "production")]), |name| {
         let mut client = Client::from_name(&name).expect("connect");
-        let present = client.get_env("NODE_ENV", true).unwrap();
+        let present = client.get_env(OsStr::new("NODE_ENV"), true).unwrap();
         assert_eq!(present.as_deref(), Some(OsStr::new("production")));
-        let missing = client.get_env("MISSING", false).unwrap();
+        let missing = client.get_env(OsStr::new("MISSING"), false).unwrap();
         assert!(missing.is_none());
     });
 
-    let node = reports.env_records.get("NODE_ENV").expect("NODE_ENV recorded");
+    let node = reports.env_records.get(OsStr::new("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");
+    let missing = reports.env_records.get(OsStr::new("MISSING")).expect("MISSING recorded");
     assert!(!missing.tracked);
     assert!(missing.value.is_none());
 }
@@ -81,29 +83,31 @@ fn get_env_found_and_not_found() {
 fn get_env_tracked_upgrade_is_monotonic() {
     let reports = run_with_server(env_map(&[("NODE_ENV", "production")]), |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();
+        let a = client.get_env(OsStr::new("NODE_ENV"), false).unwrap();
+        let b = client.get_env(OsStr::new("NODE_ENV"), true).unwrap();
+        let c = client.get_env(OsStr::new("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");
+    let node = reports.env_records.get(OsStr::new("NODE_ENV")).expect("recorded");
     assert!(node.tracked, "tracked must remain true once set");
 }
 
 #[test]
 fn concurrent_clients() {
-    let reports = run_with_server(env_map(&[("SHARED", "value")]), |name| {
-        let threads: Vec<_> = (0..4)
-            .map(|i| {
+    let paths = ["/tmp/worker_0", "/tmp/worker_1", "/tmp/worker_2", "/tmp/worker_3"];
+    let reports = run_with_server(env_map(&[("SHARED", "value")]), move |name| {
+        let threads: Vec<_> = paths
+            .iter()
+            .map(|path| {
                 let name = name.clone();
+                let path = *path;
                 thread::spawn(move || {
                     let mut client = Client::from_name(&name).expect("connect");
-                    let path = vite_str::format!("/tmp/worker_{i}");
-                    client.ignore_input(abs(path.as_str()).as_absolute_path()).unwrap();
-                    let value = client.get_env("SHARED", true).unwrap();
+                    client.ignore_input(abs(path).as_absolute_path()).unwrap();
+                    let value = client.get_env(OsStr::new("SHARED"), true).unwrap();
                     assert_eq!(value.as_deref(), Some(OsStr::new("value")));
                 })
             })
@@ -114,7 +118,7 @@ fn concurrent_clients() {
     });
 
     assert_eq!(reports.ignored_inputs.len(), 4);
-    let shared = reports.env_records.get("SHARED").expect("recorded");
+    let shared = reports.env_records.get(OsStr::new("SHARED")).expect("recorded");
     assert!(shared.tracked);
     assert_eq!(shared.value.as_deref(), Some(OsStr::new("value")));
 }