add table3

client/src/modes/handlers/event.rs

@@ -332,6 +332,52 @@ impl EventHandler {
                     if !outcome.get_message_if_ok().is_empty() {
                         return Ok(outcome);
                     }
+                } else if let Page::AddLogic(add_logic_page) = &mut router.current {
+                    // Allow ":" (enter_command_mode) even when inside AddLogic canvas
+                    if let Some(action) =
+                        config.get_general_action(key_event.code, key_event.modifiers)
+                    {
+                        if action == "enter_command_mode"
+                            && !self.command_mode
+                                && !app_state.ui.show_search_palette
+                                && !self.navigation_state.active
+                        {
+                            self.command_mode = true;
+                            self.command_input.clear();
+                            self.command_message.clear();
+                            self.key_sequence_tracker.reset();
+                            app_state.ui.focus_outside_canvas = true;
+                            return Ok(EventOutcome::Ok(String::new()));
+                        }
+                    }
+                    let movement_action_early = if let Some(act) =
+                        config.get_general_action(key_event.code, key_event.modifiers)
+                    {
+                        match act {
+                            "up" => Some(MovementAction::Up),
+                            "down" => Some(MovementAction::Down),
+                            "left" => Some(MovementAction::Left),
+                            "right" => Some(MovementAction::Right),
+                            "next" => Some(MovementAction::Next),
+                            "previous" => Some(MovementAction::Previous),
+                            "select" => Some(MovementAction::Select),
+                            "esc" => Some(MovementAction::Esc),
+                            _ => None,
+                        }
+                    } else { None };
+
+                    let outcome = add_logic::event::handle_add_logic_event(
+                        key_event,
+                        movement_action_early,
+                        config,
+                        app_state,
+                        add_logic_page,
+                        self.grpc_client.clone(),
+                        self.save_logic_result_sender.clone(),
+                    )?;
+                    if !outcome.get_message_if_ok().is_empty() {
+                        return Ok(outcome);
+                    }
                 } else if let Page::Admin(admin_state) = &mut router.current {
                     if matches!(auth_state.role, Some(UserRole::Admin)) {
                         if let Event::Key(key_event) = event {
@@ -339,8 +385,8 @@ impl EventHandler {
                                 key_event,
                                 config,
                                 app_state,
-                                admin_state,
                                 buffer_state,
+                                router,
                                 &mut self.command_message,
                             )? {
                                 return Ok(EventOutcome::Ok(self.command_message.clone()));
@@ -432,6 +478,22 @@ impl EventHandler {
                             }
                         }
                     }
+                    // Allow ":" / ctrl+; to enter command mode only when outside canvas.
+                    if action == "enter_command_mode" {
+                        if app_state.ui.focus_outside_canvas
+                            && !self.command_mode
+                                && !app_state.ui.show_search_palette
+                                && !self.navigation_state.active
+                        {
+                            self.command_mode = true;
+                            self.command_input.clear();
+                            self.command_message.clear();
+                            self.key_sequence_tracker.reset();
+                            // Keep focus outside so canvas won't receive keys
+                            app_state.ui.focus_outside_canvas = true;
+                            return Ok(EventOutcome::Ok(String::new()));
+                        }
+                    }
                 }
             }
 
