feat: block HTTP requests during active rebuilds via WatchLock (#81)

## Summary

- Obtain the shared `WatchLock` from the configured watcher before
spawning the watch thread
- Pass the lock into the HTTP serving loop
- Acquire a read guard per request, after parsing the header, so file
reads cannot race with rebuild writes
- Re-export `WatchLock` and `WatchLockGuard` from `xtask-wasm` so
consumers don't need a direct `xtask-watch` dependency to name the types
- Document why `read_header` is intentionally called before acquiring
the lock (connections are accepted and headers parsed during a build,
reducing response latency once it finishes)

## Why

Without coordination, a browser refresh mid-rebuild could receive
incomplete or inconsistent dist artifacts. Using the shared watcher lock
ensures the dev server only serves files once the current build has
fully written its output.

Closes #80
Requires rustminded/xtask-watch#34

---------

Co-authored-by: Cecile Tonglet <cecile.tonglet@cecton.com>

Author: yozhgoor

Cargo.toml

@@ -35,7 +35,7 @@ log = "0.4.14"
 sass-rs = { version = "0.2.2", optional = true }
 walkdir = "2.3.2"
 wasm-bindgen-cli-support = "0.2.100"
-xtask-watch = "0.3.2"
+xtask-watch = "0.3.3"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.112"

src/dev_server.rs

@@ -13,6 +13,7 @@ use std::{
     sync::Arc,
     thread,
 };
+use xtask_watch::WatchLock;
 
 type RequestHandler = Arc<dyn Fn(Request) -> Result<()> + Send + Sync + 'static>;
 
@@ -352,6 +353,8 @@ impl DevServer {
         }
         let dist_dir = self.dist_dir.clone().unwrap();
 
+        let watch_lock = self.watch.lock();
+
         let watch_process = {
             // mem::take so we can pass &self to build_command while the fields are empty.
             let pre_hooks = std::mem::take(&mut self.pre_hooks);
@@ -373,7 +376,8 @@ impl DevServer {
                     format!("cannot create dist directory `{}`", dist_dir.display())
                 })?;
                 let watch = self.watch.exclude_path(&dist_dir);
-                let handle = std::thread::spawn(|| match watch.run(commands) {
+
+                let handle = std::thread::spawn(move || match watch.run(commands) {
                     Ok(()) => log::trace!("Starting to watch"),
                     Err(err) => log::error!("an error occurred when starting to watch: {err}"),
                 });
@@ -385,15 +389,23 @@ impl DevServer {
         };
 
         if let Some(handler) = self.request_handler {
-            serve(self.ip, self.port, dist_dir, self.not_found_path, handler)
-                .context("an error occurred when starting to serve")?;
+            serve(
+                self.ip,
+                self.port,
+                dist_dir,
+                self.not_found_path,
+                handler,
+                watch_lock,
+            )
+            .context("an error occurred when starting to serve")?;
         } else {
             serve(
                 self.ip,
                 self.port,
                 dist_dir,
                 self.not_found_path,
                 Arc::new(default_request_handler),
+                watch_lock,
             )
             .context("an error occurred when starting to serve")?;
         }
@@ -428,6 +440,7 @@ fn serve(
     dist_dir: PathBuf,
     not_found_path: Option<PathBuf>,
     handler: RequestHandler,
+    watch_lock: WatchLock,
 ) -> Result<()> {
     let address = SocketAddr::new(ip, port);
     let listener = TcpListener::bind(address).context("cannot bind to the given address")?;
@@ -450,8 +463,14 @@ fn serve(
         let handler = handler.clone();
         let dist_dir = dist_dir.clone();
         let not_found_path = not_found_path.clone();
+        let watch_lock = watch_lock.clone();
         thread::spawn(move || {
+            // Read the request header *before* acquiring the watch lock so that connections
+            // can be accepted and parsed while a rebuild is in progress. This reduces
+            // perceived latency: the response is dispatched immediately once the build
+            // finishes rather than having to re-parse the header afterward.
             let header = warn_not_fail!(read_header(&stream));
+            let _guard = watch_lock.acquire();
             let request = Request {
                 stream: &mut stream,
                 header: header.as_ref(),

src/lib.rs

@@ -8,6 +8,7 @@ use std::process::Command;
 #[cfg(not(target_arch = "wasm32"))]
 pub use xtask_watch::{
     anyhow, cargo_metadata, cargo_metadata::camino, clap, metadata, package, xtask_command, Watch,
+    WatchLock, WatchLockGuard,
 };
 
 #[cfg(not(target_arch = "wasm32"))]