refactor: add clean() methods to AbsolutePath/RelativePath, replace direct path_clean usage

Move path_clean dependency into vite_path and expose it through typed
clean() methods on AbsolutePath and RelativePath, documenting the
symlink limitation of purely lexical normalization.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: branchseer

Cargo.lock

@@ -8,7 +8,6 @@ publish = false
 rust-version.workspace = true
 
 [dependencies]
-path-clean = { workspace = true }
 rustc-hash = { workspace = true }
 thiserror = { workspace = true }
 vite_path = { workspace = true }

crates/vite_glob/Cargo.toml

@@ -9,6 +9,7 @@ rust-version.workspace = true
 [dependencies]
 bincode = { workspace = true }
 diff-struct = { workspace = true }
+path-clean = { workspace = true }
 ref-cast = { workspace = true }
 serde = { workspace = true, features = ["derive", "rc"] }
 thiserror = { workspace = true }

crates/vite_path/Cargo.toml

@@ -200,6 +200,24 @@ impl AbsolutePath {
     pub fn ends_with<P: AsRef<Path>>(&self, path: P) -> bool {
         self.0.ends_with(path.as_ref())
     }
+
+    /// Lexically normalizes the path by resolving `.` and `..` components
+    /// without accessing the filesystem.
+    ///
+    /// **Symlink limitation**: Because this is purely lexical, it can produce
+    /// incorrect results when symlinks are involved. For example, if
+    /// `/a/link` is a symlink to `/x/y`, then cleaning `/a/link/../c`
+    /// yields `/a/c` instead of the correct `/x/c`. Use
+    /// [`std::fs::canonicalize`] when you need symlink-correct resolution.
+    #[must_use]
+    pub fn clean(&self) -> AbsolutePathBuf {
+        use path_clean::PathClean as _;
+
+        let cleaned = self.0.clean();
+        // SAFETY: Lexical cleaning of an absolute path preserves absoluteness —
+        // it only removes `.`/`..` components and redundant separators.
+        unsafe { AbsolutePathBuf::assume_absolute(cleaned) }
+    }
 }
 
 /// An Error returned from [`AbsolutePath::strip_prefix`] if the stripped path is not a valid `RelativePath`

crates/vite_path/src/absolute/mod.rs

@@ -62,6 +62,28 @@ impl RelativePath {
         relative_path_buf
     }
 
+    /// Lexically normalizes the path by resolving `..` components without
+    /// accessing the filesystem. (`.` components are already stripped by
+    /// [`RelativePathBuf::new`].)
+    ///
+    /// **Symlink limitation**: Because this is purely lexical, it can produce
+    /// incorrect results when symlinks are involved. For example, if
+    /// `a/link` is a symlink to `x/y`, then cleaning `a/link/../c`
+    /// yields `a/c` instead of the correct `x/c`. Use
+    /// [`std::fs::canonicalize`] when you need symlink-correct resolution.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the cleaned path is no longer a valid relative path, which
+    /// should never happen in practice.
+    #[must_use]
+    pub fn clean(&self) -> RelativePathBuf {
+        use path_clean::PathClean as _;
+
+        let cleaned = self.as_path().clean();
+        RelativePathBuf::new(cleaned).expect("cleaning a relative path preserves relativity")
+    }
+
     /// Returns a path that, when joined onto `base`, yields `self`.
     ///
     /// If `base` is not a prefix of `self`, returns [`None`].

crates/vite_path/src/relative.rs

@@ -23,7 +23,6 @@ fspy = { workspace = true }
 futures-util = { workspace = true }
 once_cell = { workspace = true }
 owo-colors = { workspace = true }
-path-clean = { workspace = true }
 pty_terminal_test_client = { workspace = true }
 rayon = { workspace = true }
 rusqlite = { workspace = true, features = ["bundled"] }

crates/vite_task/Cargo.toml

@@ -210,10 +210,8 @@ pub async fn spawn_with_tracking(
             // like `packages/sub-pkg/../shared/dist/output.js` that won't match
             // workspace-root-relative negative globs without normalization.
             if !resolved_negatives.is_empty() {
-                let cleaned = path_clean::PathClean::clean(relative.as_path());
-                if let Some(cleaned_str) = cleaned.to_str()
-                    && resolved_negatives.iter().any(|neg| neg.is_match(cleaned_str))
-                {
+                let cleaned = relative.clean();
+                if resolved_negatives.iter().any(|neg| neg.is_match(cleaned.as_str())) {
                     return None;
                 }
             }

crates/vite_task/src/session/execute/spawn.rs

@@ -16,14 +16,13 @@ petgraph = { workspace = true }
 rustc-hash = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
-path-clean = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
-wax = { workspace = true }
 vite_graph_ser = { workspace = true }
 vite_path = { workspace = true }
 vite_str = { workspace = true }
 vite_workspace = { workspace = true }
+wax = { workspace = true }
 
 [dev-dependencies]
 pretty_assertions = { workspace = true }

crates/vite_task_graph/Cargo.toml

@@ -195,16 +195,15 @@ fn resolve_glob_to_workspace_relative(
     workspace_root: &AbsolutePath,
 ) -> Result<Str, ResolveTaskConfigError> {
     use cow_utils::CowUtils as _;
-    use path_clean::PathClean as _;
 
     let glob = wax::Glob::new(pattern).map_err(|source| ResolveTaskConfigError::InvalidGlob {
         pattern: Str::from(pattern),
         source: Box::new(source),
     })?;
     let (invariant_prefix, variant) = glob.partition();
 
-    let joined = package_dir.as_path().join(&invariant_prefix).clean();
-    let stripped = joined.strip_prefix(workspace_root.as_path()).map_err(|_| {
+    let joined = package_dir.join(&invariant_prefix).clean();
+    let stripped = joined.as_path().strip_prefix(workspace_root.as_path()).map_err(|_| {
         ResolveTaskConfigError::GlobOutsideWorkspace { pattern: Str::from(pattern) }
     })?;
 
@@ -383,7 +382,6 @@ mod tests {
 
     use super::*;
 
-    #[expect(clippy::disallowed_types, reason = "PathBuf needed for AbsolutePathBuf::new in tests")]
     fn test_paths() -> (AbsolutePathBuf, AbsolutePathBuf) {
         if cfg!(windows) {
             (

crates/vite_task_graph/src/config/mod.rs

@@ -9,7 +9,6 @@ rust-version.workspace = true
 
 [dependencies]
 clap = { workspace = true, features = ["derive"] }
-path-clean = { workspace = true }
 petgraph = { workspace = true, features = ["serde-1"] }
 rustc-hash = { workspace = true }
 serde = { workspace = true, features = ["derive"] }