@@ -460,22 +522,6 @@ impl EventHandler {
                     // Let the current page handle decoupled movement first
                     if let Some(ma) = movement_action {
                         match &mut router.current {
-                            // LOGIN: From buttons (general) back into the canvas with 'k' (Up),
-                            // but ONLY from the left-most "Login" button.
-                            Page::AddTable(state) => {
-                                if state.handle_movement(ma) {
-                                    // Keep UI focus consistent with inputs vs. outer elements
-                                    use crate::pages::admin_panel::add_table::state::AddTableFocus;
-                                    let is_canvas_input = matches!(
-                                        state.current_focus,
-                                        AddTableFocus::InputTableName
-                                        | AddTableFocus::InputColumnName
-                                        | AddTableFocus::InputColumnType
-                                    );
-                                    app_state.ui.focus_outside_canvas = !is_canvas_input;
-                                    return Ok(EventOutcome::Ok(String::new()));
-                                }
-                            }
                             Page::Intro(state) => {
                                 if state.handle_movement(ma) {
                                     return Ok(EventOutcome::Ok(String::new()));
@@ -485,39 +531,20 @@ impl EventHandler {
                         }
                     }
 
-                    // Optional page-specific handlers (non-movement or rich actions)
-                    let client_clone = self.grpc_client.clone();
-                    let sender_clone = self.save_logic_result_sender.clone();
-                    if add_logic::nav::handle_add_logic_navigation(
-                        key_event,
-                        config,
-                        app_state,
-                        buffer_state,
-                        client_clone,
-                        sender_clone,
-                        &mut self.command_message,
-                        router,
-                    ) {
-                        return Ok(EventOutcome::Ok(
-                            self.command_message.clone(),
-                        ));
-                    }
-
                     if let Page::AddTable(add_table_state) = &mut router.current {
                         let client_clone = self.grpc_client.clone();
                         let sender_clone = self.save_table_result_sender.clone();
-                        if add_table::nav::handle_add_table_navigation(
+                        let outcome = crate::pages::admin_panel::add_table::event::handle_add_table_event(
                             key_event,
+                            movement_action,
                             config,
                             app_state,
                             add_table_state,
                             client_clone,
                             sender_clone,
-                            &mut self.command_message,
-                        ) {
-                            return Ok(EventOutcome::Ok(
-                                self.command_message.clone(),
-                            ));
+                        )?;
+                        if !outcome.get_message_if_ok().is_empty() {
+                            return Ok(outcome);
                         }
                     }
 

client/src/pages/admin/admin/event.rs

@@ -4,9 +4,9 @@ use crossterm::event::KeyEvent;
 
 use crate::buffer::state::BufferState;
 use crate::config::binds::config::Config;
-use crate::pages::admin::AdminState;
 use crate::pages::admin::main::logic::handle_admin_navigation;
 use crate::state::app::state::AppState;
+use crate::pages::routing::{Router, Page};
 
 /// Handle all Admin page-specific key events (movement + actions).
 /// Returns true if the key was handled (so the caller should stop propagation).
@@ -14,46 +14,51 @@ pub fn handle_admin_event(
     key_event: KeyEvent,
     config: &Config,
     app_state: &mut AppState,
-    admin_state: &mut AdminState,
     buffer_state: &mut BufferState,
+    router: &mut Router,
     command_message: &mut String,
 ) -> Result<bool> {
-    // 1) Map general action to MovementAction (same mapping used in event.rs)
-    let movement_action = if let Some(act) =
-        config.get_general_action(key_event.code, key_event.modifiers)
-    {
-        use crate::movement::MovementAction;
-        match act {
-            "up" => Some(MovementAction::Up),
-            "down" => Some(MovementAction::Down),
-            "left" => Some(MovementAction::Left),
-            "right" => Some(MovementAction::Right),
-            "next" => Some(MovementAction::Next),
-            "previous" => Some(MovementAction::Previous),
-            "select" => Some(MovementAction::Select),
-            "esc" => Some(MovementAction::Esc),
-            _ => None,
-        }
-    } else {
-        None
-    };
+    if let Page::Admin(admin_state) = &mut router.current {
+        // 1) Map general action to MovementAction (same mapping used in event.rs)
+        let movement_action = if let Some(act) =
+            config.get_general_action(key_event.code, key_event.modifiers)
+        {
+            use crate::movement::MovementAction;
+            match act {
+                "up" => Some(MovementAction::Up),
+                "down" => Some(MovementAction::Down),
+                "left" => Some(MovementAction::Left),
+                "right" => Some(MovementAction::Right),
+                "next" => Some(MovementAction::Next),
+                "previous" => Some(MovementAction::Previous),
+                "select" => Some(MovementAction::Select),
+                "esc" => Some(MovementAction::Esc),
+                _ => None,
+            }
+        } else {
+            None
+        };
 
-    if let Some(ma) = movement_action {
-        if admin_state.handle_movement(app_state, ma) {
+        if let Some(ma) = movement_action {
+            if admin_state.handle_movement(app_state, ma) {
+                return Ok(true);
+            }
+        }
+
+        // 2) Rich Admin navigation (buttons, selections, etc.)
+        if handle_admin_navigation(
+            key_event,
+            config,
+            app_state,
+            buffer_state,
+            router,
+            command_message,
+        ) {
             return Ok(true);
         }
-    }
 
-    // 2) Rich Admin navigation (buttons, selections, etc.)
-    if handle_admin_navigation(
-        key_event,
-        config,
-        app_state,
-        admin_state,
-        buffer_state,
-        command_message,
-    ) {
-        return Ok(true);
+        // If we reached here, nothing was handled
+        return Ok(false);
     }
 
     Ok(false)

client/src/pages/admin/admin/state.rs

@@ -1,7 +1,6 @@
 // src/pages/admin/admin/state.rs
 use ratatui::widgets::ListState;
 use crate::pages::admin_panel::add_table::state::AddTableState;
-use crate::pages::admin_panel::add_logic::state::AddLogicState;
 use crate::movement::{move_focus, MovementAction};
 use crate::state::app::state::AppState;
 
@@ -28,7 +27,6 @@ pub struct AdminState {
     pub selected_table_index: Option<usize>,
     pub current_focus: AdminFocus,
     pub add_table_state: AddTableState,
-    pub add_logic_state: AddLogicState,
 }
 
 impl AdminState {

client/src/pages/admin/main/logic.rs

@@ -5,7 +5,8 @@ use crate::config::binds::config::Config;
 use crate::buffer::state::{BufferState, AppView};
 use crate::pages::admin_panel::add_table::state::{AddTableState, LinkDefinition};
 use ratatui::widgets::ListState;
-use crate::pages::admin_panel::add_logic::state::{AddLogicState, AddLogicFocus};
+use crate::pages::admin_panel::add_logic::state::{AddLogicState, AddLogicFocus, AddLogicFormState};
+use crate::pages::routing::{Page, Router};
 
 // Helper functions list_select_next and list_select_previous remain the same
 fn list_select_next(list_state: &mut ListState, item_count: usize) {
@@ -36,11 +37,15 @@ pub fn handle_admin_navigation(
     key: crossterm::event::KeyEvent,
     config: &Config,
     app_state: &mut AppState,
-    admin_state: &mut AdminState,
     buffer_state: &mut BufferState,
+    router: &mut Router,
     command_message: &mut String,
 ) -> bool {
     let action = config.get_general_action(key.code, key.modifiers).map(String::from);
+
+    let Page::Admin(admin_state) = &mut router.current else {
+        return false;
+    };
     let current_focus = admin_state.current_focus;
     let profile_count = app_state.profile_tree.profiles.len();
     let mut handled = false;
@@ -230,20 +235,20 @@ pub fn handle_admin_navigation(
                         if let Some(profile) = app_state.profile_tree.profiles.get(p_idx) {
                             if let Some(t_idx) = admin_state.selected_table_index {
                                 if let Some(table) = profile.tables.get(t_idx) {
-                                    // Both profile and table are selected, proceed
-                                    admin_state.add_logic_state = AddLogicState {
-                                        profile_name: profile.name.clone(),
-                                        selected_table_name: Some(table.name.clone()),
-                                        selected_table_id: Some(table.id), // If you have table IDs
-                                        editor_keybinding_mode: config.editor.keybinding_mode.clone(),
-                                        current_focus: AddLogicFocus::default(),
-                                        ..AddLogicState::default()
-                                    };
-                                    
+                                    // Create AddLogic page with selected profile & table
+                                    let add_logic_form = AddLogicFormState::new_with_table(
+                                        &config.editor,
+                                        profile.name.clone(),
+                                        Some(table.id),
+                                        table.name.clone(),
+                                    );
+
+                                    // Route to AddLogic
+                                    router.current = Page::AddLogic(add_logic_form);                                    
                                     // Store table info for later fetching
                                     app_state.pending_table_structure_fetch = Some((
                                         profile.name.clone(),
-                                        table.name.clone()
+                                        table.name.clone(),
                                     ));
                                     
                                     buffer_state.update_history(AppView::AddLogic);

client/src/pages/admin_panel/add_logic/event.rs

@@ -0,0 +1,159 @@
+// src/pages/admin_panel/add_logic/event.rs
+
+use anyhow::Result;
+use crate::config::binds::config::Config;
+use crate::movement::{move_focus, MovementAction};
+use crate::pages::admin_panel::add_logic::nav::SaveLogicResultSender;
+use crate::pages::admin_panel::add_logic::state::{AddLogicFocus, AddLogicFormState};
+use crate::components::common::text_editor::TextEditor;
+use crate::services::grpc_client::GrpcClient;
+use crate::state::app::state::AppState;
+use crate::modes::handlers::event::EventOutcome;
+use canvas::{AppMode as CanvasMode, DataProvider};
+use crossterm::event::KeyEvent;
+
+/// Focus traversal order for non-canvas navigation
+const ADD_LOGIC_FOCUS_ORDER: [AddLogicFocus; 6] = [
+    AddLogicFocus::InputLogicName,
+    AddLogicFocus::InputTargetColumn,
+    AddLogicFocus::InputDescription,
+    AddLogicFocus::ScriptContentPreview,
+    AddLogicFocus::SaveButton,
+    AddLogicFocus::CancelButton,
+];
+
+/// Handles all AddLogic page-specific events.
+/// Return a non-empty Ok(message) only when the page actually consumed the key,
+/// otherwise return Ok("") to let global handling proceed.
+pub fn handle_add_logic_event(
+    key_event: KeyEvent,
+    movement: Option<MovementAction>,
+    config: &Config,
+    app_state: &mut AppState,
+    add_logic_page: &mut AddLogicFormState,
+    grpc_client: GrpcClient,
+    save_logic_sender: SaveLogicResultSender,
+) -> Result<EventOutcome> {
+    // 1) Script editor fullscreen mode
+    if add_logic_page.state.current_focus == AddLogicFocus::InsideScriptContent {
+        match key_event.code {
+            crossterm::event::KeyCode::Esc => {
+                add_logic_page.state.current_focus = AddLogicFocus::ScriptContentPreview;
+                app_state.ui.focus_outside_canvas = true;
+                return Ok(EventOutcome::Ok("Exited script editing.".to_string()));
+            }
+            _ => {
+                let changed = {
+                    let mut editor_borrow =
+                        add_logic_page.state.script_content_editor.borrow_mut();
+                    TextEditor::handle_input(
+                        &mut editor_borrow,
+                        key_event,
+                        &add_logic_page.state.editor_keybinding_mode,
+                        &mut add_logic_page.state.vim_state,
+                    )
+                };
+                if changed {
+                    add_logic_page.state.has_unsaved_changes = true;
+                    return Ok(EventOutcome::Ok("Script updated".to_string()));
+                }
+                return Ok(EventOutcome::Ok(String::new()));
+            }
+        }
+    }
+
+    // 2) Inside canvas: forward to FormEditor
+    let inside_canvas_inputs = matches!(
+        add_logic_page.state.current_focus,
+        AddLogicFocus::InputLogicName
+            | AddLogicFocus::InputTargetColumn
+            | AddLogicFocus::InputDescription
+    );
+
+    if inside_canvas_inputs {
+        // Only allow leaving the canvas with Down/Next when the form editor
+        // is in ReadOnly mode. In Edit mode, keep focus inside the canvas.
+        let in_edit_mode = add_logic_page.editor.mode() == CanvasMode::Edit;
+        if !in_edit_mode {
+            if let Some(ma) = movement {
+                let last_idx = add_logic_page
+                    .editor
+                    .data_provider()
+                    .field_count()
+                    .saturating_sub(1);
+                let at_last = add_logic_page.editor.current_field() >= last_idx;
+                if at_last && matches!(ma, MovementAction::Down | MovementAction::Next) {
+                    add_logic_page.state.last_canvas_field = last_idx;
+                    add_logic_page.state.current_focus = AddLogicFocus::ScriptContentPreview;
+                    app_state.ui.focus_outside_canvas = true;
+                    return Ok(EventOutcome::Ok("Moved to Script Preview".to_string()));
+                }
+            }
+        }
+
+        match add_logic_page.handle_key_event(key_event) {
+            canvas::keymap::KeyEventOutcome::Consumed(Some(msg)) => {
+                add_logic_page.sync_from_editor();
+                return Ok(EventOutcome::Ok(msg));
+            }
+            canvas::keymap::KeyEventOutcome::Consumed(None) => {
+                add_logic_page.sync_from_editor();
+                return Ok(EventOutcome::Ok("Input updated".into()));
+            }
+            canvas::keymap::KeyEventOutcome::Pending => {
+                return Ok(EventOutcome::Ok(String::new()));
+            }
+            canvas::keymap::KeyEventOutcome::NotMatched => {
+                // fall through
+            }
+        }
+    }
+
+    // 3) Outside canvas
+    if let Some(ma) = movement {
+        let mut current = add_logic_page.state.current_focus;
+        if move_focus(&ADD_LOGIC_FOCUS_ORDER, &mut current, ma) {
+            add_logic_page.state.current_focus = current;
+            app_state.ui.focus_outside_canvas = !matches!(
+                add_logic_page.state.current_focus,
+                AddLogicFocus::InputLogicName
+                    | AddLogicFocus::InputTargetColumn
+                    | AddLogicFocus::InputDescription
+            );
+            return Ok(EventOutcome::Ok(String::new()));
+        }
+
+        match ma {
+            MovementAction::Select => match add_logic_page.state.current_focus {
+                AddLogicFocus::ScriptContentPreview => {
+                    add_logic_page.state.current_focus = AddLogicFocus::InsideScriptContent;
+                    app_state.ui.focus_outside_canvas = false;
+                    return Ok(EventOutcome::Ok(
+                        "Fullscreen script editing. Esc to exit.".to_string(),
+                    ));
+                }
+                AddLogicFocus::SaveButton => {
+                    if let Some(msg) = add_logic_page.state.save_logic() {
+                        return Ok(EventOutcome::Ok(msg));
+                    } else {
+                        return Ok(EventOutcome::Ok("Saved (no changes)".to_string()));
+                    }
+                }
+                AddLogicFocus::CancelButton => {
+                    return Ok(EventOutcome::Ok("Cancelled Add Logic".to_string()));
+                }
+                _ => {}
+            },
+            MovementAction::Esc => {
+                if add_logic_page.state.current_focus == AddLogicFocus::ScriptContentPreview {
+                    add_logic_page.state.current_focus = AddLogicFocus::InputDescription;
+                    app_state.ui.focus_outside_canvas = false;
+                    return Ok(EventOutcome::Ok("Back to Description".to_string()));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    Ok(EventOutcome::Ok(String::new()))
+}

client/src/pages/admin_panel/add_logic/loader.rs

@@ -0,0 +1,115 @@
+// src/pages/admin_panel/add_logic/loader.rs
+use anyhow::{Context, Result};
+use tracing::{error, info, warn};
+
+use crate::pages::admin_panel::add_logic::state::AddLogicFormState;
+use crate::pages::routing::{Page, Router};
+use crate::services::grpc_client::GrpcClient;
+use crate::services::ui_service::UiService;
+use crate::state::app::state::AppState;
+
+/// Process pending table structure fetch for AddLogic page.
+/// Returns true if UI needs a redraw.
+pub async fn process_pending_table_structure_fetch(
+    app_state: &mut AppState,
+    router: &mut Router,
+    grpc_client: &mut GrpcClient,
+    command_message: &mut String,
+) -> Result<bool> {
+    let mut needs_redraw = false;
+
+    if let Some((profile_name, table_name)) = app_state.pending_table_structure_fetch.take() {
+        if let Page::AddLogic(page) = &mut router.current {
+            if page.profile_name() == profile_name
+                && page.selected_table_name().map(|s| s.as_str()) == Some(table_name.as_str())
+            {
+                info!(
+                    "Fetching table structure for {}.{}",
+                    profile_name, table_name
+                );
+
+                let fetch_message = UiService::initialize_add_logic_table_data(
+                    grpc_client,
+                    &mut page.state, // keep state here, UiService expects AddLogicState
+                    &app_state.profile_tree,
+                )
+                .await
+                .unwrap_or_else(|e| {
+                    error!(
+                        "Error initializing add_logic_table_data for {}.{}: {}",
+                        profile_name, table_name, e
+                    );
+                    format!("Error fetching table structure: {}", e)
+                });
+
+                if !fetch_message.contains("Error") && !fetch_message.contains("Warning") {
+                    info!("{}", fetch_message);
+                } else {
+                    *command_message = fetch_message;
+                }
+
+                // 🔑 Rebuild FormEditor with updated state (so suggestions work)
+                page.editor = canvas::FormEditor::new(page.state.clone());
+
+                needs_redraw = true;
+            } else {
+                error!(
+                    "Mismatch in pending_table_structure_fetch: app_state wants {}.{}, \
+                     but AddLogic state is for {}.{:?}",
+                     profile_name,
+                     table_name,
+                     page.profile_name(),
+                     page.selected_table_name()
+                );
+            }
+        } else {
+            warn!(
+                "Pending table structure fetch for {}.{} but AddLogic view is not active. Ignored.",
+                profile_name, table_name
+            );
+        }
+    }
+
+    Ok(needs_redraw)
+}
+
+/// If the AddLogic page is awaiting columns for a selected table in the script editor,
+/// fetch them and update the state. Returns true if UI needs a redraw.
+pub async fn maybe_fetch_columns_for_awaiting_table(
+    grpc_client: &mut GrpcClient,
+    page: &mut AddLogicFormState,
+    command_message: &mut String,
+) -> Result<bool> {
+    if let Some(table_name) = page
+        .state
+        .script_editor_awaiting_column_autocomplete
+        .clone()
+    {
+        let profile_name = page.state.profile_name.clone();
+
+        info!(
+            "Fetching columns for table selection: {}.{}",
+            profile_name, table_name
+        );
+        match UiService::fetch_columns_for_table(grpc_client, &profile_name, &table_name).await {
+            Ok(columns) => {
+                page.state.set_columns_for_table_autocomplete(columns.clone());
+                info!("Loaded {} columns for table '{}'", columns.len(), table_name);
+                *command_message =
+                    format!("Columns for '{}' loaded. Select a column.", table_name);
+            }
+            Err(e) => {
+                error!(
+                    "Failed to fetch columns for {}.{}: {}",
+                    profile_name, table_name, e
+                );
+                page.state.script_editor_awaiting_column_autocomplete = None;
+                page.state.deactivate_script_editor_autocomplete();
+                *command_message = format!("Error loading columns for '{}': {}", table_name, e);
+            }
+        }
+        return Ok(true);
+    }
+
+    Ok(false)
+}

client/src/pages/admin_panel/add_logic/mod.rs

@@ -3,3 +3,5 @@
 pub mod ui;
 pub mod nav;
 pub mod state;
+pub mod loader;
+pub mod event;

client/src/pages/admin_panel/add_logic/nav.rs

@@ -1,531 +1,6 @@
 // src/pages/admin_panel/add_logic/nav.rs
 
-use crate::config::binds::config::{Config, EditorKeybindingMode};
-use crate::state::app::state::AppState;
-use crate::pages::admin_panel::add_logic::state::{AddLogicFocus, AddLogicState};
-use crate::buffer::{AppView, BufferState};
-use crossterm::event::{KeyEvent, KeyCode, KeyModifiers};
-use crate::services::GrpcClient;
-use tokio::sync::mpsc;
 use anyhow::Result;
-use crate::components::common::text_editor::TextEditor;
-use crate::services::ui_service::UiService;
-use tui_textarea::CursorMove;
-use crate::pages::admin::AdminState;
-use crate::pages::routing::{Router, Page};
+use tokio::sync::mpsc;
 
 pub type SaveLogicResultSender = mpsc::Sender<Result<String>>;
-
-pub fn handle_add_logic_navigation(
-    key_event: KeyEvent,
-    config: &Config,
-    app_state: &mut AppState,
-    buffer_state: &mut BufferState,
-    grpc_client: GrpcClient,
-    save_logic_sender: SaveLogicResultSender,
-    command_message: &mut String,
-    router: &mut Router,
-) -> bool {
-    if let Page::AddLogic(add_logic_state) = &mut router.current {
-        // === FULLSCREEN SCRIPT EDITING ===
-        if add_logic_state.current_focus == AddLogicFocus::InsideScriptContent {
-            // === AUTOCOMPLETE HANDLING ===
-            if add_logic_state.script_editor_autocomplete_active {
-                match key_event.code {
-                    KeyCode::Char(c) if c.is_alphanumeric() || c == '_' => {
-                        add_logic_state.script_editor_filter_text.push(c);
-                        add_logic_state.update_script_editor_suggestions();
-                        {
-                            let mut editor_borrow =
-                                add_logic_state.script_content_editor.borrow_mut();
-                            TextEditor::handle_input(
-                                &mut editor_borrow,
-                                key_event,
-                                &add_logic_state.editor_keybinding_mode,
-                                &mut add_logic_state.vim_state,
-                            );
-                        }
-                        *command_message =
-                            format!("Filtering: @{}", add_logic_state.script_editor_filter_text);
-                        return true;
-                    }
-                    KeyCode::Backspace => {
-                        if !add_logic_state.script_editor_filter_text.is_empty() {
-                            add_logic_state.script_editor_filter_text.pop();
-                            add_logic_state.update_script_editor_suggestions();
-                            {
-                                let mut editor_borrow =
-                                    add_logic_state.script_content_editor.borrow_mut();
-                                TextEditor::handle_input(
-                                    &mut editor_borrow,
-                                    key_event,
-                                    &add_logic_state.editor_keybinding_mode,
-                                    &mut add_logic_state.vim_state,
-                                );
-                            }
-                            *command_message =
-                                if add_logic_state.script_editor_filter_text.is_empty() {
-                                    "Autocomplete: @".to_string()
-                                } else {
-                                    format!(
-                                        "Filtering: @{}",
-                                        add_logic_state.script_editor_filter_text
-                                    )
-                                };
-                        } else {
-                            let should_deactivate =
-                                if let Some((trigger_line, trigger_col)) =
-                                    add_logic_state.script_editor_trigger_position
-                                {
-                                    let current_cursor = {
-                                        let editor_borrow =
-                                            add_logic_state.script_content_editor.borrow();
-                                        editor_borrow.cursor()
-                                    };
-                                    current_cursor.0 == trigger_line
-                                        && current_cursor.1 == trigger_col + 1
-                                } else {
-                                    false
-                                };
-                            if should_deactivate {
-                                add_logic_state.deactivate_script_editor_autocomplete();
-                                *command_message = "Autocomplete cancelled".to_string();
-                            }
-                            {
-                                let mut editor_borrow =
-                                    add_logic_state.script_content_editor.borrow_mut();
-                                TextEditor::handle_input(
-                                    &mut editor_borrow,
-                                    key_event,
-                                    &add_logic_state.editor_keybinding_mode,
-                                    &mut add_logic_state.vim_state,
-                                );
-                            }
-                        }
-                        return true;
-                    }
-                    KeyCode::Tab | KeyCode::Down => {
-                        if !add_logic_state.script_editor_suggestions.is_empty() {
-                            let current = add_logic_state
-                                .script_editor_selected_suggestion_index
-                                .unwrap_or(0);
-                            let next =
-                                (current + 1) % add_logic_state.script_editor_suggestions.len();
-                            add_logic_state.script_editor_selected_suggestion_index = Some(next);
-                            *command_message = format!(
-                                "Selected: {}",
-                                add_logic_state.script_editor_suggestions[next]
-                            );
-                        }
-                        return true;
-                    }
-                    KeyCode::Up => {
-                        if !add_logic_state.script_editor_suggestions.is_empty() {
-                            let current = add_logic_state
-                                .script_editor_selected_suggestion_index
-                                .unwrap_or(0);
-                            let prev = if current == 0 {
-                                add_logic_state.script_editor_suggestions.len() - 1
-                            } else {
-                                current - 1
-                            };
-                            add_logic_state.script_editor_selected_suggestion_index = Some(prev);
-                            *command_message = format!(
-                                "Selected: {}",
-                                add_logic_state.script_editor_suggestions[prev]
-                            );
-                        }
-                        return true;
-                    }
-                    KeyCode::Enter => {
-                        if let Some(selected_idx) =
-                            add_logic_state.script_editor_selected_suggestion_index
-                        {
-                            if let Some(suggestion) = add_logic_state
-                                .script_editor_suggestions
-                                .get(selected_idx)
-                                .cloned()
-                            {
-                                let trigger_pos =
-                                    add_logic_state.script_editor_trigger_position;
-                                let filter_len =
-                                    add_logic_state.script_editor_filter_text.len();
-
-                                add_logic_state.deactivate_script_editor_autocomplete();
-                                add_logic_state.has_unsaved_changes = true;
-
-                                if let Some(pos) = trigger_pos {
-                                    let mut editor_borrow =
-                                        add_logic_state.script_content_editor.borrow_mut();
-
-                                    if suggestion == "sql" {
-                                        replace_autocomplete_text(
-                                            &mut editor_borrow,
-                                            pos,
-                                            filter_len,
-                                            "sql",
-                                        );
-                                        editor_borrow.insert_str("('')");
-                                        editor_borrow.move_cursor(CursorMove::Back);
-                                        editor_borrow.move_cursor(CursorMove::Back);
-                                        *command_message = "Inserted: @sql('')".to_string();
-                                    } else {
-                                        let is_table_selection =
-                                            add_logic_state.is_table_name_suggestion(&suggestion);
-                                        replace_autocomplete_text(
-                                            &mut editor_borrow,
-                                            pos,
-                                            filter_len,
-                                            &suggestion,
-                                        );
-
-                                        if is_table_selection {
-                                            editor_borrow.insert_str(".");
-                                            let new_cursor = editor_borrow.cursor();
-                                            drop(editor_borrow);
-
-                                            add_logic_state.script_editor_trigger_position =
-                                                Some(new_cursor);
-                                            add_logic_state.script_editor_autocomplete_active = true;
-                                            add_logic_state.script_editor_filter_text.clear();
-                                            add_logic_state
-                                                .trigger_column_autocomplete_for_table(
-                                                    suggestion.clone(),
-                                                );
-
-                                            let profile_name =
-                                                add_logic_state.profile_name.clone();
-                                            let table_name_for_fetch = suggestion.clone();
-                                            let mut client_clone = grpc_client.clone();
-                                            tokio::spawn(async move {
-                                                if let Err(e) = UiService::fetch_columns_for_table(
-                                                    &mut client_clone,
-                                                    &profile_name,
-                                                    &table_name_for_fetch,
-                                                )
-                                                .await
-                                                {
-                                                    tracing::error!(
-                                                        "Failed to fetch columns for {}.{}: {}",
-                                                        profile_name,
-                                                        table_name_for_fetch,
-                                                        e
-                                                    );
-                                                }
-                                            });
-                                            *command_message = format!(
-                                                "Selected table '{}', fetching columns...",
-                                                suggestion
-                                            );
-                                        } else {
-                                            *command_message =
-                                                format!("Inserted: {}", suggestion);
-                                        }
-                                    }
-                                }
-                                return true;
-                            }
-                        }
-                        add_logic_state.deactivate_script_editor_autocomplete();
-                        {
-                            let mut editor_borrow =
-                                add_logic_state.script_content_editor.borrow_mut();
-                            TextEditor::handle_input(
-                                &mut editor_borrow,
-                                key_event,
-                                &add_logic_state.editor_keybinding_mode,
-                                &mut add_logic_state.vim_state,
-                            );
-                        }
-                        return true;
-                    }
-                    KeyCode::Esc => {
-                        add_logic_state.deactivate_script_editor_autocomplete();
-                        *command_message = "Autocomplete cancelled".to_string();
-                    }
-                    _ => {
-                        add_logic_state.deactivate_script_editor_autocomplete();
-                        *command_message = "Autocomplete cancelled".to_string();
-                        {
-                            let mut editor_borrow =
-                                add_logic_state.script_content_editor.borrow_mut();
-                            TextEditor::handle_input(
-                                &mut editor_borrow,
-                                key_event,
-                                &add_logic_state.editor_keybinding_mode,
-                                &mut add_logic_state.vim_state,
-                            );
-                        }
-                        return true;
-                    }
-                }
-            }
-
-            // Trigger autocomplete with '@'
-            if key_event.code == KeyCode::Char('@') && key_event.modifiers == KeyModifiers::NONE {
-                let should_trigger = match add_logic_state.editor_keybinding_mode {
-                    EditorKeybindingMode::Vim => {
-                        TextEditor::is_vim_insert_mode(&add_logic_state.vim_state)
-                    }
-                    _ => true,
-                };
-                if should_trigger {
-                    let cursor_before = {
-                        let editor_borrow = add_logic_state.script_content_editor.borrow();
-                        editor_borrow.cursor()
-                    };
-                    {
-                        let mut editor_borrow =
-                            add_logic_state.script_content_editor.borrow_mut();
-                        TextEditor::handle_input(
-                            &mut editor_borrow,
-                            key_event,
-                            &add_logic_state.editor_keybinding_mode,
-                            &mut add_logic_state.vim_state,
-                        );
-                    }
-                    add_logic_state.script_editor_trigger_position = Some(cursor_before);
-                    add_logic_state.script_editor_autocomplete_active = true;
-                    add_logic_state.script_editor_filter_text.clear();
-                    add_logic_state.update_script_editor_suggestions();
-                    add_logic_state.has_unsaved_changes = true;
-                    *command_message = "Autocomplete: @ (Tab/↑↓ to navigate, Enter to select, Esc to cancel)".to_string();
-                    return true;
-                }
-            }
-
-            // Esc handling
-            if key_event.code == KeyCode::Esc && key_event.modifiers == KeyModifiers::NONE {
-                match add_logic_state.editor_keybinding_mode {
-                    EditorKeybindingMode::Vim => {
-                        let was_insert =
-                            TextEditor::is_vim_insert_mode(&add_logic_state.vim_state);
-                        {
-                            let mut editor_borrow =
-                                add_logic_state.script_content_editor.borrow_mut();
-                            TextEditor::handle_input(
-                                &mut editor_borrow,
-                                key_event,
-                                &add_logic_state.editor_keybinding_mode,
-                                &mut add_logic_state.vim_state,
-                            );
-                        }
-                        if was_insert {
-                            *command_message =
-                                "VIM: Normal Mode. Esc again to exit script.".to_string();
-                        } else {
-                            add_logic_state.current_focus =
-                                AddLogicFocus::ScriptContentPreview;
-                            app_state.ui.focus_outside_canvas = true;
-                            *command_message = "Exited script editing.".to_string();
-                        }
-                    }
-                    _ => {
-                        add_logic_state.current_focus = AddLogicFocus::ScriptContentPreview;
-                        app_state.ui.focus_outside_canvas = true;
-                        *command_message = "Exited script editing.".to_string();
-                    }
-                }
-                return true;
-            }
-
-            // Normal text input
-            let changed = {
-                let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                TextEditor::handle_input(
-                    &mut editor_borrow,
-                    key_event,
-                    &add_logic_state.editor_keybinding_mode,
-                    &mut add_logic_state.vim_state,
-                )
-            };
-            if changed {
-                add_logic_state.has_unsaved_changes = true;
-            }
-            return true;
-        }
-
-        // === NON-FULLSCREEN NAVIGATION ===
-        let action = config.get_general_action(key_event.code, key_event.modifiers);
-        let current_focus = add_logic_state.current_focus;
-        let mut handled = true;
-        let mut new_focus = current_focus;
-
-        match action.as_deref() {
-            Some("exit_table_scroll") => {
-                handled = false;
-            }
-            Some("move_up") => {
-                match current_focus {
-                    AddLogicFocus::InputLogicName => {}
-                    AddLogicFocus::InputTargetColumn => new_focus = AddLogicFocus::InputLogicName,
-                    AddLogicFocus::InputDescription => {
-                        new_focus = AddLogicFocus::InputTargetColumn
-                    }
-                    AddLogicFocus::ScriptContentPreview => {
-                        new_focus = AddLogicFocus::InputDescription
-                    }
-                    AddLogicFocus::SaveButton => new_focus = AddLogicFocus::ScriptContentPreview,
-                    AddLogicFocus::CancelButton => new_focus = AddLogicFocus::SaveButton,
-                    _ => handled = false,
-                }
-            }
-            Some("move_down") => {
-                match current_focus {
-                    AddLogicFocus::InputLogicName => {
-                        new_focus = AddLogicFocus::InputTargetColumn
-                    }
-                    AddLogicFocus::InputTargetColumn => {
-                        new_focus = AddLogicFocus::InputDescription
-                    }
-                    AddLogicFocus::InputDescription => {
-                        add_logic_state.last_canvas_field = 2;
-                        new_focus = AddLogicFocus::ScriptContentPreview;
-                    }
-                    AddLogicFocus::ScriptContentPreview => {
-                        new_focus = AddLogicFocus::SaveButton
-                    }
-                    AddLogicFocus::SaveButton => new_focus = AddLogicFocus::CancelButton,
-                    AddLogicFocus::CancelButton => {}
-                    _ => handled = false,
-                }
-            }
-            Some("next_option") => {
-                match current_focus {
-                    AddLogicFocus::InputLogicName
-                    | AddLogicFocus::InputTargetColumn
-                    | AddLogicFocus::InputDescription => {
-                        new_focus = AddLogicFocus::ScriptContentPreview
-                    }
-                    AddLogicFocus::ScriptContentPreview => {
-                        new_focus = AddLogicFocus::SaveButton
-                    }
-                    AddLogicFocus::SaveButton => new_focus = AddLogicFocus::CancelButton,
-                    AddLogicFocus::CancelButton => {}
-                    _ => handled = false,
-                }
-            }
-            Some("previous_option") => {
-                match current_focus {
-                    AddLogicFocus::InputLogicName
-                    | AddLogicFocus::InputTargetColumn
-                    | AddLogicFocus::InputDescription => {}
-                    AddLogicFocus::ScriptContentPreview => {
-                        new_focus = AddLogicFocus::InputDescription
-                    }
-                    AddLogicFocus::SaveButton => {
-                        new_focus = AddLogicFocus::ScriptContentPreview
-                    }
-                    AddLogicFocus::CancelButton => new_focus = AddLogicFocus::SaveButton,
-                    _ => handled = false,
-                }
-            }
-            Some("next_field") => {
-                new_focus = match current_focus {
-                    AddLogicFocus::InputLogicName => AddLogicFocus::InputTargetColumn,
-                    AddLogicFocus::InputTargetColumn => AddLogicFocus::InputDescription,
-                    AddLogicFocus::InputDescription => AddLogicFocus::ScriptContentPreview,
-                    AddLogicFocus::ScriptContentPreview => AddLogicFocus::SaveButton,
-                    AddLogicFocus::SaveButton => AddLogicFocus::CancelButton,
-                    AddLogicFocus::CancelButton => AddLogicFocus::InputLogicName,
-                    _ => current_focus,
-                };
-            }
-            Some("prev_field") => {
-                new_focus = match current_focus {
-                    AddLogicFocus::InputLogicName => AddLogicFocus::CancelButton,
-                    AddLogicFocus::InputTargetColumn => AddLogicFocus::InputLogicName,
-                    AddLogicFocus::InputDescription => AddLogicFocus::InputTargetColumn,
-                    AddLogicFocus::ScriptContentPreview => AddLogicFocus::InputDescription,
-                    AddLogicFocus::SaveButton => AddLogicFocus::ScriptContentPreview,
-                    AddLogicFocus::CancelButton => AddLogicFocus::SaveButton,
-                    _ => current_focus,
-                };
-            }
-            Some("select") => {
-                match current_focus {
-                    AddLogicFocus::ScriptContentPreview => {
-                        new_focus = AddLogicFocus::InsideScriptContent;
-                        app_state.ui.focus_outside_canvas = false;
-                        let mode_hint = match add_logic_state.editor_keybinding_mode {
-                            EditorKeybindingMode::Vim => {
-                                "VIM mode - 'i'/'a'/'o' to edit"
-                            }
-                            _ => "Enter/Ctrl+E to edit",
-                        };
-                        *command_message = format!(
-                            "Fullscreen script editing. {} or Esc to exit.",
-                            mode_hint
-                        );
-                        handled = true;
-                    }
-                    AddLogicFocus::SaveButton => {
-                        *command_message = "Save logic action".to_string();
-                        handled = true;
-                    }
-                    AddLogicFocus::CancelButton => {
-                        buffer_state.update_history(AppView::Admin);
-                        *command_message = "Cancelled Add Logic".to_string();
-                        handled = true;
-                    }
-                    AddLogicFocus::InputLogicName
-                    | AddLogicFocus::InputTargetColumn
-                    | AddLogicFocus::InputDescription => {
-                        // Focus canvas inputs; let canvas keymap handle editing
-                        app_state.ui.focus_outside_canvas = false;
-                        handled = false; // forward to canvas
-                    }
-                    _ => handled = false,
-                }
-            }
-            Some("toggle_edit_mode") => {
-                match current_focus {
-                    AddLogicFocus::InputLogicName
-                    | AddLogicFocus::InputTargetColumn
-                    | AddLogicFocus::InputDescription => {
-                        app_state.ui.focus_outside_canvas = false;
-                        *command_message =
-                            "Focus moved to input. Use i/a (Vim) or type to edit.".to_string();
-                        handled = true;
-                    }
-                    _ => {
-                        *command_message = "Cannot toggle edit mode here.".to_string();
-                    }
-                }
-            }
-            _ => handled = false,
-        }
-
-        if handled && current_focus != new_focus {
-            add_logic_state.current_focus = new_focus;
-            let new_is_canvas_input_focus = matches!(
-                new_focus,
-                AddLogicFocus::InputLogicName
-                    | AddLogicFocus::InputTargetColumn
-                    | AddLogicFocus::InputDescription
-            );
-            if new_is_canvas_input_focus {
-                app_state.ui.focus_outside_canvas = false;
-            } else {
-                app_state.ui.focus_outside_canvas = true;
-            }
-        }
-        handled
-    } else {
-        false
-    }
-}
-
-fn replace_autocomplete_text(
-    editor: &mut tui_textarea::TextArea,
-    trigger_pos: (usize, usize),
-    filter_len: usize,
-    replacement: &str,
-) {
-    let filter_start_pos = (trigger_pos.0, trigger_pos.1 + 1);
-    editor.move_cursor(CursorMove::Jump(filter_start_pos.0 as u16, filter_start_pos.1 as u16));
-    for _ in 0..filter_len {
-        editor.delete_next_char();
-    }
-    editor.insert_str(replacement);
-}

client/src/pages/admin_panel/add_logic/state.rs

@@ -1,7 +1,8 @@
 // src/pages/admin_panel/add_logic/state.rs
 use crate::config::binds::config::{EditorConfig, EditorKeybindingMode};
 use crate::components::common::text_editor::{TextEditor, VimState};
-use canvas::{DataProvider, AppMode};
+use canvas::{DataProvider, AppMode, FormEditor, SuggestionItem};
+use crossterm::event::KeyCode;
 use std::cell::RefCell;
 use std::rc::Rc;
 use tui_textarea::TextArea;
@@ -98,6 +99,19 @@ impl AddLogicState {
 
     pub const INPUT_FIELD_COUNT: usize = 3;
 
+    /// Build canvas SuggestionItem list for target column
+    pub fn column_suggestions_sync(&self, query: &str) -> Vec<SuggestionItem> {
+        let q = query.to_lowercase();
+        self.table_columns_for_suggestions
+            .iter()
+            .filter(|c| q.is_empty() || c.to_lowercase().contains(&q))
+            .map(|c| SuggestionItem {
+                display_text: c.clone(),
+                value_to_store: c.clone(),
+            })
+        .collect()
+    }
+
     /// Updates the target_column_suggestions based on current input.
     pub fn update_target_column_suggestions(&mut self) {
         let current_input = self.target_column_input.to_lowercase();
@@ -315,3 +329,237 @@ impl DataProvider for AddLogicState {
         field_index == 1
     }
 }
+
+// Wrapper that owns both the raw state and its FormEditor (like LoginFormState)
+pub struct AddLogicFormState {
+    pub state: AddLogicState,
+    pub editor: FormEditor<AddLogicState>,
+    pub focus_outside_canvas: bool,
+}
+
+// manual Debug because FormEditor may not implement Debug
+impl std::fmt::Debug for AddLogicFormState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AddLogicFormState")
+            .field("state", &self.state)
+            .field("focus_outside_canvas", &self.focus_outside_canvas)
+            .finish()
+    }
+}
+
+impl AddLogicFormState {
+    pub fn new(editor_config: &EditorConfig) -> Self {
+        let state = AddLogicState::new(editor_config);
+        let editor = FormEditor::new(state.clone());
+        Self {
+            state,
+            editor,
+            focus_outside_canvas: false,
+        }
+    }
+
+    pub fn new_with_table(
+        editor_config: &EditorConfig,
+        profile_name: String,
+        table_id: Option<i64>,
+        table_name: String,
+    ) -> Self {
+        let mut state = AddLogicState::new(editor_config);
+        state.profile_name = profile_name;
+        state.selected_table_id = table_id;
+        state.selected_table_name = Some(table_name);
+        let editor = FormEditor::new(state.clone());
+        Self {
+            state,
+            editor,
+            focus_outside_canvas: false,
+        }
+    }
+
+    pub fn from_state(state: AddLogicState) -> Self {
+        let editor = FormEditor::new(state.clone());
+        Self {
+            state,
+            editor,
+            focus_outside_canvas: false,
+        }
+    }
+
+    /// Sync state from editor's data provider snapshot
+    pub fn sync_from_editor(&mut self) {
+        self.state = self.editor.data_provider().clone();
+    }
+
+    // === Delegates to AddLogicState fields ===
+
+    pub fn current_focus(&self) -> AddLogicFocus {
+        self.state.current_focus
+    }
+
+    pub fn set_current_focus(&mut self, focus: AddLogicFocus) {
+        self.state.current_focus = focus;
+    }
+
+    pub fn has_unsaved_changes(&self) -> bool {
+        self.state.has_unsaved_changes
+    }
+
+    pub fn set_has_unsaved_changes(&mut self, changed: bool) {
+        self.state.has_unsaved_changes = changed;
+    }
+
+    pub fn profile_name(&self) -> &str {
+        &self.state.profile_name
+    }
+
+    pub fn selected_table_name(&self) -> Option<&String> {
+        self.state.selected_table_name.as_ref()
+    }
+
+    pub fn selected_table_id(&self) -> Option<i64> {
+        self.state.selected_table_id
+    }
+
+    pub fn script_content_editor(&self) -> &Rc<RefCell<TextArea<'static>>> {
+        &self.state.script_content_editor
+    }
+
+    pub fn script_content_editor_mut(&mut self) -> &mut Rc<RefCell<TextArea<'static>>> {
+        &mut self.state.script_content_editor
+    }
+
+    pub fn vim_state(&self) -> &VimState {
+        &self.state.vim_state
+    }
+
+    pub fn vim_state_mut(&mut self) -> &mut VimState {
+        &mut self.state.vim_state
+    }
+
+    pub fn editor_keybinding_mode(&self) -> &EditorKeybindingMode {
+        &self.state.editor_keybinding_mode
+    }
+
+    pub fn script_editor_autocomplete_active(&self) -> bool {
+        self.state.script_editor_autocomplete_active
+    }
+
+    pub fn script_editor_suggestions(&self) -> &Vec<String> {
+        &self.state.script_editor_suggestions
+    }
+
+    pub fn script_editor_selected_suggestion_index(&self) -> Option<usize> {
+        self.state.script_editor_selected_suggestion_index
+    }
+
+    pub fn target_column_suggestions(&self) -> &Vec<String> {
+        &self.state.target_column_suggestions
+    }
+
+    pub fn selected_target_column_suggestion_index(&self) -> Option<usize> {
+        self.state.selected_target_column_suggestion_index
+    }
+
+    pub fn in_target_column_suggestion_mode(&self) -> bool {
+        self.state.in_target_column_suggestion_mode
+    }
+
+    pub fn show_target_column_suggestions(&self) -> bool {
+        self.state.show_target_column_suggestions
+    }
+
+    // === Delegates to FormEditor ===
+
+    pub fn mode(&self) -> AppMode {
+        self.editor.mode()
+    }
+
+    pub fn cursor_position(&self) -> usize {
+        self.editor.cursor_position()
+    }
+
+    pub fn handle_key_event(
+        &mut self,
+        key_event: crossterm::event::KeyEvent,
+    ) -> canvas::keymap::KeyEventOutcome {
+        // Customize behavior for Target Column (field index 1) in Edit mode,
+        // mirroring how Register page does suggestions for Role.
+        let in_target_col_field = self.editor.current_field() == 1;
+        let in_edit_mode = self.editor.mode() == canvas::AppMode::Edit;
+
+        if in_target_col_field && in_edit_mode {
+            match key_event.code {
+                // Tab: open suggestions if inactive; otherwise cycle next
+                KeyCode::Tab => {
+                    if !self.editor.is_suggestions_active() {
+                        if let Some(query) = self.editor.start_suggestions(1) {
+                            let items = self.state.column_suggestions_sync(&query);
+                            let applied =
+                                self.editor.apply_suggestions_result(1, &query, items);
+                            if applied {
+                                self.editor.update_inline_completion();
+                            }
+                        }
+                    } else {
+                        self.editor.suggestions_next();
+                    }
+                    return canvas::keymap::KeyEventOutcome::Consumed(None);
+                }
+                // Shift+Tab: cycle suggestions too (fallback to next)
+                KeyCode::BackTab => {
+                    if self.editor.is_suggestions_active() {
+                        self.editor.suggestions_next();
+                        return canvas::keymap::KeyEventOutcome::Consumed(None);
+                    }
+                }
+                // Enter: apply selected suggestion (if active)
+                KeyCode::Enter => {
+                    if self.editor.is_suggestions_active() {
+                        let _ = self.editor.apply_suggestion();
+                        return canvas::keymap::KeyEventOutcome::Consumed(None);
+                    }
+                }
+                // Esc: close suggestions if active
+                KeyCode::Esc => {
+                    if self.editor.is_suggestions_active() {
+                        self.editor.close_suggestions();
+                        return canvas::keymap::KeyEventOutcome::Consumed(None);
+                    }
+                }
+                // Character input: mutate then refresh suggestions if active
+                KeyCode::Char(_) => {
+                    let outcome = self.editor.handle_key_event(key_event);
+                    if self.editor.is_suggestions_active() {
+                        if let Some(query) = self.editor.start_suggestions(1) {
+                            let items = self.state.column_suggestions_sync(&query);
+                            let applied =
+                                self.editor.apply_suggestions_result(1, &query, items);
+                            if applied {
+                                self.editor.update_inline_completion();
+                            }
+                        }
+                    }
+                    return outcome;
+                }
+                // Backspace/Delete: mutate then refresh suggestions if active
+                KeyCode::Backspace | KeyCode::Delete => {
+                    let outcome = self.editor.handle_key_event(key_event);
+                    if self.editor.is_suggestions_active() {
+                        if let Some(query) = self.editor.start_suggestions(1) {
+                            let items = self.state.column_suggestions_sync(&query);
+                            let applied =
+                                self.editor.apply_suggestions_result(1, &query, items);
+                            if applied {
+                                self.editor.update_inline_completion();
+                            }
+                        }
+                    }
+                    return outcome;
+                }
+                _ => { /* fall through */ }
+            }
+        }
+        // Default: let canvas handle it
+        self.editor.handle_key_event(key_event)
+    }
+}

client/src/pages/admin_panel/add_logic/ui.rs

@@ -1,8 +1,8 @@
 // src/pages/admin_panel/add_logic/ui.rs
 use crate::config::colors::themes::Theme;
 use crate::state::app::state::AppState;
-use crate::pages::admin_panel::add_logic::state::{AddLogicFocus, AddLogicState};
-use canvas::{render_canvas, FormEditor};
+use crate::pages::admin_panel::add_logic::state::{AddLogicFocus, AddLogicState, AddLogicFormState};
+use canvas::{render_canvas, render_suggestions_dropdown, DefaultCanvasTheme, FormEditor};
 use ratatui::{
     layout::{Alignment, Constraint, Direction, Layout, Rect},
     style::{Modifier, Style},
@@ -19,7 +19,7 @@ pub fn render_add_logic(
     area: Rect,
     theme: &Theme,
     app_state: &AppState,
-    add_logic_state: &mut AddLogicState,
+    add_logic_state: &mut AddLogicFormState,
 ) {
     let main_block = Block::default()
         .title(" Add New Logic Script ")
@@ -32,9 +32,13 @@ pub fn render_add_logic(
     f.render_widget(main_block, area);
 
     // Handle full-screen script editing
-    if add_logic_state.current_focus == AddLogicFocus::InsideScriptContent {
-        let mut editor_ref = add_logic_state.script_content_editor.borrow_mut();
-        let border_style_color = if crate::components::common::text_editor::TextEditor::is_vim_insert_mode(&add_logic_state.vim_state) {
+    if add_logic_state.current_focus() == AddLogicFocus::InsideScriptContent {
+        let mut editor_ref = add_logic_state
+            .state
+            .script_content_editor
+            .borrow_mut();
+
+        let border_style_color = if crate::components::common::text_editor::TextEditor::is_vim_insert_mode(add_logic_state.vim_state()) {
             theme.highlight
         } else {
             theme.secondary
@@ -44,13 +48,13 @@ pub fn render_add_logic(
         editor_ref.set_cursor_line_style(Style::default());
         editor_ref.set_cursor_style(Style::default().add_modifier(Modifier::REVERSED));
 
-        let script_title_hint = match add_logic_state.editor_keybinding_mode {
+        let script_title_hint = match add_logic_state.editor_keybinding_mode() {
             EditorKeybindingMode::Vim => {
-                let vim_mode_status = crate::components::common::text_editor::TextEditor::get_vim_mode_status(&add_logic_state.vim_state);
+                let vim_mode_status = crate::components::common::text_editor::TextEditor::get_vim_mode_status(add_logic_state.vim_state());
                 format!("Script {}", vim_mode_status)
             }
             EditorKeybindingMode::Emacs | EditorKeybindingMode::Default => {
-                if crate::components::common::text_editor::TextEditor::is_vim_insert_mode(&add_logic_state.vim_state) {
+                if crate::components::common::text_editor::TextEditor::is_vim_insert_mode(add_logic_state.vim_state()) {
                     "Script (Editing)".to_string()
                 } else {
                     "Script".to_string()
@@ -72,10 +76,10 @@ pub fn render_add_logic(
         drop(editor_ref);
 
         // === SCRIPT EDITOR AUTOCOMPLETE RENDERING ===
-        if add_logic_state.script_editor_autocomplete_active && !add_logic_state.script_editor_suggestions.is_empty() {
+        if add_logic_state.script_editor_autocomplete_active() && !add_logic_state.script_editor_suggestions().is_empty() {
             // Get the current cursor position from textarea
             let current_cursor = {
-                let editor_borrow = add_logic_state.script_content_editor.borrow();
+                let editor_borrow = add_logic_state.script_content_editor().borrow();
                 editor_borrow.cursor() // Returns (row, col) as (usize, usize)
             };
 
@@ -103,8 +107,8 @@ pub fn render_add_logic(
                 input_rect,
                 f.area(), // Full frame area for clamping
                 theme,
-                &add_logic_state.script_editor_suggestions,
-                add_logic_state.script_editor_selected_suggestion_index,
+                add_logic_state.script_editor_suggestions(),
+                add_logic_state.script_editor_selected_suggestion_index(),
             );
         }
 
@@ -128,66 +132,61 @@ pub fn render_add_logic(
     let buttons_area = main_chunks[3];
 
     // Top info
+    let table_label = if let Some(name) = add_logic_state.selected_table_name() {
+        name.clone()
+    } else if let Some(id) = add_logic_state.selected_table_id() {
+        format!("ID {}", id)
+    } else {
+        "Global (Not Selected)".to_string()
+    };
+
     let profile_text = Paragraph::new(vec![
         Line::from(Span::styled(
-            format!("Profile: {}", add_logic_state.profile_name),
-            Style::default().fg(theme.fg),
+                format!("Profile: {}", add_logic_state.profile_name()),
+                Style::default().fg(theme.fg),
         )),
         Line::from(Span::styled(
-            format!(
-                "Table: {}",
-                add_logic_state
-                    .selected_table_name
-                    .clone()
-                    .unwrap_or_else(|| add_logic_state.selected_table_id
-                        .map(|id| format!("ID {}", id))
-                        .unwrap_or_else(|| "Global (Not Selected)".to_string()))
-            ),
-            Style::default().fg(theme.fg),
+                format!("Table: {}", table_label),
+                Style::default().fg(theme.fg),
         )),
     ])
-    .block(
-        Block::default()
+        .block(
+            Block::default()
             .borders(Borders::BOTTOM)
             .border_style(Style::default().fg(theme.secondary)),
-    );
+        );
     f.render_widget(profile_text, top_info_area);
 
     // Canvas - USING CANVAS LIBRARY
     let focus_on_canvas_inputs = matches!(
-        add_logic_state.current_focus,
+        add_logic_state.current_focus(),
         AddLogicFocus::InputLogicName
             | AddLogicFocus::InputTargetColumn
             | AddLogicFocus::InputDescription
     );
 
-    let editor = FormEditor::new(add_logic_state.clone());
-    let active_field_rect = render_canvas(f, canvas_area, &editor, theme);
+    let editor = &add_logic_state.editor;
+    let active_field_rect = render_canvas(f, canvas_area, editor, theme);
 
-    // --- Render Autocomplete for Target Column ---
-    if editor.mode() == canvas::AppMode::Edit && editor.current_field() == 1 { // Target Column field
-        if add_logic_state.in_target_column_suggestion_mode && add_logic_state.show_target_column_suggestions {
-            if !add_logic_state.target_column_suggestions.is_empty() {
-                if let Some(input_rect) = active_field_rect {
-                    autocomplete::render_autocomplete_dropdown(
-                        f,
-                        input_rect,
-                        f.area(), // Full frame area for clamping
-                        theme,
-                        &add_logic_state.target_column_suggestions,
-                        add_logic_state.selected_target_column_suggestion_index,
-                    );
-                }
-            }
+    // --- Canvas suggestions dropdown (Target Column, etc.) ---
+    if editor.mode() == canvas::AppMode::Edit {
+        if let Some(input_rect) = active_field_rect {
+            render_suggestions_dropdown(
+                f,
+                f.area(),
+                input_rect,
+                &DefaultCanvasTheme,
+                editor,
+            );
         }
     }
 
     // Script content preview
     {
-        let mut editor_ref = add_logic_state.script_content_editor.borrow_mut();
+        let mut editor_ref = add_logic_state.script_content_editor().borrow_mut();
         editor_ref.set_cursor_line_style(Style::default());
 
-        let is_script_preview_focused = add_logic_state.current_focus == AddLogicFocus::ScriptContentPreview;
+        let is_script_preview_focused = add_logic_state.current_focus() == AddLogicFocus::ScriptContentPreview;
 
         if is_script_preview_focused {
             editor_ref.set_cursor_style(Style::default().add_modifier(Modifier::REVERSED));
@@ -256,7 +255,7 @@ pub fn render_add_logic(
     let save_button = Paragraph::new(" Save Logic ")
         .style(get_button_style(
             AddLogicFocus::SaveButton,
-            add_logic_state.current_focus,
+            add_logic_state.current_focus(),
         ))
         .alignment(Alignment::Center)
         .block(
@@ -264,7 +263,7 @@ pub fn render_add_logic(
                 .borders(Borders::ALL)
                 .border_type(BorderType::Rounded)
                 .border_style(get_button_border_style(
-                    add_logic_state.current_focus == AddLogicFocus::SaveButton,
+                    add_logic_state.current_focus() == AddLogicFocus::SaveButton,
                     theme,
                 )),
         );
@@ -273,7 +272,7 @@ pub fn render_add_logic(
     let cancel_button = Paragraph::new(" Cancel ")
         .style(get_button_style(
             AddLogicFocus::CancelButton,
-            add_logic_state.current_focus,
+            add_logic_state.current_focus(),
         ))
         .alignment(Alignment::Center)
         .block(
@@ -281,7 +280,7 @@ pub fn render_add_logic(
                 .borders(Borders::ALL)
                 .border_type(BorderType::Rounded)
                 .border_style(get_button_border_style(
-                    add_logic_state.current_focus == AddLogicFocus::CancelButton,
+                    add_logic_state.current_focus() == AddLogicFocus::CancelButton,
                     theme,
                 )),
         );

client/src/pages/admin_panel/add_table/event.rs

@@ -0,0 +1,130 @@
+// src/pages/admin_panel/add_table/event.rs
+
+use anyhow::Result;
+use crate::config::binds::config::Config;
+use crate::movement::{move_focus, MovementAction};
+use crate::pages::admin_panel::add_table::logic::{
+    handle_add_column_action, handle_delete_selected_columns, handle_save_table_action,
+};
+use crate::pages::admin_panel::add_table::nav::SaveTableResultSender;
+use crate::pages::admin_panel::add_table::state::{AddTableFocus, AddTableFormState};
+use crate::services::GrpcClient;
+use crate::state::app::state::AppState;
+use crate::modes::handlers::event::EventOutcome;
+use crossterm::event::KeyEvent;
+
+/// Focus traversal order for AddTable (outside canvas)
+const ADD_TABLE_FOCUS_ORDER: [AddTableFocus; 7] = [
+    AddTableFocus::InputTableName,
+    AddTableFocus::InputColumnName,
+    AddTableFocus::InputColumnType,
+    AddTableFocus::AddColumnButton,
+    AddTableFocus::SaveButton,
+    AddTableFocus::DeleteSelectedButton,
+    AddTableFocus::CancelButton,
+];
+
+/// Unified AddTable event handler (like AddLogic)
+pub fn handle_add_table_event(
+    key_event: KeyEvent,
+    movement: Option<MovementAction>,
+    _config: &Config,
+    app_state: &mut AppState,
+    page: &mut AddTableFormState,
+    mut grpc_client: GrpcClient,
+    save_result_sender: SaveTableResultSender,
+) -> Result<EventOutcome> {
+    // 1) Inside canvas (FormEditor)
+    let inside_canvas_inputs = matches!(
+        page.current_focus(),
+        AddTableFocus::InputTableName
+            | AddTableFocus::InputColumnName
+            | AddTableFocus::InputColumnType
+    );
+
+    if inside_canvas_inputs {
+        match page.editor.handle_key_event(key_event) {
+            canvas::keymap::KeyEventOutcome::Consumed(Some(msg)) => {
+                page.sync_from_editor();
+                return Ok(EventOutcome::Ok(msg));
+            }
+            canvas::keymap::KeyEventOutcome::Consumed(None) => {
+                page.sync_from_editor();
+                return Ok(EventOutcome::Ok("Input updated".into()));
+            }
+            canvas::keymap::KeyEventOutcome::Pending => {
+                return Ok(EventOutcome::Ok(String::new()));
+            }
+            canvas::keymap::KeyEventOutcome::NotMatched => {
+                // fall through
+            }
+        }
+    }
+
+    // 2) Movement outside canvas
+    if let Some(ma) = movement {
+        let mut current = page.current_focus();
+        if move_focus(&ADD_TABLE_FOCUS_ORDER, &mut current, ma) {
+            page.set_current_focus(current);
+            app_state.ui.focus_outside_canvas = !matches!(
+                page.current_focus(),
+                AddTableFocus::InputTableName
+                    | AddTableFocus::InputColumnName
+                    | AddTableFocus::InputColumnType
+            );
+            return Ok(EventOutcome::Ok(String::new()));
+        }
+
+        // 3) Rich actions
+        match ma {
+            MovementAction::Select => match page.current_focus() {
+                AddTableFocus::AddColumnButton => {
+                    if let Some(focus_after_add) =
+                        crate::pages::admin_panel::add_table::logic::handle_add_column_action(
+                            &mut page.state,
+                            &mut String::new(),
+                        )
+                    {
+                        page.set_current_focus(focus_after_add);
+                        return Ok(EventOutcome::Ok("Column added".into()));
+                    }
+                }
+                AddTableFocus::SaveButton => {
+                    if page.state.table_name.is_empty() {
+                        return Ok(EventOutcome::Ok("Cannot save: Table name is empty".into()));
+                    }
+                    if page.state.columns.is_empty() {
+                        return Ok(EventOutcome::Ok("Cannot save: No columns defined".into()));
+                    }
+                    app_state.show_loading_dialog("Saving", "Please wait...");
+                    let state_clone = page.state.clone();
+                    let sender_clone = save_result_sender.clone();
+                    tokio::spawn(async move {
+                        let result =
+                            crate::pages::admin_panel::add_table::logic::handle_save_table_action(
+                                &mut grpc_client,
+                                &state_clone,
+                            )
+                            .await;
+                        let _ = sender_clone.send(result).await;
+                    });
+                    return Ok(EventOutcome::Ok("Saving table...".into()));
+                }
+                AddTableFocus::DeleteSelectedButton => {
+                    let msg =
+                        crate::pages::admin_panel::add_table::logic::handle_delete_selected_columns(
+                            &mut page.state,
+                        );
+                    return Ok(EventOutcome::Ok(msg));
+                }
+                AddTableFocus::CancelButton => {
+                    return Ok(EventOutcome::Ok("Cancelled Add Table".into()));
+                }
+                _ => {}
+            },
+            _ => {}
+        }
+    }
+
+    Ok(EventOutcome::Ok(String::new()))
+}

client/src/pages/admin_panel/add_table/mod.rs

@@ -4,3 +4,4 @@ pub mod ui;
 pub mod nav;
 pub mod state;
 pub mod logic;
+pub mod event;

client/src/pages/admin_panel/add_table/nav.rs

@@ -1,206 +1,6 @@
 // src/pages/admin_panel/add_table/nav.rs
 
-use crate::config::binds::config::Config;
-use crate::state::{
-    app::state::AppState,
-};
-use crate::pages::admin_panel::add_table::state::{AddTableFocus, AddTableState};
-use crossterm::event::{KeyEvent};
-use ratatui::widgets::TableState;
-use crate::pages::admin_panel::add_table::logic::{handle_add_column_action, handle_save_table_action};
-use crate::ui::handlers::context::DialogPurpose;
-use crate::services::GrpcClient;
-use tokio::sync::mpsc;
 use anyhow::Result;
+use tokio::sync::mpsc;
 
 pub type SaveTableResultSender = mpsc::Sender<Result<String>>;
-
-fn navigate_table_up(table_state: &mut TableState, item_count: usize) -> bool {
-    if item_count == 0 { return false; }
-    let current_selection = table_state.selected();
-    match current_selection {
-        Some(index) => {
-            if index > 0 { table_state.select(Some(index - 1)); true }
-            else { false }
-        }
-        None => { table_state.select(Some(0)); true }
-    }
-}
-
-fn navigate_table_down(table_state: &mut TableState, item_count: usize) -> bool {
-     if item_count == 0 { return false; }
-    let current_selection = table_state.selected();
-    match current_selection {
-        Some(index) => {
-            if index < item_count - 1 { table_state.select(Some(index + 1)); true }
-            else { false }
-        }
-        None => { table_state.select(Some(0)); true }
-    }
-}
-
-pub fn handle_add_table_navigation(
-    key: KeyEvent,
-    config: &Config,
-    app_state: &mut AppState,
-    add_table_state: &mut AddTableState,
-    grpc_client: GrpcClient,
-    save_result_sender: SaveTableResultSender,
-    command_message: &mut String,
-) -> bool {
-    let action = config.get_general_action(key.code, key.modifiers);
-    let current_focus = add_table_state.current_focus;
-    let mut handled = true;
-    let mut new_focus = current_focus;
-
-    if matches!(current_focus, AddTableFocus::InsideColumnsTable | AddTableFocus::InsideIndexesTable | AddTableFocus::InsideLinksTable) {
-        if matches!(action.as_deref(), Some("next_option") | Some("previous_option")) {
-            *command_message = "Press Esc to exit table item navigation first.".to_string();
-            return true;
-        }
-    }
-
-    match action.as_deref() {
-       Some("exit_table_scroll") => {
-           match current_focus {
-               AddTableFocus::InsideColumnsTable => {
-                   add_table_state.column_table_state.select(None);
-                   new_focus = AddTableFocus::ColumnsTable;
-                   // *command_message = "Exited Columns Table".to_string(); // Minimal change: remove message
-               }
-               AddTableFocus::InsideIndexesTable => {
-                   add_table_state.index_table_state.select(None);
-                   new_focus = AddTableFocus::IndexesTable;
-                   // *command_message = "Exited Indexes Table".to_string();
-               }
-               AddTableFocus::InsideLinksTable => {
-                   add_table_state.link_table_state.select(None);
-                   new_focus = AddTableFocus::LinksTable;
-                   // *command_message = "Exited Links Table".to_string();
-               }
-               _ => handled = false,
-           }
-       }
-        Some("move_up") => {
-            match current_focus {
-                AddTableFocus::InputTableName => {
-                    // MINIMAL CHANGE: Do nothing, new_focus remains current_focus
-                    // *command_message = "At top of form.".to_string(); // Remove message
-                }
-                AddTableFocus::InputColumnName => new_focus = AddTableFocus::InputTableName,
-                AddTableFocus::InputColumnType => new_focus = AddTableFocus::InputColumnName,
-                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::InputColumnType,
-                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::AddColumnButton,
-                AddTableFocus::IndexesTable => new_focus = AddTableFocus::ColumnsTable,
-                AddTableFocus::LinksTable => new_focus = AddTableFocus::IndexesTable,
-                AddTableFocus::InsideColumnsTable => { navigate_table_up(&mut add_table_state.column_table_state, add_table_state.columns.len()); }
-                AddTableFocus::InsideIndexesTable => { navigate_table_up(&mut add_table_state.index_table_state, add_table_state.indexes.len()); }
-                AddTableFocus::InsideLinksTable => { navigate_table_up(&mut add_table_state.link_table_state, add_table_state.links.len()); }
-                AddTableFocus::SaveButton => new_focus = AddTableFocus::LinksTable,
-                AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::SaveButton,
-                AddTableFocus::CancelButton => new_focus = AddTableFocus::DeleteSelectedButton,
-            }
-        }
-        Some("move_down") => {
-            match current_focus {
-                AddTableFocus::InputTableName => new_focus = AddTableFocus::InputColumnName,
-                AddTableFocus::InputColumnName => new_focus = AddTableFocus::InputColumnType,
-                AddTableFocus::InputColumnType => {
-                    add_table_state.last_canvas_field = 2;
-                    new_focus = AddTableFocus::AddColumnButton;
-                },
-                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::ColumnsTable,
-                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::IndexesTable,
-                AddTableFocus::IndexesTable => new_focus = AddTableFocus::LinksTable,
-                AddTableFocus::LinksTable => new_focus = AddTableFocus::SaveButton,
-                AddTableFocus::InsideColumnsTable => { navigate_table_down(&mut add_table_state.column_table_state, add_table_state.columns.len()); }
-                AddTableFocus::InsideIndexesTable => { navigate_table_down(&mut add_table_state.index_table_state, add_table_state.indexes.len()); }
-                AddTableFocus::InsideLinksTable => { navigate_table_down(&mut add_table_state.link_table_state, add_table_state.links.len()); }
-                AddTableFocus::SaveButton => new_focus = AddTableFocus::DeleteSelectedButton,
-                AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::CancelButton,
-                AddTableFocus::CancelButton => {
-                    // MINIMAL CHANGE: Do nothing, new_focus remains current_focus
-                    // *command_message = "At bottom of form.".to_string(); // Remove message
-                }
-            }
-        }
-        Some("next_option") => { // This logic should already be non-wrapping
-            match current_focus {
-                AddTableFocus::InputTableName | AddTableFocus::InputColumnName | AddTableFocus::InputColumnType =>
-                    { new_focus = AddTableFocus::AddColumnButton; }
-                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::ColumnsTable,
-                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::IndexesTable,
-                AddTableFocus::IndexesTable => new_focus = AddTableFocus::LinksTable,
-                AddTableFocus::LinksTable => new_focus = AddTableFocus::SaveButton,
-                AddTableFocus::SaveButton => new_focus = AddTableFocus::DeleteSelectedButton,
-                AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::CancelButton,
-                AddTableFocus::CancelButton => { /* *command_message = "At last focusable area.".to_string(); */ } // No change in focus
-                _ => handled = false,
-            }
-        }
-        Some("previous_option") => { // This logic should already be non-wrapping
-            match current_focus {
-                AddTableFocus::InputTableName | AddTableFocus::InputColumnName | AddTableFocus::InputColumnType =>
-                    { /* *command_message = "At first focusable area.".to_string(); */ } // No change in focus
-                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::InputColumnType,
-                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::AddColumnButton,
-                AddTableFocus::IndexesTable => new_focus = AddTableFocus::ColumnsTable,
-                AddTableFocus::LinksTable => new_focus = AddTableFocus::IndexesTable,
-                AddTableFocus::SaveButton => new_focus = AddTableFocus::LinksTable,
-                AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::SaveButton,
-                AddTableFocus::CancelButton => new_focus = AddTableFocus::DeleteSelectedButton,
-                _ => handled = false,
-            }
-        }
-        Some("next_field") => {
-            new_focus = match current_focus {
-                AddTableFocus::InputTableName => AddTableFocus::InputColumnName, AddTableFocus::InputColumnName => AddTableFocus::InputColumnType, AddTableFocus::InputColumnType => AddTableFocus::AddColumnButton, AddTableFocus::AddColumnButton => AddTableFocus::ColumnsTable,
-                AddTableFocus::ColumnsTable | AddTableFocus::InsideColumnsTable => AddTableFocus::IndexesTable, AddTableFocus::IndexesTable | AddTableFocus::InsideIndexesTable => AddTableFocus::LinksTable, AddTableFocus::LinksTable | AddTableFocus::InsideLinksTable => AddTableFocus::SaveButton,
-                AddTableFocus::SaveButton => AddTableFocus::DeleteSelectedButton, AddTableFocus::DeleteSelectedButton => AddTableFocus::CancelButton, AddTableFocus::CancelButton => AddTableFocus::InputTableName,
-            };
-        }
-        Some("prev_field") => {
-            new_focus = match current_focus {
-                AddTableFocus::InputTableName => AddTableFocus::CancelButton, AddTableFocus::InputColumnName => AddTableFocus::InputTableName, AddTableFocus::InputColumnType => AddTableFocus::InputColumnName, AddTableFocus::AddColumnButton => AddTableFocus::InputColumnType,
-                AddTableFocus::ColumnsTable | AddTableFocus::InsideColumnsTable => AddTableFocus::AddColumnButton, AddTableFocus::IndexesTable | AddTableFocus::InsideIndexesTable => AddTableFocus::ColumnsTable, AddTableFocus::LinksTable | AddTableFocus::InsideLinksTable => AddTableFocus::IndexesTable,
-                AddTableFocus::SaveButton => AddTableFocus::LinksTable, AddTableFocus::DeleteSelectedButton => AddTableFocus::SaveButton, AddTableFocus::CancelButton => AddTableFocus::DeleteSelectedButton,
-            };
-        }
-        Some("select") => {
-            match current_focus {
-                AddTableFocus::ColumnsTable => { new_focus = AddTableFocus::InsideColumnsTable; if add_table_state.column_table_state.selected().is_none() && !add_table_state.columns.is_empty() { add_table_state.column_table_state.select(Some(0)); } /* Message removed */ }
-                AddTableFocus::IndexesTable => { new_focus = AddTableFocus::InsideIndexesTable; if add_table_state.index_table_state.selected().is_none() && !add_table_state.indexes.is_empty() { add_table_state.index_table_state.select(Some(0)); } /* Message removed */ }
-                AddTableFocus::LinksTable => { new_focus = AddTableFocus::InsideLinksTable; if add_table_state.link_table_state.selected().is_none() && !add_table_state.links.is_empty() { add_table_state.link_table_state.select(Some(0)); } /* Message removed */ }
-                AddTableFocus::InsideColumnsTable => { if let Some(index) = add_table_state.column_table_state.selected() { if let Some(col) = add_table_state.columns.get_mut(index) { col.selected = !col.selected; add_table_state.has_unsaved_changes = true; /* Message removed */ }} /* else { Message removed } */ }
-                AddTableFocus::InsideIndexesTable => { if let Some(index) = add_table_state.index_table_state.selected() { if let Some(idx_def) = add_table_state.indexes.get_mut(index) { idx_def.selected = !idx_def.selected; add_table_state.has_unsaved_changes = true; /* Message removed */ }} /* else { Message removed } */ }
-                AddTableFocus::InsideLinksTable => { if let Some(index) = add_table_state.link_table_state.selected() { if let Some(link) = add_table_state.links.get_mut(index) { link.selected = !link.selected; add_table_state.has_unsaved_changes = true; /* Message removed */ }} /* else { Message removed } */ }
-                AddTableFocus::AddColumnButton => { if let Some(focus_after_add) = handle_add_column_action(add_table_state, command_message) { new_focus = focus_after_add; } else { /* Message already set by handle_add_column_action */ }}
-                AddTableFocus::SaveButton => { if add_table_state.table_name.is_empty() { *command_message = "Cannot save: Table name is empty.".to_string(); } else if add_table_state.columns.is_empty() { *command_message = "Cannot save: No columns defined.".to_string(); } else { *command_message = "Saving table...".to_string(); app_state.show_loading_dialog("Saving", "Please wait..."); let mut client_clone = grpc_client.clone(); let state_clone = add_table_state.clone(); let sender_clone = save_result_sender.clone(); tokio::spawn(async move { let result = handle_save_table_action(&mut client_clone, &state_clone).await; let _ = sender_clone.send(result).await; }); }}
-                AddTableFocus::DeleteSelectedButton => { let columns_to_delete: Vec<(usize, String, String)> = add_table_state.columns.iter().enumerate().filter(|(_, col)| col.selected).map(|(index, col)| (index, col.name.clone(), col.data_type.clone())).collect(); if columns_to_delete.is_empty() { *command_message = "No columns selected for deletion.".to_string(); } else { let column_details: String = columns_to_delete.iter().map(|(index, name, dtype)| format!("{}. {} ({})", index + 1, name, dtype)).collect::<Vec<String>>().join("\n"); let message = format!("Delete the following columns?\n\n{}", column_details); app_state.show_dialog("Confirm Deletion", &message, vec!["Confirm".to_string(), "Cancel".to_string()], DialogPurpose::ConfirmDeleteColumns); }}
-                AddTableFocus::CancelButton => { *command_message = "Action: Cancel Add Table (Not Implemented)".to_string(); }
-                _ => { handled = false; }
-            }
-        }
-        _ => handled = false,
-    }
-
-    if handled && current_focus != new_focus {
-        add_table_state.current_focus = new_focus;
-        // Minimal change: Command message update logic can be simplified or removed if not desired
-        // For now, let's keep it minimal and only update if it was truly a focus change,
-        // and not a boundary message.
-        if !command_message.starts_with("At ") && current_focus != new_focus { // Avoid overwriting boundary messages
-            // *command_message = format!("Focus: {:?}", add_table_state.current_focus); // Optional: restore if needed
-        }
-
-
-        let new_is_canvas_input_focus = matches!(new_focus,
-            AddTableFocus::InputTableName | AddTableFocus::InputColumnName | AddTableFocus::InputColumnType
-        );
-        app_state.ui.focus_outside_canvas = !new_is_canvas_input_focus;
-    }
-    // If not handled, command_message remains as it was (e.g., from a deeper function call or previous event)
-    // or can be cleared if that's the desired default. For minimal change, we leave it.
-
-    handled
-}

client/src/pages/admin_panel/add_table/state.rs

@@ -1,6 +1,7 @@
 // src/pages/admin_panel/add_table/state.rs
 
 use canvas::{DataProvider, AppMode};
+use canvas::FormEditor;
 use ratatui::widgets::TableState;
 use serde::{Deserialize, Serialize};
 use crate::movement::{move_focus, MovementAction};
@@ -381,3 +382,77 @@ impl AddTableState {
         move_focus(&ORDER, &mut self.current_focus, action)
     }
 }
+
+pub struct AddTableFormState {
+    pub state: AddTableState,
+    pub editor: FormEditor<AddTableState>,
+    pub focus_outside_canvas: bool,
+}
+
+impl std::fmt::Debug for AddTableFormState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AddTableFormState")
+            .field("state", &self.state)
+            .field("focus_outside_canvas", &self.focus_outside_canvas)
+            .finish()
+    }
+}
+
+impl AddTableFormState {
+    pub fn new(profile_name: String) -> Self {
+        let mut state = AddTableState::default();
+        state.profile_name = profile_name;
+        let editor = FormEditor::new(state.clone());
+        Self {
+            state,
+            editor,
+            focus_outside_canvas: false,
+        }
+    }
+
+    pub fn from_state(state: AddTableState) -> Self {
+        let editor = FormEditor::new(state.clone());
+        Self {
+            state,
+            editor,
+            focus_outside_canvas: false,
+        }
+    }
+
+    /// Sync state from editor’s snapshot
+    pub fn sync_from_editor(&mut self) {
+        self.state = self.editor.data_provider().clone();
+    }
+
+    // === Delegates to AddTableState fields ===
+    pub fn current_focus(&self) -> AddTableFocus {
+        self.state.current_focus
+    }
+    pub fn set_current_focus(&mut self, focus: AddTableFocus) {
+        self.state.current_focus = focus;
+    }
+    pub fn profile_name(&self) -> &str {
+        &self.state.profile_name
+    }
+    pub fn table_name(&self) -> &str {
+        &self.state.table_name
+    }
+    pub fn columns(&self) -> &Vec<ColumnDefinition> {
+        &self.state.columns
+    }
+    pub fn indexes(&self) -> &Vec<IndexDefinition> {
+        &self.state.indexes
+    }
+    pub fn links(&self) -> &Vec<LinkDefinition> {
+        &self.state.links
+    }
+    pub fn column_table_state(&mut self) -> &mut TableState {
+        &mut self.state.column_table_state
+    }
+    pub fn index_table_state(&mut self) -> &mut TableState {
+        &mut self.state.index_table_state
+    }
+    pub fn link_table_state(&mut self) -> &mut TableState {
+        &mut self.state.link_table_state
+    }
+}

client/src/pages/admin_panel/add_table/ui.rs

@@ -1,8 +1,8 @@
 // src/pages/admin_panel/add_table/ui.rs
 use crate::config::colors::themes::Theme;
 use crate::state::app::state::AppState;
-use crate::pages::admin_panel::add_table::state::{AddTableFocus, AddTableState};
-use canvas::{render_canvas, FormEditor};
+use crate::pages::admin_panel::add_table::state::{AddTableFocus, AddTableFormState};
+use canvas::render_canvas;
 use ratatui::{
     layout::{Alignment, Constraint, Direction, Layout, Rect},
     style::{Modifier, Style},
@@ -19,7 +19,7 @@ pub fn render_add_table(
     area: Rect,
     theme: &Theme,
     app_state: &AppState,
-    add_table_state: &mut AddTableState,
+    add_table_state: &mut AddTableFormState,
 ) {
     // --- Configuration ---
     // Threshold width to switch between wide and narrow layouts
@@ -27,7 +27,7 @@ pub fn render_add_table(
 
     // --- State Checks ---
     let focus_on_canvas_inputs = matches!(
-        add_table_state.current_focus,
+        add_table_state.current_focus(),
         AddTableFocus::InputTableName
             | AddTableFocus::InputColumnName
             | AddTableFocus::InputColumnType
@@ -45,11 +45,11 @@ pub fn render_add_table(
     f.render_widget(main_block, area);
 
     // --- Fullscreen Columns Table Check (Narrow Screens Only) ---
-    if area.width < NARROW_LAYOUT_THRESHOLD && add_table_state.current_focus == AddTableFocus::InsideColumnsTable {
+    if area.width < NARROW_LAYOUT_THRESHOLD && add_table_state.current_focus() == AddTableFocus::InsideColumnsTable {
         // Render ONLY the columns table taking the full inner area
         let columns_border_style = Style::default().fg(theme.highlight); // Always highlighted when fullscreen
         let column_rows: Vec<Row<'_>> = add_table_state
-            .columns
+            .columns()
             .iter()
             .map(|col_def| {
                 Row::new(vec![
@@ -80,16 +80,16 @@ pub fn render_add_table(
                 .fg(theme.highlight),
             )
             .highlight_symbol(" > "); // Use the inside symbol
-        f.render_stateful_widget(columns_table, inner_area, &mut add_table_state.column_table_state);
+        f.render_stateful_widget(columns_table, inner_area, add_table_state.column_table_state());
         return; // IMPORTANT: Stop rendering here for fullscreen mode
     }
 
     // --- Fullscreen Indexes Table Check ---
-    if add_table_state.current_focus == AddTableFocus::InsideIndexesTable { // Remove width check
+    if add_table_state.current_focus() == AddTableFocus::InsideIndexesTable { // Remove width check
         // Render ONLY the indexes table taking the full inner area
         let indexes_border_style = Style::default().fg(theme.highlight); // Always highlighted when fullscreen
         let index_rows: Vec<Row<'_>> = add_table_state
-            .indexes
+            .indexes()
             .iter()
             .map(|index_def| {
                 Row::new(vec![
@@ -115,16 +115,16 @@ pub fn render_add_table(
             )
             .row_highlight_style(Style::default().add_modifier(Modifier::REVERSED).fg(theme.highlight))
             .highlight_symbol(" > "); // Use the inside symbol
-        f.render_stateful_widget(indexes_table, inner_area, &mut add_table_state.index_table_state);
+        f.render_stateful_widget(indexes_table, inner_area, &mut add_table_state.index_table_state());
         return; // IMPORTANT: Stop rendering here for fullscreen mode
     }
 
     // --- Fullscreen Links Table Check ---
-    if add_table_state.current_focus == AddTableFocus::InsideLinksTable {
+    if add_table_state.current_focus() == AddTableFocus::InsideLinksTable {
         // Render ONLY the links table taking the full inner area
         let links_border_style = Style::default().fg(theme.highlight); // Always highlighted when fullscreen
         let link_rows: Vec<Row<'_>> = add_table_state
-            .links
+            .links()
             .iter()
             .map(|link_def| {
                 Row::new(vec![
@@ -151,7 +151,7 @@ pub fn render_add_table(
             )
             .row_highlight_style(Style::default().add_modifier(Modifier::REVERSED).fg(theme.highlight))
             .highlight_symbol(" > "); // Use the inside symbol
-        f.render_stateful_widget(links_table, inner_area, &mut add_table_state.link_table_state);
+        f.render_stateful_widget(links_table, inner_area, &mut add_table_state.link_table_state());
         return; // IMPORTANT: Stop rendering here for fullscreen mode
     }
 
@@ -220,11 +220,11 @@ pub fn render_add_table(
         // --- Top Info Rendering (Wide - 2 lines) ---
         let profile_text = Paragraph::new(vec![
             Line::from(Span::styled(
-                format!("Profile: {}", add_table_state.profile_name),
+                format!("Profile: {}", add_table_state.profile_name()),
                 theme.fg,
             )),
             Line::from(Span::styled(
-                format!("Table name: {}", add_table_state.table_name),
+                format!("Table name: {}", add_table_state.table_name()),
                 theme.fg,
             )),
         ])
@@ -276,14 +276,14 @@ pub fn render_add_table(
             .split(top_info_area);
 
         let profile_text = Paragraph::new(Span::styled(
-            format!("Profile: {}", add_table_state.profile_name),
+            format!("Profile: {}", add_table_state.profile_name()),
             theme.fg,
         ))
         .alignment(Alignment::Left);
         f.render_widget(profile_text, top_info_chunks[0]);
 
         let table_name_text = Paragraph::new(Span::styled(
-            format!("Table: {}", add_table_state.table_name),
+            format!("Table: {}", add_table_state.table_name()),
             theme.fg,
         ))
         .alignment(Alignment::Left);
@@ -293,14 +293,14 @@ pub fn render_add_table(
     // --- Common Widget Rendering (Uses calculated areas) ---
 
     // --- Columns Table Rendering ---
-    let columns_focused = matches!(add_table_state.current_focus, AddTableFocus::ColumnsTable | AddTableFocus::InsideColumnsTable);
+    let columns_focused = matches!(add_table_state.current_focus(), AddTableFocus::ColumnsTable | AddTableFocus::InsideColumnsTable);
     let columns_border_style = if columns_focused {
         Style::default().fg(theme.highlight)
     } else {
         Style::default().fg(theme.secondary)
     };
     let column_rows: Vec<Row<'_>> = add_table_state
-        .columns
+        .columns()
         .iter()
         .map(|col_def| {
             Row::new(vec![
@@ -341,12 +341,11 @@ pub fn render_add_table(
     f.render_stateful_widget(
         columns_table,
         columns_area,
-        &mut add_table_state.column_table_state,
+        &mut add_table_state.column_table_state(),
     );
 
     // --- Canvas Rendering (Column Definition Input) - USING CANVAS LIBRARY ---
-    let editor = FormEditor::new(add_table_state.clone());
-    let _active_field_rect = render_canvas(f, canvas_area, &editor, theme);
+    let _active_field_rect = render_canvas(f, canvas_area, &add_table_state.editor, theme);
 
     // --- Button Style Helpers ---
     let get_button_style = |button_focus: AddTableFocus, current_focus| {
@@ -374,11 +373,11 @@ pub fn render_add_table(
 
     // --- Add Button Rendering ---
     // Determine if the add button is focused
-    let is_add_button_focused = add_table_state.current_focus == AddTableFocus::AddColumnButton;
+    let is_add_button_focused = add_table_state.current_focus() == AddTableFocus::AddColumnButton;
 
     // Create the Add button Paragraph widget
     let add_button = Paragraph::new(" Add ")
-        .style(get_button_style(AddTableFocus::AddColumnButton, add_table_state.current_focus)) // Use existing closure
+        .style(get_button_style(AddTableFocus::AddColumnButton, add_table_state.current_focus())) // Use existing closure
         .alignment(Alignment::Center)
         .block(
             Block::default()
@@ -391,14 +390,14 @@ pub fn render_add_table(
     f.render_widget(add_button, add_button_area);
 
     // --- Indexes Table Rendering ---
-    let indexes_focused = matches!(add_table_state.current_focus, AddTableFocus::IndexesTable | AddTableFocus::InsideIndexesTable);
+    let indexes_focused = matches!(add_table_state.current_focus(), AddTableFocus::IndexesTable | AddTableFocus::InsideIndexesTable);
     let indexes_border_style = if indexes_focused {
         Style::default().fg(theme.highlight)
     } else {
         Style::default().fg(theme.secondary)
     };
     let index_rows: Vec<Row<'_>> = add_table_state
-        .indexes
+        .indexes()
         .iter()
         .map(|index_def| { // Use index_def now
             Row::new(vec![
@@ -432,18 +431,18 @@ pub fn render_add_table(
     f.render_stateful_widget(
         indexes_table,
         indexes_area,
-        &mut add_table_state.index_table_state,
+        &mut add_table_state.index_table_state(),
     );
 
     // --- Links Table Rendering ---
-    let links_focused = matches!(add_table_state.current_focus, AddTableFocus::LinksTable | AddTableFocus::InsideLinksTable);
+    let links_focused = matches!(add_table_state.current_focus(), AddTableFocus::LinksTable | AddTableFocus::InsideLinksTable);
     let links_border_style = if links_focused {
         Style::default().fg(theme.highlight)
     } else {
         Style::default().fg(theme.secondary)
     };
     let link_rows: Vec<Row<'_>> = add_table_state
-        .links
+        .links()
         .iter()
         .map(|link_def| {
             Row::new(vec![
@@ -477,7 +476,7 @@ pub fn render_add_table(
     f.render_stateful_widget(
         links_table,
         links_area,
-        &mut add_table_state.link_table_state,
+        &mut add_table_state.link_table_state(),
     );
 
     // --- Save/Cancel Buttons Rendering ---
@@ -493,7 +492,7 @@ pub fn render_add_table(
     let save_button = Paragraph::new(" Save table ")
         .style(get_button_style(
             AddTableFocus::SaveButton,
-            add_table_state.current_focus,
+            add_table_state.current_focus(),
         ))
         .alignment(Alignment::Center)
         .block(
@@ -501,7 +500,7 @@ pub fn render_add_table(
                 .borders(Borders::ALL)
                 .border_type(BorderType::Rounded)
                 .border_style(get_button_border_style(
-                    add_table_state.current_focus == AddTableFocus::SaveButton, // Pass bool
+                    add_table_state.current_focus() == AddTableFocus::SaveButton, // Pass bool
                     theme,
                 )),
         );
@@ -510,7 +509,7 @@ pub fn render_add_table(
     let delete_button = Paragraph::new(" Delete Selected ")
         .style(get_button_style(
             AddTableFocus::DeleteSelectedButton,
-            add_table_state.current_focus,
+            add_table_state.current_focus(),
         ))
         .alignment(Alignment::Center)
         .block(
@@ -518,7 +517,7 @@ pub fn render_add_table(
                 .borders(Borders::ALL)
                 .border_type(BorderType::Rounded)
                 .border_style(get_button_border_style(
-                    add_table_state.current_focus == AddTableFocus::DeleteSelectedButton, // Pass bool
+                    add_table_state.current_focus() == AddTableFocus::DeleteSelectedButton, // Pass bool
                     theme,
                 )),
         );
@@ -527,7 +526,7 @@ pub fn render_add_table(
     let cancel_button = Paragraph::new(" Cancel ")
         .style(get_button_style(
             AddTableFocus::CancelButton,
-            add_table_state.current_focus,
+            add_table_state.current_focus(),
         ))
         .alignment(Alignment::Center)
         .block(
@@ -535,7 +534,7 @@ pub fn render_add_table(
                 .borders(Borders::ALL)
                 .border_type(BorderType::Rounded)
                 .border_style(get_button_border_style(
-                    add_table_state.current_focus == AddTableFocus::CancelButton, // Pass bool
+                    add_table_state.current_focus() == AddTableFocus::CancelButton, // Pass bool
                     theme,
                 )),
         );

client/src/pages/login/event.rs

@@ -35,7 +35,8 @@ pub fn handle_login_event(
         if !login_page.focus_outside_canvas {
             let last_idx = login_page.editor.data_provider().field_count().saturating_sub(1);
             let at_last = login_page.editor.current_field() >= last_idx;
-            if at_last
+            if login_page.editor.mode() == CanvasMode::ReadOnly
+                && at_last
                 && matches!(
                     (key_code, modifiers),
                     (KeyCode::Char('j'), KeyModifiers::NONE) | (KeyCode::Down, _)

client/src/pages/register/event.rs

@@ -38,7 +38,8 @@ pub fn handle_register_event(
         if !register_page.focus_outside_canvas {
             let last_idx = register_page.editor.data_provider().field_count().saturating_sub(1);
             let at_last = register_page.editor.current_field() >= last_idx;
-            if at_last
+            if register_page.editor.mode() == CanvasMode::ReadOnly
+                && at_last
                 && matches!(
                     (key_code, modifiers),
                     (KeyCode::Char('j'), KeyModifiers::NONE) | (KeyCode::Down, _)

client/src/pages/routing/router.rs

@@ -1,7 +1,7 @@
 // src/pages/routing/router.rs
 use crate::state::pages::auth::AuthState;
-use crate::pages::admin_panel::add_logic::state::AddLogicState;
-use crate::pages::admin_panel::add_table::state::AddTableState;
+use crate::pages::admin_panel::add_logic::state::AddLogicFormState;
+use crate::pages::admin_panel::add_table::state::AddTableFormState;
 use crate::pages::admin::AdminState;
 use crate::pages::forms::FormState;
 use crate::pages::login::LoginFormState;
@@ -14,8 +14,8 @@ pub enum Page {
     Login(LoginFormState),
     Register(RegisterFormState),
     Admin(AdminState),
-    AddLogic(AddLogicState),
-    AddTable(AddTableState),
+    AddLogic(AddLogicFormState),
+    AddTable(AddTableFormState),
     Form(String),
 }
 

client/src/ui/handlers/ui.rs

@@ -12,6 +12,8 @@ use crate::state::pages::auth::AuthState;
 use crate::state::pages::auth::UserRole;
 use crate::pages::login::LoginFormState;
 use crate::pages::register::RegisterFormState;
+use crate::pages::admin_panel::add_table;
+use crate::pages::admin_panel::add_logic;
 use crate::pages::admin::AdminState;
 use crate::pages::admin::AdminFocus;
 use crate::pages::admin::admin;
@@ -423,8 +425,23 @@ pub async fn run_ui() -> Result<()> {
 
                     router.navigate(Page::Admin(admin_state.clone()));
                 }
-                AppView::AddTable => router.navigate(Page::AddTable(admin_state.add_table_state.clone())),
-                AppView::AddLogic => router.navigate(Page::AddLogic(admin_state.add_logic_state.clone())),
+                AppView::AddTable => {
+                    router.navigate(Page::AddTable(
+                            add_table::state::AddTableFormState::from_state(
+                                admin_state.add_table_state.clone(),
+                            ),
+                    ));
+                    if let Page::AddTable(page) = &mut router.current {
+                        // Ensure keymap is set once
+                        page.editor.set_keymap(config.build_canvas_keymap());
+                    }
+                }
+                AppView::AddLogic => {
+                    if let Page::AddLogic(page) = &mut router.current {
+                        // Ensure keymap is set once
+                        page.editor.set_keymap(config.build_canvas_keymap());
+                    }
+                }
                 AppView::Form(path) => {
                     // Keep current_view_* consistent with the active buffer path
                     if let Some((profile, table)) = path.split_once('/') {
@@ -485,67 +502,25 @@ pub async fn run_ui() -> Result<()> {
             }
         }
 
-        // Continue with the rest of the positioning logic...
-        // Now we can use CanvasState methods like get_current_input(), current_field(), etc.
+        let needs_redraw_from_fetch = add_logic::loader::process_pending_table_structure_fetch(
+            &mut app_state,
+            &mut router,
+            &mut grpc_client,
+            &mut event_handler.command_message,
+        ).await.unwrap_or(false);
 
-        if let Some((profile_name, table_name)) = app_state.pending_table_structure_fetch.take() {
-            if let Page::AddLogic(state) = &mut router.current {
-                if state.profile_name == profile_name
-                    && state.selected_table_name.as_deref() == Some(table_name.as_str())
-                {
-                    info!("Fetching table structure for {}.{}", profile_name, table_name);
-                    let fetch_message = UiService::initialize_add_logic_table_data(
-                        &mut grpc_client,
-                        state,
-                        &app_state.profile_tree,
-                    )
-                        .await
-                        .unwrap_or_else(|e| {
-                            error!("Error initializing add_logic_table_data: {}", e);
-                            format!("Error fetching table structure: {}", e)
-                        });
-
-                    if !fetch_message.contains("Error") && !fetch_message.contains("Warning") {
-                        info!("{}", fetch_message);
-                    } else {
-                        event_handler.command_message = fetch_message;
-                    }
-                    needs_redraw = true;
-                } else {
-                    error!(
-                        "Mismatch in pending_table_structure_fetch: app_state wants {}.{}, but AddLogic state is for {}.{:?}",
-                        profile_name,
-                        table_name,
-                        state.profile_name,
-                        state.selected_table_name
-                    );
-                }
-            } else {
-                warn!(
-                    "Pending table structure fetch for {}.{} but AddLogic view is not active. Fetch ignored.",
-                    profile_name, table_name
-                );
-            }
+        if needs_redraw_from_fetch {
+            needs_redraw = true;
         }
 
         if let Page::AddLogic(state) = &mut router.current {
-            if let Some(table_name) = state.script_editor_awaiting_column_autocomplete.clone() {
-                let profile_name = state.profile_name.clone();
+            let needs_redraw_from_columns = add_logic::loader::maybe_fetch_columns_for_awaiting_table(
+                &mut grpc_client,
+                state,
+                &mut event_handler.command_message,
+            ).await.unwrap_or(false);
 
-                info!("Fetching columns for table selection: {}.{}", profile_name, table_name);
-                match UiService::fetch_columns_for_table(&mut grpc_client, &profile_name, &table_name).await {
-                    Ok(columns) => {
-                        state.set_columns_for_table_autocomplete(columns.clone());
-                        info!("Loaded {} columns for table '{}'", columns.len(), table_name);
-                        event_handler.command_message = format!("Columns for '{}' loaded. Select a column.", table_name);
-                    }
-                    Err(e) => {
-                        error!("Failed to fetch columns for {}.{}: {}", profile_name, table_name, e);
-                        state.script_editor_awaiting_column_autocomplete = None;
-                        state.deactivate_script_editor_autocomplete();
-                        event_handler.command_message = format!("Error loading columns for '{}': {}", table_name, e);
-                    }
-                }
+            if needs_redraw_from_columns {
                 needs_redraw = true;
             }
         }
@@ -676,6 +651,12 @@ pub async fn run_ui() -> Result<()> {
                         if let Page::Register(page) = &router.current {
                             let _ = CursorManager::update_for_mode(page.editor.mode());
                         }
+                        if let Page::AddTable(page) = &router.current {
+                            let _ = CursorManager::update_for_mode(page.editor.mode());
+                        }
+                        if let Page::AddLogic(page) = &router.current {
+                            let _ = CursorManager::update_for_mode(page.editor.mode());
+                        }
                     }
                 }
                 AppMode::Command => {