fix: CJS event loop pumping — track timers for _waitForActiveHandles

Timer callbacks (setTimeout/setInterval) use stream events, not pending
bridge promises, so the V8 event loop never entered for CJS scripts
with only timers. Fix: expose _getPendingTimerCount and _waitForTimerDrain
from the timer system, and have _waitForActiveHandles check for pending
timers in addition to active handles.

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

Author: NathanFlurry

packages/nodejs/src/bridge/active-handles.ts

@@ -75,35 +75,61 @@ export function _unregisterHandle(id: string): void {
 }
 
 /**
- * Wait for all active handles to complete.
- * Returns immediately if no handles are active.
+ * Wait for all active handles and pending timers to complete.
+ * Returns immediately if no handles are active and no timers are pending.
+ *
+ * Timers (setTimeout/setInterval) are tracked separately via _getPendingTimerCount
+ * and _waitForTimerDrain exposed from the process bridge module. This ensures CJS
+ * scripts that create timers don't exit before the timers fire.
  */
 export function _waitForActiveHandles(): Promise<void> {
-	if (_getActiveHandles().length === 0) {
+	const getPendingTimerCount = (globalThis as Record<string, unknown>)
+		._getPendingTimerCount as (() => number) | undefined;
+	const waitForTimerDrain = (globalThis as Record<string, unknown>)
+		._waitForTimerDrain as (() => Promise<void>) | undefined;
+
+	const hasHandles = _getActiveHandles().length > 0;
+	const hasTimers =
+		typeof getPendingTimerCount === "function" && getPendingTimerCount() > 0;
+
+	if (!hasHandles && !hasTimers) {
 		return Promise.resolve();
 	}
-	return new Promise((resolve) => {
-		let settled = false;
-		const complete = () => {
-			if (settled) {
-				return;
-			}
-			settled = true;
-			resolve();
-		};
-		_waitResolvers.push(complete);
-		const poll = () => {
-			if (settled) {
-				return;
-			}
-			if (_getActiveHandles().length === 0) {
-				complete();
-				return;
-			}
-			setTimeout(poll, 10);
-		};
-		setTimeout(poll, 10);
-	});
+
+	const promises: Promise<void>[] = [];
+
+	if (hasHandles) {
+		promises.push(
+			new Promise((resolve) => {
+				let settled = false;
+				const complete = () => {
+					if (settled) {
+						return;
+					}
+					settled = true;
+					resolve();
+				};
+				_waitResolvers.push(complete);
+				const poll = () => {
+					if (settled) {
+						return;
+					}
+					if (_getActiveHandles().length === 0) {
+						complete();
+						return;
+					}
+					setTimeout(poll, 10);
+				};
+				setTimeout(poll, 10);
+			}),
+		);
+	}
+
+	if (hasTimers && typeof waitForTimerDrain === "function") {
+		promises.push(waitForTimerDrain());
+	}
+
+	return Promise.all(promises).then(() => {});
 }
 
 /**

packages/nodejs/src/bridge/process.ts

@@ -1365,6 +1365,39 @@ class TimerHandle {
 }
 
 const _timerEntries = new Map<number, TimerEntry>();
+let _timerDrainResolvers: Array<() => void> = [];
+
+/**
+ * Check if all timers have been drained and resolve any waiters.
+ * Called after a timer fires or is cleared.
+ */
+function checkTimerDrain(): void {
+  if (_timerEntries.size === 0 && _timerDrainResolvers.length > 0) {
+    const resolvers = _timerDrainResolvers;
+    _timerDrainResolvers = [];
+    resolvers.forEach((r) => r());
+  }
+}
+
+/**
+ * Returns the number of pending timer entries (setTimeout + setInterval).
+ * Used by _waitForActiveHandles to detect pending async work.
+ */
+function _getPendingTimerCount(): number {
+  return _timerEntries.size;
+}
+
+/**
+ * Returns a Promise that resolves when all timer entries have been drained.
+ * If no timers are pending, resolves immediately.
+ */
+function _waitForTimerDrain(): Promise<void> {
+  if (_timerEntries.size === 0) return Promise.resolve();
+  return new Promise((resolve) => {
+    _timerDrainResolvers.push(resolve);
+  });
+}
+
 const _nextTickQueue: NextTickEntry[] = [];
 let _nextTickScheduled = false;
 
@@ -1426,6 +1459,8 @@ function timerDispatch(_eventType: string, payload: unknown): void {
   if (entry.repeat && _timerEntries.has(timerId)) {
     armKernelTimer(timerId);
   }
+
+  checkTimerDrain();
 }
 
 export function setTimeout(
@@ -1456,6 +1491,7 @@ export function clearTimeout(timer: TimerHandle | number | undefined): void {
     _timerEntries.delete(id);
   }
   bridgeDispatchSync<void>(TIMER_DISPATCH.clear, id);
+  checkTimerDrain();
 }
 
 export function setInterval(
@@ -1482,6 +1518,8 @@ export function clearInterval(timer: TimerHandle | number | undefined): void {
 }
 
 exposeCustomGlobal("_timerDispatch", timerDispatch);
+exposeCustomGlobal("_getPendingTimerCount", _getPendingTimerCount);
+exposeCustomGlobal("_waitForTimerDrain", _waitForTimerDrain);
 
 export function setImmediate(
   callback: (...args: unknown[]) => void,

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

@@ -686,4 +686,84 @@ describe('Node RuntimeDriver', () => {
       expect(uniquePids.size).toBe(12);
     });
   });
+
+  describe('CJS event loop pumping', () => {
+    let kernel: Kernel;
+
+    afterEach(async () => {
+      await kernel?.dispose();
+    });
+
+    it('setTimeout callback fires before CJS script exits', async () => {
+      const vfs = new SimpleVFS();
+      kernel = createKernel({ filesystem: vfs as any });
+      await kernel.mount(createNodeRuntime());
+
+      const chunks: Uint8Array[] = [];
+      const proc = kernel.spawn('node', ['-e', `
+        setTimeout(() => {
+          console.log("TIMER_FIRED");
+          process.exit(0);
+        }, 100);
+      `], {
+        onStdout: (data) => chunks.push(data),
+      });
+
+      const code = await proc.wait();
+      const output = chunks.map(c => new TextDecoder().decode(c)).join('');
+      expect(code).toBe(0);
+      expect(output).toContain('TIMER_FIRED');
+    });
+
+    it('async main with console.log produces output', async () => {
+      const vfs = new SimpleVFS();
+      kernel = createKernel({ filesystem: vfs as any });
+      await kernel.mount(createNodeRuntime());
+
+      const chunks: Uint8Array[] = [];
+      const proc = kernel.spawn('node', ['-e', `
+        async function main() {
+          console.log("ASYNC_HELLO");
+        }
+        main();
+      `], {
+        onStdout: (data) => chunks.push(data),
+      });
+
+      const code = await proc.wait();
+      const output = chunks.map(c => new TextDecoder().decode(c)).join('');
+      expect(code).toBe(0);
+      expect(output).toContain('ASYNC_HELLO');
+    });
+
+    it('chained setTimeout callbacks all execute', async () => {
+      const vfs = new SimpleVFS();
+      kernel = createKernel({ filesystem: vfs as any });
+      await kernel.mount(createNodeRuntime());
+
+      const chunks: Uint8Array[] = [];
+      const proc = kernel.spawn('node', ['-e', `
+        let count = 0;
+        function step() {
+          count++;
+          console.log("STEP:" + count);
+          if (count < 3) {
+            setTimeout(step, 50);
+          } else {
+            process.exit(0);
+          }
+        }
+        setTimeout(step, 50);
+      `], {
+        onStdout: (data) => chunks.push(data),
+      });
+
+      const code = await proc.wait();
+      const output = chunks.map(c => new TextDecoder().decode(c)).join('');
+      expect(code).toBe(0);
+      expect(output).toContain('STEP:1');
+      expect(output).toContain('STEP:2');
+      expect(output).toContain('STEP:3');
+    });
+  });
 });