fix: destroy V8 session on process kill to prevent dangling IPC socket

When a spawned process was killed, the V8 session's execute() promise
remained pending with its handler registered in sessionHandlers, keeping
the IPC socket ref'd and preventing Node.js from exiting.

Two fixes:
1. Track the current V8 session in NodeExecutionDriver and destroy it
   during terminate()/dispose() to unregister the session handler and
   unref the IPC socket.
2. Close streaming stdin source on process kill so pending reads resolve
   instead of hanging forever.

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

Author: NathanFlurry

packages/nodejs/src/execution-driver.ts

@@ -772,6 +772,8 @@ export class NodeExecutionDriver implements RuntimeDriver {
 	private configuredMaxTimers?: number;
 	private configuredMaxHandles?: number;
 	private pid?: number;
+	// Track the current V8 session so it can be destroyed on terminate/dispose
+	private _currentSession: V8Session | null = null;
 
 	constructor(options: NodeExecutionDriverOptions) {
 		this.memoryLimit = options.memoryLimit ?? 128;
@@ -1250,6 +1252,9 @@ export class NodeExecutionDriver implements RuntimeDriver {
 				bindingKeys,
 			);
 
+			// Track session so terminate/dispose can destroy it
+			this._currentSession = session;
+
 			// Execute in V8 session
 			const result = await session.execute({
 				bridgeCode,
@@ -1381,6 +1386,7 @@ export class NodeExecutionDriver implements RuntimeDriver {
 				exports: undefined as T,
 			};
 		} finally {
+			this._currentSession = null;
 			await session.destroy().catch(() => {});
 			this.finalizeExecutionState(finalExitCode);
 		}
@@ -1389,6 +1395,11 @@ export class NodeExecutionDriver implements RuntimeDriver {
 	dispose(): void {
 		if (this.disposed) return;
 		this.disposed = true;
+		// Destroy V8 session to unregister handler and unref IPC socket
+		if (this._currentSession) {
+			this._currentSession.destroy().catch(() => {});
+			this._currentSession = null;
+		}
 		killActiveChildProcesses(this.state);
 		clearActiveHostTimers(this.state);
 		if (this.pid !== undefined) {
@@ -1398,6 +1409,11 @@ export class NodeExecutionDriver implements RuntimeDriver {
 
 	async terminate(): Promise<void> {
 		if (this.disposed) return;
+		// Destroy V8 session to unregister handler and unref IPC socket
+		if (this._currentSession) {
+			await this._currentSession.destroy().catch(() => {});
+			this._currentSession = null;
+		}
 		killActiveChildProcesses(this.state);
 		const closers = Array.from(this.state.activeHttpServerClosers.values());
 		await Promise.allSettled(closers.map((close) => close()));

packages/nodejs/src/kernel-runtime.ts

@@ -565,6 +565,10 @@ class NodeRuntimeDriver implements RuntimeDriver {
         if (exitResolved) return;
         const normalizedSignal = signal > 0 ? signal : 15;
         killedSignal = normalizedSignal;
+        // Close streaming stdin so pending reads resolve
+        if (ctx.streamStdin) {
+          streamCloseStdin();
+        }
         const driver = this._activeDrivers.get(ctx.pid);
         if (!driver) {
           reportKilledExit(normalizedSignal);

packages/nodejs/test/kernel-runtime.test.ts

@@ -880,4 +880,60 @@ describe('Node RuntimeDriver', () => {
       expect(output).toContain('direct node script');
     });
   });
+
+  describe('dispose cleanup (no dangling handles)', () => {
+    it('kernel.dispose after killing a streamStdin process leaves no active handles', async () => {
+      const k = createKernel({ filesystem: new SimpleVFS() });
+      await k.mount(createNodeRuntime());
+
+      // Write a long-running stdin reader script
+      await k.writeFile('/tmp/reader.mjs', new TextEncoder().encode(
+        `process.stdin.setEncoding('utf8');\n` +
+        `process.stdin.on('data', (d) => process.stdout.write('GOT:' + d));\n`
+      ));
+
+      const chunks: Uint8Array[] = [];
+      const proc = k.spawn('node', ['/tmp/reader.mjs'], {
+        streamStdin: true,
+        onStdout: (data) => chunks.push(data),
+      });
+
+      // Send data and verify it's received
+      proc.writeStdin('hello\n');
+      await new Promise(r => setTimeout(r, 200));
+      const output = chunks.map(c => new TextDecoder().decode(c)).join('');
+      expect(output).toContain('GOT:hello');
+
+      // Kill the process
+      proc.kill();
+      const code = await proc.wait();
+      expect(code).toBe(143); // SIGTERM = 128 + 15
+
+      // Dispose the kernel — if the IPC socket is still ref'd, vitest hangs
+      await k.dispose();
+    }, 10_000);
+
+    it('kernel.dispose after killing a streamStdin process closes stdin source', async () => {
+      const k = createKernel({ filesystem: new SimpleVFS() });
+      await k.mount(createNodeRuntime());
+
+      // Write a script that blocks on stdin
+      await k.writeFile('/tmp/blocker.mjs', new TextEncoder().encode(
+        `process.stdin.resume();\n` +
+        `process.stdin.on('data', () => {});\n`
+      ));
+
+      const proc = k.spawn('node', ['/tmp/blocker.mjs'], {
+        streamStdin: true,
+      });
+
+      // Kill immediately — stdin source should be closed
+      proc.kill();
+      const code = await proc.wait();
+      expect(code).toBe(143);
+
+      await k.dispose();
+      // Test passes if it completes without hanging
+    }, 10_000);
+  });
 });