refactor: extract AnchoredGlob into vite_glob crate

Replace the ResolvedNegativeGlob tuple type alias with a proper
AnchoredGlob struct that encapsulates glob partitioning, path cleaning,
and prefix-based matching behind a clean API.

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

Author: branchseer

Cargo.lock

@@ -8,7 +8,9 @@ publish = false
 rust-version.workspace = true
 
 [dependencies]
+path-clean = { workspace = true }
 thiserror = { workspace = true }
+vite_path = { workspace = true }
 wax = { workspace = true }
 
 [dev-dependencies]

crates/vite_glob/Cargo.toml

@@ -0,0 +1,62 @@
+use std::sync::Arc;
+
+use vite_path::AbsolutePath;
+use wax::Glob;
+
+use crate::Error;
+
+/// A glob pattern anchored to an absolute directory.
+///
+/// Created by partitioning a glob into an invariant prefix and a variant (dynamic)
+/// part, then resolving the prefix against a base directory. The prefix is cleaned
+/// to normalize `..` components.
+///
+/// For example, `../shared/dist/**` relative to `/ws/packages/app` produces:
+/// - `prefix`: `/ws/packages/shared/dist`
+/// - `variant`: `Some(Glob("**"))`
+#[derive(Debug)]
+pub struct AnchoredGlob {
+    prefix: Arc<AbsolutePath>,
+    variant: Option<Glob<'static>>,
+}
+
+impl AnchoredGlob {
+    /// Create an `AnchoredGlob` by resolving `pattern` relative to `base_dir`.
+    ///
+    /// The pattern is partitioned into an invariant prefix and a variant glob.
+    /// The prefix is joined with `base_dir` and cleaned (normalizing `..`).
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the glob pattern is invalid.
+    ///
+    /// # Panics
+    ///
+    /// Panics if cleaning an absolute path somehow produces a non-absolute path.
+    pub fn new(pattern: &str, base_dir: &AbsolutePath) -> Result<Self, Error> {
+        use path_clean::PathClean as _;
+
+        let glob = Glob::new(pattern)?;
+        let (prefix_path, variant) = glob.partition();
+        let cleaned = base_dir.as_path().join(&prefix_path).clean();
+        // Cleaning an absolute path always produces an absolute path
+        let prefix = Arc::<AbsolutePath>::from(
+            vite_path::AbsolutePathBuf::new(cleaned)
+                .expect("cleaning an absolute path produces an absolute path"),
+        );
+        Ok(Self { prefix, variant: variant.map(Glob::into_owned) })
+    }
+
+    /// Check if an absolute path matches this anchored glob.
+    #[must_use]
+    pub fn is_match(&self, path: &AbsolutePath) -> bool {
+        use wax::Program as _;
+        let Ok(remainder) = path.as_path().strip_prefix(self.prefix.as_path()) else {
+            return false;
+        };
+        let Some(v) = &self.variant else {
+            return remainder.as_os_str().is_empty();
+        };
+        v.is_match(remainder)
+    }
+}

crates/vite_glob/src/anchored.rs

@@ -1,8 +1,10 @@
+mod anchored;
 mod error;
 
 #[expect(clippy::disallowed_types, reason = "wax::Glob::is_match requires std::path::Path")]
 use std::path::Path;
 
+pub use anchored::AnchoredGlob;
 pub use error::Error;
 use wax::{Glob, Program};
 

crates/vite_glob/src/lib.rs

@@ -34,6 +34,7 @@ thiserror = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "io-std", "io-util", "macros", "sync"] }
 tracing = { workspace = true }
 twox-hash = { workspace = true }
+vite_glob = { workspace = true }
 vite_path = { workspace = true }
 vite_select = { workspace = true }
 vite_str = { workspace = true }

crates/vite_task/Cargo.toml

@@ -10,14 +10,13 @@ use std::{
     io::{self, Read},
 };
 
