fix(test): align the shared tree-kill helper with @vxrn/test/setup

process-tree.ts now uses the same tree-kill strategy as killProcessTree in packages/test/src/setup.ts: execSync taskkill /F /T on Windows (deterministic, was fire-and-forget spawn) and an async group SIGTERM -> 200ms grace -> group SIGKILL on POSIX (was a detached 1000ms setTimeout). The helper is async so the dev-server suites await deterministic cleanup, and the 'mirrors setup.ts' doc comment is now accurate. Validated on Windows 11 and WSL (Linux node 24.3): tree-termination tests pass on both; typecheck, oxlint, oxfmt clean.

Author: YevheniiKotyrlo

tests/test/tests/metro-compiler.test.ts

@@ -32,9 +32,9 @@ const oneRunEntry = join(
 describe('Metro React compiler', { retry: 1 }, () => {
   let devServer: ChildProcess | null = null
 
-  afterEach(() => {
+  afterEach(async () => {
     if (devServer) {
-      killProcessTree(devServer.pid)
+      await killProcessTree(devServer.pid)
       devServer = null
     }
   })

tests/test/tests/metro-startup-order.test.ts

@@ -91,7 +91,7 @@ describe('Metro startup order', () => {
     })
 
     // Kill the server (tree-kill: taskkill /T on Windows, process-group on POSIX)
-    killProcessTree(devServer.pid)
+    await killProcessTree(devServer.pid)
     await new Promise((r) => setTimeout(r, 500))
 
     // Verify the order - Vite should be ready BEFORE Metro

tests/test/tests/process-cleanup.test.ts

@@ -39,13 +39,13 @@ describe('process cleanup', () => {
   let devServer: ChildProcess | null = null
   let wrapper: ChildProcess | null = null
 
-  afterEach(() => {
+  afterEach(async () => {
     // Clean up any leftover processes (tree-kill so dev-server workers don't orphan)
     if (devServer?.pid && isRunning(devServer.pid)) {
-      killProcessTree(devServer.pid)
+      await killProcessTree(devServer.pid)
     }
     if (wrapper?.pid && isRunning(wrapper.pid)) {
-      killProcessTree(wrapper.pid)
+      await killProcessTree(wrapper.pid)
     }
   })
 
@@ -132,7 +132,7 @@ describe('process cleanup', () => {
     expect(isRunning(devServer.pid!)).toBe(true)
 
     // Clean up (tree-kill so dev-server workers don't orphan)
-    killProcessTree(devServer.pid)
+    await killProcessTree(devServer.pid)
   }, 15000)
 })
 
@@ -221,7 +221,7 @@ describe('process tree termination', () => {
       expect(isRunning(server.pid!)).toBe(true)
       expect(isRunning(workerPid)).toBe(true)
 
-      killProcessTree(server.pid)
+      await killProcessTree(server.pid)
       await new Promise((r) => setTimeout(r, 2000))
 
       expect(isRunning(server.pid!)).toBe(false)
@@ -256,7 +256,7 @@ describe('process tree termination', () => {
       expect(isRunning(server.pid!)).toBe(true)
       expect(isRunning(workerPid)).toBe(true)
 
-      killProcessTree(server.pid)
+      await killProcessTree(server.pid)
       await new Promise((r) => setTimeout(r, 2000))
 
       expect(isRunning(server.pid!)).toBe(false)

tests/test/tests/process-tree.ts

@@ -1,10 +1,11 @@
-import { spawn } from 'node:child_process'
+import { execSync } from 'node:child_process'
 
 /**
  * Tree-kill a spawned dev server together with the worker processes it forked,
  * cross-platform. Shared by the spawn-based tests in this directory so they all
- * clean up the same (correct) way — mirrors `killProcessTree` in
- * packages/test/src/setup.ts.
+ * clean up the same way, using the same tree-kill strategy as `killProcessTree`
+ * in packages/test/src/setup.ts: on POSIX a graceful group SIGTERM, a brief
+ * grace period, then a group SIGKILL; on Windows `taskkill /F /T`.
  *
  * POSIX: signal the whole process group via the negative PID. This requires the
  * server to have been spawned with `detached: true` so it leads its own group;
@@ -18,20 +19,21 @@ import { spawn } from 'node:child_process'
  * `taskkill /F /T` walks the PID tree and ends those workers too. (Node has no
  * built-in tree-kill, so this one shell-out is unavoidable for a robust result.)
  */
-export function killProcessTree(pid: number | undefined): void {
+export async function killProcessTree(pid: number | undefined): Promise<void> {
   if (!pid) return
 
   if (process.platform === 'win32') {
     try {
-      spawn('taskkill', ['/F', '/T', '/PID', String(pid)], { stdio: 'ignore' })
+      execSync(`taskkill /F /T /PID ${pid}`, { stdio: 'ignore' })
     } catch {
       // process already gone — fine
     }
     return
   }
 
-  // POSIX: graceful group SIGTERM, then a group SIGKILL fallback. The inner
-  // fallbacks signal the single process when the pid is not a group leader.
+  // POSIX: graceful group SIGTERM, a brief grace period, then a group SIGKILL
+  // fallback. The inner fallbacks signal the single process when the pid is not
+  // a group leader.
   try {
     process.kill(-pid, 'SIGTERM')
   } catch {
@@ -41,15 +43,16 @@ export function killProcessTree(pid: number | undefined): void {
       // already gone
     }
   }
-  setTimeout(() => {
+
+  await new Promise((resolve) => setTimeout(resolve, 200))
+
+  try {
+    process.kill(-pid, 'SIGKILL')
+  } catch {
     try {
-      process.kill(-pid, 'SIGKILL')
+      process.kill(pid, 'SIGKILL')
     } catch {
-      try {
-        process.kill(pid, 'SIGKILL')
-      } catch {
-        // already gone
-      }
+      // already gone
     }
-  }, 1000)
+  }
 }