refactor(server): drop 'static bound on handler

The driver future owns the handler via `Rc<H>` and only needs `H` to
outlive the future. Parameterize `ServerHandle` and `serve` over a
lifetime so callers with non-`'static` handlers are supported.

For `'static` handlers (the expected common case), nothing changes
at the call site — inference picks `'static`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: wan9chi

crates/vite_task_server/src/lib.rs

@@ -31,8 +31,8 @@ pub trait Handler {
 ///
 /// Dropping `driver` before it resolves tears everything down immediately —
 /// listener closed, per-client tasks cancelled, handler discarded.
-pub struct ServerHandle<H> {
-    pub driver: LocalBoxFuture<'static, H>,
+pub struct ServerHandle<'h, H> {
+    pub driver: LocalBoxFuture<'h, H>,
     pub stop_accepting: StopAccepting,
 }
 
@@ -65,7 +65,7 @@ impl StopAccepting {
 /// The driver future panics if, after drain, the handler still has other
 /// `Rc` references — which would indicate a logic bug in the server
 /// (per-client futures should all have dropped their clones by then).
-pub fn serve<H: Handler + 'static>(handler: H) -> io::Result<(OsString, ServerHandle<H>)> {
+pub fn serve<'h, H: Handler + 'h>(handler: H) -> io::Result<(OsString, ServerHandle<'h, H>)> {
     let handler_rc = Rc::new(handler);
     let stop_token = CancellationToken::new();
     let (name, bound) = bind_listener()?;

docs/runner-task-ipc/server-design.md

@@ -9,7 +9,7 @@ The IPC server runs per spawn execution **only when fspy is enabled**, letting t
 1. **Server doesn't take a cancellation token.** The caller signals "stop accepting" via `StopAccepting::signal()`. The server has no awareness of external cancellation.
 2. **Handler is moved in, returned out.** The caller doesn't keep a reference. The driver owns the handler; on drain completion it returns it by value. No self-reference, no `&H` lifetime.
 3. **`Rc<H>` + `CancellationToken` internally** — both hidden from the public API.
-4. **Driver is `!Send`, `'static`** — matches the existing execute pipeline shape (`LocalBoxFuture<'static, ...>` throughout).
+4. **Driver is `!Send`**, lifetime bounded by `H`'s lifetime — if `H: 'static`, the driver is `'static`; if `H` borrows, the driver respects that.
 
 ## Server API
 
@@ -21,12 +21,12 @@ pub trait Handler {
     fn get_env(&self, name: &str, tracked: bool) -> Option<Arc<OsStr>>;
 }
 
-pub fn serve<H: Handler + 'static>(
+pub fn serve<'h, H: Handler + 'h>(
     handler: H,
-) -> io::Result<(OsString, ServerHandle<H>)>;
+) -> io::Result<(OsString, ServerHandle<'h, H>)>;
 
-pub struct ServerHandle<H> {
-    pub driver: LocalBoxFuture<'static, H>,
+pub struct ServerHandle<'h, H> {
+    pub driver: LocalBoxFuture<'h, H>,
     pub stop_accepting: StopAccepting,
 }
 
@@ -115,11 +115,11 @@ if !fast_fail_token.is_cancelled() && !interrupt_token.is_cancelled() {
 
 ## Design-decision log
 
-### Why `H: 'static`?
+### Why no `'static` bound on `H`?
 
-Storing the driver in `FspyState` without a lifetime parameter requires `LocalBoxFuture<'static, H>`, which requires `H: 'static`. The concrete `IpcRecorder` is naturally `'static` — it owns all its fields (RefCells, cloned env config).
+The driver future _owns_ the handler (via `Rc<H>` internally). It doesn't need to outlive `H` — it just needs `H` to outlive the future. So the signature is `serve<'h, H: Handler + 'h>` and the returned `ServerHandle<'h, H>` carries the lifetime. If the caller's `H` is `'static`, the driver is `'static`; if `H` borrows, the driver respects that.
 
-An earlier direction ("don't require `'static` on Handler") was specifically to avoid `spawn_local`, which requires `'static` tasks. Requiring `'static` on the trait type is acceptable when the concrete handler naturally has no borrow.
+If the caller wants to store `ServerHandle` in a struct without a lifetime parameter, they can use a `'static` handler (naturally satisfied by handlers that own all their state via `RefCell<...>` + cloned data).
 
 ### Why `Rc<H>` internally instead of `&H`?