refactor: rename window_state to window and add Window struct

- Rename window_state.rs to window.rs
- Add Window struct that holds both WindowHandle<RootView> and WindowState
- Update global_state to use Window instead of WindowState directly
- Update all references in lib.rs, renderer.rs, host_command.rs

Author: fzdwx

multi-agent-research-system.md

@@ -16,7 +16,7 @@ rust/src/
 ├── renderer.rs         # RootView, render_element_to_gpui (div/text/span/img)
 ├── element.rs         # ReactElement, ElementStyle, ElementData structures
 ├── host_command.rs     # async_channel command bus (TriggerRender, UpdateElements)
-├── window_state.rs    # ElementTree, render_count, ROOT_ELEMENT_ID
+├── window.rs         # Window, WindowState, element tree management
 ├── global_state.rs     # Global state management (lazy_static)
 ├── ffi_types.rs       # FFI type bindings (serde)
 └── logging.rs         # Logging utilities (logforth)
@@ -30,7 +30,7 @@ rust/src/
 | FFI helpers        | ffi_helpers.rs  | ptr_to_u64, read_c_string, validate_result_ptr             |
 | GPUI rendering     | renderer.rs     | render_element_to_gpui (div/text/span/img)                 |
 | Command bus        | host_command.rs | init(cx), send_host_command(TriggerRender)                 |
-| Window state       | window_state.rs | update_element_tree(), render_count, ROOT_ELEMENT_ID       |
+| Window             | window.rs       | Window, WindowState, update_element_tree(), render_count   |
 | Element structures | element.rs      | ReactElement, ElementStyle, ChildElement                   |
 
 ## CONVENTIONS

rust/src/AGENTS.md

@@ -1,13 +1,13 @@
 use std::{collections::HashMap, sync::{Arc, RwLock, atomic::{AtomicBool, Ordering}}};
 
-use gpui::Global;
-
-use crate::window_state::WindowState;
+use gpui::{AnyWindowHandle, Global, WindowHandle};
+use crate::renderer::RootView;
+use crate::window::Window;
 
 pub struct GlobalState {
 	gpui_initialized:    AtomicBool,
 	gpui_thread_started: AtomicBool,
-	window_states:       RwLock<HashMap<u64, Arc<WindowState>>>,
+	windows:             RwLock<HashMap<u64, Arc<Window>>>,
 }
 
 impl Global for GlobalState {}
@@ -17,7 +17,7 @@ impl GlobalState {
 		Self {
 			gpui_initialized:    AtomicBool::new(false),
 			gpui_thread_started: AtomicBool::new(false),
-			window_states:       RwLock::new(HashMap::new()),
+			windows:             RwLock::new(HashMap::new()),
 		}
 	}
 
@@ -33,21 +33,27 @@ impl GlobalState {
 		self.gpui_thread_started.store(value, Ordering::SeqCst);
 	}
 
