chore: US-028 V8 event loop infrastructure for Pi interactive TUI

V8 sidecar improvements for interactive TUI support:
- sync_call call_id matching to handle interleaved async responses
- ResponseReceiver::defer() for non-matching BridgeResponse routing
- MODULE_RESOLVE_STATE persists through event loop for dynamic import
- V8 crate upgraded to v134 (from v130)
- Improved error reporting with stderr in IPC close messages

Pi interactive TUI still blocked by V8 microtask checkpoint hang
(perform_microtask_checkpoint blocks on TUI render cycles).

Author: NathanFlurry

native/v8-runtime/Cargo.lock

@@ -10,7 +10,7 @@ name = "secure-exec-v8"
 path = "src/main.rs"
 
 [dependencies]
-v8 = "130"
+v8 = "134"
 crossbeam-channel = "0.5"
 signal-hook = "0.3"
 libc = "0.2"

native/v8-runtime/Cargo.toml

@@ -528,8 +528,7 @@ pub fn resolve_pending_promise(
         resolver.resolve(scope, undef.into());
     }
 
-    // Flush microtasks after resolution
-    scope.perform_microtask_checkpoint();
+    // Microtask checkpoint is the caller's responsibility (explicit policy).
 
     Ok(())
 }

native/v8-runtime/src/bridge.rs

@@ -378,6 +378,7 @@ pub fn execute_script(
                 None => (1, None),
             };
         }
