fix: microtask loop flush, extensive IPC tracing. PI eval completes but main() stuck - pending bridge promise blocks.

Author: NathanFlurry

native/v8-runtime/src/execution.rs

@@ -946,9 +946,10 @@ pub fn execute_module(
         }
 
         // Evaluate
-        eprintln!("[v8-runtime] evaluating module...");
+        let eval_start = std::time::Instant::now();
+        eprintln!("[v8-runtime] evaluating module (resource={})...", resource_name_str);
         let eval_result = module.evaluate(tc);
-        eprintln!("[v8-runtime] evaluate done: result={}", eval_result.is_some());
+        eprintln!("[v8-runtime] evaluate done: result={} elapsed={}ms", eval_result.is_some(), eval_start.elapsed().as_millis());
         if eval_result.is_none() {
             clear_module_state();
             return match tc.exception() {

native/v8-runtime/src/session.rs

@@ -856,10 +856,18 @@ 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();
+        // Flush microtasks before blocking. Run in a loop to drain the full
+        // microtask queue -- each checkpoint may resolve Promises that schedule
+        // new microtasks (e.g., async function await chains).
+        for _ in 0..100 {
+            scope.perform_microtask_checkpoint();
+            // Check if new deferred work appeared from microtask processing
+            if let Some(dq) = deferred {
+                if !dq.lock().unwrap().is_empty() {
+                    break; // New bridge work to process
+                }
+            }
+        }
 
         // Re-check exit conditions after microtask flush — the microtask may
         // have resolved all pending promises or registered new handles.

packages/nodejs/src/bridge-handlers.ts

@@ -3443,8 +3443,11 @@ export function buildModuleLoadingBridgeHandlers(
 		}
 
 		// Regular files load differently for CommonJS require() vs V8's ESM loader.
+		console.error(`[loadFile-async] falling to async path for: ${p.slice(-60)}`);
 		return (async () => {
+			console.error(`[loadFile-async] loading from VFS: ${p.slice(-60)}`);
 			const source = await loadFile(p, deps.filesystem);
+			console.error(`[loadFile-async] VFS result: ${source ? source.length + ' bytes' : 'null'}`);
 			if (source === null) return null;
 			if (loadMode === "require") {
 				return transformSourceForRequire(source, p);

packages/nodejs/src/module-access.ts

@@ -476,6 +476,7 @@ export class ModuleAccessFileSystem implements VirtualFileSystem {
 				!this.hostNodeModulesRoot ||
 				!this.isWithinAllowedOverlayRoots(canonical)
 			) {
+				console.error(`[module-access] OUT_OF_SCOPE: virtualPath=${virtualPath} canonical=${canonical} allowedRoots=${this.overlayAllowedRoots.length} first3=${this.overlayAllowedRoots.slice(0,3).join(', ')}`);
 				throw createModuleAccessError(
 					MODULE_ACCESS_OUT_OF_SCOPE,
 					`resolved path for '${virtualPath}' escapes allowed overlay roots`,