-	pub fn get_window_state(&self, window_id: u64) -> Arc<WindowState> {
-		let mut states =
-			self.window_states.write().expect("Failed to acquire window_states write lock");
-		states.entry(window_id).or_insert_with(|| Arc::new(WindowState::new())).clone()
+	/// Add a window with its GPUI handle
+	pub fn add_window(&self, handle: WindowHandle<RootView>) {
+		let window_id = handle.window_id().as_u64();
+		let mut windows = self.windows.write().expect("Failed to acquire windows write lock");
+		windows.insert(window_id, Arc::new(Window::new(handle)));
+	}
+
+	/// Get a window by ID, returns None if not found
+	pub fn get_window(&self, window_id: u64) -> Option<Arc<Window>> {
+		let windows = self.windows.read().expect("Failed to acquire windows read lock");
+		windows.get(&window_id).cloned()
 	}
 
-	pub fn get_window_state_ref(&self, window_id: u64) -> Option<Arc<WindowState>> {
-		let states = self.window_states.read().expect("Failed to acquire window_states read lock");
-		states.get(&window_id).cloned()
+	pub fn get_window_ref(&self, window_id: u64) -> Option<Arc<Window>> {
+		let windows = self.windows.read().expect("Failed to acquire windows read lock");
+		windows.get(&window_id).cloned()
 	}
 
-	pub fn remove_window_state(&self, window_id: u64) {
-		let mut states =
-			self.window_states.write().expect("Failed to acquire window_states write lock");
-		states.remove(&window_id);
+	pub fn remove_window(&self, window_id: u64) {
+		let mut windows = self.windows.write().expect("Failed to acquire windows write lock");
+		windows.remove(&window_id);
 	}
 }
 

rust/src/global_state.rs

@@ -116,28 +116,29 @@ pub fn handle_on_app_thread(command: HostCommand, app: &mut App) {
 			let window = app.open_window(window_options, |_window, cx| {
 				let state = cx.new(|_| crate::renderer::RootState { render_count: 0 });
 				cx.new(|_| crate::renderer::RootView { state, last_render: 0, window_id: 0 })
-			});
-			let real_window_id = window.as_ref().unwrap().window_id().as_u64();
+			}).unwrap();
+			let window_id = window.window_id().as_u64();
+			log::info!("Created window with id: {}", window_id);
 
-			log::info!("Created window with id: {}", real_window_id);
-
-			let handle = window.as_ref().unwrap();
-			handle
+			window
 				.update(app, |view: &mut crate::renderer::RootView, _, _| {
-					view.window_id = real_window_id;
+					view.window_id = window_id;
 				})
 				.ok();
+			// Store the window handle in our Window struct
+			GLOBAL_STATE.add_window(window);
 
-			let _ = GLOBAL_STATE.get_window_state(real_window_id);
-
-			let _ = response_tx.send(real_window_id);
+			let _ = response_tx.send(window_id);
 		}
 		HostCommand::TriggerRender { window_id } => {
-			if let Some(window) = app.windows().iter().find(|w| w.window_id() == window_id.into()) {
-				let window_state = GLOBAL_STATE.get_window_state(window_id);
-				window_state.increment_render_count();
-
-				if let Err(e) = window.update(app, |_, window, _cx| {
+			if let Some(gpui_window) = app.windows().iter().find(|w| w.window_id() == window_id.into()) {
+				let Some(window) = GLOBAL_STATE.get_window(window_id) else {
+					log::warn!("TriggerRender: window {} not found", window_id);
+					return;
+				};
+				window.state().increment_render_count();
+
+				if let Err(e) = gpui_window.update(app, |_, window, _cx| {
 					log::trace!("Calling window.refresh() for window {}", window_id);
 					window.refresh();
 				}) {

rust/src/host_command.rs

@@ -5,7 +5,7 @@ mod global_state;
 mod host_command;
 mod logging;
 mod renderer;
-mod window_state;
+mod window;
 
 use std::{ffi::{CStr, c_char}, sync::Arc};
 
@@ -115,7 +115,10 @@ pub extern "C" fn gpui_render_frame(
 			children
 		);
 
-		let window_state = GLOBAL_STATE.get_window_state(window_id);
+		let Some(window) = GLOBAL_STATE.get_window(window_id) else {
+			log::error!("gpui_render_frame: window {} not found", window_id);
+			return;
+		};
 
 		let element = Arc::new(ReactElement {
 			global_id,
@@ -126,7 +129,8 @@ pub extern "C" fn gpui_render_frame(
 			event_handlers: None,
 		});
 
-		let mut element_map = window_state
+		let mut element_map = window
+			.state()
 			.element_map
 			.lock()
 			.expect("Failed to acquire element_map lock in gpui_render_frame");
@@ -148,11 +152,11 @@ pub extern "C" fn gpui_render_frame(
 
 		drop(element_map);
 
-		window_state.set_root_element_id(global_id);
+		window.state().set_root_element_id(global_id);
 
-		window_state.rebuild_tree(global_id, &children);
+		window.state().rebuild_tree(global_id, &children);
 
-		window_state.update_element_tree();
+		window.state().update_element_tree();
 
 		send_host_command(HostCommand::TriggerRender { window_id });
 
@@ -166,8 +170,11 @@ pub extern "C" fn gpui_render_frame(
 pub extern "C" fn gpui_trigger_render(window_id_ptr: *const u8, _result: *mut FfiResult) {
 	unsafe {
 		let window_id = ptr_to_u64(window_id_ptr);
-		let window_state = GLOBAL_STATE.get_window_state(window_id);
-		window_state.increment_render_count();
+		let Some(window) = GLOBAL_STATE.get_window(window_id) else {
+			log::error!("gpui_render_frame: window {} not found", window_id);
+			return;
+		};
+		window.state().increment_render_count();
 		send_host_command(HostCommand::TriggerRender { window_id });
 	}
 }
@@ -197,9 +204,13 @@ pub extern "C" fn gpui_batch_update_elements(
 
 		log::info!("Batch update: Processing {} elements for window {}", count, window_id);
 
-		let window_state = GLOBAL_STATE.get_window_state(window_id);
+		let Some(window) = GLOBAL_STATE.get_window(window_id) else {
+			log::error!("gpui_render_frame: window {} not found", window_id);
+			return;
+		};
 
-		let mut element_map = window_state
+		let mut element_map = window
+			.state()
 			.element_map
 			.lock()
 			.expect("Failed to acquire element_map lock in gpui_batch_update_elements");
@@ -258,7 +269,7 @@ pub extern "C" fn gpui_batch_update_elements(
 		// window_state.update_element_tree();
 		send_host_command(HostCommand::TriggerRender { window_id });
 
-		let trigger = window_state.get_render_count();
+		let trigger = window.state().get_render_count();
 		log::debug!("Triggering render, current count: {}", trigger);
 
 		*result = FfiResult::success();

rust/src/lib.rs

@@ -14,8 +14,11 @@ pub struct RootView {
 
 impl RootView {
 	fn update_state(&mut self, cx: &mut Context<Self>) {
-		let window_state = GLOBAL_STATE.get_window_state(self.window_id);
-		let trigger = window_state.get_render_count();
+		let Some(window) = GLOBAL_STATE.get_window(self.window_id) else {
+			log::warn!("update_state: window {} not found", self.window_id);
+			return;
+		};
+		let trigger = window.state().get_render_count();
 		log::trace!(
 			"update_state: window_id={}, trigger={}, last_render={}",
 			self.window_id,
@@ -42,8 +45,12 @@ impl Render for RootView {
 		let render_start = std::time::Instant::now();
 		self.update_state(cx);
 
-		let window_state = GLOBAL_STATE.get_window_state(self.window_id);
-		let tree = window_state
+		let Some(window) = GLOBAL_STATE.get_window(self.window_id) else {
+			log::warn!("RootView.render: window {} not found", self.window_id);
+			return div().child("Window not found");
+		};
+		let tree = window
+			.state()
 			.element_tree
 			.lock()
 			.expect("Failed to acquire element_tree lock in RootView.render");

rust/src/renderer.rs

@@ -1,6 +1,9 @@
 use std::{collections::HashMap, sync::{Arc, Mutex, atomic::{AtomicU64, Ordering}}};
 
+use gpui::WindowHandle;
+
 use crate::element::ReactElement;
+use crate::renderer::RootView;
 
 pub struct WindowState {
 	pub root_element_id: AtomicU64,
@@ -89,3 +92,26 @@ impl WindowState {
 impl Default for WindowState {
 	fn default() -> Self { Self::new() }
 }
+
+pub struct Window {
+	/// The GPUI window handle
+	gpui_window: WindowHandle<RootView>,
+	/// The React element state for this window
+	state:        Arc<WindowState>,
+}
+
+impl Window {
+	/// Create a new window with the given GPUI handle
+	pub fn new(gpui_window: WindowHandle<RootView>) -> Self {
+		Self { gpui_window, state: Arc::new(WindowState::new()) }
+	}
+
+	/// Get a reference to the GPUI window handle
+	pub fn gpui_window(&self) -> &WindowHandle<RootView> { &self.gpui_window }
+
+	/// Get the window state
+	pub fn state(&self) -> &Arc<WindowState> { &self.state }
+
+	/// Get mutable access to the window state
+	pub fn state_mut(&mut self) -> &mut Arc<WindowState> { &mut self.state }
+}