refactor(cache): unify glob resolution into generic ResolvedGlob type

Replace the negative-glob-specific `ResolvedNegativeGlob` struct,
`resolve_negative_globs()`, and `is_excluded()` with a single generic
`ResolvedGlob` type that provides both `walk()` (for positive globs)
and `matches()` (for negative globs). The partition + path_clean logic
now lives in one place (`ResolvedGlob::new`).

Also normalize fspy-tracked paths in `PostRunFingerprint::create` so
stored keys are always clean (no `..` components), making cache miss
messages deterministic.

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

Author: branchseer

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

@@ -17,10 +17,7 @@ use vite_path::{AbsolutePath, RelativePathBuf};
 use vite_str::Str;
 use vite_task_graph::config::ResolvedInputConfig;
 
-use super::{
-    glob_inputs::{is_excluded, resolve_negative_globs},
-    spawn::PathRead,
-};
+use super::{glob_inputs::ResolvedGlob, spawn::PathRead};
 use crate::collections::HashMap;
 
 /// Post-run fingerprint capturing file state after execution.
@@ -90,26 +87,38 @@ impl PostRunFingerprint {
             return Ok(Self { inferred_inputs: HashMap::default() });
         }
 
-        // Resolve negative globs relative to the package directory (glob_base),
-        // handling `..` components so patterns like `!../shared/dist/**` work.
-        let resolved_negatives = resolve_negative_globs(&input_config.negative_globs, glob_base)?;
+        let negatives: Vec<ResolvedGlob> = input_config
+            .negative_globs
+            .iter()
+            .map(|p| ResolvedGlob::new(p.as_str(), glob_base))
+            .collect::<anyhow::Result<_>>()?;
 
         let inferred_inputs = path_reads
             .par_iter()
