fix(client): bypass interprocess linger pool on Drop (Windows)

The runner-aware addon's e2e fixtures (`ipc_client_test`,
`vite_build_cache`, `vite_dev_disable_cache`) all carry
`platform = "unix"` with the note that on Windows CI the Node child
aborts with `failed to start the persistent thread of the Interprocess
linger pool: Access is denied` when the napi addon tears down. The
panic comes from `interprocess::os::windows::named_pipe::stream::Drop`
handing dirty pipes to a lazily-spawned background thread that calls
`FlushFileBuffers` for graceful close. Windows CI containers refuse
the `CreateThread` from inside Node's worker-thread finalizer with
ACCESS_DENIED, the crate `expect`s on that path, and the panic kills
the child.

Add a `Drop` impl for `Client` that, on Windows, reaches into the
underlying `DuplexPipeStream` via `local_socket::Stream::NamedPipe(_)`
and calls `assume_flushed()` so the inner stream's `Drop` skips the
limbo detour. The IPC is strictly request/response, so once we have
read each response the server has already consumed every byte we sent
— there is nothing to flush at close time anyway.

The fix unblocks Windows CI for every test that goes through the
addon. Drop `platform = "unix"` from all nine `[[e2e]]` cases that
were gated on the bug; they remain `ignore = true` because they still
need a pnpm-populated `node_modules` to run.

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

Author: wan9chi

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/snapshots.toml

@@ -5,10 +5,6 @@ Exercises `ignoreInput` through `@voidzero-dev/vite-task-client`.
 The runner treats `cache_like/` as non-input, so mutations to it between
 runs do not invalidate the cache.
 """
-# Unix-only for now: on Windows CI, interprocess 2.4 aborts the child
-# with "failed to start the persistent thread of the Interprocess linger
-# pool: Access is denied" when the Node addon tries to connect.
-platform = "unix"
 ignore = true
 steps = [
   { argv = [
@@ -36,10 +32,6 @@ Exercises `ignoreOutput`. The task reads and writes `sidecar/tmp.txt`;
 without the ignore the runner's read-write overlap check would refuse to
 cache the run ("read and wrote 'sidecar/tmp.txt'").
 """