+
     }
 
     if bridge_ctx.is_some() {
@@ -562,12 +563,12 @@ fn build_os_config<'s>(
 
 /// Thread-local state for module resolution during execute_module.
 /// Avoids passing user data through V8's ResolveModuleCallback (which is a plain fn pointer).
-struct ModuleResolveState {
-    bridge_ctx: *const BridgeCallContext,
+pub(crate) struct ModuleResolveState {
+    pub(crate) bridge_ctx: *const BridgeCallContext,
     /// identity_hash → resource_name for referrer lookup
-    module_names: HashMap<NonZeroI32, String>,
+    pub(crate) module_names: HashMap<NonZeroI32, String>,
     /// resolved_path → Global<Module> cache
-    module_cache: HashMap<String, v8::Global<v8::Module>>,
+    pub(crate) module_cache: HashMap<String, v8::Global<v8::Module>>,
 }
 
 // SAFETY: ModuleResolveState is only accessed from the session thread
@@ -576,7 +577,7 @@ struct ModuleResolveState {
 unsafe impl Send for ModuleResolveState {}
 
 thread_local! {
-    static MODULE_RESOLVE_STATE: RefCell<Option<ModuleResolveState>> = const { RefCell::new(None) };
+    pub(crate) static MODULE_RESOLVE_STATE: RefCell<Option<ModuleResolveState>> = const { RefCell::new(None) };
 }
 
 fn clear_module_state() {

native/v8-runtime/src/execution.rs

@@ -62,6 +62,9 @@ impl FrameSender for WriterFrameSender {
 /// Production code uses a channel-based implementation; tests use a buffer-based one.
 pub trait ResponseReceiver: Send {
     fn recv_response(&self) -> Result<BinaryFrame, String>;
+    /// Defer a frame for later processing (used when sync_call receives
+    /// a BridgeResponse for a different call_id).
+    fn defer(&self, frame: BinaryFrame);
 }
 
 /// ResponseReceiver that reads frames from a byte buffer via ipc_binary::read_frame.
@@ -81,6 +84,10 @@ impl ReaderResponseReceiver {
 }
 
 impl ResponseReceiver for ReaderResponseReceiver {
+    fn defer(&self, _frame: BinaryFrame) {
+        // Test-only receiver — deferred frames are dropped
+    }
+
     fn recv_response(&self) -> Result<BinaryFrame, String> {
         let mut reader = self.reader.lock().unwrap();
         ipc_binary::read_frame(&mut *reader)
@@ -132,6 +139,10 @@ impl FrameSender for StubFrameSender {
 struct StubResponseReceiver;
 
 impl ResponseReceiver for StubResponseReceiver {
+    fn defer(&self, _frame: BinaryFrame) {
+        panic!("stub bridge function called during snapshot creation")
+    }
+
     fn recv_response(&self) -> Result<BinaryFrame, String> {
         panic!("stub bridge function called during snapshot creation — bridge IIFE must not call bridge functions at setup time")
     }
@@ -227,35 +238,42 @@ impl BridgeCallContext {
             return Err(format!("failed to write BridgeCall: {}", e));
         }
 
-        // Receive BridgeResponse directly (no re-serialization)
+        // Receive BridgeResponse matching our call_id.
+        // Non-matching BridgeResponses (from async bridge calls like timers)
+        // are deferred for later processing by the event loop.
         let response = {
             let rx = self.response_rx.lock().unwrap();
-            match rx.recv_response() {
-                Ok(frame) => frame,
-                Err(e) => {
-                    self.pending_calls.lock().unwrap().remove(&call_id);
-                    return Err(e);
+            loop {
+                match rx.recv_response() {
+                    Ok(frame) => {
+                        match &frame {
+                            BinaryFrame::BridgeResponse { call_id: resp_id, .. } if *resp_id == call_id => {
+                                break frame;
+                            }
+                            _ => {
+                                // Non-matching response — defer for event loop
+                                rx.defer(frame);
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        self.pending_calls.lock().unwrap().remove(&call_id);
+                        return Err(e);
+                    }
                 }
             }
         };
 
         // Remove from pending
         self.pending_calls.lock().unwrap().remove(&call_id);
 
-        // Validate and extract BridgeResponse
+        // Extract BridgeResponse
         match response {
             BinaryFrame::BridgeResponse {
-                call_id: resp_id,
                 status,
                 payload,
                 ..
             } => {
-                if resp_id != call_id {
-                    return Err(format!(
-                        "call_id mismatch: expected {}, got {}",
-                        call_id, resp_id
-                    ));
-                }
                 if status == 1 {
                     // Error: payload is UTF-8 error message
                     Err(String::from_utf8_lossy(&payload).to_string())
@@ -266,7 +284,7 @@ impl BridgeCallContext {
                     Ok(Some(payload))
                 }
             }
-            _ => Err("expected BridgeResponse, got different message type".into()),
+            _ => unreachable!("loop only breaks on BridgeResponse"),
         }
     }
 

native/v8-runtime/src/host_call.rs

@@ -511,18 +511,33 @@ fn session_thread(
                             )
                         };
 
+                        // Re-initialize module resolve state for the event loop.
+                        // execute_script/execute_module clear MODULE_RESOLVE_STATE
+                        // on return, but dynamic import() calls during the event loop
+                        // (e.g. from timer callbacks) need it to resolve modules.
+                        execution::MODULE_RESOLVE_STATE.with(|cell| {
+                            if cell.borrow().is_none() {
+                                *cell.borrow_mut() = Some(execution::ModuleResolveState {
+                                    bridge_ctx: &bridge_ctx as *const _,
+                                    module_names: std::collections::HashMap::new(),
+                                    module_cache: std::collections::HashMap::new(),
+                                });
+                            }
+                        });
+
                         // Run event loop if there are pending async promises
                         let mut terminated = if pending.len() > 0 {
                             let scope = &mut v8::HandleScope::new(iso);
                             let ctx = v8::Local::new(scope, &exec_context);
                             let scope = &mut v8::ContextScope::new(scope, ctx);
-                            !run_event_loop(
+                            let result = run_event_loop(
                                 scope,
                                 &rx,
                                 &pending,
                                 maybe_abort_rx.as_ref(),
                                 Some(&deferred_queue),
-                            )
+                            );
+                            !result
                         } else {
                             false
                         };
@@ -560,6 +575,11 @@ fn session_thread(
                             }
                         }
 
+                        // Clear module resolve state after event loop completes
+                        execution::MODULE_RESOLVE_STATE.with(|cell| {
+                            *cell.borrow_mut() = None;
+                        });
+
                         // Check if timeout fired
                         let timed_out = timeout_guard.as_ref().is_some_and(|g| g.timed_out());
 
@@ -737,7 +757,6 @@ pub(crate) fn run_event_loop(
                     Err(_) => return false,
                 },
                 recv(abort) -> _ => {
-                    // Timeout fired — abort channel closed
                     scope.terminate_execution();
                     return false;
                 },
@@ -778,13 +797,13 @@ fn dispatch_event_loop_frame(
             let (result, error) = if status == 1 {
                 (None, Some(String::from_utf8_lossy(&payload).to_string()))
             } else if !payload.is_empty() {
-                // status=0: V8-serialized, status=2: raw binary (Uint8Array)
+                // V8-serialized or raw binary
                 (Some(payload), None)
             } else {
                 (None, None)
             };
             let _ = crate::bridge::resolve_pending_promise(scope, pending, call_id, result, error);
-            // Microtasks already flushed in resolve_pending_promise
+            scope.perform_microtask_checkpoint();
             true
         }
         BinaryFrame::StreamEvent {
@@ -846,6 +865,10 @@ impl ChannelResponseReceiver {
 }
 
 impl crate::host_call::ResponseReceiver for ChannelResponseReceiver {
+    fn defer(&self, frame: BinaryFrame) {
+        self.deferred.lock().unwrap().push_back(frame);
+    }
+
     fn recv_response(&self) -> Result<BinaryFrame, String> {
         loop {
             // Wait for next command, with optional abort monitoring

native/v8-runtime/src/session.rs

@@ -120,13 +120,14 @@ export async function createV8Runtime(
 
 	child.on("exit", (code, signal) => {
 		processAlive = false;
+		const stderrSuffix = stderrBuf ? `\nstderr: ${stderrBuf}` : "";
 		if (code !== 0 && code !== null) {
 			exitError = new Error(
-				`V8 runtime process exited with code ${code}`,
+				`V8 runtime process exited with code ${code}${stderrSuffix}`,
 			);
 		} else if (signal) {
 			exitError = new Error(
-				`V8 runtime process killed by signal ${signal}`,
+				`V8 runtime process killed by signal ${signal}${stderrSuffix}`,
 			);
 		}
 
@@ -184,8 +185,9 @@ export async function createV8Runtime(
 			// Reject all pending executions — the Rust process may have
 			// deadlocked without exiting, so we can't rely on the 'exit'
 			// event alone.
+			const stderrInfo = stderrBuf ? `\nstderr: ${stderrBuf}` : "";
 			rejectPendingSessions(
-				new Error("IPC connection closed"),
+				new Error(`IPC connection closed${stderrInfo}`),
 			);
 		},
 		onError: (err) => {