-            .filter(|(path, _)| {
-                if resolved_negatives.is_empty() {
-                    return true;
-                }
-                // Convert workspace-relative path to absolute for negative glob matching.
-                // Clean the path to resolve any `..` components from fspy-tracked paths
+            .filter_map(|(relative_path, path_read)| {
+                // Clean the absolute path to normalize `..` from fspy-tracked paths
                 // (e.g., `packages/sub-pkg/../shared/dist/output.js`).
-                let absolute = path_clean::PathClean::clean(base_dir.join(path).as_path());
-                !is_excluded(&absolute, &resolved_negatives)
-            })
-            .map(|(relative_path, path_read)| {
-                let full_path = Arc::<AbsolutePath>::from(base_dir.join(relative_path));
-                let fingerprint = fingerprint_path(&full_path, *path_read)?;
-                Ok((relative_path.clone(), fingerprint))
+                let cleaned_abs =
+                    path_clean::PathClean::clean(base_dir.join(relative_path).as_path());
+
+                // Apply negative globs against the cleaned path
+                if negatives.iter().any(|neg| neg.matches(&cleaned_abs)) {
+                    return None;
+                }
+
+                // Derive a cleaned workspace-relative key so stored paths are normalized
+                let clean_key = cleaned_abs
+                    .strip_prefix(base_dir.as_path())
+                    .ok()
+                    .and_then(|p| RelativePathBuf::new(p).ok())
+                    .unwrap_or_else(|| relative_path.clone());
+
+                let full_path = Arc::<AbsolutePath>::from(base_dir.join(&clean_key));
+                let fingerprint = match fingerprint_path(&full_path, *path_read) {
+                    Ok(f) => f,
+                    Err(e) => return Some(Err(e)),
+                };
+                Some(Ok((clean_key, fingerprint)))
             })
             .collect::<anyhow::Result<HashMap<_, _>>>()?;
 

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

@@ -17,49 +17,58 @@ use vite_path::{AbsolutePath, RelativePathBuf};
 use vite_str::Str;
 use wax::{Glob, Program as _};
 
-/// A negative glob pattern resolved to an absolute base directory and optional variant.
+/// A glob pattern resolved to an absolute base directory.
 ///
-/// For example, `../shared/dist/**` relative to `/ws/packages/app` resolves to:
-/// - `resolved_base`: `/ws/packages/shared/dist`
+/// Uses [`wax::Glob::partition`] to separate the invariant prefix from the
+/// wildcard suffix, then resolves the prefix to an absolute path via
+/// [`path_clean`] (normalizing components like `..`).
+///
+/// For example, `../shared/src/**` relative to `/ws/packages/app` resolves to:
+/// - `resolved_base`: `/ws/packages/shared/src`
 /// - `variant`: `Some(Glob("**"))`
 #[expect(clippy::disallowed_types, reason = "path_clean returns std::path::PathBuf")]
-pub struct ResolvedNegativeGlob {
+pub struct ResolvedGlob {
     resolved_base: std::path::PathBuf,
     variant: Option<Glob<'static>>,
 }
 
-/// Resolve negative globs relative to `base_dir`, handling `..` components.
-///
-/// Uses [`Glob::partition`] to split each pattern into an invariant base and an
-/// optional variant, then resolves the base with [`path_clean`] to normalize `..`.
-pub fn resolve_negative_globs(
-    patterns: &std::collections::BTreeSet<Str>,
-    base_dir: &AbsolutePath,
-) -> anyhow::Result<Vec<ResolvedNegativeGlob>> {
-    patterns
-        .iter()
-        .map(|pattern| {
-            let glob = Glob::new(pattern.as_str())?.into_owned();
-            let (base_pathbuf, variant) = glob.partition();
-            let base_str = base_pathbuf.to_str().unwrap_or(".");
-            let resolved_base = if base_str.is_empty() {
-                base_dir.as_path().to_path_buf()
-            } else {
-                base_dir.join(base_str).as_path().clean()
-            };
-            Ok(ResolvedNegativeGlob { resolved_base, variant: variant.map(Glob::into_owned) })
-        })
-        .collect()
-}
+impl ResolvedGlob {
+    /// Resolve a glob pattern relative to `base_dir`.
+    pub fn new(pattern: &str, base_dir: &AbsolutePath) -> anyhow::Result<Self> {
+        let glob = Glob::new(pattern)?.into_owned();
+        let (base_pathbuf, variant) = glob.partition();
+        let base_str = base_pathbuf.to_str().unwrap_or(".");
+        let resolved_base = if base_str.is_empty() {
+            base_dir.as_path().to_path_buf()
+        } else {
+            base_dir.join(base_str).as_path().clean()
+        };
+        Ok(Self { resolved_base, variant: variant.map(Glob::into_owned) })
+    }
+
+    /// Walk the filesystem and yield matching file paths.
+    #[expect(clippy::disallowed_types, reason = "yields std::path::PathBuf from wax walker")]
+    pub fn walk(&self) -> Box<dyn Iterator<Item = std::path::PathBuf> + '_> {
+        match &self.variant {
+            Some(variant_glob) => Box::new(
+                variant_glob
+                    .walk(&self.resolved_base)
+                    .filter_map(Result::ok)
+                    .map(wax::walk::Entry::into_path),
+            ),
+            None => Box::new(std::iter::once(self.resolved_base.clone())),
+        }
+    }
 
-/// Check if an absolute path is excluded by any of the resolved negative globs.
-#[expect(clippy::disallowed_types, reason = "matching against std::path::Path from wax walker")]
-pub fn is_excluded(path: &std::path::Path, negatives: &[ResolvedNegativeGlob]) -> bool {
-    negatives.iter().any(|neg| {
-        path.strip_prefix(&neg.resolved_base).ok().is_some_and(|remainder| {
-            neg.variant.as_ref().map_or(remainder.as_os_str().is_empty(), |v| v.is_match(remainder))
+    /// Check if an absolute path matches this resolved glob.
+    #[expect(clippy::disallowed_types, reason = "matching against std::path::Path")]
+    pub fn matches(&self, path: &std::path::Path) -> bool {
+        path.strip_prefix(&self.resolved_base).ok().is_some_and(|remainder| {
+            self.variant
+                .as_ref()
+                .map_or(remainder.as_os_str().is_empty(), |v| v.is_match(remainder))
         })
-    })
+    }
 }
 
 /// Compute globbed inputs by walking positive glob patterns and filtering with negative patterns.
@@ -88,7 +97,6 @@ pub fn is_excluded(path: &std::path::Path, negatives: &[ResolvedNegativeGlob]) -
 /// )?;
 /// // Returns: { "packages/foo/src/index.ts" => 0x1234..., ... }
 /// ```
-#[expect(clippy::disallowed_types, reason = "path_clean and wax walker return std::path types")]
 pub fn compute_globbed_inputs(
     base_dir: &AbsolutePath,
     workspace_root: &AbsolutePath,
@@ -100,43 +108,24 @@ pub fn compute_globbed_inputs(
         return Ok(BTreeMap::new());
     }
 
-    // Resolve negative globs, normalizing `..` components
-    let resolved_negatives = resolve_negative_globs(negative_globs, base_dir)?;
+    let negatives: Vec<ResolvedGlob> = negative_globs
+        .iter()
+        .map(|p| ResolvedGlob::new(p.as_str(), base_dir))
+        .collect::<anyhow::Result<_>>()?;
 
     let mut result = BTreeMap::new();
 
-    // Walk each positive glob pattern, resolving `..` via partition + path_clean
     for pattern in positive_globs {
-        let glob = Glob::new(pattern.as_str())?.into_owned();
-        let (base_pathbuf, variant) = glob.partition();
-        let base_str = base_pathbuf.to_str().unwrap_or(".");
-        let resolved_base = if base_str.is_empty() {
-            base_dir.as_path().to_path_buf()
-        } else {
-            base_dir.join(base_str).as_path().clean()
-        };
-
-        let entries: Box<dyn Iterator<Item = std::path::PathBuf>> = match variant {
-            Some(variant_glob) => Box::new(
-                variant_glob
-                    .walk(&resolved_base)
-                    .filter_map(Result::ok)
-                    .map(wax::walk::Entry::into_path),
-            ),
-            None => {
-                // No wildcard: exact file path
-                Box::new(std::iter::once(resolved_base))
-            }
-        };
+        let resolved = ResolvedGlob::new(pattern.as_str(), base_dir)?;
 
-        for absolute_path in entries {
+        for absolute_path in resolved.walk() {
             // Skip non-files
             if !absolute_path.is_file() {
                 continue;
             }
 
             // Apply negative patterns
-            if is_excluded(&absolute_path, &resolved_negatives) {
+            if negatives.iter().any(|neg| neg.matches(&absolute_path)) {
                 continue;
             }
 

crates/vite_task_bin/tests/e2e_snapshots/fixtures/inputs-negative-glob-subpackage/snapshots/dotdot auto negative - miss on non-excluded sibling inferred file.snap

@@ -10,6 +10,6 @@ export const shared = 'initial';
 > replace-file-content packages/shared/src/utils.ts initial modified
 
 > vp run sub-pkg#dotdot-auto-negative
-~/packages/sub-pkg$ print-file ../shared/src/utils.ts ../shared/dist/output.js ✗ cache miss: content of input 'packages/sub-pkg/../shared/src/utils.ts' changed, executing
+~/packages/sub-pkg$ print-file ../shared/src/utils.ts ../shared/dist/output.js ✗ cache miss: content of input 'packages/shared/src/utils.ts' changed, executing
 export const shared = 'modified';
 // initial shared output