-# Unix-only for now: on Windows CI, interprocess 2.4 aborts the child
-# with "failed to start the persistent thread of the Interprocess linger
-# pool: Access is denied" when the Node addon tries to connect.
-platform = "unix"
 ignore = true
 steps = [
   { argv = [
@@ -70,10 +62,6 @@ comment = """
 Exercises `disableCache`. The tool asks the runner not to cache this run,
 so the next invocation re-executes instead of hitting a prior entry.
 """
-# Unix-only for now: on Windows CI, interprocess 2.4 aborts the child
-# with "failed to start the persistent thread of the Interprocess linger
-# pool: Access is denied" when the Node addon tries to connect.
-platform = "unix"
 ignore = true
 steps = [
   { argv = [
@@ -96,10 +84,6 @@ its match-set snapshot enter the post-run fingerprint: later runs diff the
 current match-set against what was stored and miss on add / remove / change,
 but hit when only non-matching envs differ.
 """
-# Unix-only for now: on Windows CI, interprocess 2.4 aborts the child
-# with "failed to start the persistent thread of the Interprocess linger
-# pool: Access is denied" when the Node addon tries to connect.
-platform = "unix"
 ignore = true
 steps = [
   { argv = [
@@ -213,10 +197,6 @@ Exercises `getEnv(name, { tracked: true })`. The env value becomes part
 of the post-run fingerprint: the same value still hits, a different value
 misses with `tracked env 'PROBE_ENV' changed`.
 """
-# Unix-only for now: on Windows CI, interprocess 2.4 aborts the child
-# with "failed to start the persistent thread of the Interprocess linger
-# pool: Access is denied" when the Node addon tries to connect.
-platform = "unix"
 ignore = true
 steps = [
   { argv = [

crates/vite_task_bin/tests/e2e_snapshots/fixtures/vite_build_cache/snapshots.toml

@@ -3,10 +3,6 @@ name = "vite_build_caches_and_restores_outputs"
 comment = """
 `vt run --cache build` must produce a cache hit on the second run without any manual input/output configuration. Vite reports `ignoreInput(outDir)` + `ignoreInput/Output(cacheDir)` via `@voidzero-dev/vite-task-client`, so fspy-detected reads of `dist/` and writes to `node_modules/.vite/` don't poison the cache.
 """
-# Unix-only for now: on Windows CI, interprocess 2.4 aborts the child
-# with "failed to start the persistent thread of the Interprocess linger
-# pool: Access is denied" when the Node addon tries to connect.
-platform = "unix"
 ignore = true
 steps = [
   { argv = [
@@ -43,10 +39,6 @@ name = "vite_prefix_env_change_invalidates_cache"
 comment = """
 `VITE_MODE` is picked up by Vite's patched `loadEnv`, which asks the runner for every `VITE_*` env via `getEnvs(pattern, { tracked: true })`. Flipping its value between runs must invalidate the cache AND change the build output — Vite's `define` plugin substitutes `import.meta.env.VITE_MODE` at build time, so dead-code elimination leaves only the branch matching the value.
 """
-# Unix-only for now: on Windows CI, interprocess 2.4 aborts the child
-# with "failed to start the persistent thread of the Interprocess linger
-# pool: Access is denied" when the Node addon tries to connect.
-platform = "unix"
 ignore = true
 steps = [
   { argv = [
@@ -113,10 +105,6 @@ name = "vite_node_env_change_invalidates_cache"
 comment = """
 `NODE_ENV` enters the build's cache fingerprint via Vite's `getEnv('NODE_ENV')` call in `resolveConfig`. Same value → cache hit; different value → cache miss with `tracked env 'NODE_ENV' changed`.
 """
-# Unix-only for now: on Windows CI, interprocess 2.4 aborts the child
-# with "failed to start the persistent thread of the Interprocess linger
-# pool: Access is denied" when the Node addon tries to connect.
-platform = "unix"
 ignore = true
 steps = [
   { argv = [

crates/vite_task_bin/tests/e2e_snapshots/fixtures/vite_dev_disable_cache/snapshots.toml

@@ -3,10 +3,6 @@ name = "vite_dev_disables_cache"
 comment = """
 `vt run --cache dev` brings up a Vite dev server programmatically on an ephemeral port and closes it immediately. Vite's `_createServer` calls `disableCache()` via `@voidzero-dev/vite-task-client`, so this run is never stored — the next invocation re-executes (cache miss / NotFound).
 """
-# Unix-only for now: on Windows CI, interprocess 2.4 aborts the child
-# with "failed to start the persistent thread of the Interprocess linger
-# pool: Access is denied" when the Node addon tries to connect.
-platform = "unix"
 ignore = true
 steps = [
   { argv = [

crates/vite_task_client/src/lib.rs

@@ -16,6 +16,36 @@ pub struct Client {
     scratch: RefCell<Vec<u8>>,
 }
 
+/// Windows-only: flush pending writes through to the runner ourselves,
+/// then bypass `interprocess`'s named-pipe limbo so dropping the stream
+/// doesn't spawn its linger-pool thread.
+///
+/// Why: every send marks the pipe as "dirty" and `interprocess`'s `Drop`
+/// hands dirty pipes to a background thread that calls
+/// `FlushFileBuffers` for graceful close. That thread is created lazily,
+/// and on locked-down Windows runners (Node worker threads inside CI
+/// containers) the `CreateThread` from the napi finalizer can return
+/// ACCESS_DENIED. The crate panics on that path with `failed to start
+/// the persistent thread of the Interprocess linger pool`, killing the
+/// Node child.
+///
+/// `flush()` calls the real `FlushFileBuffers`, which blocks until the
+/// runner has read every byte we sent — this is what the linger pool
+/// would have done off-thread. `assume_flushed()` then clears the dirty
+/// flag so the inner `Drop` closes the handle directly instead of
+/// detouring through the linger pool. Together they preserve the
+/// protocol guarantee that fire-and-forget calls (`ignoreInput`,
+/// `ignoreOutput`, `disableCache`) reach the runner before the child
+/// exits.
+#[cfg(windows)]
+impl Drop for Client {
+    fn drop(&mut self) {
+        let interprocess::local_socket::Stream::NamedPipe(np_stream) = self.stream.get_mut();
+        let _ = np_stream.inner().flush();
+        np_stream.inner().assume_flushed();
+    }
+}
+
 impl Client {
     /// Scans `envs` for the runner's IPC connection info and connects if
     /// present. Typical callers pass `std::env::vars_os()`.