perf(fs): use std::fs instead of tokio::fs in FileSystemOs

tokio::fs offloads every syscall to the blocking threadpool (semaphore +
task harness + park/unpark). Resolution issues a large number of tiny
stat/read calls whose kernel time is dwarfed by that per-call scheduling
overhead (~14% of total instructions in the resolver callgrind bench).
std::fs runs them inline, matching the existing wasm impl and the
upstream synchronous resolver. The async FileSystem trait is unchanged;
callers wanting resolution off the reactor should spawn_blocking the
whole resolve, not each syscall.

Author: stormslowly

src/file_system.rs

@@ -147,19 +147,27 @@ impl FileSystemOs {
 #[cfg(not(target_arch = "wasm32"))]
 #[async_trait::async_trait]
 impl FileSystem for FileSystemOs {
+  // The FS trait is async, but resolution issues a large number of tiny
+  // `stat`/`read` syscalls whose kernel time is dwarfed by the per-call cost of
+  // tokio's `spawn_blocking` machinery (blocking-pool semaphore + task harness +
+  // park/unpark). Calling `std::fs` directly removes that scheduling overhead
+  // (~14% of total instructions in the resolver bench) and matches both the
+  // wasm impl below and the upstream synchronous resolver. Callers that need
+  // resolution off the async reactor should `spawn_blocking` the whole resolve,
+  // not each syscall.
   async fn read(&self, path: &Path) -> io::Result<Vec<u8>> {
     cfg_if! {
       if #[cfg(feature = "yarn_pnp")] {
         if self.options.enable_pnp {
             return match VPath::from(path)? {
                 VPath::Zip(info) => self.pnp_lru.read(info.physical_base_path(), info.zip_path),
-                VPath::Virtual(info) => tokio::fs::read(info.physical_base_path()).await,
-                VPath::Native(path) => tokio::fs::read(&path).await,
+                VPath::Virtual(info) => fs::read(info.physical_base_path()),
+                VPath::Native(path) => fs::read(&path),
             }
         }
     }}
 
-    tokio::fs::read(path).await
+    fs::read(path)
   }
 
   async fn read_to_string(&self, path: &Path) -> io::Result<String> {
@@ -168,13 +176,13 @@ impl FileSystem for FileSystemOs {
         if self.options.enable_pnp {
             return match VPath::from(path)? {
                 VPath::Zip(info) => self.pnp_lru.read_to_string(info.physical_base_path(), info.zip_path),
-                VPath::Virtual(info) => tokio::fs::read_to_string(info.physical_base_path()).await,
-                VPath::Native(path) => tokio::fs::read_to_string(&path).await,
+                VPath::Virtual(info) => fs::read_to_string(info.physical_base_path()),
+                VPath::Native(path) => fs::read_to_string(&path),
                 }
             }
         }
     }
-    tokio::fs::read_to_string(path).await
+    fs::read_to_string(path)
   }
 
   async fn metadata(&self, path: &Path) -> io::Result<FileMetadata> {
@@ -187,23 +195,19 @@ impl FileSystem for FileSystemOs {
                         .file_type(info.physical_base_path(), info.zip_path)
                         .map(FileMetadata::from),
                     VPath::Virtual(info) => {
-                        tokio::fs::metadata(info.physical_base_path())
-                            .await
-                            .map(FileMetadata::from)
+                        fs::metadata(info.physical_base_path()).map(FileMetadata::from)
                     }
-                    VPath::Native(path) => tokio::fs::metadata(path).await.map(FileMetadata::from),
+                    VPath::Native(path) => fs::metadata(path).map(FileMetadata::from),
                 }
             }
         }
     }
 
-    tokio::fs::metadata(path).await.map(FileMetadata::from)
+    fs::metadata(path).map(FileMetadata::from)
   }
 
   async fn symlink_metadata(&self, path: &Path) -> io::Result<FileMetadata> {
-    tokio::fs::symlink_metadata(path)
-      .await
-      .map(FileMetadata::from)
+    fs::symlink_metadata(path).map(FileMetadata::from)
   }
 
   async fn canonicalize(&self, path: &Path) -> io::Result<PathBuf> {