+use vite_glob::AnchoredGlob;
 #[cfg(test)]
 use vite_path::AbsolutePathBuf;
 use vite_path::{AbsolutePath, RelativePathBuf};
 use vite_str::Str;
 use wax::{Glob, walk::Entry as _};
 
-use super::spawn::ResolvedNegativeGlob;
-
 /// Collect walk entries into the result map, filtering against resolved negatives.
 ///
 /// Each positive glob is partitioned into an invariant prefix and a variant pattern.
@@ -28,11 +27,10 @@ use super::spawn::ResolvedNegativeGlob;
 fn collect_walk_entries(
     walk: impl Iterator<Item = Result<wax::walk::GlobEntry, wax::walk::WalkError>>,
     workspace_root: &AbsolutePath,
-    resolved_negatives: &[ResolvedNegativeGlob],
+    resolved_negatives: &[AnchoredGlob],
     result: &mut BTreeMap<RelativePathBuf, u64>,
 ) -> anyhow::Result<()> {
     use path_clean::PathClean as _;
-    use wax::Program as _;
 
     for entry in walk {
         let entry = match entry {
@@ -53,21 +51,18 @@ fn collect_walk_entries(
         // Clean the path to normalize `..` components (from globs like `../shared/src/**`)
         let cleaned_path = entry.path().clean();
 
+        // Convert to AbsolutePath for negative matching and workspace-relative stripping
+        let Some(cleaned_abs) = AbsolutePath::new(&cleaned_path) else {
+            continue;
+        };
+
         // Filter against resolved negatives
-        if resolved_negatives.iter().any(|(prefix, variant)| {
-            let Ok(remainder) = cleaned_path.strip_prefix(prefix) else {
-                return false;
-            };
-            variant.as_ref().map_or(remainder.as_os_str().is_empty(), |v| v.is_match(remainder))
-        }) {
+        if resolved_negatives.iter().any(|neg| neg.is_match(cleaned_abs)) {
             continue;
         }
 
         // Compute path relative to workspace_root for the result
-        let Some(relative_to_workspace) = cleaned_path
-            .strip_prefix(workspace_root.as_path())
-            .ok()
-            .and_then(|p| RelativePathBuf::new(p).ok())
+        let Some(relative_to_workspace) = cleaned_abs.strip_prefix(workspace_root).ok().flatten()
         else {
             continue; // Skip if path is outside workspace_root
         };
@@ -116,15 +111,9 @@ pub fn compute_globbed_inputs(
         return Ok(BTreeMap::new());
     }
 
-    // Resolve negatives: partition + clean to get (absolute_prefix, variant)
-    let resolved_negatives: Vec<ResolvedNegativeGlob> = negative_globs
+    let resolved_negatives: Vec<AnchoredGlob> = negative_globs
         .iter()
-        .map(|p| {
-            let glob = Glob::new(p.as_str())?.into_owned();
-            let (prefix, variant) = glob.partition();
-            let resolved = base_dir.as_path().join(&prefix).clean();
-            Ok((resolved, variant.map(Glob::into_owned)))
-        })
+        .map(|p| Ok(AnchoredGlob::new(p.as_str(), base_dir)?))
         .collect::<anyhow::Result<_>>()?;
 
     let mut result = BTreeMap::new();

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

@@ -15,7 +15,7 @@ use vite_task_plan::{
 use self::{
     fingerprint::PostRunFingerprint,
     glob_inputs::compute_globbed_inputs,
-    spawn::{ResolvedNegativeGlob, SpawnResult, TrackedPathAccesses, spawn_with_tracking},
+    spawn::{SpawnResult, TrackedPathAccesses, spawn_with_tracking},
 };
 use super::{
     cache::{CacheEntryValue, ExecutionCache},
@@ -422,25 +422,14 @@ pub async fn execute_spawn(
     SpawnOutcome::Spawned(result.exit_status)
 }
 
-/// Resolve negative glob patterns into absolute prefix + optional variant for fspy path filtering.
-///
-/// Each negative glob is partitioned into an invariant prefix and a variant (dynamic) part.
-/// The prefix is joined with `glob_base` and cleaned to produce an absolute path for efficient
-/// prefix-based filtering in `spawn_with_tracking`.
+/// Resolve negative glob patterns into [`AnchoredGlob`]s for filtering.
 fn resolve_negative_globs(
     glob_base: &AbsolutePath,
     negative_globs: &std::collections::BTreeSet<vite_str::Str>,
-) -> anyhow::Result<Vec<ResolvedNegativeGlob>> {
-    use path_clean::PathClean as _;
-
+) -> anyhow::Result<Vec<vite_glob::AnchoredGlob>> {
     negative_globs
         .iter()
-        .map(|p| {
-            let glob = wax::Glob::new(p.as_str())?.into_owned();
-            let (prefix, variant) = glob.partition();
-            let resolved = glob_base.as_path().join(&prefix).clean();
-            Ok((resolved, variant.map(wax::Glob::into_owned)))
-        })
+        .map(|p| Ok(vite_glob::AnchoredGlob::new(p.as_str(), glob_base)?))
         .collect()
 }
 

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

@@ -11,6 +11,7 @@ use fspy::AccessMode;
 use rustc_hash::FxHashSet;
 use serde::Serialize;
 use tokio::io::{AsyncReadExt as _, AsyncWrite, AsyncWriteExt as _};
+use vite_glob::AnchoredGlob;
 use vite_path::{AbsolutePath, RelativePathBuf};
 use vite_task_plan::SpawnCommand;
 
@@ -54,12 +55,6 @@ pub struct TrackedPathAccesses {
     pub path_writes: FxHashSet<RelativePathBuf>,
 }
 
-/// Resolved negative glob pattern for filtering fspy-tracked paths.
-/// The `PathBuf` is the resolved absolute prefix (glob base + invariant prefix, cleaned).
-/// The `Option<Glob>` is the variant (dynamic) part of the pattern, if any.
-#[expect(clippy::disallowed_types, reason = "wax partition returns std::path::PathBuf")]
-pub type ResolvedNegativeGlob = (std::path::PathBuf, Option<wax::Glob<'static>>);
-
 /// Spawn a command with optional file system tracking via fspy, using piped stdio.
 ///
 /// Returns the execution result including exit status and duration.
@@ -82,7 +77,7 @@ pub async fn spawn_with_tracking(
     stderr_writer: &mut (dyn AsyncWrite + Unpin),
     std_outputs: Option<&mut Vec<StdOutput>>,
     path_accesses: Option<&mut TrackedPathAccesses>,
-    resolved_negatives: &[ResolvedNegativeGlob],
+    resolved_negatives: &[AnchoredGlob],
 ) -> anyhow::Result<SpawnResult> {
     /// The tracking state of the spawned process.
     /// Determined by whether `path_accesses` is `Some` (fspy enabled) or `None` (fspy disabled).
@@ -217,19 +212,13 @@ pub async fn spawn_with_tracking(
 
         // Filter against resolved negative globs.
         // Clean the path to normalize `..` only for matching purposes, since
-        // resolved negatives are cleaned absolute paths.
+        // AnchoredGlob prefixes are cleaned absolute paths.
         if !resolved_negatives.is_empty() {
             let cleaned_abs =
                 path_clean::PathClean::clean(workspace_root.join(&relative_path).as_path());
-            if resolved_negatives.iter().any(|(resolved_prefix, variant)| {
-                let Ok(remainder) = cleaned_abs.strip_prefix(resolved_prefix) else {
-                    return false;
-                };
-                variant.as_ref().map_or(remainder.as_os_str().is_empty(), |v| {
-                    use wax::Program as _;
-                    v.is_match(remainder)
-                })
-            }) {
+            if let Some(cleaned) = AbsolutePath::new(&cleaned_abs)
+                && resolved_negatives.iter().any(|neg| neg.is_match(cleaned))
+            {
                 continue;
             }
         }