fix: flush microtasks in event loop before blocking, add extensive stdin chain logging

Author: NathanFlurry

native/v8-runtime/src/execution.rs

@@ -930,9 +930,10 @@ pub fn execute_module(
         prefetch_module_imports(tc, bridge_ctx, module, resource_name_str);
 
         // Instantiate (calls resolve callback for each import — mostly cache hits now)
-        if module
-            .instantiate_module(tc, module_resolve_callback)
-            .is_none()
+        eprintln!("[v8-runtime] instantiating module...");
+        let inst_result = module.instantiate_module(tc, module_resolve_callback);
+        eprintln!("[v8-runtime] instantiate result: {:?}", inst_result.is_some());
+        if inst_result.is_none()
         {
             clear_module_state();
             return match tc.exception() {
@@ -945,7 +946,9 @@ pub fn execute_module(
         }
 
         // Evaluate
+        eprintln!("[v8-runtime] evaluating module...");
         let eval_result = module.evaluate(tc);
+        eprintln!("[v8-runtime] evaluate done: result={}", eval_result.is_some());
         if eval_result.is_none() {
             clear_module_state();
             return match tc.exception() {
@@ -1287,6 +1290,7 @@ fn resolve_or_compile_module<'s>(
     };
     let mut compiled = v8::script_compiler::Source::new(v8_source, Some(&origin));
     let module = v8::script_compiler::compile_module(scope, &mut compiled)?;
+    eprintln!("[v8-runtime] compiled OK: {}", &resolved_path);
 
     MODULE_RESOLVE_STATE.with(|cell| {
         if let Some(state) = cell.borrow_mut().as_mut() {

native/v8-runtime/src/session.rs

@@ -856,6 +856,21 @@ pub(crate) fn run_event_loop(
             }
         }
 
+        // Flush microtasks before blocking. This ensures that Promise
+        // continuations (e.g., main() returning from async module evaluation)
+        // run even when no bridge commands are pending.
+        scope.perform_microtask_checkpoint();
+
+        // Re-check exit conditions after microtask flush — the microtask may
+        // have resolved all pending promises or registered new handles.
+        if pending.len() == 0
+            && !execution::pending_module_evaluation_needs_wait(scope)
+            && !execution::pending_script_evaluation_needs_wait(scope)
+            && deferred.map(|dq| dq.lock().unwrap().is_empty()).unwrap_or(true)
+        {
+            break;
+        }
+
         // Receive next command, with optional abort monitoring
         let cmd = if let Some(abort) = abort_rx {
             crossbeam_channel::select! {

packages/nodejs/src/bridge-handlers.ts

@@ -3609,10 +3609,13 @@ export function buildKernelStdinDispatchHandlers(
 
 	handlers[K.kernelStdinRead] = async () => {
 			checkBridgeBudget(deps);
+			console.error(`[kernelStdinRead] hasLiveSource=${!!deps.liveStdinSource} reading...`);
 			if (!deps.liveStdinSource) {
+				console.error(`[kernelStdinRead] no source, returning done`);
 				return { done: true };
 			}
 			const chunk = await deps.liveStdinSource.read();
+			console.error(`[kernelStdinRead] got chunk: ${chunk ? chunk.length + ' bytes' : 'null'}`);
 			if (chunk === null || chunk.length === 0) {
 				return { done: true };
 			}

packages/nodejs/src/execution-driver.ts

@@ -1515,6 +1515,7 @@ function buildPostRestoreScript(
 	}
 
 	// Enable streaming stdin for non-TTY processes that need live stdin delivery
+	console.error(`[postRestore] streamStdin=${bridgeConfig.streamStdin} mode=${mode}`);
 	if (bridgeConfig.streamStdin) {
 		parts.push(`globalThis.__runtimeStreamStdin = true;`);
 	}

packages/nodejs/src/kernel-runtime.ts

@@ -506,6 +506,7 @@ class NodeRuntimeDriver implements RuntimeDriver {
     let batchStdinResolve: ((data: string | undefined) => void) | null = null;
     let batchStdinPromise: Promise<string | undefined> | undefined;
 
+    console.error(`[kernel-runtime] pid=${ctx.pid} streamStdin=${ctx.streamStdin} command=${command}`);
     if (ctx.streamStdin) {
       // Streaming mode: writeStdin delivers data to the running process immediately
       const stdinQueue: Uint8Array[] = [];