style: apply rustfmt formatting

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

Author: branchseer

crates/vite_task/src/session/cache/display.rs

@@ -39,7 +39,6 @@ pub enum SpawnFingerprintChange {
     // Working directory change
     /// Working directory changed
     CwdChanged,
-
 }
 
 /// Format a single spawn fingerprint change as human-readable text.

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

@@ -398,8 +398,11 @@ impl ExecutionCache {
         )
         .await?;
         out.write_all(b"------- pre_run_fingerprint_cache -------\n")?;
-        self.list_table::<PreRunFingerprint, CommandCacheValue>("pre_run_fingerprint_cache", &mut out)
-            .await?;
+        self.list_table::<PreRunFingerprint, CommandCacheValue>(
+            "pre_run_fingerprint_cache",
+            &mut out,
+        )
+        .await?;
         Ok(())
     }
 }

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

@@ -114,10 +114,8 @@ impl PostRunFingerprint {
         &self,
         base_dir: &AbsolutePath,
     ) -> anyhow::Result<Option<PostRunFingerprintMismatch>> {
-        let input_mismatch = self
-            .inferred_inputs
-            .par_iter()
-            .find_map_any(|(input_relative_path, path_fingerprint)| {
+        let input_mismatch = self.inferred_inputs.par_iter().find_map_any(
+            |(input_relative_path, path_fingerprint)| {
                 let input_full_path = Arc::<AbsolutePath>::from(base_dir.join(input_relative_path));
                 let path_read = PathRead {
                     read_dir_entries: matches!(path_fingerprint, PathFingerprint::Folder(Some(_))),
@@ -133,7 +131,8 @@ impl PostRunFingerprint {
                         path: input_relative_path.clone(),
                     }))
                 }
-            });
+            },
+        );
         input_mismatch.transpose()
     }
 }

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

@@ -12,11 +12,10 @@ use vite_task_plan::{
     SpawnExecution,
 };
 
-use self::glob_inputs::compute_globbed_inputs;
-
 use self::{
     fingerprint::PostRunFingerprint,
-    spawn::{SpawnResult, spawn_with_tracking},
+    glob_inputs::compute_globbed_inputs,
+    spawn::{SpawnResult, TrackedPathAccesses, spawn_with_tracking},
 };
 use super::{
     cache::{CommandCacheValue, ExecutionCache},
@@ -30,7 +29,6 @@ use super::{
     },
 };
 use crate::Session;
-use self::spawn::TrackedPathAccesses;
 
 /// Outcome of a spawned execution.
 ///
@@ -353,55 +351,54 @@ pub async fn execute_spawn(
 
     // 6. Update cache if successful and determine cache update status.
     //    Errors during cache update are terminal (reported through finish).
-    let (cache_update_status, cache_error) =
-        if let Some((cache_metadata, globbed_inputs)) = cache_metadata_and_inputs {
-            if result.exit_status.success() {
-                // path_reads is empty when inference is disabled (path_accesses is None)
-                let empty_path_reads = Default::default();
-                let path_reads = path_accesses
-                    .as_ref()
-                    .map(|pa| &pa.path_reads)
-                    .unwrap_or(&empty_path_reads);
-
-                // Execution succeeded — attempt to create fingerprint and update cache
-                match PostRunFingerprint::create(
-                    path_reads,
-                    cache_base_path,
-                    &cache_metadata.input_config,
-                ) {
-                    Ok(post_run_fingerprint) => {
-                        let new_cache_value = CommandCacheValue {
-                            post_run_fingerprint,
-                            std_outputs: std_outputs.unwrap_or_default().into(),
-                            duration: result.duration,
-                        };
-                        match cache
-                            .update(cache_metadata, globbed_inputs, cache_base_path, new_cache_value)
-                            .await
-                        {
-                            Ok(()) => (CacheUpdateStatus::Updated, None),
-                            Err(err) => (
-                                CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheDisabled),
-                                Some(ExecutionError::Cache {
-                                    kind: CacheErrorKind::Update,
-                                    source: err,
-                                }),
-                            ),
-                        }
+    let (cache_update_status, cache_error) = if let Some((cache_metadata, globbed_inputs)) =
+        cache_metadata_and_inputs
+    {
+        if result.exit_status.success() {
+            // path_reads is empty when inference is disabled (path_accesses is None)
+            let empty_path_reads = Default::default();
+            let path_reads =
+                path_accesses.as_ref().map(|pa| &pa.path_reads).unwrap_or(&empty_path_reads);
+
+            // Execution succeeded — attempt to create fingerprint and update cache
+            match PostRunFingerprint::create(
+                path_reads,
+                cache_base_path,
+                &cache_metadata.input_config,
+            ) {
+                Ok(post_run_fingerprint) => {
+                    let new_cache_value = CommandCacheValue {
+                        post_run_fingerprint,
+                        std_outputs: std_outputs.unwrap_or_default().into(),
+                        duration: result.duration,
+                    };
+                    match cache
+                        .update(cache_metadata, globbed_inputs, cache_base_path, new_cache_value)
+                        .await
+                    {
+                        Ok(()) => (CacheUpdateStatus::Updated, None),
+                        Err(err) => (
+                            CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheDisabled),
+                            Some(ExecutionError::Cache {
+                                kind: CacheErrorKind::Update,
+                                source: err,
+                            }),
+                        ),
                     }
-                    Err(err) => (
-                        CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheDisabled),
-                        Some(ExecutionError::PostRunFingerprint(err)),
-                    ),
                 }
-            } else {
-                // Execution failed with non-zero exit status — don't update cache
-                (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::NonZeroExitStatus), None)
+                Err(err) => (
+                    CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheDisabled),
+                    Some(ExecutionError::PostRunFingerprint(err)),
+                ),
             }
         } else {
-            // Caching was disabled for this task
-            (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheDisabled), None)
-        };
+            // Execution failed with non-zero exit status — don't update cache
+            (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::NonZeroExitStatus), None)
+        }
+    } else {
+        // Caching was disabled for this task
+        (CacheUpdateStatus::NotUpdated(CacheNotUpdatedReason::CacheDisabled), None)
+    };
 
     // 7. Finish the leaf execution with the result and optional cache error.
     //    Cache update/fingerprint failures are reported but do not affect the outcome —

crates/vite_task_bin/src/lib.rs

@@ -126,7 +126,11 @@ impl vite_task::CommandHandler for CommandHandler {
                     program: find_executable(get_path_env(&envs), &command.cwd, "print-env")?,
                     args: [name.clone()].into(),
                     cache_config: UserCacheConfig::with_config({
-                        EnabledCacheConfig { envs: None, pass_through_envs: Some(vec![name]), inputs: None }
+                        EnabledCacheConfig {
+                            envs: None,
+                            pass_through_envs: Some(vec![name]),
+                            inputs: None,
+                        }
                     }),
                     envs: Arc::new(envs),
                 }))