working autocomplete now, with backwards deprecation

.envrc

@@ -0,0 +1 @@
+use flake

.gitignore

@@ -1,2 +1,7 @@
 /target
 .env
+/tantivy_indexes
+server/tantivy_indexes
+steel_decimal/tests/property_tests.proptest-regressions
+.direnv/
+canvas/*.toml

Cargo.toml

@@ -1,19 +1,55 @@
 [workspace]
-members = ["client", "server", "common"]
+members = ["client", "server", "common", "search", "canvas"]
 resolver = "2"
 
 [workspace.package]
 # TODO: idk how to do the name, fix later
-# name = "Multieko2"
-version = "0.3.13"
+# name = "komp_ac"
+version = "0.4.2"
 edition = "2021"
 license = "GPL-3.0-or-later"
 authors = ["Filip Priečinský <filippriec@gmail.com>"]
 description = "Poriadny uctovnicky software."
 readme = "README.md"
-repository = "https://gitlab.com/filipriec/multieko2"
+repository = "https://gitlab.com/filipriec/komp_ac"
 categories = ["command-line-interface"]
 
 # [workspace.metadata]
 # TODO:
-# documentation = "https://docs.rs/accounting-client"`
+# documentation = "https://docs.rs/accounting-client"
+
+[workspace.dependencies]
+# Async and gRPC
+tokio = { version = "1.44.2", features = ["full"] }
+tonic = "0.13.0"
+prost = "0.13.5"
+async-trait = "0.1.88"
+prost-types = "0.13.0"
+
+# Data Handling & Serialization
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.140"
+time = "0.3.41"
+
+# Utilities & Error Handling
+anyhow = "1.0.98"
+dotenvy = "0.15.7"
+lazy_static = "1.5.0"
+tracing = "0.1.41"
+
+# Search crate
+tantivy = "0.24.1"
+
+# Steel_decimal crate
+rust_decimal = { version = "1.37.2", features = ["maths", "serde"] }
+rust_decimal_macros = "1.37.1"
+thiserror = "2.0.12"
+regex = "1.11.1"
+
+# Canvas crate
+ratatui = { version = "0.29.0", features = ["crossterm"] }
+crossterm = "0.28.1"
+toml = "0.8.20"
+unicode-width = "0.2.0"
+
+common = { path = "./common" }

canvas/CANVAS_MIGRATION.md

@@ -0,0 +1,334 @@
+# Canvas Library Migration Guide
+
+## Overview
+
+This guide covers the migration from the legacy canvas library structure to the new clean, modular architecture. The new design separates core canvas functionality from autocomplete features, providing better type safety and maintainability.
+
+## Key Changes
+
+### 1. **Modular Architecture**
+```
+# Old Structure (LEGACY)
+src/
+├── state.rs              # Mixed canvas + autocomplete
+├── actions/edit.rs       # Mixed concerns
+├── gui/render.rs         # Everything together
+└── suggestions.rs        # Legacy file
+
+# New Structure (CLEAN)
+src/
+├── canvas/               # Core canvas functionality
+│   ├── state.rs         # CanvasState trait only
+│   ├── actions/edit.rs  # Canvas actions only
+│   └── gui.rs           # Canvas rendering
+├── autocomplete/         # Rich autocomplete features
+│   ├── state.rs         # AutocompleteCanvasState trait
+│   ├── types.rs         # SuggestionItem, AutocompleteState
+│   ├── actions.rs       # Autocomplete actions
+│   └── gui.rs           # Autocomplete dropdown rendering
+└── dispatcher.rs         # Action routing
+```
+
+### 2. **Trait Separation**
+- **CanvasState**: Core form functionality (navigation, input, validation)
+- **AutocompleteCanvasState**: Optional rich autocomplete features
+
+### 3. **Rich Suggestions**
+Replaced simple string suggestions with typed, rich suggestion objects.
+
+## Migration Steps
+
+### Step 1: Update Import Paths
+
+**Find and Replace these imports:**
+
+```rust
+# OLD IMPORTS
+use canvas::CanvasState;
+use canvas::CanvasAction;
+use canvas::ActionContext;
+use canvas::HighlightState;
+use canvas::CanvasTheme;
+use canvas::ActionDispatcher;
+use canvas::ActionResult;
+
+# NEW IMPORTS
+use canvas::canvas::CanvasState;
+use canvas::canvas::CanvasAction;
+use canvas::canvas::ActionContext;
+use canvas::canvas::HighlightState;
+use canvas::canvas::CanvasTheme;
+use canvas::dispatcher::ActionDispatcher;
+use canvas::canvas::ActionResult;
+```
+
+**Complex imports:**
+```rust
+# OLD
+use canvas::{CanvasAction, ActionDispatcher, ActionResult};
+
+# NEW
+use canvas::{canvas::CanvasAction, dispatcher::ActionDispatcher, canvas::ActionResult};
+```
+
+### Step 2: Clean Up State Implementation
+
+**Remove legacy methods from your CanvasState implementation:**
+
+```rust
+impl CanvasState for YourFormState {
+    // Keep all the core methods:
+    fn current_field(&self) -> usize { /* ... */ }
+    fn get_current_input(&self) -> &str { /* ... */ }
+    // ... etc
+
+    // ❌ REMOVE these legacy methods:
+    // fn get_suggestions(&self) -> Option<&[String]>
+    // fn get_selected_suggestion_index(&self) -> Option<usize>
+    // fn set_selected_suggestion_index(&mut self, index: Option<usize>)
+    // fn activate_suggestions(&mut self, suggestions: Vec<String>)
+    // fn deactivate_suggestions(&mut self)
+}
+```
+
+### Step 3: Implement Rich Autocomplete (Optional)
+
+**If you want rich autocomplete features:**
+
+```rust
+use canvas::autocomplete::{AutocompleteCanvasState, SuggestionItem, AutocompleteState};
+
+impl AutocompleteCanvasState for YourFormState {
+    type SuggestionData = YourDataType; // e.g., Hit, CustomRecord, etc.
+
+    fn supports_autocomplete(&self, field_index: usize) -> bool {
+        // Define which fields support autocomplete
+        matches!(field_index, 2 | 3 | 5) // Example: only certain fields
+    }
+
+    fn autocomplete_state(&self) -> Option<&AutocompleteState<Self::SuggestionData>> {
+        Some(&self.autocomplete)
+    }
+
+    fn autocomplete_state_mut(&mut self) -> Option<&mut AutocompleteState<Self::SuggestionData>> {
+        Some(&mut self.autocomplete)
+    }
+}
+```
+
+**Add autocomplete field to your state:**
+```rust
+pub struct YourFormState {
+    // ... existing fields
+    pub autocomplete: AutocompleteState<YourDataType>,
+}
+```
+
+### Step 4: Migrate Suggestions
+
+**Old way (simple strings):**
+```rust
+let suggestions = vec!["John".to_string(), "Jane".to_string()];
+form_state.activate_suggestions(suggestions);
+```
+
+**New way (rich objects):**
+```rust
+let suggestions = vec![
+    SuggestionItem::new(
+        hit1,                                    // Your data object
+        "John Doe (Manager) | ID: 123".to_string(), // What user sees
+        "123".to_string(),                       // What gets stored
+    ),
+    SuggestionItem::simple(hit2, "Jane".to_string()), // Simple version
+];
+form_state.set_autocomplete_suggestions(suggestions);
+```
+
+### Step 5: Update Rendering
+
+**Old rendering:**
+```rust
+// Manual autocomplete rendering
+if form_state.autocomplete_active {
+    render_autocomplete_dropdown(/* ... */);
+}
+```
+
+**New rendering:**
+```rust
+// Canvas handles everything
+use canvas::canvas::render_canvas;
+
+let active_field_rect = render_canvas(f, area, form_state, theme, edit_mode, highlight_state);
+
+// Optional: Rich autocomplete (if implementing AutocompleteCanvasState)
+if form_state.is_autocomplete_active() {
+    if let Some(autocomplete_state) = form_state.autocomplete_state() {
+        canvas::autocomplete::render_autocomplete_dropdown(
+            f, f.area(), active_field_rect.unwrap(), theme, autocomplete_state
+        );
+    }
+}
+```
+
+### Step 6: Update Method Calls
+
+**Replace legacy method calls:**
+```rust
+# OLD
+form_state.deactivate_suggestions();
+
+# NEW - Option A: Add your own method
+impl YourFormState {
+    pub fn deactivate_autocomplete(&mut self) {
+        self.autocomplete_active = false;
+        self.autocomplete_suggestions.clear();
+        self.selected_suggestion_index = None;
+    }
+}
+form_state.deactivate_autocomplete();
+
+# NEW - Option B: Use rich autocomplete trait
+form_state.deactivate_autocomplete(); // If implementing AutocompleteCanvasState
+```
+
+## Benefits of New Architecture
+
+### 1. **Clean Separation of Concerns**
+- Canvas: Form rendering, navigation, input handling
+- Autocomplete: Rich suggestions, dropdown management, async loading
+
+### 2. **Type Safety**
+```rust
+// Old: Stringly typed
+let suggestions: Vec<String> = vec!["user1".to_string()];
+
+// New: Fully typed with your domain objects
+let suggestions: Vec<SuggestionItem<UserRecord>> = vec![
+    SuggestionItem::new(user_record, display_text, stored_value)
+];
+```
+
+### 3. **Rich UX Capabilities**
+- **Display vs Storage**: Show "John Doe (Manager)" but store user ID
+- **Loading States**: Built-in spinner/loading indicators
+- **Async Support**: Designed for async suggestion fetching
+- **Display Overrides**: Show friendly text while storing normalized data
+
+### 4. **Future-Proof**
+- Easy to add new autocomplete features
+- Canvas features don't interfere with autocomplete
+- Modular: Use only what you need
+
+## Advanced Features
+
+### Display Overrides
+Perfect for foreign key relationships:
+
+```rust
+// User selects "John Doe (Manager) | ID: 123"
+// Field stores: "123" (for database)
+// User sees: "John Doe" (friendly display)
+
+impl CanvasState for FormState {
+    fn get_display_value_for_field(&self, index: usize) -> &str {
+        if let Some(display_text) = self.link_display_map.get(&index) {
+            return display_text.as_str(); // Shows "John Doe"
+        }
+        self.inputs().get(index).map(|s| s.as_str()).unwrap_or("") // Shows "123"
+    }
+    
+    fn has_display_override(&self, index: usize) -> bool {
+        self.link_display_map.contains_key(&index)
+    }
+}
+```
+
+### Progressive Enhancement
+Start simple, add features when needed:
+
+```rust
+// Week 1: Basic usage
+SuggestionItem::simple(data, "John".to_string());
+
+// Week 5: Rich display
+SuggestionItem::new(data, "John Doe (Manager)".to_string(), "John".to_string());
+
+// Week 10: Store IDs, show names
+SuggestionItem::new(user, "John Doe (Manager)".to_string(), "123".to_string());
+```
+
+## Breaking Changes Summary
+
+1. **Import paths changed**: Add `canvas::` or `dispatcher::` prefixes
+2. **Legacy suggestion methods removed**: Replace with rich autocomplete or custom methods
+3. **No more simple suggestions**: Use `SuggestionItem` for typed suggestions
+4. **Trait split**: `AutocompleteCanvasState` is now separate and optional
+
+## Troubleshooting
+
+### Common Compilation Errors
+
+**Error**: `no method named 'get_suggestions' found`
+**Fix**: Remove legacy method from `CanvasState` implementation
+
+**Error**: `no 'CanvasState' in the root`
+**Fix**: Change `use canvas::CanvasState` to `use canvas::canvas::CanvasState`
+
+**Error**: `trait bound 'FormState: CanvasState' is not satisfied`
+**Fix**: Make sure your state properly implements the new `CanvasState` trait
+
+### Migration Checklist
+
+- [ ] Updated all import paths
+- [ ] Removed legacy methods from CanvasState implementation
+- [ ] Added custom autocomplete methods if needed
+- [ ] Updated suggestion usage to SuggestionItem
+- [ ] Updated rendering calls
+- [ ] Tested form functionality
+- [ ] Tested autocomplete functionality (if using)
+
+## Example: Complete Migration
+
+**Before:**
+```rust
+use canvas::{CanvasState, CanvasAction};
+
+impl CanvasState for FormState {
+    fn get_suggestions(&self) -> Option<&[String]> { /* ... */ }
+    fn deactivate_suggestions(&mut self) { /* ... */ }
+    // ... other methods
+}
+```
+
+**After:**
+```rust
+use canvas::canvas::{CanvasState, CanvasAction};
+use canvas::autocomplete::{AutocompleteCanvasState, SuggestionItem};
+
+impl CanvasState for FormState {
+    // Only core canvas methods, no suggestion methods
+    fn current_field(&self) -> usize { /* ... */ }
+    fn get_current_input(&self) -> &str { /* ... */ }
+    // ... other core methods only
+}
+
+impl AutocompleteCanvasState for FormState {
+    type SuggestionData = Hit;
+    
+    fn supports_autocomplete(&self, field_index: usize) -> bool {
+        self.fields[field_index].is_link
+    }
+    
+    fn autocomplete_state(&self) -> Option<&AutocompleteState<Self::SuggestionData>> {
+        Some(&self.autocomplete)
+    }
+    
+    fn autocomplete_state_mut(&mut self) -> Option<&mut AutocompleteState<Self::SuggestionData>> {
+        Some(&mut self.autocomplete)
+    }
+}
+```
+
+This migration results in cleaner, more maintainable, and more powerful code!

canvas/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+name = "canvas"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+description.workspace = true
+readme.workspace = true
+repository.workspace = true
+categories.workspace = true
+
+[dependencies]
+common = { path = "../common" }
+ratatui = { workspace = true, optional = true }
+crossterm = { workspace = true }
+anyhow = { workspace = true }
+tokio = { workspace = true, optional = true }
+toml = { workspace = true }
+serde = { workspace = true }
+unicode-width.workspace = true
+thiserror = { workspace = true }
+
+tracing = "0.1.41"
+tracing-subscriber = "0.3.19"
+async-trait = { workspace = true, optional = true }
+
+[dev-dependencies]
+tokio-test = "0.4.4"
+
+[features]
+default = []
+gui = ["ratatui"]
+autocomplete = ["tokio", "async-trait"]
+
+[[example]]
+name = "autocomplete"
+required-features = ["autocomplete", "gui"]
+path = "examples/autocomplete.rs"
+
+[[example]]
+name = "canvas_gui_demo"
+required-features = ["gui"]
+path = "examples/canvas_gui_demo.rs"

canvas/README.md

@@ -0,0 +1,337 @@
+# Canvas 🎨
+
+A reusable, type-safe canvas system for building form-based TUI applications with vim-like modal editing.
+
+## ✨ Features
+
+- **Type-Safe Actions**: No more string-based action names - everything is compile-time checked
+- **Generic Design**: Implement `CanvasState` once, get navigation, editing, and suggestions for free
+- **Vim-Like Experience**: Modal editing with familiar keybindings
+- **Suggestion System**: Built-in autocomplete and suggestions support
+- **Framework Agnostic**: Works with any TUI framework or raw terminal handling
+- **Async Ready**: Full async/await support for modern Rust applications
+- **Batch Operations**: Execute multiple actions atomically
+- **Extensible**: Custom actions and feature-specific handling
+
+## 🚀 Quick Start
+
+Add to your `Cargo.toml`:
+
+```toml
+cargo add canvas
+```
+
+Implement the `CanvasState` trait:
+
+```rust
+use canvas::prelude::*;
+
+#[derive(Debug)]
+struct LoginForm {
+    current_field: usize,
+    cursor_pos: usize,
+    username: String,
+    password: String,
+    has_changes: bool,
+}
+
+impl CanvasState for LoginForm {
+    fn current_field(&self) -> usize { self.current_field }
+    fn current_cursor_pos(&self) -> usize { self.cursor_pos }
+    fn set_current_field(&mut self, index: usize) { self.current_field = index; }
+    fn set_current_cursor_pos(&mut self, pos: usize) { self.cursor_pos = pos; }
+
+    fn get_current_input(&self) -> &str {
+        match self.current_field {
+            0 => &self.username,
+            1 => &self.password,
+            _ => "",
+        }
+    }
+
+    fn get_current_input_mut(&mut self) -> &mut String {
+        match self.current_field {
+            0 => &mut self.username,
+            1 => &mut self.password,
+            _ => unreachable!(),
+        }
+    }
+
+    fn inputs(&self) -> Vec<&String> { vec![&self.username, &self.password] }
+    fn fields(&self) -> Vec<&str> { vec!["Username", "Password"] }
+    fn has_unsaved_changes(&self) -> bool { self.has_changes }
+    fn set_has_unsaved_changes(&mut self, changed: bool) { self.has_changes = changed; }
+}
+```
+
+Use the type-safe action dispatcher:
+
+```rust
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut form = LoginForm::new();
+    let mut ideal_cursor = 0;
+
+    // Type a character - compile-time safe!
+    ActionDispatcher::dispatch(
+        CanvasAction::InsertChar('h'),
+        &mut form,
+        &mut ideal_cursor,
+    ).await?;
+
+    // Move to next field
+    ActionDispatcher::dispatch(
+        CanvasAction::NextField,
+        &mut form,
+        &mut ideal_cursor,
+    ).await?;
+
+    // Batch operations
+    let actions = vec![
+        CanvasAction::InsertChar('p'),
+        CanvasAction::InsertChar('a'),
+        CanvasAction::InsertChar('s'),
+        CanvasAction::InsertChar('s'),
+    ];
+
+    ActionDispatcher::dispatch_batch(actions, &mut form, &mut ideal_cursor).await?;
+
+    Ok(())
+}
+```
+
+## 🎯 Type-Safe Actions
+
+The Canvas system uses strongly-typed actions instead of error-prone strings:
+
+```rust
+// ✅ Type-safe - impossible to make typos
+ActionDispatcher::dispatch(CanvasAction::MoveLeft, &mut form, &mut cursor).await?;
+
+// ❌ Old way - runtime errors waiting to happen
+execute_edit_action("move_left", key, &mut form, &mut cursor).await?;
+execute_edit_action("move_leftt", key, &mut form, &mut cursor).await?; // Oops!
+```
+
+### Available Actions
+
+```rust
+pub enum CanvasAction {
+    // Character input
+    InsertChar(char),
+    
+    // Deletion
+    DeleteBackward,
+    DeleteForward,
+    
+    // Movement
+    MoveLeft, MoveRight, MoveUp, MoveDown,
+    MoveLineStart, MoveLineEnd,
+    MoveWordNext, MoveWordPrev,
+    
+    // Navigation
+    NextField, PrevField,
+    MoveFirstLine, MoveLastLine,
+    
+    // Suggestions
+    SuggestionUp, SuggestionDown,
+    SelectSuggestion, ExitSuggestions,
+    
+    // Extensibility
+    Custom(String),
+}
+```
+
+## 🔧 Advanced Features
+
+### Suggestions and Autocomplete
+
+```rust
+impl CanvasState for MyForm {
+    fn get_suggestions(&self) -> Option<&[String]> {
+        if self.suggestions.is_active {
+            Some(&self.suggestions.suggestions)
+        } else {
+            None
+        }
+    }
+
+    fn handle_feature_action(&mut self, action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+        match action {
+            CanvasAction::InsertChar('@') => {
+                // Trigger email suggestions
+                let suggestions = vec![
+                    format!("{}@gmail.com", self.username),
+                    format!("{}@company.com", self.username),
+                ];
+                self.activate_suggestions(suggestions);
+                None // Let generic handler insert the '@'
+            }
+            CanvasAction::SelectSuggestion => {
+                if let Some(suggestion) = self.suggestions.get_selected() {
+                    *self.get_current_input_mut() = suggestion.clone();
+                    self.deactivate_autocomplete();
+                    Some("Applied suggestion".to_string())
+                }
+                None
+            }
+            _ => None,
+        }
+    }
+}
+```
+
+### Custom Actions
+
+```rust
+fn handle_feature_action(&mut self, action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+    match action {
+        CanvasAction::Custom(cmd) => match cmd.as_str() {
+            "uppercase" => {
+                *self.get_current_input_mut() = self.get_current_input().to_uppercase();
+                Some("Converted to uppercase".to_string())
+            }
+            "validate_email" => {
+                if self.get_current_input().contains('@') {
+                    Some("Email is valid".to_string())
+                } else {
+                    Some("Invalid email format".to_string())
+                }
+            }
+            _ => None,
+        },
+        _ => None,
+    }
+}
+```
+
+### Integration with TUI Frameworks
+
+Canvas is framework-agnostic and works with any TUI library:
+
+```rust
+// Works with crossterm (see examples)
+// Works with termion
+// Works with ratatui/tui-rs
+// Works with cursive
+// Works with raw terminal I/O
+```
+
+## 🏗️ Architecture
+
+Canvas follows a clean, layered architecture:
+
+```
+┌─────────────────────────────────────┐
+│           Your Application          │
+├─────────────────────────────────────┤
+│         ActionDispatcher            │  ← High-level API
+├─────────────────────────────────────┤
+│     CanvasAction (Type-Safe)        │  ← Type safety layer
+├─────────────────────────────────────┤
+│        Action Handlers              │  ← Core logic
+├─────────────────────────────────────┤
+│        CanvasState Trait            │  ← Your implementation
+└─────────────────────────────────────┘
+```
+
+## 🤝 Why Canvas?
+
+### Before Canvas
+```rust
+// ❌ Error-prone string actions
+execute_action("move_left", key, state)?;
+execute_action("move_leftt", key, state)?; // Runtime error!
+
+// ❌ Duplicate navigation logic everywhere
+impl MyLoginForm { /* navigation code */ }
+impl MyConfigForm { /* same navigation code */ }
+impl MyDataForm { /* same navigation code again */ }
+
+// ❌ Manual cursor and field management
+if key == Key::Tab {
+    current_field = (current_field + 1) % fields.len();
+    cursor_pos = cursor_pos.min(current_input.len());
+}
+```
+
+### With Canvas
+```rust
+// ✅ Type-safe actions
+ActionDispatcher::dispatch(CanvasAction::MoveLeft, state, cursor)?;
+// Typos are impossible - won't compile!
+
+// ✅ Implement once, use everywhere
+impl CanvasState for MyForm { /* minimal implementation */ }
+// All navigation, editing, suggestions work automatically!
+
+// ✅ High-level operations
+ActionDispatcher::dispatch_batch(actions, state, cursor)?;
+```
+
+## 📖 Documentation
+
+- **API Docs**: `cargo doc --open`
+- **Examples**: See `examples/` directory
+- **Migration Guide**: See `CANVAS_MIGRATION.md`
+
+## 🔄 Migration from String-Based Actions
+
+Canvas provides backwards compatibility during migration:
+
+```rust
+// Legacy support (deprecated)
+execute_edit_action("move_left", key, state, cursor).await?;
+
+// New type-safe way
+ActionDispatcher::dispatch(CanvasAction::MoveLeft, state, cursor).await?;
+```
+
+## 🧪 Testing
+
+```bash
+# Run all tests
+cargo test
+
+# Run specific example
+cargo run --example simple_login
+
+# Check type safety
+cargo check
+```
+
+## 📋 Requirements
+
+- Rust 1.70+
+- Terminal with cursor support
+- Optional: async runtime (tokio) for examples
+
+## 🤔 FAQ
+
+**Q: Does Canvas work with [my TUI framework]?**  
+A: Yes! Canvas is framework-agnostic. Just implement `CanvasState` and handle the key events.
+
+**Q: Can I extend Canvas with custom actions?**  
+A: Absolutely! Use `CanvasAction::Custom("my_action")` or implement `handle_feature_action`.
+
+**Q: Is Canvas suitable for complex forms?**  
+A: Yes! See the `config_screen` example for validation, suggestions, and multi-field forms.
+
+**Q: How do I migrate from string-based actions?**  
+A: Canvas provides backwards compatibility. Migrate incrementally using the type-safe APIs.
+
+## 📄 License
+
+Licensed under either of:
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE))
+- MIT License ([LICENSE-MIT](LICENSE-MIT))
+
+at your option.
+
+## 🙏 Contributing
+
+Will write here something later on, too busy rn
+
+---
+
+Built with ❤️ for the Rust TUI community

canvas/docs/new_function_to_config.txt

@@ -0,0 +1,77 @@
+❯ git status
+On branch main
+Your branch is ahead of 'origin/main' by 1 commit.
+  (use "git push" to publish your local commits)
+
+Changes not staged for commit:
+  (use "git add <file>..." to update what will be committed)
+  (use "git restore <file>..." to discard changes in working directory)
+	modified:   src/canvas/actions/handlers/edit.rs
+	modified:   src/canvas/actions/types.rs
+
+no changes added to commit (use "git add" and/or "git commit -a")
+❯ git --no-pager diff
+diff --git a/canvas/src/canvas/actions/handlers/edit.rs b/canvas/src/canvas/actions/handlers/edit.rs
+index a26fe6f..fa1becb 100644
+--- a/canvas/src/canvas/actions/handlers/edit.rs
++++ b/canvas/src/canvas/actions/handlers/edit.rs
+@@ -29,6 +29,21 @@ pub async fn handle_edit_action<S: CanvasState>(
+             Ok(ActionResult::success())
+         }
+
++        CanvasAction::SelectAll => {
++            // Select all text in current field
++            let current_input = state.get_current_input();
++            let text_length = current_input.len();
++
++            // Set cursor to start and select all
++            state.set_current_cursor_pos(0);
++            // TODO: You'd need to add selection state to CanvasState trait
++            // For now, just move cursor to end to "select" all
++            state.set_current_cursor_pos(text_length);
++            *ideal_cursor_column = text_length;
++
++            Ok(ActionResult::success_with_message(&format!("Selected all {} characters", text_length)))
++        }
++
+         CanvasAction::DeleteBackward => {
+             let cursor_pos = state.current_cursor_pos();
+             if cursor_pos > 0 {
+@@ -323,6 +338,13 @@ impl ActionHandlerIntrospection for EditHandler {
+             is_required: false,
+         });
+
++        actions.push(ActionSpec {
++            name: "select_all".to_string(),
++            description: "Select all text in current field".to_string(),
++            examples: vec!["Ctrl+a".to_string()],
++            is_required: false, // Optional action
++        });
++
+         HandlerCapabilities {
+             mode_name: "edit".to_string(),
+             actions,
+diff --git a/canvas/src/canvas/actions/types.rs b/canvas/src/canvas/actions/types.rs
+index 433a4d5..3794596 100644
+--- a/canvas/src/canvas/actions/types.rs
++++ b/canvas/src/canvas/actions/types.rs
+@@ -31,6 +31,8 @@ pub enum CanvasAction {
+     NextField,
+     PrevField,
+
++    SelectAll,
++
+     // Autocomplete actions
+     TriggerAutocomplete,
+     SuggestionUp,
+@@ -62,6 +64,7 @@ impl CanvasAction {
+             "move_word_end_prev" => Self::MoveWordEndPrev,
+             "next_field" => Self::NextField,
+             "prev_field" => Self::PrevField,
++            "select_all" => Self::SelectAll,
+             "trigger_autocomplete" => Self::TriggerAutocomplete,
+             "suggestion_up" => Self::SuggestionUp,
+             "suggestion_down" => Self::SuggestionDown,
+╭─      ~/Doc/p/komp_ac/canvas  on    main ⇡1 !2 
+╰─
+

canvas/examples/autocomplete.rs

@@ -0,0 +1,417 @@
+// examples/autocomplete.rs
+// Run with: cargo run --example autocomplete --features "autocomplete,gui"
+
+use std::io;
+use crossterm::{
+    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyModifiers},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+};
+use ratatui::{
+    backend::{Backend, CrosstermBackend},
+    layout::{Constraint, Direction, Layout},
+    style::Color,
+    text::{Line, Span},
+    widgets::{Block, Borders, Paragraph},
+    Frame, Terminal,
+};
+
+use canvas::{
+    canvas::{
+        gui::render_canvas,
+        modes::AppMode,
+        state::{ActionContext, CanvasState},
+        theme::CanvasTheme,
+    },
+    autocomplete::{
+        AutocompleteCanvasState,
+        AutocompleteState,
+        SuggestionItem,
+        execute_with_autocomplete,
+        handle_autocomplete_feature_action,
+    },
+    CanvasAction,
+};
+
+// Add the async_trait import
+use async_trait::async_trait;
+
+// Simple theme implementation
+#[derive(Clone)]
+struct DemoTheme;
+
+impl CanvasTheme for DemoTheme {
+    fn bg(&self) -> Color { Color::Reset }
+    fn fg(&self) -> Color { Color::White }
+    fn accent(&self) -> Color { Color::Cyan }
+    fn secondary(&self) -> Color { Color::Gray }
+    fn highlight(&self) -> Color { Color::Yellow }
+    fn highlight_bg(&self) -> Color { Color::DarkGray }
+    fn warning(&self) -> Color { Color::Red }
+    fn border(&self) -> Color { Color::Gray }
+}
+
+// Custom suggestion data type
+#[derive(Clone, Debug)]
+struct EmailSuggestion {
+    email: String,
+    provider: String,
+}
+
+// Demo form state with autocomplete
+struct AutocompleteFormState {
+    fields: Vec<String>,
+    field_names: Vec<String>,
+    current_field: usize,
+    cursor_pos: usize,
+    mode: AppMode,
+    has_changes: bool,
+    debug_message: String,
+
+    // Autocomplete state
+    autocomplete: AutocompleteState<EmailSuggestion>,
+}
+
+impl AutocompleteFormState {
+    fn new() -> Self {
+        Self {
+            fields: vec![
+                "John Doe".to_string(),
+                "john@".to_string(), // Partial email to demonstrate autocomplete
+                "+1 234 567 8900".to_string(),
+                "San Francisco".to_string(),
+            ],
+            field_names: vec![
+                "Name".to_string(),
+                "Email".to_string(),
+                "Phone".to_string(),
+                "City".to_string(),
+            ],
+            current_field: 1, // Start on email field
+            cursor_pos: 5, // Position after "john@"
+            mode: AppMode::Edit,
+            has_changes: false,
+            debug_message: "Type in email field, Tab to trigger autocomplete, Enter to select, Esc to cancel".to_string(),
+            autocomplete: AutocompleteState::new(),
+        }
+    }
+}
+
+impl CanvasState for AutocompleteFormState {
+    fn current_field(&self) -> usize { self.current_field }
+    fn current_cursor_pos(&self) -> usize { self.cursor_pos }
+    fn set_current_field(&mut self, index: usize) {
+        self.current_field = index.min(self.fields.len().saturating_sub(1));
+        // Clear autocomplete when changing fields
+        if self.is_autocomplete_active() {
+            self.clear_autocomplete_suggestions();
+        }
+    }
+    fn set_current_cursor_pos(&mut self, pos: usize) {
+        let max_pos = if self.mode == AppMode::Edit {
+            self.fields[self.current_field].len()
+        } else {
+            self.fields[self.current_field].len().saturating_sub(1)
+        };
+        self.cursor_pos = pos.min(max_pos);
+    }
+    fn current_mode(&self) -> AppMode { self.mode }
+    fn get_current_input(&self) -> &str { &self.fields[self.current_field] }
+    fn get_current_input_mut(&mut self) -> &mut String { &mut self.fields[self.current_field] }
+    fn inputs(&self) -> Vec<&String> { self.fields.iter().collect() }
+    fn fields(&self) -> Vec<&str> { self.field_names.iter().map(|s| s.as_str()).collect() }
+    fn has_unsaved_changes(&self) -> bool { self.has_changes }
+    fn set_has_unsaved_changes(&mut self, changed: bool) { self.has_changes = changed; }
+
+    fn handle_feature_action(&mut self, action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+        // Handle autocomplete actions first
+        if let Some(result) = handle_autocomplete_feature_action(action, self) {
+            return Some(result);
+        }
+
+        // Handle other custom actions
+        match action {
+            CanvasAction::Custom(cmd) => {
+                match cmd.as_str() {
+                    "toggle_mode" => {
+                        self.mode = match self.mode {
+                            AppMode::Edit => AppMode::ReadOnly,
+                            AppMode::ReadOnly => AppMode::Edit,
+                            _ => AppMode::Edit,
+                        };
+                        Some(format!("Switched to {:?} mode", self.mode))
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+    }
+}
+
+// Add the #[async_trait] attribute to the implementation
+#[async_trait]
+impl AutocompleteCanvasState for AutocompleteFormState {
+    type SuggestionData = EmailSuggestion;
+
+    fn supports_autocomplete(&self, field_index: usize) -> bool {
+        // Only enable autocomplete for email field (index 1)
+        field_index == 1
+    }
+
+    fn autocomplete_state(&self) -> Option<&AutocompleteState<Self::SuggestionData>> {
+        Some(&self.autocomplete)
+    }
+
+    fn autocomplete_state_mut(&mut self) -> Option<&mut AutocompleteState<Self::SuggestionData>> {
+        Some(&mut self.autocomplete)
+    }
+
+    fn should_trigger_autocomplete(&self) -> bool {
+        let current_input = self.get_current_input();
+        let current_field = self.current_field();
+
+        // Trigger for email field when we have "@" and at least 1 more character
+        self.supports_autocomplete(current_field) &&
+        current_input.contains('@') &&
+        current_input.len() > current_input.find('@').unwrap_or(0) + 1 &&
+        !self.is_autocomplete_active()
+    }
+
+    /// This is where the magic happens - user implements their own async fetching
+    async fn trigger_autocomplete_suggestions(&mut self) {
+        // 1. Activate UI (shows loading spinner)
+        self.activate_autocomplete();
+        self.set_autocomplete_loading(true);
+
+        // 2. Get current input for querying
+        let query = self.get_current_input().to_string();
+
+        // 3. Extract domain part from email
+        let domain_part = if let Some(at_pos) = query.find('@') {
+            query[at_pos + 1..].to_string()
+        } else {
+            self.set_autocomplete_loading(false);
+            return; // No @ symbol, can't suggest
+        };
+
+        // 4. SIMULATE ASYNC API CALL (in real code, this would be HTTP request)
+        let email_prefix = query[..query.find('@').unwrap()].to_string();
+        let suggestions = tokio::task::spawn_blocking(move || {
+            // Simulate network delay
+            std::thread::sleep(std::time::Duration::from_millis(200));
+
+            // Create mock suggestions based on domain input
+            let popular_domains = vec![
+                ("gmail.com", "Gmail"),
+                ("yahoo.com", "Yahoo Mail"),
+                ("outlook.com", "Outlook"),
+                ("hotmail.com", "Hotmail"),
+                ("company.com", "Company Email"),
+                ("university.edu", "University"),
+            ];
+
+            let mut results = Vec::new();
+
+            for (domain, provider) in popular_domains {
+                if domain.starts_with(&domain_part) || domain_part.is_empty() {
+                    let full_email = format!("{}@{}", email_prefix, domain);
+                    results.push(SuggestionItem::new(
+                        EmailSuggestion {
+                            email: full_email.clone(),
+                            provider: provider.to_string(),
+                        },
+                        format!("{} ({})", full_email, provider), // display text
+                        full_email, // value to store
+                    ));
+                }
+            }
+
+            results
+        }).await.unwrap_or_default();
+
+        // 5. Provide suggestions back to library
+        self.set_autocomplete_suggestions(suggestions);
+    }
+}
+
+async fn handle_key_press(key: KeyCode, modifiers: KeyModifiers, state: &mut AutocompleteFormState) -> bool {
+    if key == KeyCode::F(10) || (key == KeyCode::Char('c') && modifiers.contains(KeyModifiers::CONTROL)) {
+        return false; // Quit
+    }
+
+    let action = match key {
+        // === AUTOCOMPLETE KEYS ===
+        KeyCode::Tab => {
+            if state.is_autocomplete_active() {
+                Some(CanvasAction::SuggestionDown) // Navigate suggestions
+            } else if state.supports_autocomplete(state.current_field()) {
+                Some(CanvasAction::TriggerAutocomplete) // Manual trigger
+            } else {
+                Some(CanvasAction::NextField) // Normal tab
+            }
+        }
+
+        KeyCode::BackTab => {
+            if state.is_autocomplete_active() {
+                Some(CanvasAction::SuggestionUp)
+            } else {
+                Some(CanvasAction::PrevField)
+            }
+        }
+
+        KeyCode::Enter => {
+            if state.is_autocomplete_active() {
+                Some(CanvasAction::SelectSuggestion) // Apply suggestion
+            } else {
+                Some(CanvasAction::NextField)
+            }
+        }
+
+        KeyCode::Esc => {
+            if state.is_autocomplete_active() {
+                Some(CanvasAction::ExitSuggestions) // Close autocomplete
+            } else {
+                Some(CanvasAction::Custom("toggle_mode".to_string()))
+            }
+        }
+
+        // === STANDARD CANVAS KEYS ===
+        KeyCode::Left => Some(CanvasAction::MoveLeft),
+        KeyCode::Right => Some(CanvasAction::MoveRight),
+        KeyCode::Up => Some(CanvasAction::MoveUp),
+        KeyCode::Down => Some(CanvasAction::MoveDown),
+        KeyCode::Home => Some(CanvasAction::MoveLineStart),
+        KeyCode::End => Some(CanvasAction::MoveLineEnd),
+        KeyCode::Backspace => Some(CanvasAction::DeleteBackward),
+        KeyCode::Delete => Some(CanvasAction::DeleteForward),
+
+        // Character input
+        KeyCode::Char(c) if !modifiers.contains(KeyModifiers::CONTROL) => {
+            Some(CanvasAction::InsertChar(c))
+        }
+
+        _ => None,
+    };
+
+    if let Some(action) = action {
+        match execute_with_autocomplete(action.clone(), state).await {
+            Ok(result) => {
+                if let Some(msg) = result.message() {
+                    state.debug_message = msg.to_string();
+                } else {
+                    state.debug_message = format!("Executed: {:?}", action);
+                }
+                true
+            }
+            Err(e) => {
+                state.debug_message = format!("Error: {}", e);
+                true
+            }
+        }
+    } else {
+        state.debug_message = format!("Unhandled key: {:?}", key);
+        true
+    }
+}
+
+async fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut state: AutocompleteFormState) -> io::Result<()> {
+    let theme = DemoTheme;
+
+    loop {
+        terminal.draw(|f| ui(f, &state, &theme))?;
+
+        if let Event::Key(key) = event::read()? {
+            let should_continue = handle_key_press(key.code, key.modifiers, &mut state).await;
+            if !should_continue {
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn ui(f: &mut Frame, state: &AutocompleteFormState, theme: &DemoTheme) {
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([
+            Constraint::Min(8),
+            Constraint::Length(5),
+        ])
+        .split(f.area());
+
+    // Render the canvas form
+    let active_field_rect = render_canvas(
+        f,
+        chunks[0],
+        state,
+        theme,
+        state.mode == AppMode::Edit,
+        &canvas::HighlightState::Off,
+    );
+
+    // Render autocomplete dropdown on top if active
+    if let Some(input_rect) = active_field_rect {
+        canvas::render_autocomplete_dropdown(
+            f,
+            chunks[0],
+            input_rect,
+            theme,
+            &state.autocomplete,
+        );
+    }
+
+    // Status info
+    let autocomplete_status = if state.is_autocomplete_active() {
+        if state.autocomplete.is_loading {
+            "Loading suggestions..."
+        } else if state.has_autocomplete_suggestions() {
+            "Use Tab/Shift+Tab to navigate, Enter to select, Esc to cancel"
+        } else {
+            "No suggestions found"
+        }
+    } else {
+        "Tab to trigger autocomplete"
+    };
+
+    let status_lines = vec![
+        Line::from(Span::raw(format!("Mode: {:?} | Field: {}/{} | Cursor: {}",
+            state.mode, state.current_field + 1, state.fields.len(), state.cursor_pos))),
+        Line::from(Span::raw(format!("Autocomplete: {}", autocomplete_status))),
+        Line::from(Span::raw(state.debug_message.clone())),
+        Line::from(Span::raw("F10: Quit | Tab: Trigger/Navigate autocomplete | Enter: Select | Esc: Cancel/Toggle mode")),
+    ];
+
+    let status = Paragraph::new(status_lines)
+        .block(Block::default().borders(Borders::ALL).title("Status & Help"));
+
+    f.render_widget(status, chunks[1]);
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    let state = AutocompleteFormState::new();
+
+    let res = run_app(&mut terminal, state).await;
+
+    disable_raw_mode()?;
+    execute!(
+        terminal.backend_mut(),
+        LeaveAlternateScreen,
+        DisableMouseCapture
+    )?;
+    terminal.show_cursor()?;
+
+    if let Err(err) = res {
+        println!("{:?}", err);
+    }
+
+    Ok(())
+}

canvas/examples/canvas_gui_demo.rs

@@ -0,0 +1,388 @@
+// examples/canvas_gui_demo.rs
+
+use std::io;
+use crossterm::{
+    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyModifiers},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+};
+use ratatui::{
+    backend::{Backend, CrosstermBackend},
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Style},
+    text::{Line, Span},
+    widgets::{Block, Borders, Paragraph},
+    Frame, Terminal,
+};
+
+use canvas::{
+    canvas::{
+        gui::render_canvas,
+        modes::{AppMode, HighlightState, ModeManager},
+        state::{ActionContext, CanvasState},
+        theme::CanvasTheme,
+    },
+    CanvasAction, execute,
+};
+
+// Simple theme implementation
+#[derive(Clone)]
+struct DemoTheme;
+
+impl CanvasTheme for DemoTheme {
+    fn bg(&self) -> Color { Color::Reset }
+    fn fg(&self) -> Color { Color::White }
+    fn accent(&self) -> Color { Color::Cyan }
+    fn secondary(&self) -> Color { Color::Gray }
+    fn highlight(&self) -> Color { Color::Yellow }
+    fn highlight_bg(&self) -> Color { Color::DarkGray }
+    fn warning(&self) -> Color { Color::Red }
+    fn border(&self) -> Color { Color::Gray }
+}
+
+// Demo form state
+struct DemoFormState {
+    fields: Vec<String>,
+    field_names: Vec<String>,
+    current_field: usize,
+    cursor_pos: usize,
+    mode: AppMode,
+    highlight_state: HighlightState,
+    has_changes: bool,
+    debug_message: String,
+}
+
+impl DemoFormState {
+    fn new() -> Self {
+        Self {
+            fields: vec![
+                "John Doe".to_string(),
+                "john.doe@example.com".to_string(),
+                "+1 234 567 8900".to_string(),
+                "123 Main Street Apt 4B".to_string(),
+                "San Francisco".to_string(),
+                "This is a test comment with multiple words".to_string(),
+            ],
+            field_names: vec![
+                "Name".to_string(),
+                "Email".to_string(),
+                "Phone".to_string(),
+                "Address".to_string(),
+                "City".to_string(),
+                "Comments".to_string(),
+            ],
+            current_field: 0,
+            cursor_pos: 0,
+            mode: AppMode::ReadOnly,
+            highlight_state: HighlightState::Off,
+            has_changes: false,
+            debug_message: "Ready - Use hjkl to move, w for next word, i to edit".to_string(),
+        }
+    }
+
+    fn enter_edit_mode(&mut self) {
+        if ModeManager::can_enter_edit_mode(self.mode) {
+            self.mode = AppMode::Edit;
+            self.debug_message = "Entered EDIT mode".to_string();
+        }
+    }
+
+    fn enter_readonly_mode(&mut self) {
+        if ModeManager::can_enter_read_only_mode(self.mode) {
+            self.mode = AppMode::ReadOnly;
+            self.highlight_state = HighlightState::Off;
+            self.debug_message = "Entered READ-ONLY mode".to_string();
+        }
+    }
+
+    fn enter_highlight_mode(&mut self) {
+        if ModeManager::can_enter_highlight_mode(self.mode) {
+            self.mode = AppMode::Highlight;
+            self.highlight_state = HighlightState::Characterwise {
+                anchor: (self.current_field, self.cursor_pos),
+            };
+            self.debug_message = "Entered VISUAL mode".to_string();
+        }
+    }
+}
+
+impl CanvasState for DemoFormState {
+    fn current_field(&self) -> usize {
+        self.current_field
+    }
+
+    fn current_cursor_pos(&self) -> usize {
+        self.cursor_pos
+    }
+
+    fn set_current_field(&mut self, index: usize) {
+        self.current_field = index.min(self.fields.len().saturating_sub(1));
+        self.cursor_pos = self.fields[self.current_field].len();
+    }
+
+    fn set_current_cursor_pos(&mut self, pos: usize) {
+        let max_pos = self.fields[self.current_field].len();
+        self.cursor_pos = pos.min(max_pos);
+    }
+
+    fn current_mode(&self) -> AppMode {
+        self.mode
+    }
+
+    fn get_current_input(&self) -> &str {
+        &self.fields[self.current_field]
+    }
+
+    fn get_current_input_mut(&mut self) -> &mut String {
+        &mut self.fields[self.current_field]
+    }
+
+    fn inputs(&self) -> Vec<&String> {
+        self.fields.iter().collect()
+    }
+
+    fn fields(&self) -> Vec<&str> {
+        self.field_names.iter().map(|s| s.as_str()).collect()
+    }
+
+    fn has_unsaved_changes(&self) -> bool {
+        self.has_changes
+    }
+
+    fn set_has_unsaved_changes(&mut self, changed: bool) {
+        self.has_changes = changed;
+    }
+
+    fn handle_feature_action(&mut self, action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+        match action {
+            CanvasAction::Custom(cmd) => {
+                match cmd.as_str() {
+                    "enter_edit_mode" => {
+                        self.enter_edit_mode();
+                        Some("Entered edit mode".to_string())
+                    }
+                    "enter_readonly_mode" => {
+                        self.enter_readonly_mode();
+                        Some("Entered read-only mode".to_string())
+                    }
+                    "enter_highlight_mode" => {
+                        self.enter_highlight_mode();
+                        Some("Entered highlight mode".to_string())
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+    }
+}
+
+/// Simple key mapping - users have full control!
+async fn handle_key_press(key: KeyCode, modifiers: KeyModifiers, state: &mut DemoFormState) -> bool {
+    let is_edit_mode = state.mode == AppMode::Edit;
+    
+    // Handle quit first
+    if (key == KeyCode::Char('q') && modifiers.contains(KeyModifiers::CONTROL)) ||
+       (key == KeyCode::Char('c') && modifiers.contains(KeyModifiers::CONTROL)) ||
+       key == KeyCode::F(10) {
+        return false; // Signal to quit
+    }
+
+    // Users directly map keys to actions - no configuration needed!
+    let action = match (state.mode, key, modifiers) {
+        // === READ-ONLY MODE KEYS ===
+        (AppMode::ReadOnly, KeyCode::Char('h'), _) => Some(CanvasAction::MoveLeft),
+        (AppMode::ReadOnly, KeyCode::Char('j'), _) => Some(CanvasAction::MoveDown),
+        (AppMode::ReadOnly, KeyCode::Char('k'), _) => Some(CanvasAction::MoveUp),
+        (AppMode::ReadOnly, KeyCode::Char('l'), _) => Some(CanvasAction::MoveRight),
+        (AppMode::ReadOnly, KeyCode::Char('w'), _) => Some(CanvasAction::MoveWordNext),
+        (AppMode::ReadOnly, KeyCode::Char('b'), _) => Some(CanvasAction::MoveWordPrev),
+        (AppMode::ReadOnly, KeyCode::Char('e'), _) => Some(CanvasAction::MoveWordEnd),
+        (AppMode::ReadOnly, KeyCode::Char('0'), _) => Some(CanvasAction::MoveLineStart),
+        (AppMode::ReadOnly, KeyCode::Char('$'), _) => Some(CanvasAction::MoveLineEnd),
+        (AppMode::ReadOnly, KeyCode::Tab, _) => Some(CanvasAction::NextField),
+        (AppMode::ReadOnly, KeyCode::BackTab, _) => Some(CanvasAction::PrevField),
+        
+        // === EDIT MODE KEYS ===
+        (AppMode::Edit, KeyCode::Left, _) => Some(CanvasAction::MoveLeft),
+        (AppMode::Edit, KeyCode::Right, _) => Some(CanvasAction::MoveRight),
+        (AppMode::Edit, KeyCode::Up, _) => Some(CanvasAction::MoveUp),
+        (AppMode::Edit, KeyCode::Down, _) => Some(CanvasAction::MoveDown),
+        (AppMode::Edit, KeyCode::Home, _) => Some(CanvasAction::MoveLineStart),
+        (AppMode::Edit, KeyCode::End, _) => Some(CanvasAction::MoveLineEnd),
+        (AppMode::Edit, KeyCode::Backspace, _) => Some(CanvasAction::DeleteBackward),
+        (AppMode::Edit, KeyCode::Delete, _) => Some(CanvasAction::DeleteForward),
+        (AppMode::Edit, KeyCode::Tab, _) => Some(CanvasAction::NextField),
+        (AppMode::Edit, KeyCode::BackTab, _) => Some(CanvasAction::PrevField),
+        
+        // Vim-style movement in edit mode (optional)
+        (AppMode::Edit, KeyCode::Char('h'), m) if m.contains(KeyModifiers::CONTROL) => Some(CanvasAction::MoveLeft),
+        (AppMode::Edit, KeyCode::Char('l'), m) if m.contains(KeyModifiers::CONTROL) => Some(CanvasAction::MoveRight),
+        
+        // Word movement with Ctrl in edit mode
+        (AppMode::Edit, KeyCode::Left, m) if m.contains(KeyModifiers::CONTROL) => Some(CanvasAction::MoveWordPrev),
+        (AppMode::Edit, KeyCode::Right, m) if m.contains(KeyModifiers::CONTROL) => Some(CanvasAction::MoveWordNext),
+        
+        // === MODE TRANSITIONS === 
+        (AppMode::ReadOnly, KeyCode::Char('i'), _) => Some(CanvasAction::Custom("enter_edit_mode".to_string())),
+        (AppMode::ReadOnly, KeyCode::Char('a'), _) => {
+            // 'a' moves to end of line then enters edit mode
+            if let Ok(_) = execute(CanvasAction::MoveLineEnd, state).await {
+                Some(CanvasAction::Custom("enter_edit_mode".to_string()))
+            } else {
+                None
+            }
+        },
+        (AppMode::ReadOnly, KeyCode::Char('v'), _) => Some(CanvasAction::Custom("enter_highlight_mode".to_string())),
+        (_, KeyCode::Esc, _) => Some(CanvasAction::Custom("enter_readonly_mode".to_string())),
+        
+        // === CHARACTER INPUT IN EDIT MODE ===
+        (AppMode::Edit, KeyCode::Char(c), m) if !m.contains(KeyModifiers::CONTROL) && !m.contains(KeyModifiers::ALT) => {
+            Some(CanvasAction::InsertChar(c))
+        },
+        
+        // === ARROW KEYS IN READ-ONLY MODE ===
+        (AppMode::ReadOnly, KeyCode::Left, _) => Some(CanvasAction::MoveLeft),
+        (AppMode::ReadOnly, KeyCode::Right, _) => Some(CanvasAction::MoveRight),
+        (AppMode::ReadOnly, KeyCode::Up, _) => Some(CanvasAction::MoveUp),
+        (AppMode::ReadOnly, KeyCode::Down, _) => Some(CanvasAction::MoveDown),
+        
+        _ => None,
+    };
+
+    // Execute the action if we found one
+    if let Some(action) = action {
+        match execute(action.clone(), state).await {
+            Ok(result) => {
+                if result.is_success() {
+                    // Mark as changed for editing actions
+                    if is_edit_mode {
+                        match action {
+                            CanvasAction::InsertChar(_) | CanvasAction::DeleteBackward | CanvasAction::DeleteForward => {
+                                state.set_has_unsaved_changes(true);
+                            }
+                            _ => {}
+                        }
+                    }
+                    
+                    if let Some(msg) = result.message() {
+                        state.debug_message = msg.to_string();
+                    } else {
+                        state.debug_message = format!("Executed: {}", action.description());
+                    }
+                } else if let Some(msg) = result.message() {
+                    state.debug_message = format!("Error: {}", msg);
+                }
+            }
+            Err(e) => {
+                state.debug_message = format!("Error executing action: {}", e);
+            }
+        }
+    } else {
+        state.debug_message = format!("Unhandled key: {:?} (mode: {:?})", key, state.mode);
+    }
+
+    true // Continue running
+}
+
+async fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut state: DemoFormState) -> io::Result<()> {
+    let theme = DemoTheme;
+
+    loop {
+        terminal.draw(|f| ui(f, &state, &theme))?;
+
+        if let Event::Key(key) = event::read()? {
+            let should_continue = handle_key_press(key.code, key.modifiers, &mut state).await;
+            if !should_continue {
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn ui(f: &mut Frame, state: &DemoFormState, theme: &DemoTheme) {
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([
+            Constraint::Min(8),
+            Constraint::Length(4),
+        ])
+        .split(f.area());
+
+    // Render the canvas form
+    render_canvas(
+        f,
+        chunks[0],
+        state,
+        theme,
+        state.mode == AppMode::Edit,
+        &state.highlight_state,
+    );
+
+    // Render status bar
+    let mode_text = match state.mode {
+        AppMode::Edit => "EDIT",
+        AppMode::ReadOnly => "NORMAL",
+        AppMode::Highlight => "VISUAL",
+        AppMode::General => "GENERAL",
+        AppMode::Command => "COMMAND",
+    };
+
+    let status_text = if state.has_changes {
+        format!("-- {} -- [Modified]", mode_text)
+    } else {
+        format!("-- {} --", mode_text)
+    };
+
+    let position_text = format!("Field: {}/{} | Cursor: {} | Actions: {}", 
+        state.current_field + 1,
+        state.fields.len(),
+        state.cursor_pos,
+        CanvasAction::movement_actions().len() + CanvasAction::editing_actions().len());
+
+    let help_text = match state.mode {
+        AppMode::ReadOnly => "hjkl/arrows: Move | Tab/Shift+Tab: Fields | w/b/e: Words | 0/$: Line | i/a: Edit | v: Visual | F10: Quit",
+        AppMode::Edit => "Type to edit | Arrows/Ctrl+arrows: Move | Tab: Next field | Backspace/Delete: Delete | Home/End: Line | Esc: Normal | F10: Quit",
+        AppMode::Highlight => "hjkl/arrows: Select | w/b/e: Words | 0/$: Line | Esc: Normal | F10: Quit",
+        _ => "Esc: Normal | F10: Quit",
+    };
+
+    let status = Paragraph::new(vec![
+        Line::from(Span::styled(status_text, Style::default().fg(theme.accent()))),
+        Line::from(Span::styled(position_text, Style::default().fg(theme.fg()))),
+        Line::from(Span::styled(state.debug_message.clone(), Style::default().fg(theme.warning()))),
+        Line::from(Span::styled(help_text, Style::default().fg(theme.secondary()))),
+    ])
+    .block(Block::default().borders(Borders::ALL).title("Status"));
+
+    f.render_widget(status, chunks[1]);
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    let state = DemoFormState::new();
+
+    let res = run_app(&mut terminal, state).await;
+
+    disable_raw_mode()?;
+    execute!(
+        terminal.backend_mut(),
+        LeaveAlternateScreen,
+        DisableMouseCapture
+    )?;
+    terminal.show_cursor()?;
+
+    if let Err(err) = res {
+        println!("{:?}", err);
+    }
+
+    Ok(())
+}

canvas/integration_patterns.rs

@@ -0,0 +1,620 @@
+// examples/integration_patterns.rs
+//! Advanced integration patterns showing how Canvas works with:
+//! - State management patterns
+//! - Event-driven architectures
+//! - Validation systems
+//! - Custom rendering
+//!
+//! Run with: cargo run --example integration_patterns
+
+use canvas::prelude::*;
+use std::collections::HashMap;
+
+#[tokio::main]
+async fn main() {
+    println!("🔧 Canvas Integration Patterns");
+    println!("==============================\n");
+
+    // Pattern 1: State machine integration
+    state_machine_example().await;
+
+    // Pattern 2: Event-driven architecture
+    event_driven_example().await;
+
+    // Pattern 3: Validation pipeline
+    validation_pipeline_example().await;
+
+    // Pattern 4: Multi-form orchestration
+    multi_form_example().await;
+}
+
+// Pattern 1: Canvas with state machine
+async fn state_machine_example() {
+    println!("🔄 Pattern 1: State Machine Integration");
+
+    #[derive(Debug, Clone, PartialEq)]
+    enum FormState {
+        Initial,
+        Editing,
+        Validating,
+        Submitting,
+        Success,
+        Error(String),
+    }
+
+    #[derive(Debug)]
+    struct StateMachineForm {
+        // Canvas state
+        current_field: usize,
+        cursor_pos: usize,
+        username: String,
+        password: String,
+        has_changes: bool,
+
+        // State machine
+        state: FormState,
+    }
+
+    impl StateMachineForm {
+        fn new() -> Self {
+            Self {
+                current_field: 0,
+                cursor_pos: 0,
+                username: String::new(),
+                password: String::new(),
+                has_changes: false,
+                state: FormState::Initial,
+            }
+        }
+
+        fn transition_to(&mut self, new_state: FormState) -> String {
+            let old_state = self.state.clone();
+            self.state = new_state;
+            format!("State transition: {:?} -> {:?}", old_state, self.state)
+        }
+
+        fn can_submit(&self) -> bool {
+            matches!(self.state, FormState::Editing) &&
+            !self.username.trim().is_empty() &&
+            !self.password.trim().is_empty()
+        }
+    }
+
+    impl CanvasState for StateMachineForm {
+        fn current_field(&self) -> usize { self.current_field }
+        fn current_cursor_pos(&self) -> usize { self.cursor_pos }
+        fn set_current_field(&mut self, index: usize) { self.current_field = index.min(1); }
+        fn set_current_cursor_pos(&mut self, pos: usize) { self.cursor_pos = pos; }
+
+        fn get_current_input(&self) -> &str {
+            match self.current_field {
+                0 => &self.username,
+                1 => &self.password,
+                _ => "",
+            }
+        }
+
+        fn get_current_input_mut(&mut self) -> &mut String {
+            match self.current_field {
+                0 => &mut self.username,
+                1 => &mut self.password,
+                _ => unreachable!(),
+            }
+        }
+
+        fn inputs(&self) -> Vec<&String> { vec![&self.username, &self.password] }
+        fn fields(&self) -> Vec<&str> { vec!["Username", "Password"] }
+        fn has_unsaved_changes(&self) -> bool { self.has_changes }
+
+        fn set_has_unsaved_changes(&mut self, changed: bool) {
+            self.has_changes = changed;
+            // Transition to editing state when user starts typing
+            if changed && self.state == FormState::Initial {
+                self.state = FormState::Editing;
+            }
+        }
+
+        fn handle_feature_action(&mut self, action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+            match action {
+                CanvasAction::Custom(cmd) => match cmd.as_str() {
+                    "submit" => {
+                        if self.can_submit() {
+                            let msg = self.transition_to(FormState::Submitting);
+                            // Simulate submission
+                            self.state = FormState::Success;
+                            Some(format!("{} -> Form submitted successfully", msg))
+                        } else {
+                            let msg = self.transition_to(FormState::Error("Invalid form data".to_string()));
+                            Some(msg)
+                        }
+                    }
+                    "reset" => {
+                        self.username.clear();
+                        self.password.clear();
+                        self.has_changes = false;
+                        Some(self.transition_to(FormState::Initial))
+                    }
+                    _ => None,
+                },
+                _ => None,
+            }
+        }
+    }
+
+    let mut form = StateMachineForm::new();
+    let mut ideal_cursor = 0;
+
+    println!("  Initial state: {:?}", form.state);
+
+    // Type some text to trigger state change
+    let _result = ActionDispatcher::dispatch(
+        CanvasAction::InsertChar('u'),
+        &mut form,
+        &mut ideal_cursor,
+    ).await.unwrap();
+    println!("  After typing: {:?}", form.state);
+
+    // Try to submit (should fail)
+    let result = ActionDispatcher::dispatch(
+        CanvasAction::Custom("submit".to_string()),
+        &mut form,
+        &mut ideal_cursor,
+    ).await.unwrap();
+    println!("  Submit result: {}", result.message().unwrap_or(""));
+    println!("  ✅ State machine integration works!\n");
+}
+
+// Pattern 2: Event-driven architecture
+async fn event_driven_example() {
+    println!("📡 Pattern 2: Event-Driven Architecture");
+
+    #[derive(Debug, Clone)]
+    enum FormEvent {
+        FieldChanged { field: usize, old_value: String, new_value: String },
+        ValidationTriggered { field: usize, is_valid: bool },
+        ActionExecuted { action: String, success: bool },
+    }
+
+    #[derive(Debug)]
+    struct EventDrivenForm {
+        current_field: usize,
+        cursor_pos: usize,
+        email: String,
+        has_changes: bool,
+        events: Vec<FormEvent>,
+    }
+
+    impl EventDrivenForm {
+        fn new() -> Self {
+            Self {
+                current_field: 0,
+                cursor_pos: 0,
+                email: String::new(),
+                has_changes: false,
+                events: Vec::new(),
+            }
+        }
+
+        fn emit_event(&mut self, event: FormEvent) {
+            println!("  📡 Event: {:?}", event);
+            self.events.push(event);
+        }
+
+        fn validate_email(&self) -> bool {
+            self.email.contains('@') && self.email.contains('.')
+        }
+    }
+
+    impl CanvasState for EventDrivenForm {
+        fn current_field(&self) -> usize { self.current_field }
+        fn current_cursor_pos(&self) -> usize { self.cursor_pos }
+        fn set_current_field(&mut self, index: usize) { self.current_field = index; }
+        fn set_current_cursor_pos(&mut self, pos: usize) { self.cursor_pos = pos; }
+
+        fn get_current_input(&self) -> &str { &self.email }
+        fn get_current_input_mut(&mut self) -> &mut String { &mut self.email }
+        fn inputs(&self) -> Vec<&String> { vec![&self.email] }
+        fn fields(&self) -> Vec<&str> { vec!["Email"] }
+        fn has_unsaved_changes(&self) -> bool { self.has_changes }
+
+        fn set_has_unsaved_changes(&mut self, changed: bool) {
+            if changed != self.has_changes {
+                let old_value = if self.has_changes { "modified" } else { "unmodified" };
+                let new_value = if changed { "modified" } else { "unmodified" };
+
+                self.emit_event(FormEvent::FieldChanged {
+                    field: self.current_field,
+                    old_value: old_value.to_string(),
+                    new_value: new_value.to_string(),
+                });
+            }
+            self.has_changes = changed;
+        }
+
+        fn handle_feature_action(&mut self, action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+            match action {
+                CanvasAction::Custom(cmd) => match cmd.as_str() {
+                    "validate" => {
+                        let is_valid = self.validate_email();
+                        self.emit_event(FormEvent::ValidationTriggered {
+                            field: self.current_field,
+                            is_valid,
+                        });
+
+                        self.emit_event(FormEvent::ActionExecuted {
+                            action: "validate".to_string(),
+                            success: true,
+                        });
+
+                        if is_valid {
+                            Some("Email is valid!".to_string())
+                        } else {
+                            Some("Email is invalid".to_string())
+                        }
+                    }
+                    _ => None,
+                },
+                _ => None,
+            }
+        }
+    }
+
+    let mut form = EventDrivenForm::new();
+    let mut ideal_cursor = 0;
+
+    // Type an email address
+    let email = "user@example.com";
+    for c in email.chars() {
+        ActionDispatcher::dispatch(
+            CanvasAction::InsertChar(c),
+            &mut form,
+            &mut ideal_cursor,
+        ).await.unwrap();
+    }
+
+    // Validate the email
+    let result = ActionDispatcher::dispatch(
+        CanvasAction::Custom("validate".to_string()),
+        &mut form,
+        &mut ideal_cursor,
+    ).await.unwrap();
+
+    println!("  Final email: {}", form.email);
+    println!("  Validation result: {}", result.message().unwrap_or(""));
+    println!("  Total events captured: {}", form.events.len());
+    println!("  ✅ Event-driven architecture works!\n");
+}
+
+// Pattern 3: Validation pipeline
+async fn validation_pipeline_example() {
+    println!("✅ Pattern 3: Validation Pipeline");
+
+    type ValidationRule = Box<dyn Fn(&str) -> Result<(), String>>;
+
+    // Custom Debug implementation since function pointers don't implement Debug
+    struct ValidatedForm {
+        current_field: usize,
+        cursor_pos: usize,
+        password: String,
+        has_changes: bool,
+        validators: HashMap<usize, Vec<ValidationRule>>,
+    }
+
+    impl std::fmt::Debug for ValidatedForm {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            f.debug_struct("ValidatedForm")
+                .field("current_field", &self.current_field)
+                .field("cursor_pos", &self.cursor_pos)
+                .field("password", &self.password)
+                .field("has_changes", &self.has_changes)
+                .field("validators", &format!("HashMap with {} entries", self.validators.len()))
+                .finish()
+        }
+    }
+
+    impl ValidatedForm {
+        fn new() -> Self {
+            let mut validators: HashMap<usize, Vec<ValidationRule>> = HashMap::new();
+
+            // Password validators
+            let mut password_validators: Vec<ValidationRule> = Vec::new();
+            password_validators.push(Box::new(|value| {
+                if value.len() < 8 {
+                    Err("Password must be at least 8 characters".to_string())
+                } else {
+                    Ok(())
+                }
+            }));
+            password_validators.push(Box::new(|value| {
+                if !value.chars().any(|c| c.is_uppercase()) {
+                    Err("Password must contain at least one uppercase letter".to_string())
+                } else {
+                    Ok(())
+                }
+            }));
+            password_validators.push(Box::new(|value| {
+                if !value.chars().any(|c| c.is_numeric()) {
+                    Err("Password must contain at least one number".to_string())
+                } else {
+                    Ok(())
+                }
+            }));
+
+            validators.insert(0, password_validators);
+
+            Self {
+                current_field: 0,
+                cursor_pos: 0,
+                password: String::new(),
+                has_changes: false,
+                validators,
+            }
+        }
+
+        fn validate_field(&self, field_index: usize) -> Vec<String> {
+            let mut errors = Vec::new();
+
+            if let Some(validators) = self.validators.get(&field_index) {
+                let value = match field_index {
+                    0 => &self.password,
+                    _ => return errors,
+                };
+
+                for validator in validators {
+                    if let Err(error) = validator(value) {
+                        errors.push(error);
+                    }
+                }
+            }
+
+            errors
+        }
+    }
+
+    impl CanvasState for ValidatedForm {
+        fn current_field(&self) -> usize { self.current_field }
+        fn current_cursor_pos(&self) -> usize { self.cursor_pos }
+        fn set_current_field(&mut self, index: usize) { self.current_field = index; }
+        fn set_current_cursor_pos(&mut self, pos: usize) { self.cursor_pos = pos; }
+
+        fn get_current_input(&self) -> &str { &self.password }
+        fn get_current_input_mut(&mut self) -> &mut String { &mut self.password }
+        fn inputs(&self) -> Vec<&String> { vec![&self.password] }
+        fn fields(&self) -> Vec<&str> { vec!["Password"] }
+        fn has_unsaved_changes(&self) -> bool { self.has_changes }
+        fn set_has_unsaved_changes(&mut self, changed: bool) { self.has_changes = changed; }
+
+        fn handle_feature_action(&mut self, action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+            match action {
+                CanvasAction::Custom(cmd) => match cmd.as_str() {
+                    "validate" => {
+                        let errors = self.validate_field(self.current_field);
+                        if errors.is_empty() {
+                            Some("Password meets all requirements!".to_string())
+                        } else {
+                            Some(format!("Validation errors: {}", errors.join(", ")))
+                        }
+                    }
+                    _ => None,
+                },
+                _ => None,
+            }
+        }
+    }
+
+    let mut form = ValidatedForm::new();
+    let mut ideal_cursor = 0;
+
+    // Test with weak password
+    let weak_password = "abc";
+    for c in weak_password.chars() {
+        ActionDispatcher::dispatch(
+            CanvasAction::InsertChar(c),
+            &mut form,
+            &mut ideal_cursor,
+        ).await.unwrap();
+    }
+
+    let result = ActionDispatcher::dispatch(
+        CanvasAction::Custom("validate".to_string()),
+        &mut form,
+        &mut ideal_cursor,
+    ).await.unwrap();
+    println!("  Weak password '{}': {}", form.password, result.message().unwrap_or(""));
+
+    // Clear and test with strong password
+    form.password.clear();
+    form.cursor_pos = 0;
+
+    let strong_password = "StrongPass123";
+    for c in strong_password.chars() {
+        ActionDispatcher::dispatch(
+            CanvasAction::InsertChar(c),
+            &mut form,
+            &mut ideal_cursor,
+        ).await.unwrap();
+    }
+
+    let result = ActionDispatcher::dispatch(
+        CanvasAction::Custom("validate".to_string()),
+        &mut form,
+        &mut ideal_cursor,
+    ).await.unwrap();
+    println!("  Strong password '{}': {}", form.password, result.message().unwrap_or(""));
+    println!("  ✅ Validation pipeline works!\n");
+}
+
+// Pattern 4: Multi-form orchestration
+async fn multi_form_example() {
+    println!("🎭 Pattern 4: Multi-Form Orchestration");
+
+    #[derive(Debug)]
+    struct PersonalInfoForm {
+        current_field: usize,
+        cursor_pos: usize,
+        name: String,
+        age: String,
+        has_changes: bool,
+    }
+
+    #[derive(Debug)]
+    struct ContactInfoForm {
+        current_field: usize,
+        cursor_pos: usize,
+        email: String,
+        phone: String,
+        has_changes: bool,
+    }
+
+    // Implement CanvasState for both forms
+    impl CanvasState for PersonalInfoForm {
+        fn current_field(&self) -> usize { self.current_field }
+        fn current_cursor_pos(&self) -> usize { self.cursor_pos }
+        fn set_current_field(&mut self, index: usize) { self.current_field = index.min(1); }
+        fn set_current_cursor_pos(&mut self, pos: usize) { self.cursor_pos = pos; }
+
+        fn get_current_input(&self) -> &str {
+            match self.current_field {
+                0 => &self.name,
+                1 => &self.age,
+                _ => "",
+            }
+        }
+
+        fn get_current_input_mut(&mut self) -> &mut String {
+            match self.current_field {
+                0 => &mut self.name,
+                1 => &mut self.age,
+                _ => unreachable!(),
+            }
+        }
+
+        fn inputs(&self) -> Vec<&String> { vec![&self.name, &self.age] }
+        fn fields(&self) -> Vec<&str> { vec!["Name", "Age"] }
+        fn has_unsaved_changes(&self) -> bool { self.has_changes }
+        fn set_has_unsaved_changes(&mut self, changed: bool) { self.has_changes = changed; }
+    }
+
+    impl CanvasState for ContactInfoForm {
+        fn current_field(&self) -> usize { self.current_field }
+        fn current_cursor_pos(&self) -> usize { self.cursor_pos }
+        fn set_current_field(&mut self, index: usize) { self.current_field = index.min(1); }
+        fn set_current_cursor_pos(&mut self, pos: usize) { self.cursor_pos = pos; }
+
+        fn get_current_input(&self) -> &str {
+            match self.current_field {
+                0 => &self.email,
+                1 => &self.phone,
+                _ => "",
+            }
+        }
+
+        fn get_current_input_mut(&mut self) -> &mut String {
+            match self.current_field {
+                0 => &mut self.email,
+                1 => &mut self.phone,
+                _ => unreachable!(),
+            }
+        }
+
+        fn inputs(&self) -> Vec<&String> { vec![&self.email, &self.phone] }
+        fn fields(&self) -> Vec<&str> { vec!["Email", "Phone"] }
+        fn has_unsaved_changes(&self) -> bool { self.has_changes }
+        fn set_has_unsaved_changes(&mut self, changed: bool) { self.has_changes = changed; }
+    }
+
+    // Form orchestrator
+    #[derive(Debug)]
+    struct FormOrchestrator {
+        personal_form: PersonalInfoForm,
+        contact_form: ContactInfoForm,
+        current_form: usize, // 0 = personal, 1 = contact
+    }
+
+    impl FormOrchestrator {
+        fn new() -> Self {
+            Self {
+                personal_form: PersonalInfoForm {
+                    current_field: 0,
+                    cursor_pos: 0,
+                    name: String::new(),
+                    age: String::new(),
+                    has_changes: false,
+                },
+                contact_form: ContactInfoForm {
+                    current_field: 0,
+                    cursor_pos: 0,
+                    email: String::new(),
+                    phone: String::new(),
+                    has_changes: false,
+                },
+                current_form: 0,
+            }
+        }
+
+        async fn execute_action(&mut self, action: CanvasAction) -> ActionResult {
+            let mut ideal_cursor = 0;
+
+            match self.current_form {
+                0 => ActionDispatcher::dispatch(action, &mut self.personal_form, &mut ideal_cursor).await.unwrap(),
+                1 => ActionDispatcher::dispatch(action, &mut self.contact_form, &mut ideal_cursor).await.unwrap(),
+                _ => ActionResult::error("Invalid form index"),
+            }
+        }
+
+        fn switch_form(&mut self) -> String {
+            self.current_form = (self.current_form + 1) % 2;
+            match self.current_form {
+                0 => "Switched to Personal Info form".to_string(),
+                1 => "Switched to Contact Info form".to_string(),
+                _ => "Unknown form".to_string(),
+            }
+        }
+
+        fn current_form_name(&self) -> &str {
+            match self.current_form {
+                0 => "Personal Info",
+                1 => "Contact Info",
+                _ => "Unknown",
+            }
+        }
+    }
+
+    let mut orchestrator = FormOrchestrator::new();
+
+    println!("  Current form: {}", orchestrator.current_form_name());
+
+    // Fill personal info
+    for &c in &['J', 'o', 'h', 'n'] {
+        orchestrator.execute_action(CanvasAction::InsertChar(c)).await;
+    }
+
+    orchestrator.execute_action(CanvasAction::NextField).await;
+
+    for &c in &['2', '5'] {
+        orchestrator.execute_action(CanvasAction::InsertChar(c)).await;
+    }
+
+    println!("  Personal form - Name: '{}', Age: '{}'",
+             orchestrator.personal_form.name,
+             orchestrator.personal_form.age);
+
+    // Switch to contact form
+    let switch_msg = orchestrator.switch_form();
+    println!("  {}", switch_msg);
+
+    // Fill contact info
+    for &c in &['j', 'o', 'h', 'n', '@', 'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm'] {
+        orchestrator.execute_action(CanvasAction::InsertChar(c)).await;
+    }
+
+    orchestrator.execute_action(CanvasAction::NextField).await;
+
+    for &c in &['5', '5', '5', '-', '1', '2', '3', '4'] {
+        orchestrator.execute_action(CanvasAction::InsertChar(c)).await;
+    }
+
+    println!("  Contact form - Email: '{}', Phone: '{}'",
+             orchestrator.contact_form.email,
+             orchestrator.contact_form.phone);
+}

canvas/src/autocomplete/actions.rs

@@ -0,0 +1,170 @@
+// src/autocomplete/actions.rs
+
+use crate::canvas::state::CanvasState;
+use crate::autocomplete::state::AutocompleteCanvasState;
+use crate::canvas::actions::types::{CanvasAction, ActionResult};
+use crate::canvas::actions::execute;
+use anyhow::Result;
+
+/// Enhanced execute function for states that support autocomplete
+/// This is the main entry point for autocomplete-aware canvas execution
+///
+/// Use this instead of canvas::execute() if you want autocomplete behavior:
+/// ```rust
+/// execute_with_autocomplete(action, &mut state).await?;
+/// ```
+pub async fn execute_with_autocomplete<S: CanvasState + AutocompleteCanvasState + Send>(
+    action: CanvasAction,
+    state: &mut S,
+) -> Result<ActionResult> {
+    match &action {
+        // === AUTOCOMPLETE-SPECIFIC ACTIONS ===
+
+        CanvasAction::TriggerAutocomplete => {
+            if state.supports_autocomplete(state.current_field()) {
+                state.trigger_autocomplete_suggestions().await;
+                Ok(ActionResult::success_with_message("Triggered autocomplete"))
+            } else {
+                Ok(ActionResult::success_with_message("Autocomplete not supported for this field"))
+            }
+        }
+
+        CanvasAction::SuggestionUp => {
+            if state.has_autocomplete_suggestions() {
+                state.move_suggestion_selection(-1);
+                Ok(ActionResult::success())
+            } else {
+                Ok(ActionResult::success_with_message("No suggestions available"))
+            }
+        }
+
+        CanvasAction::SuggestionDown => {
+            if state.has_autocomplete_suggestions() {
+                state.move_suggestion_selection(1);
+                Ok(ActionResult::success())
+            } else {
+                Ok(ActionResult::success_with_message("No suggestions available"))
+            }
+        }
+
+        CanvasAction::SelectSuggestion => {
+            if let Some(message) = state.apply_selected_suggestion() {
+                Ok(ActionResult::success_with_message(&message))
+            } else {
+                Ok(ActionResult::success_with_message("No suggestion to select"))
+            }
+        }
+
+        CanvasAction::ExitSuggestions => {
+            state.clear_autocomplete_suggestions();
+            Ok(ActionResult::success_with_message("Closed autocomplete"))
+        }
+
+        // === TEXT INSERTION WITH AUTO-TRIGGER ===
+
+        CanvasAction::InsertChar(_) => {
+            // First, execute the character insertion normally
+            let result = execute(action, state).await?;
+
+            // After successful insertion, check if we should auto-trigger autocomplete
+            if result.is_success() && state.should_trigger_autocomplete() {
+                state.trigger_autocomplete_suggestions().await;
+            }
+
+            Ok(result)
+        }
+
+        // === NAVIGATION/EDITING ACTIONS (clear autocomplete first) ===
+
+        CanvasAction::MoveLeft | CanvasAction::MoveRight |
+        CanvasAction::MoveUp | CanvasAction::MoveDown |
+        CanvasAction::NextField | CanvasAction::PrevField |
+        CanvasAction::DeleteBackward | CanvasAction::DeleteForward => {
+            // Clear autocomplete when navigating/editing
+            if state.is_autocomplete_active() {
+                state.clear_autocomplete_suggestions();
+            }
+
+            // Execute the action normally
+            execute(action, state).await
+        }
+
+        // === ALL OTHER ACTIONS (normal execution) ===
+
+        _ => {
+            // For all other actions, just execute normally
+            execute(action, state).await
+        }
+    }
+}
+
+/// Helper function to integrate autocomplete actions with CanvasState.handle_feature_action()
+///
+/// Use this in your CanvasState implementation like this:
+/// ```rust
+/// fn handle_feature_action(&mut self, action: &CanvasAction, context: &ActionContext) -> Option<String> {
+///     // Try autocomplete first
+///     if let Some(result) = handle_autocomplete_feature_action(action, self) {
+///         return Some(result);
+///     }
+///
+///     // Handle your other custom actions...
+///     None
+/// }
+/// ```
+pub fn handle_autocomplete_feature_action<S: CanvasState + AutocompleteCanvasState + Send>(
+    action: &CanvasAction,
+    state: &S,
+) -> Option<String> {
+    match action {
+        CanvasAction::TriggerAutocomplete => {
+            if state.supports_autocomplete(state.current_field()) {
+                if state.is_autocomplete_active() {
+                    Some("Autocomplete already active".to_string())
+                } else {
+                    None // Let execute_with_autocomplete handle it
+                }
+            } else {
+                Some("Autocomplete not available for this field".to_string())
+            }
+        }
+
+        CanvasAction::SuggestionUp | CanvasAction::SuggestionDown => {
+            if state.is_autocomplete_active() {
+                None // Let execute_with_autocomplete handle navigation
+            } else {
+                Some("No autocomplete suggestions to navigate".to_string())
+            }
+        }
+
+        CanvasAction::SelectSuggestion => {
+            if state.has_autocomplete_suggestions() {
+                None // Let execute_with_autocomplete handle selection
+            } else {
+                Some("No suggestion to select".to_string())
+            }
+        }
+
+        CanvasAction::ExitSuggestions => {
+            if state.is_autocomplete_active() {
+                None // Let execute_with_autocomplete handle exit
+            } else {
+                Some("No autocomplete to close".to_string())
+            }
+        }
+
+        _ => None // Not an autocomplete action
+    }
+}
+
+/// Legacy compatibility function - kept for backward compatibility
+/// This is the old function signature, now it just wraps the new system
+#[deprecated(note = "Use execute_with_autocomplete instead")]
+pub async fn execute_canvas_action_with_autocomplete<S: CanvasState + AutocompleteCanvasState + Send>(
+    action: CanvasAction,
+    state: &mut S,
+    _ideal_cursor_column: &mut usize, // Ignored - new system manages this internally
+    _config: Option<&()>, // Ignored - no more config system
+) -> Result<ActionResult> {
+    execute_with_autocomplete(action, state).await
+}

canvas/src/autocomplete/gui.rs

@@ -0,0 +1,192 @@
+// src/autocomplete/gui.rs
+
+#[cfg(feature = "gui")]
+use ratatui::{
+    layout::{Alignment, Rect},
+    style::{Modifier, Style},
+    widgets::{Block, Borders, List, ListItem, ListState, Paragraph},
+    Frame,
+};
+
+// Use the correct import from our types module
+use crate::autocomplete::types::AutocompleteState;
+
+#[cfg(feature = "gui")]
+use crate::canvas::theme::CanvasTheme;
+
+#[cfg(feature = "gui")]
+use unicode_width::UnicodeWidthStr;
+
+/// Render autocomplete dropdown - call this AFTER rendering canvas
+#[cfg(feature = "gui")]
+pub fn render_autocomplete_dropdown<T: CanvasTheme, D: Clone + Send + 'static>(
+    f: &mut Frame,
+    frame_area: Rect,
+    input_rect: Rect,
+    theme: &T,
+    autocomplete_state: &AutocompleteState<D>,
+) {
+    if !autocomplete_state.is_active {
+        return;
+    }
+
+    if autocomplete_state.is_loading {
+        render_loading_indicator(f, frame_area, input_rect, theme);
+    } else if !autocomplete_state.suggestions.is_empty() {
+        render_suggestions_dropdown(f, frame_area, input_rect, theme, autocomplete_state);
+    }
+}
+
+/// Show loading spinner/text
+#[cfg(feature = "gui")]
+fn render_loading_indicator<T: CanvasTheme>(
+    f: &mut Frame,
+    frame_area: Rect,
+    input_rect: Rect,
+    theme: &T,
+) {
+    let loading_text = "Loading suggestions...";
+    let loading_width = loading_text.width() as u16 + 4; // +4 for borders and padding
+    let loading_height = 3;
+
+    let dropdown_area = calculate_dropdown_position(
+        input_rect,
+        frame_area,
+        loading_width,
+        loading_height,
+    );
+
+    let loading_block = Block::default()
+        .style(Style::default().bg(theme.bg()));
+
+    let loading_paragraph = Paragraph::new(loading_text)
+        .block(loading_block)
+        .style(Style::default().fg(theme.fg()))
+        .alignment(Alignment::Center);
+
+    f.render_widget(loading_paragraph, dropdown_area);
+}
+
+/// Show actual suggestions list
+#[cfg(feature = "gui")]
+fn render_suggestions_dropdown<T: CanvasTheme, D: Clone + Send + 'static>(
+    f: &mut Frame,
+    frame_area: Rect,
+    input_rect: Rect,
+    theme: &T,
+    autocomplete_state: &AutocompleteState<D>,
+) {
+    let display_texts: Vec<&str> = autocomplete_state.suggestions
+        .iter()
+        .map(|item| item.display_text.as_str())
+        .collect();
+
+    let dropdown_dimensions = calculate_dropdown_dimensions(&display_texts);
+    let dropdown_area = calculate_dropdown_position(
+        input_rect,
+        frame_area,
+        dropdown_dimensions.width,
+        dropdown_dimensions.height,
+    );
+
+    // Background
+    let dropdown_block = Block::default()
+        .style(Style::default().bg(theme.bg()));
+
+    // List items
+    let items = create_suggestion_list_items(
+        &display_texts,
+        autocomplete_state.selected_index,
+        dropdown_dimensions.width,
+        theme,
+    );
+
+    let list = List::new(items).block(dropdown_block);
+    let mut list_state = ListState::default();
+    list_state.select(autocomplete_state.selected_index);
+
+    f.render_stateful_widget(list, dropdown_area, &mut list_state);
+}
+
+/// Calculate dropdown size based on suggestions - updated to match client dimensions
+#[cfg(feature = "gui")]
+fn calculate_dropdown_dimensions(display_texts: &[&str]) -> DropdownDimensions {
+    let max_width = display_texts
+        .iter()
+        .map(|text| text.width())
+        .max()
+        .unwrap_or(0) as u16;
+
+    let horizontal_padding = 2; // Changed from 4 to 2 to match client
+    let width = (max_width + horizontal_padding).max(10); // Changed from 12 to 10 to match client
+    let height = (display_texts.len() as u16).min(5); // Removed +2 since no borders
+
+    DropdownDimensions { width, height }
+}
+
+/// Position dropdown to stay in bounds
+#[cfg(feature = "gui")]
+fn calculate_dropdown_position(
+    input_rect: Rect,
+    frame_area: Rect,
+    dropdown_width: u16,
+    dropdown_height: u16,
+) -> Rect {
+    let mut dropdown_area = Rect {
+        x: input_rect.x,
+        y: input_rect.y + 1, // below input field
+        width: dropdown_width,
+        height: dropdown_height,
+    };
+
+    // Keep in bounds
+    if dropdown_area.bottom() > frame_area.height {
+        dropdown_area.y = input_rect.y.saturating_sub(dropdown_height);
+    }
+    if dropdown_area.right() > frame_area.width {
+        dropdown_area.x = frame_area.width.saturating_sub(dropdown_width);
+    }
+    dropdown_area.x = dropdown_area.x.max(0);
+    dropdown_area.y = dropdown_area.y.max(0);
+
+    dropdown_area
+}
+
+/// Create styled list items - updated to match client spacing
+#[cfg(feature = "gui")]
+fn create_suggestion_list_items<'a, T: CanvasTheme>(
+    display_texts: &'a [&'a str],
+    selected_index: Option<usize>,
+    dropdown_width: u16,
+    theme: &T,
+) -> Vec<ListItem<'a>> {
+    let horizontal_padding = 2; // Changed from 4 to 2 to match client
+    let available_width = dropdown_width; // No border padding needed
+
+    display_texts
+        .iter()
+        .enumerate()
+        .map(|(i, text)| {
+            let is_selected = selected_index == Some(i);
+            let text_width = text.width() as u16;
+            let padding_needed = available_width.saturating_sub(text_width);
+            let padded_text = format!("{}{}", text, " ".repeat(padding_needed as usize));
+
+            ListItem::new(padded_text).style(if is_selected {
+                Style::default()
+                    .fg(theme.bg())
+                    .bg(theme.highlight())
+                    .add_modifier(Modifier::BOLD)
+            } else {
+                Style::default().fg(theme.fg()).bg(theme.bg())
+            })
+        })
+        .collect()
+}
+
+/// Helper struct for dropdown dimensions
+#[cfg(feature = "gui")]
+struct DropdownDimensions {
+    width: u16,
+    height: u16,
+}

canvas/src/autocomplete/mod.rs

@@ -0,0 +1,22 @@
+// src/autocomplete/mod.rs
+
+pub mod types;
+pub mod state;
+pub mod actions;
+
+#[cfg(feature = "gui")]
+pub mod gui;
+
+// Re-export the main autocomplete API
+pub use types::{SuggestionItem, AutocompleteState};
+pub use state::AutocompleteCanvasState;
+
+// Re-export the new action functions
+pub use actions::{
+    execute_with_autocomplete,
+    handle_autocomplete_feature_action,
+};
+
+// Re-export GUI functions if available
+#[cfg(feature = "gui")]
+pub use gui::render_autocomplete_dropdown;

canvas/src/autocomplete/state.rs

@@ -0,0 +1,189 @@
+// src/autocomplete/state.rs
+
+use crate::canvas::state::CanvasState;
+use async_trait::async_trait;
+
+/// OPTIONAL extension trait for states that want rich autocomplete functionality.
+/// Only implement this if you need the new autocomplete features.
+///
+/// # User Workflow:
+/// 1. User presses trigger key (Tab, Ctrl+K, etc.)
+/// 2. User's key mapping calls CanvasAction::TriggerAutocomplete
+/// 3. Library calls your trigger_autocomplete_suggestions() method
+/// 4. You implement async fetching logic in that method
+/// 5. You call set_autocomplete_suggestions() with results
+/// 6. Library manages UI state and navigation
+#[async_trait]
+pub trait AutocompleteCanvasState: CanvasState {
+    /// Associated type for suggestion data (e.g., Hit, String, CustomType)
+    type SuggestionData: Clone + Send + 'static;
+
+    /// Check if a field supports autocomplete (user decides which fields)
+    fn supports_autocomplete(&self, _field_index: usize) -> bool {
+        false // Default: no autocomplete support
+    }
+
+    /// Get autocomplete state (read-only)
+    fn autocomplete_state(&self) -> Option<&crate::autocomplete::AutocompleteState<Self::SuggestionData>> {
+        None // Default: no autocomplete state
+    }
+
+    /// Get autocomplete state (mutable)
+    fn autocomplete_state_mut(&mut self) -> Option<&mut crate::autocomplete::AutocompleteState<Self::SuggestionData>> {
+        None // Default: no autocomplete state
+    }
+
+    // === PUBLIC API METHODS (called by library) ===
+
+    /// Activate autocomplete for current field (shows loading spinner)
+    fn activate_autocomplete(&mut self) {
+        let current_field = self.current_field();
+        if let Some(state) = self.autocomplete_state_mut() {
+            state.activate(current_field);
+        }
+    }
+
+    /// Deactivate autocomplete (hides dropdown)
+    fn deactivate_autocomplete(&mut self) {
+        if let Some(state) = self.autocomplete_state_mut() {
+            state.deactivate();
+        }
+    }
+
+    /// Set suggestions (called after your async fetch completes)
+    fn set_autocomplete_suggestions(&mut self, suggestions: Vec<crate::autocomplete::SuggestionItem<Self::SuggestionData>>) {
+        if let Some(state) = self.autocomplete_state_mut() {
+            state.set_suggestions(suggestions);
+        }
+    }
+
+    /// Set loading state (show/hide spinner)
+    fn set_autocomplete_loading(&mut self, loading: bool) {
+        if let Some(state) = self.autocomplete_state_mut() {
+            state.is_loading = loading;
+        }
+    }
+
+    // === QUERY METHODS ===
+
+    /// Check if autocomplete is currently active/visible
+    fn is_autocomplete_active(&self) -> bool {
+        self.autocomplete_state()
+            .map(|state| state.is_active)
+            .unwrap_or(false)
+    }
+
+    /// Check if autocomplete has suggestions ready for navigation
+    fn is_autocomplete_ready(&self) -> bool {
+        self.autocomplete_state()
+            .map(|state| state.is_ready())
+            .unwrap_or(false)
+    }
+
+    /// Check if there are available suggestions
+    fn has_autocomplete_suggestions(&self) -> bool {
+        self.autocomplete_state()
+            .map(|state| !state.suggestions.is_empty())
+            .unwrap_or(false)
+    }
+
+    // === USER-IMPLEMENTABLE METHODS ===
+
+    /// Check if autocomplete should be triggered automatically (e.g., after typing 2+ chars)
+    /// Override this to implement your own trigger logic
+    fn should_trigger_autocomplete(&self) -> bool {
+        let current_input = self.get_current_input();
+        let current_field = self.current_field();
+
+        self.supports_autocomplete(current_field) &&
+        current_input.len() >= 2 && // Default: trigger after 2 chars
+        !self.is_autocomplete_active()
+    }
+
+    /// **USER MUST IMPLEMENT**: Trigger autocomplete suggestions (async)
+    /// This is where you implement your API calls, caching, etc.
+    ///
+    /// # Example Implementation:
+    /// ```rust
+    /// #[async_trait]
+    /// impl AutocompleteCanvasState for MyState {
+    ///     type SuggestionData = MyData;
+    ///     
+    ///     async fn trigger_autocomplete_suggestions(&mut self) {
+    ///         self.activate_autocomplete(); // Show loading state
+    ///
+    ///         let query = self.get_current_input().to_string();
+    ///         let suggestions = my_api.search(&query).await.unwrap_or_default();
+    ///
+    ///         self.set_autocomplete_suggestions(suggestions);
+    ///     }
+    /// }
+    /// ```
+    async fn trigger_autocomplete_suggestions(&mut self) {
+        // Activate autocomplete UI
+        self.activate_autocomplete();
+
+        // Default: just show loading state
+        // User should override this to do actual async fetching
+        self.set_autocomplete_loading(true);
+
+        // In a real implementation, you'd:
+        // 1. Get current input: let query = self.get_current_input();
+        // 2. Make API call: let results = api.search(query).await;
+        // 3. Convert to suggestions: let suggestions = results.into_suggestions();
+        // 4. Set suggestions: self.set_autocomplete_suggestions(suggestions);
+    }
+
+    // === INTERNAL NAVIGATION METHODS (called by library actions) ===
+
+    /// Clear autocomplete suggestions and hide dropdown
+    fn clear_autocomplete_suggestions(&mut self) {
+        self.deactivate_autocomplete();
+    }
+
+    /// Move selection up/down in suggestions list
+    fn move_suggestion_selection(&mut self, direction: i32) {
+        if let Some(state) = self.autocomplete_state_mut() {
+            if direction > 0 {
+                state.select_next();
+            } else {
+                state.select_previous();
+            }
+        }
+    }
+
+    /// Get currently selected suggestion for display/application
+    fn get_selected_suggestion(&self) -> Option<crate::autocomplete::SuggestionItem<Self::SuggestionData>> {
+        self.autocomplete_state()?
+            .get_selected()
+            .cloned()
+    }
+
+    /// Apply the selected suggestion to the current field
+    fn apply_suggestion(&mut self, suggestion: &crate::autocomplete::SuggestionItem<Self::SuggestionData>) {
+        // Apply the value to current field
+        *self.get_current_input_mut() = suggestion.value_to_store.clone();
+        self.set_has_unsaved_changes(true);
+
+        // Clear autocomplete
+        self.clear_autocomplete_suggestions();
+    }
+
+    /// Apply the currently selected suggestion (convenience method)
+    fn apply_selected_suggestion(&mut self) -> Option<String> {
+        if let Some(suggestion) = self.get_selected_suggestion() {
+            let display_text = suggestion.display_text.clone();
+            self.apply_suggestion(&suggestion);
+            Some(format!("Applied: {}", display_text))
+        } else {
+            None
+        }
+    }
+
+    // === LEGACY COMPATIBILITY ===
+
+    /// INTERNAL: Apply selected autocomplete value to current field (legacy method)
+    fn apply_autocomplete_selection(&mut self) -> Option<String> {
+        self.apply_selected_suggestion()
+    }
+}

canvas/src/autocomplete/types.rs

@@ -0,0 +1,126 @@
+// canvas/src/autocomplete.rs
+
+/// Generic suggestion item that clients push to canvas
+#[derive(Debug, Clone)]
+pub struct SuggestionItem<T> {
+    /// The underlying data (client-specific, e.g., Hit, String, etc.)
+    pub data: T,
+    /// Text to display in the dropdown
+    pub display_text: String,
+    /// Value to store in the form field when selected
+    pub value_to_store: String,
+}
+
+impl<T> SuggestionItem<T> {
+    pub fn new(data: T, display_text: String, value_to_store: String) -> Self {
+        Self {
+            data,
+            display_text,
+            value_to_store,
+        }
+    }
+    
+    /// Convenience constructor for simple string suggestions
+    pub fn simple(data: T, text: String) -> Self {
+        Self {
+            data,
+            display_text: text.clone(),
+            value_to_store: text,
+        }
+    }
+}
+
+/// Autocomplete state managed by canvas
+#[derive(Debug, Clone)]
+pub struct AutocompleteState<T> {
+    /// Whether autocomplete is currently active/visible
+    pub is_active: bool,
+    /// Whether suggestions are being loaded (for spinner/loading indicator)
+    pub is_loading: bool,
+    /// Current suggestions to display
+    pub suggestions: Vec<SuggestionItem<T>>,
+    /// Currently selected suggestion index
+    pub selected_index: Option<usize>,
+    /// Field index that triggered autocomplete (for context)
+    pub active_field: Option<usize>,
+}
+
+impl<T> Default for AutocompleteState<T> {
+    fn default() -> Self {
+        Self {
+            is_active: false,
+            is_loading: false,
+            suggestions: Vec::new(),
+            selected_index: None,
+            active_field: None,
+        }
+    }
+}
+
+impl<T> AutocompleteState<T> {
+    pub fn new() -> Self {
+        Self::default()
+    }
+    
+    /// Activate autocomplete for a specific field
+    pub fn activate(&mut self, field_index: usize) {
+        self.is_active = true;
+        self.active_field = Some(field_index);
+        self.selected_index = None;
+        self.suggestions.clear();
+        self.is_loading = true;
+    }
+    
+    /// Deactivate autocomplete and clear state
+    pub fn deactivate(&mut self) {
+        self.is_active = false;
+        self.is_loading = false;
+        self.suggestions.clear();
+        self.selected_index = None;
+        self.active_field = None;
+    }
+    
+    /// Set suggestions and stop loading
+    pub fn set_suggestions(&mut self, suggestions: Vec<SuggestionItem<T>>) {
+        self.suggestions = suggestions;
+        self.is_loading = false;
+        self.selected_index = if self.suggestions.is_empty() { 
+            None 
+        } else { 
+            Some(0) 
+        };
+    }
+    
+    /// Move selection down
+    pub fn select_next(&mut self) {
+        if !self.suggestions.is_empty() {
+            let current = self.selected_index.unwrap_or(0);
+            self.selected_index = Some((current + 1) % self.suggestions.len());
+        }
+    }
+    
+    /// Move selection up
+    pub fn select_previous(&mut self) {
+        if !self.suggestions.is_empty() {
+            let current = self.selected_index.unwrap_or(0);
+            self.selected_index = Some(
+                if current == 0 { 
+                    self.suggestions.len() - 1 
+                } else { 
+                    current - 1 
+                }
+            );
+        }
+    }
+    
+    /// Get currently selected suggestion
+    pub fn get_selected(&self) -> Option<&SuggestionItem<T>> {
+        self.selected_index
+            .and_then(|idx| self.suggestions.get(idx))
+    }
+    
+    /// Check if autocomplete is ready for interaction (active and has suggestions)
+    pub fn is_ready(&self) -> bool {
+        self.is_active && !self.suggestions.is_empty() && !self.is_loading
+    }
+}

canvas/src/canvas/actions/handlers/dispatcher.rs

@@ -0,0 +1,43 @@
+// src/canvas/actions/handlers/dispatcher.rs
+
+use crate::canvas::state::{CanvasState, ActionContext};
+use crate::canvas::actions::{CanvasAction, ActionResult};
+use crate::canvas::modes::AppMode;
+use anyhow::Result;
+
+use super::{handle_edit_action, handle_readonly_action, handle_highlight_action};
+
+/// Main action dispatcher - routes actions to mode-specific handlers
+pub async fn dispatch_action<S: CanvasState>(
+    action: CanvasAction,
+    state: &mut S,
+    ideal_cursor_column: &mut usize,
+) -> Result<ActionResult> {
+    // Check if the application wants to handle this action first
+    let context = ActionContext {
+        key_code: None,
+        ideal_cursor_column: *ideal_cursor_column,
+        current_input: state.get_current_input().to_string(),
+        current_field: state.current_field(),
+    };
+
+    if let Some(result) = state.handle_feature_action(&action, &context) {
+        return Ok(ActionResult::HandledByFeature(result));
+    }
+
+    // Route to mode-specific handler
+    match state.current_mode() {
+        AppMode::Edit => {
+            handle_edit_action(action, state, ideal_cursor_column).await
+        }
+        AppMode::ReadOnly => {
+            handle_readonly_action(action, state, ideal_cursor_column).await
+        }
+        AppMode::Highlight => {
+            handle_highlight_action(action, state, ideal_cursor_column).await
+        }
+        AppMode::General | AppMode::Command => {
+            Ok(ActionResult::success_with_message("Mode does not handle canvas actions directly"))
+        }
+    }
+}

canvas/src/canvas/actions/handlers/edit.rs

@@ -0,0 +1,213 @@
+// src/canvas/actions/handlers/edit.rs
+//! Edit mode action handler
+//!
+//! Handles user input when in edit mode, supporting text entry, deletion,
+//! and cursor movement with edit-specific behavior (cursor can go past end of text).
+
+use crate::canvas::actions::types::{CanvasAction, ActionResult};
+use crate::canvas::actions::movement::*;
+use crate::canvas::state::CanvasState;
+use anyhow::Result;
+
+/// Edit mode uses cursor-past-end behavior for text insertion
+const FOR_EDIT_MODE: bool = true;
+
+/// Handle actions in edit mode with edit-specific cursor behavior
+///
+/// Edit mode allows text modification and uses cursor positioning that can
+/// go past the end of existing text to facilitate insertion.
+///
+/// # Arguments
+/// * `action` - The action to perform
+/// * `state` - Mutable canvas state
+/// * `ideal_cursor_column` - Desired column for vertical movement (maintained across line changes)
+pub async fn handle_edit_action<S: CanvasState>(
+    action: CanvasAction,
+    state: &mut S,
+    ideal_cursor_column: &mut usize,
+) -> Result<ActionResult> {
+    match action {
+        CanvasAction::InsertChar(c) => {
+            // Insert character at cursor position and advance cursor
+            let cursor_pos = state.current_cursor_pos();
+            let input = state.get_current_input_mut();
+            input.insert(cursor_pos, c);
+            state.set_current_cursor_pos(cursor_pos + 1);
+            state.set_has_unsaved_changes(true);
+            *ideal_cursor_column = cursor_pos + 1;
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::DeleteBackward => {
+            // Delete character before cursor (Backspace behavior)
+            let cursor_pos = state.current_cursor_pos();
+            if cursor_pos > 0 {
+                let input = state.get_current_input_mut();
+                input.remove(cursor_pos - 1);
+                state.set_current_cursor_pos(cursor_pos - 1);
+                state.set_has_unsaved_changes(true);
+                *ideal_cursor_column = cursor_pos - 1;
+            }
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::DeleteForward => {
+            // Delete character at cursor position (Delete key behavior)
+            let cursor_pos = state.current_cursor_pos();
+            let input = state.get_current_input_mut();
+            if cursor_pos < input.len() {
+                input.remove(cursor_pos);
+                state.set_has_unsaved_changes(true);
+            }
+            Ok(ActionResult::success())
+        }
+
+        // Cursor movement actions
+        CanvasAction::MoveLeft => {
+            let new_pos = move_left(state.current_cursor_pos());
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveRight => {
+            let current_input = state.get_current_input();
+            let current_pos = state.current_cursor_pos();
+            let new_pos = move_right(current_pos, current_input, FOR_EDIT_MODE);
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            Ok(ActionResult::success())
+        }
+
+        // Field navigation (treating single-line fields as "lines")
+        CanvasAction::MoveUp => {
+            let current_field = state.current_field();
+            if current_field > 0 {
+                state.set_current_field(current_field - 1);
+                let current_input = state.get_current_input();
+                let new_pos = safe_cursor_position(current_input, *ideal_cursor_column, FOR_EDIT_MODE);
+                state.set_current_cursor_pos(new_pos);
+            }
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveDown => {
+            let current_field = state.current_field();
+            let total_fields = state.fields().len();
+            if current_field < total_fields - 1 {
+                state.set_current_field(current_field + 1);
+                let current_input = state.get_current_input();
+                let new_pos = safe_cursor_position(current_input, *ideal_cursor_column, FOR_EDIT_MODE);
+                state.set_current_cursor_pos(new_pos);
+            }
+            Ok(ActionResult::success())
+        }
+
+        // Line-based movement
+        CanvasAction::MoveLineStart => {
+            let new_pos = line_start_position();
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveLineEnd => {
+            let current_input = state.get_current_input();
+            let new_pos = line_end_position(current_input, FOR_EDIT_MODE);
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            Ok(ActionResult::success())
+        }
+
+        // Document-level movement (first/last field)
+        CanvasAction::MoveFirstLine => {
+            state.set_current_field(0);
+            let current_input = state.get_current_input();
+            let new_pos = safe_cursor_position(current_input, 0, FOR_EDIT_MODE);
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveLastLine => {
+            let last_field = state.fields().len() - 1;
+            state.set_current_field(last_field);
+            let current_input = state.get_current_input();
+            let new_pos = line_end_position(current_input, FOR_EDIT_MODE);
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            Ok(ActionResult::success())
+        }
+
+        // Word-based movement
+        CanvasAction::MoveWordNext => {
+            let current_input = state.get_current_input();
+            if !current_input.is_empty() {
+                let new_pos = find_next_word_start(current_input, state.current_cursor_pos());
+                state.set_current_cursor_pos(new_pos);
+                *ideal_cursor_column = new_pos;
+            }
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveWordEnd => {
+            let current_input = state.get_current_input();
+            if !current_input.is_empty() {
+                let new_pos = find_word_end(current_input, state.current_cursor_pos());
+                state.set_current_cursor_pos(new_pos);
+                *ideal_cursor_column = new_pos;
+            }
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveWordPrev => {
+            let current_input = state.get_current_input();
+            if !current_input.is_empty() {
+                let new_pos = find_prev_word_start(current_input, state.current_cursor_pos());
+                state.set_current_cursor_pos(new_pos);
+                *ideal_cursor_column = new_pos;
+            }
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveWordEndPrev => {
+            let current_input = state.get_current_input();
+            if !current_input.is_empty() {
+                let new_pos = find_prev_word_end(current_input, state.current_cursor_pos());
+                state.set_current_cursor_pos(new_pos);
+                *ideal_cursor_column = new_pos;
+            }
+            Ok(ActionResult::success())
+        }
+
+        // Field navigation with simple wrapping behavior
+        CanvasAction::NextField | CanvasAction::PrevField => {
+            let current_field = state.current_field();
+            let total_fields = state.fields().len();
+
+            let new_field = match action {
+                CanvasAction::NextField => {
+                    (current_field + 1) % total_fields // Simple wrap
+                }
+                CanvasAction::PrevField => {
+                    if current_field == 0 { total_fields - 1 } else { current_field - 1 } // Simple wrap
+                }
+                _ => unreachable!(),
+            };
+
+            state.set_current_field(new_field);
+            let current_input = state.get_current_input();
+            let new_pos = safe_cursor_position(current_input, *ideal_cursor_column, FOR_EDIT_MODE);
+            state.set_current_cursor_pos(new_pos);
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::Custom(action_str) => {
+            Ok(ActionResult::success_with_message(&format!("Custom edit action: {}", action_str)))
+        }
+
+        _ => {
+            Ok(ActionResult::success_with_message("Action not implemented for edit mode"))
+        }
+    }
+}

canvas/src/canvas/actions/handlers/highlight.rs

@@ -0,0 +1,104 @@
+// src/canvas/actions/handlers/highlight.rs
+
+use crate::canvas::actions::types::{CanvasAction, ActionResult};
+use crate::canvas::actions::movement::*;
+use crate::canvas::state::CanvasState;
+use anyhow::Result;
+
+const FOR_EDIT_MODE: bool = false; // Highlight mode uses read-only cursor behavior
+
+/// Handle actions in highlight/visual mode
+/// TODO: Implement selection logic and highlight-specific behaviors
+pub async fn handle_highlight_action<S: CanvasState>(
+    action: CanvasAction,
+    state: &mut S,
+    ideal_cursor_column: &mut usize,
+) -> Result<ActionResult> {
+    match action {
+        // Movement actions work similar to read-only mode but with selection
+        CanvasAction::MoveLeft => {
+            let new_pos = move_left(state.current_cursor_pos());
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            // TODO: Update selection range
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveRight => {
+            let current_input = state.get_current_input();
+            let current_pos = state.current_cursor_pos();
+            let new_pos = move_right(current_pos, current_input, FOR_EDIT_MODE);
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            // TODO: Update selection range
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveWordNext => {
+            let current_input = state.get_current_input();
+            if !current_input.is_empty() {
+                let new_pos = find_next_word_start(current_input, state.current_cursor_pos());
+                let final_pos = clamp_cursor_position(new_pos, current_input, FOR_EDIT_MODE);
+                state.set_current_cursor_pos(final_pos);
+                *ideal_cursor_column = final_pos;
+                // TODO: Update selection range
+            }
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveWordEnd => {
+            let current_input = state.get_current_input();
+            if !current_input.is_empty() {
+                let new_pos = find_word_end(current_input, state.current_cursor_pos());
+                let final_pos = clamp_cursor_position(new_pos, current_input, FOR_EDIT_MODE);
+                state.set_current_cursor_pos(final_pos);
+                *ideal_cursor_column = final_pos;
+                // TODO: Update selection range
+            }
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveWordPrev => {
+            let current_input = state.get_current_input();
+            if !current_input.is_empty() {
+                let new_pos = find_prev_word_start(current_input, state.current_cursor_pos());
+                state.set_current_cursor_pos(new_pos);
+                *ideal_cursor_column = new_pos;
+                // TODO: Update selection range
+            }
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveLineStart => {
+            let new_pos = line_start_position();
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            // TODO: Update selection range
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveLineEnd => {
+            let current_input = state.get_current_input();
+            let new_pos = line_end_position(current_input, FOR_EDIT_MODE);
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            // TODO: Update selection range
+            Ok(ActionResult::success())
+        }
+
+        // Highlight mode doesn't handle editing actions
+        CanvasAction::InsertChar(_) |
+        CanvasAction::DeleteBackward |
+        CanvasAction::DeleteForward => {
+            Ok(ActionResult::success_with_message("Action not available in highlight mode"))
+        }
+
+        CanvasAction::Custom(action_str) => {
+            Ok(ActionResult::success_with_message(&format!("Custom highlight action: {}", action_str)))
+        }
+
+        _ => {
+            Ok(ActionResult::success_with_message("Action not implemented for highlight mode"))
+        }
+    }
+}

canvas/src/canvas/actions/handlers/mod.rs

@@ -0,0 +1,11 @@
+// src/canvas/actions/handlers/mod.rs
+
+pub mod edit;
+pub mod readonly;
+pub mod highlight;
+pub mod dispatcher;
+
+pub use edit::handle_edit_action;
+pub use readonly::handle_readonly_action;
+pub use highlight::handle_highlight_action;
+pub use dispatcher::dispatch_action;

canvas/src/canvas/actions/handlers/readonly.rs

@@ -0,0 +1,183 @@
+// src/canvas/actions/handlers/readonly.rs
+
+use crate::canvas::actions::types::{CanvasAction, ActionResult};
+use crate::canvas::actions::movement::*;
+use crate::canvas::state::CanvasState;
+use anyhow::Result;
+
+const FOR_EDIT_MODE: bool = false; // Read-only mode flag
+
+/// Handle actions in read-only mode with read-only specific cursor behavior
+pub async fn handle_readonly_action<S: CanvasState>(
+    action: CanvasAction,
+    state: &mut S,
+    ideal_cursor_column: &mut usize,
+) -> Result<ActionResult> {
+    match action {
+        CanvasAction::MoveLeft => {
+            let new_pos = move_left(state.current_cursor_pos());
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveRight => {
+            let current_input = state.get_current_input();
+            let current_pos = state.current_cursor_pos();
+            let new_pos = move_right(current_pos, current_input, FOR_EDIT_MODE);
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveUp => {
+            let current_field = state.current_field();
+            let new_field = current_field.saturating_sub(1);
+            state.set_current_field(new_field);
+
+            // Apply ideal cursor column with read-only bounds
+            let current_input = state.get_current_input();
+            let new_pos = safe_cursor_position(current_input, *ideal_cursor_column, FOR_EDIT_MODE);
+            state.set_current_cursor_pos(new_pos);
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveDown => {
+            let current_field = state.current_field();
+            let total_fields = state.fields().len();
+            if total_fields == 0 {
+                return Ok(ActionResult::success_with_message("No fields to navigate"));
+            }
+
+            let new_field = (current_field + 1).min(total_fields - 1);
+            state.set_current_field(new_field);
+
+            // Apply ideal cursor column with read-only bounds
+            let current_input = state.get_current_input();
+            let new_pos = safe_cursor_position(current_input, *ideal_cursor_column, FOR_EDIT_MODE);
+            state.set_current_cursor_pos(new_pos);
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveFirstLine => {
+            let total_fields = state.fields().len();
+            if total_fields == 0 {
+                return Ok(ActionResult::success_with_message("No fields to navigate"));
+            }
+
+            state.set_current_field(0);
+            let current_input = state.get_current_input();
+            let new_pos = safe_cursor_position(current_input, *ideal_cursor_column, FOR_EDIT_MODE);
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveLastLine => {
+            let total_fields = state.fields().len();
+            if total_fields == 0 {
+                return Ok(ActionResult::success_with_message("No fields to navigate"));
+            }
+
+            let last_field = total_fields - 1;
+            state.set_current_field(last_field);
+            let current_input = state.get_current_input();
+            let new_pos = safe_cursor_position(current_input, *ideal_cursor_column, FOR_EDIT_MODE);
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveLineStart => {
+            let new_pos = line_start_position();
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveLineEnd => {
+            let current_input = state.get_current_input();
+            let new_pos = line_end_position(current_input, FOR_EDIT_MODE);
+            state.set_current_cursor_pos(new_pos);
+            *ideal_cursor_column = new_pos;
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveWordNext => {
+            let current_input = state.get_current_input();
+            if !current_input.is_empty() {
+                let new_pos = find_next_word_start(current_input, state.current_cursor_pos());
+                let final_pos = clamp_cursor_position(new_pos, current_input, FOR_EDIT_MODE);
+                state.set_current_cursor_pos(final_pos);
+                *ideal_cursor_column = final_pos;
+            }
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveWordEnd => {
+            let current_input = state.get_current_input();
+            if !current_input.is_empty() {
+                let current_pos = state.current_cursor_pos();
+                let new_pos = find_word_end(current_input, current_pos);
+                let final_pos = clamp_cursor_position(new_pos, current_input, FOR_EDIT_MODE);
+                state.set_current_cursor_pos(final_pos);
+                *ideal_cursor_column = final_pos;
+            }
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveWordPrev => {
+            let current_input = state.get_current_input();
+            if !current_input.is_empty() {
+                let new_pos = find_prev_word_start(current_input, state.current_cursor_pos());
+                state.set_current_cursor_pos(new_pos);
+                *ideal_cursor_column = new_pos;
+            }
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveWordEndPrev => {
+            let current_input = state.get_current_input();
+            if !current_input.is_empty() {
+                let new_pos = find_prev_word_end(current_input, state.current_cursor_pos());
+                state.set_current_cursor_pos(new_pos);
+                *ideal_cursor_column = new_pos;
+            }
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::NextField | CanvasAction::PrevField => {
+            let current_field = state.current_field();
+            let total_fields = state.fields().len();
+
+            let new_field = match action {
+                CanvasAction::NextField => {
+                    (current_field + 1) % total_fields // Simple wrap
+                }
+                CanvasAction::PrevField => {
+                    if current_field == 0 { total_fields - 1 } else { current_field - 1 } // Simple wrap
+                }
+                _ => unreachable!(),
+            };
+
+            state.set_current_field(new_field);
+            *ideal_cursor_column = state.current_cursor_pos();
+            Ok(ActionResult::success())
+        }
+
+        // Read-only mode doesn't handle editing actions
+        CanvasAction::InsertChar(_) |
+        CanvasAction::DeleteBackward |
+        CanvasAction::DeleteForward => {
+            Ok(ActionResult::success_with_message("Action not available in read-only mode"))
+        }
+
+        CanvasAction::Custom(action_str) => {
+            Ok(ActionResult::success_with_message(&format!("Custom readonly action: {}", action_str)))
+        }
+
+        _ => {
+            Ok(ActionResult::success_with_message("Action not implemented for read-only mode"))
+        }
+    }
+}

canvas/src/canvas/actions/mod.rs

@@ -0,0 +1,8 @@
+// src/canvas/actions/mod.rs
+
+pub mod types;
+pub mod handlers;
+pub mod movement;
+
+// Re-export the main API
+pub use types::{CanvasAction, ActionResult, execute};

canvas/src/canvas/actions/movement/char.rs

@@ -0,0 +1,49 @@
+// src/canvas/actions/movement/char.rs
+
+/// Calculate new position when moving left
+pub fn move_left(current_pos: usize) -> usize {
+    current_pos.saturating_sub(1)
+}
+
+/// Calculate new position when moving right
+pub fn move_right(current_pos: usize, text: &str, for_edit_mode: bool) -> usize {
+    if text.is_empty() {
+        return current_pos;
+    }
+
+    if for_edit_mode {
+        // Edit mode: can move past end of text
+        (current_pos + 1).min(text.len())
+    } else {
+        // Read-only/highlight mode: stays within text bounds
+        if current_pos < text.len().saturating_sub(1) {
+            current_pos + 1
+        } else {
+            current_pos
+        }
+    }
+}
+
+/// Check if cursor position is valid for the given mode
+pub fn is_valid_cursor_position(pos: usize, text: &str, for_edit_mode: bool) -> bool {
+    if text.is_empty() {
+        return pos == 0;
+    }
+
+    if for_edit_mode {
+        pos <= text.len()
+    } else {
+        pos < text.len()
+    }
+}
+
+/// Clamp cursor position to valid bounds for the given mode
+pub fn clamp_cursor_position(pos: usize, text: &str, for_edit_mode: bool) -> usize {
+    if text.is_empty() {
+        0
+    } else if for_edit_mode {
+        pos.min(text.len())
+    } else {
+        pos.min(text.len().saturating_sub(1))
+    }
+}

canvas/src/canvas/actions/movement/line.rs

@@ -0,0 +1,32 @@
+// src/canvas/actions/movement/line.rs
+
+/// Calculate cursor position for line start
+pub fn line_start_position() -> usize {
+    0
+}
+
+/// Calculate cursor position for line end
+pub fn line_end_position(text: &str, for_edit_mode: bool) -> usize {
+    if text.is_empty() {
+        0
+    } else if for_edit_mode {
+        // Edit mode: cursor can go past end of text
+        text.len()
+    } else {
+        // Read-only/highlight mode: cursor stays on last character
+        text.len().saturating_sub(1)
+    }
+}
+
+/// Calculate safe cursor position when switching fields
+pub fn safe_cursor_position(text: &str, ideal_column: usize, for_edit_mode: bool) -> usize {
+    if text.is_empty() {
+        0
+    } else if for_edit_mode {
+        // Edit mode: cursor can go past end
+        ideal_column.min(text.len())
+    } else {
+        // Read-only/highlight mode: cursor stays within text
+        ideal_column.min(text.len().saturating_sub(1))
+    }
+}

canvas/src/canvas/actions/movement/mod.rs

@@ -0,0 +1,10 @@
+// src/canvas/actions/movement/mod.rs
+
+pub mod word;
+pub mod line;
+pub mod char;
+
+// Re-export commonly used functions
+pub use word::{find_next_word_start, find_word_end, find_prev_word_start, find_prev_word_end};
+pub use line::{line_start_position, line_end_position, safe_cursor_position};
+pub use char::{move_left, move_right, is_valid_cursor_position, clamp_cursor_position};

canvas/src/canvas/actions/movement/word.rs

@@ -0,0 +1,146 @@
+// src/canvas/actions/movement/word.rs
+
+#[derive(PartialEq)]
+enum CharType {
+    Whitespace,
+    Alphanumeric,
+    Punctuation,
+}
+
+fn get_char_type(c: char) -> CharType {
+    if c.is_whitespace() {
+        CharType::Whitespace
+    } else if c.is_alphanumeric() {
+        CharType::Alphanumeric
+    } else {
+        CharType::Punctuation
+    }
+}
+
+/// Find the start of the next word from the current position
+pub fn find_next_word_start(text: &str, current_pos: usize) -> usize {
+    let chars: Vec<char> = text.chars().collect();
+    if chars.is_empty() {
+        return 0;
+    }
+    let current_pos = current_pos.min(chars.len());
+
+    if current_pos == chars.len() {
+        return current_pos;
+    }
+
+    let mut pos = current_pos;
+    let initial_type = get_char_type(chars[pos]);
+
+    // Skip current word/token
+    while pos < chars.len() && get_char_type(chars[pos]) == initial_type {
+        pos += 1;
+    }
+
+    // Skip whitespace
+    while pos < chars.len() && get_char_type(chars[pos]) == CharType::Whitespace {
+        pos += 1;
+    }
+
+    pos
+}
+
+/// Find the end of the current or next word
+pub fn find_word_end(text: &str, current_pos: usize) -> usize {
+    let chars: Vec<char> = text.chars().collect();
+    let len = chars.len();
+    if len == 0 {
+        return 0;
+    }
+
+    let mut pos = current_pos.min(len - 1);
+    let current_type = get_char_type(chars[pos]);
+    
+    // If we're not on whitespace, move to end of current word
+    if current_type != CharType::Whitespace {
+        while pos < len && get_char_type(chars[pos]) == current_type {
+            pos += 1;
+        }
+        return pos.saturating_sub(1);
+    }
+
+    // If we're on whitespace, find next word and go to its end
+    pos = find_next_word_start(text, pos);
+    if pos >= len {
+        return len.saturating_sub(1);
+    }
+
+    let word_type = get_char_type(chars[pos]);
+    while pos < len && get_char_type(chars[pos]) == word_type {
+        pos += 1;
+    }
+
+    pos.saturating_sub(1).min(len.saturating_sub(1))
+}
+
+/// Find the start of the previous word
+pub fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
+    let chars: Vec<char> = text.chars().collect();
+    if chars.is_empty() || current_pos == 0 {
+        return 0;
+    }
+
+    let mut pos = current_pos.saturating_sub(1);
+
+    // Skip whitespace backwards
+    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
+        pos -= 1;
+    }
+
+    // Move to start of word
+    if get_char_type(chars[pos]) != CharType::Whitespace {
+        let word_type = get_char_type(chars[pos]);
+        while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
+            pos -= 1;
+        }
+    }
+
+    if pos == 0 && get_char_type(chars[0]) == CharType::Whitespace {
+        0
+    } else {
+        pos
+    }
+}
+
+/// Find the end of the previous word
+pub fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
+    let chars: Vec<char> = text.chars().collect();
+    if chars.is_empty() || current_pos == 0 {
+        return 0;
+    }
+
+    let mut pos = current_pos.saturating_sub(1);
+
+    // Skip whitespace backwards
+    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
+        pos -= 1;
+    }
+
+    if pos == 0 && get_char_type(chars[0]) == CharType::Whitespace {
+        return 0;
+    }
+    if pos == 0 && get_char_type(chars[0]) != CharType::Whitespace {
+        return 0;
+    }
+
+    let word_type = get_char_type(chars[pos]);
+    while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
+        pos -= 1;
+    }
+
+    // Skip whitespace before this word
+    while pos > 0 && get_char_type(chars[pos - 1]) == CharType::Whitespace {
+        pos -= 1;
+    }
+
+    if pos > 0 {
+        pos - 1
+    } else {
+        0
+    }
+}

canvas/src/canvas/actions/types.rs

@@ -0,0 +1,184 @@
+// src/canvas/actions/types.rs
+
+use crate::canvas::state::CanvasState;
+use anyhow::Result;
+
+/// All available canvas actions
+#[derive(Debug, Clone, PartialEq)]
+pub enum CanvasAction {
+    // Movement actions
+    MoveLeft,
+    MoveRight,
+    MoveUp,
+    MoveDown,
+    
+    // Word movement
+    MoveWordNext,
+    MoveWordPrev,
+    MoveWordEnd,
+    MoveWordEndPrev,
+    
+    // Line movement
+    MoveLineStart,
+    MoveLineEnd,
+    
+    // Field movement
+    NextField,
+    PrevField,
+    MoveFirstLine,
+    MoveLastLine,
+    
+    // Editing actions
+    InsertChar(char),
+    DeleteBackward,
+    DeleteForward,
+    
+    // Autocomplete actions
+    TriggerAutocomplete,
+    SuggestionUp,
+    SuggestionDown,
+    SelectSuggestion,
+    ExitSuggestions,
+    
+    // Custom actions
+    Custom(String),
+}
+
+/// Result type for canvas actions
+#[derive(Debug, Clone)]
+pub enum ActionResult {
+    Success,
+    Message(String),
+    HandledByApp(String),
+    HandledByFeature(String), // Keep for compatibility
+    Error(String),
+}
+
+impl ActionResult {
+    pub fn success() -> Self {
+        Self::Success
+    }
+    
+    pub fn success_with_message(msg: &str) -> Self {
+        Self::Message(msg.to_string())
+    }
+    
+    pub fn handled_by_app(msg: &str) -> Self {
+        Self::HandledByApp(msg.to_string())
+    }
+    
+    pub fn error(msg: &str) -> Self {
+        Self::Error(msg.to_string())
+    }
+    
+    pub fn is_success(&self) -> bool {
+        matches!(self, Self::Success | Self::Message(_) | Self::HandledByApp(_) | Self::HandledByFeature(_))
+    }
+    
+    pub fn message(&self) -> Option<&str> {
+        match self {
+            Self::Message(msg) | Self::HandledByApp(msg) | Self::HandledByFeature(msg) | Self::Error(msg) => Some(msg),
+            Self::Success => None,
+        }
+    }
+}
+
+/// Execute a canvas action on the given state
+pub async fn execute<S: CanvasState>(
+    action: CanvasAction,
+    state: &mut S,
+) -> Result<ActionResult> {
+    let mut ideal_cursor_column = 0;
+    
+    super::handlers::dispatch_action(action, state, &mut ideal_cursor_column).await
+}
+
+impl CanvasAction {
+    /// Get a human-readable description of this action
+    pub fn description(&self) -> &'static str {
+        match self {
+            Self::MoveLeft => "move left",
+            Self::MoveRight => "move right",
+            Self::MoveUp => "move up",
+            Self::MoveDown => "move down",
+            Self::MoveWordNext => "next word",
+            Self::MoveWordPrev => "previous word",
+            Self::MoveWordEnd => "word end",
+            Self::MoveWordEndPrev => "previous word end",
+            Self::MoveLineStart => "line start",
+            Self::MoveLineEnd => "line end",
+            Self::NextField => "next field",
+            Self::PrevField => "previous field",
+            Self::MoveFirstLine => "first field",
+            Self::MoveLastLine => "last field",
+            Self::InsertChar(c) => "insert character",
+            Self::DeleteBackward => "delete backward",
+            Self::DeleteForward => "delete forward",
+            Self::TriggerAutocomplete => "trigger autocomplete",
+            Self::SuggestionUp => "suggestion up",
+            Self::SuggestionDown => "suggestion down",
+            Self::SelectSuggestion => "select suggestion",
+            Self::ExitSuggestions => "exit suggestions",
+            Self::Custom(name) => "custom action",
+        }
+    }
+
+    /// Get all movement-related actions
+    pub fn movement_actions() -> Vec<CanvasAction> {
+        vec![
+            Self::MoveLeft,
+            Self::MoveRight,
+            Self::MoveUp,
+            Self::MoveDown,
+            Self::MoveWordNext,
+            Self::MoveWordPrev,
+            Self::MoveWordEnd,
+            Self::MoveWordEndPrev,
+            Self::MoveLineStart,
+            Self::MoveLineEnd,
+            Self::NextField,
+            Self::PrevField,
+            Self::MoveFirstLine,
+            Self::MoveLastLine,
+        ]
+    }
+
+    /// Get all editing-related actions
+    pub fn editing_actions() -> Vec<CanvasAction> {
+        vec![
+            Self::InsertChar(' '), // Example char
+            Self::DeleteBackward,
+            Self::DeleteForward,
+        ]
+    }
+
+    /// Get all autocomplete-related actions
+    pub fn autocomplete_actions() -> Vec<CanvasAction> {
+        vec![
+            Self::TriggerAutocomplete,
+            Self::SuggestionUp,
+            Self::SuggestionDown,
+            Self::SelectSuggestion,
+            Self::ExitSuggestions,
+        ]
+    }
+
+    /// Check if this action modifies text content
+    pub fn is_editing_action(&self) -> bool {
+        matches!(self,
+            Self::InsertChar(_) |
+            Self::DeleteBackward |
+            Self::DeleteForward
+        )
+    }
+
+    /// Check if this action moves the cursor
+    pub fn is_movement_action(&self) -> bool {
+        matches!(self,
+            Self::MoveLeft | Self::MoveRight | Self::MoveUp | Self::MoveDown |
+            Self::MoveWordNext | Self::MoveWordPrev | Self::MoveWordEnd | Self::MoveWordEndPrev |
+            Self::MoveLineStart | Self::MoveLineEnd | Self::NextField | Self::PrevField |
+            Self::MoveFirstLine | Self::MoveLastLine
+        )
+    }
+}

canvas/src/canvas/gui.rs

@@ -0,0 +1,338 @@
+// canvas/src/canvas/gui.rs
+
+#[cfg(feature = "gui")]
+use ratatui::{
+    layout::{Alignment, Constraint, Direction, Layout, Rect},
+    style::{Modifier, Style},
+    text::{Line, Span},
+    widgets::{Block, Borders, BorderType, Paragraph},
+    Frame,
+};
+
+use crate::canvas::state::CanvasState;
+use crate::canvas::modes::HighlightState;
+
+#[cfg(feature = "gui")]
+use crate::canvas::theme::CanvasTheme;
+
+#[cfg(feature = "gui")]
+use std::cmp::{max, min};
+
+/// Render ONLY the canvas form fields - no autocomplete
+#[cfg(feature = "gui")]
+pub fn render_canvas<T: CanvasTheme>(
+    f: &mut Frame,
+    area: Rect,
+    form_state: &impl CanvasState,
+    theme: &T,
+    is_edit_mode: bool,
+    highlight_state: &HighlightState,
+) -> Option<Rect> {
+    let fields: Vec<&str> = form_state.fields();
+    let current_field_idx = form_state.current_field();
+    let inputs: Vec<&String> = form_state.inputs();
+
+    render_canvas_fields(
+        f,
+        area,
+        &fields,
+        &current_field_idx,
+        &inputs,
+        theme,
+        is_edit_mode,
+        highlight_state,
+        form_state.current_cursor_pos(),
+        form_state.has_unsaved_changes(),
+        |i| form_state.get_display_value_for_field(i).to_string(),
+        |i| form_state.has_display_override(i),
+    )
+}
+
+/// Core canvas field rendering
+#[cfg(feature = "gui")]
+fn render_canvas_fields<T: CanvasTheme, F1, F2>(
+    f: &mut Frame,
+    area: Rect,
+    fields: &[&str],
+    current_field_idx: &usize,
+    inputs: &[&String],
+    theme: &T,
+    is_edit_mode: bool,
+    highlight_state: &HighlightState,
+    current_cursor_pos: usize,
+    has_unsaved_changes: bool,
+    get_display_value: F1,
+    has_display_override: F2,
+) -> Option<Rect>
+where
+    F1: Fn(usize) -> String,
+    F2: Fn(usize) -> bool,
+{
+    // Create layout
+    let columns = Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([Constraint::Percentage(30), Constraint::Percentage(70)])
+        .split(area);
+
+    // Border style based on state
+    let border_style = if has_unsaved_changes {
+        Style::default().fg(theme.warning())
+    } else if is_edit_mode {
+        Style::default().fg(theme.accent())
+    } else {
+        Style::default().fg(theme.secondary())
+    };
+
+    // Input container
+    let input_container = Block::default()
+        .borders(Borders::ALL)
+        .border_type(BorderType::Rounded)
+        .border_style(border_style)
+        .style(Style::default().bg(theme.bg()));
+
+    let input_block = Rect {
+        x: columns[1].x,
+        y: columns[1].y,
+        width: columns[1].width,
+        height: fields.len() as u16 + 2,
+    };
+
+    f.render_widget(&input_container, input_block);
+
+    // Input area layout
+    let input_area = input_container.inner(input_block);
+    let input_rows = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints(vec![Constraint::Length(1); fields.len()])
+        .split(input_area);
+
+    // Render field labels
+    render_field_labels(f, columns[0], input_block, fields, theme);
+
+    // Render field values and return active field rect
+    render_field_values(
+        f,
+        input_rows.to_vec(), // Fix: Convert Rc<[Rect]> to Vec<Rect>
+        inputs,
+        current_field_idx,
+        theme,
+        highlight_state,
+        current_cursor_pos,
+        get_display_value,
+        has_display_override,
+    )
+}
+
+/// Render field labels
+#[cfg(feature = "gui")]
+fn render_field_labels<T: CanvasTheme>(
+    f: &mut Frame,
+    label_area: Rect,
+    input_block: Rect,
+    fields: &[&str],
+    theme: &T,
+) {
+    for (i, field) in fields.iter().enumerate() {
+        let label = Paragraph::new(Line::from(Span::styled(
+            format!("{}:", field),
+            Style::default().fg(theme.fg()),
+        )));
+        f.render_widget(
+            label,
+            Rect {
+                x: label_area.x,
+                y: input_block.y + 1 + i as u16,
+                width: label_area.width,
+                height: 1,
+            },
+        );
+    }
+}
+
+/// Render field values with highlighting
+#[cfg(feature = "gui")]
+fn render_field_values<T: CanvasTheme, F1, F2>(
+    f: &mut Frame,
+    input_rows: Vec<Rect>,
+    inputs: &[&String],
+    current_field_idx: &usize,
+    theme: &T,
+    highlight_state: &HighlightState,
+    current_cursor_pos: usize,
+    get_display_value: F1,
+    has_display_override: F2,
+) -> Option<Rect>
+where
+    F1: Fn(usize) -> String,
+    F2: Fn(usize) -> bool,
+{
+    let mut active_field_input_rect = None;
+
+    for (i, _input) in inputs.iter().enumerate() {
+        let is_active = i == *current_field_idx;
+        let text = get_display_value(i);
+        
+        // Apply highlighting
+        let line = apply_highlighting(
+            &text,
+            i,
+            current_field_idx,
+            current_cursor_pos,
+            highlight_state,
+            theme,
+            is_active,
+        );
+
+        let input_display = Paragraph::new(line).alignment(Alignment::Left);
+        f.render_widget(input_display, input_rows[i]);
+
+        // Set cursor for active field
+        if is_active {
+            active_field_input_rect = Some(input_rows[i]);
+            set_cursor_position(f, input_rows[i], &text, current_cursor_pos, has_display_override(i));
+        }
+    }
+
+    active_field_input_rect
+}
+
+/// Apply highlighting based on highlight state
+#[cfg(feature = "gui")]
+fn apply_highlighting<'a, T: CanvasTheme>(
+    text: &'a str,
+    field_index: usize,
+    current_field_idx: &usize,
+    current_cursor_pos: usize,
+    highlight_state: &HighlightState,
+    theme: &T,
+    is_active: bool,
+) -> Line<'a> {
+    let text_len = text.chars().count();
+
+    match highlight_state {
+        HighlightState::Off => {
+            Line::from(Span::styled(
+                text,
+                if is_active {
+                    Style::default().fg(theme.highlight())
+                } else {
+                    Style::default().fg(theme.fg())
+                },
+            ))
+        }
+        HighlightState::Characterwise { anchor } => {
+            apply_characterwise_highlighting(text, text_len, field_index, current_field_idx, current_cursor_pos, anchor, theme, is_active)
+        }
+        HighlightState::Linewise { anchor_line } => {
+            apply_linewise_highlighting(text, field_index, current_field_idx, anchor_line, theme, is_active)
+        }
+    }
+}
+
+/// Apply characterwise highlighting
+#[cfg(feature = "gui")]
+fn apply_characterwise_highlighting<'a, T: CanvasTheme>(
+    text: &'a str,
+    text_len: usize,
+    field_index: usize,
+    current_field_idx: &usize,
+    current_cursor_pos: usize,
+    anchor: &(usize, usize),
+    theme: &T,
+    is_active: bool,
+) -> Line<'a> {
+    let (anchor_field, anchor_char) = *anchor;
+    let start_field = min(anchor_field, *current_field_idx);
+    let end_field = max(anchor_field, *current_field_idx);
+
+    let highlight_style = Style::default()
+        .fg(theme.highlight())
+        .bg(theme.highlight_bg())
+        .add_modifier(Modifier::BOLD);
+    let normal_style_in_highlight = Style::default().fg(theme.highlight());
+    let normal_style_outside = Style::default().fg(theme.fg());
+
+    if field_index >= start_field && field_index <= end_field {
+        if start_field == end_field {
+            let (start_char, end_char) = if anchor_field == *current_field_idx {
+                (min(anchor_char, current_cursor_pos), max(anchor_char, current_cursor_pos))
+            } else if anchor_field < *current_field_idx {
+                (anchor_char, current_cursor_pos)
+            } else {
+                (current_cursor_pos, anchor_char)
+            };
+
+            let clamped_start = start_char.min(text_len);
+            let clamped_end = end_char.min(text_len);
+
+            let before: String = text.chars().take(clamped_start).collect();
+            let highlighted: String = text.chars()
+                .skip(clamped_start)
+                .take(clamped_end.saturating_sub(clamped_start) + 1)
+                .collect();
+            let after: String = text.chars().skip(clamped_end + 1).collect();
+
+            Line::from(vec![
+                Span::styled(before, normal_style_in_highlight),
+                Span::styled(highlighted, highlight_style),
+                Span::styled(after, normal_style_in_highlight),
+            ])
+        } else {
+            // Multi-field selection
+            Line::from(Span::styled(text, highlight_style))
+        }
+    } else {
+        Line::from(Span::styled(
+            text,
+            if is_active { normal_style_in_highlight } else { normal_style_outside }
+        ))
+    }
+}
+
+/// Apply linewise highlighting
+#[cfg(feature = "gui")]
+fn apply_linewise_highlighting<'a, T: CanvasTheme>(
+    text: &'a str,
+    field_index: usize,
+    current_field_idx: &usize,
+    anchor_line: &usize,
+    theme: &T,
+    is_active: bool,
+) -> Line<'a> {
+    let start_field = min(*anchor_line, *current_field_idx);
+    let end_field = max(*anchor_line, *current_field_idx);
+    
+    let highlight_style = Style::default()
+        .fg(theme.highlight())
+        .bg(theme.highlight_bg())
+        .add_modifier(Modifier::BOLD);
+    let normal_style_in_highlight = Style::default().fg(theme.highlight());
+    let normal_style_outside = Style::default().fg(theme.fg());
+
+    if field_index >= start_field && field_index <= end_field {
+        Line::from(Span::styled(text, highlight_style))
+    } else {
+        Line::from(Span::styled(
+            text,
+            if is_active { normal_style_in_highlight } else { normal_style_outside }
+        ))
+    }
+}
+
+/// Set cursor position
+#[cfg(feature = "gui")]
+fn set_cursor_position(
+    f: &mut Frame,
+    field_rect: Rect,
+    text: &str,
+    current_cursor_pos: usize,
+    has_display_override: bool,
+) {
+    let cursor_x = if has_display_override {
+        field_rect.x + text.chars().count() as u16
+    } else {
+        field_rect.x + current_cursor_pos as u16
+    };
+    let cursor_y = field_rect.y;
+    f.set_cursor_position((cursor_x, cursor_y));
+}

canvas/src/canvas/mod.rs

@@ -0,0 +1,18 @@
+// src/canvas/mod.rs
+
+pub mod actions;
+pub mod gui;
+pub mod modes;
+pub mod state;
+pub mod theme;
+
+// Re-export main types for convenience
+pub use actions::{CanvasAction, ActionResult};
+pub use modes::{AppMode, ModeManager, HighlightState};
+pub use state::{CanvasState, ActionContext};
+
+#[cfg(feature = "gui")]
+pub use theme::CanvasTheme;
+
+#[cfg(feature = "gui")]
+pub use gui::render_canvas;

canvas/src/canvas/modes/highlight.rs

@@ -0,0 +1,15 @@
+// src/state/app/highlight.rs
+// canvas/src/modes/highlight.rs
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum HighlightState {
+    Off,
+    Characterwise { anchor: (usize, usize) }, // (field_index, char_position)
+    Linewise { anchor_line: usize },          // field_index
+}
+
+impl Default for HighlightState {
+    fn default() -> Self {
+        HighlightState::Off
+    }
+}

canvas/src/canvas/modes/manager.rs

@@ -0,0 +1,33 @@
+// src/modes/handlers/mode_manager.rs
+// canvas/src/modes/manager.rs
+
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AppMode {
+    General,   // For intro and admin screens
+    ReadOnly,  // Canvas read-only mode
+    Edit,      // Canvas edit mode
+    Highlight, // Canvas highlight/visual mode
+    Command,   // Command mode overlay
+}
+
+pub struct ModeManager;
+
+impl ModeManager {
+    // Mode transition rules
+    pub fn can_enter_command_mode(current_mode: AppMode) -> bool {
+        !matches!(current_mode, AppMode::Edit)
+    }
+
+    pub fn can_enter_edit_mode(current_mode: AppMode) -> bool {
+        matches!(current_mode, AppMode::ReadOnly)
+    }
+
+    pub fn can_enter_read_only_mode(current_mode: AppMode) -> bool {
+        matches!(current_mode, AppMode::Edit | AppMode::Command | AppMode::Highlight)
+    }
+
+    pub fn can_enter_highlight_mode(current_mode: AppMode) -> bool {
+        matches!(current_mode, AppMode::ReadOnly)
+    }
+}

canvas/src/canvas/modes/mod.rs

@@ -0,0 +1,7 @@
+// canvas/src/modes/mod.rs
+
+pub mod highlight;
+pub mod manager;
+
+pub use highlight::HighlightState;
+pub use manager::{AppMode, ModeManager};

canvas/src/canvas/state.rs

@@ -0,0 +1,117 @@
+// src/canvas/state.rs
+//! Canvas state trait and related types
+//! 
+//! This module defines the core trait that any form or input system must implement
+//! to work with the canvas library.
+
+use crate::canvas::actions::CanvasAction;
+use crate::canvas::modes::AppMode;
+
+/// Context information passed to feature-specific action handlers
+#[derive(Debug)]
+pub struct ActionContext {
+    /// Original key code that triggered this action (for backwards compatibility)
+    pub key_code: Option<crossterm::event::KeyCode>,
+    /// Current ideal cursor column for vertical movement
+    pub ideal_cursor_column: usize,
+    /// Current input text
+    pub current_input: String,
+    /// Current field index
+    pub current_field: usize,
+}
+
+/// Core trait that any form-like state must implement to work with canvas
+/// 
+/// This trait enables the same mode behaviors (edit, read-only, highlight) to work
+/// across any implementation - login forms, data entry forms, configuration screens, etc.
+/// 
+/// # Required Implementation
+/// 
+/// Your struct needs to track:
+/// - Current field index and cursor position
+/// - All input field values 
+/// - Current interaction mode
+/// - Whether there are unsaved changes
+/// 
+/// # Example Implementation
+/// 
+/// ```rust
+/// struct MyForm {
+///     fields: Vec<String>,
+///     current_field: usize, 
+///     cursor_pos: usize,
+///     mode: AppMode,
+///     dirty: bool,
+/// }
+/// 
+/// impl CanvasState for MyForm {
+///     fn current_field(&self) -> usize { self.current_field }
+///     fn current_cursor_pos(&self) -> usize { self.cursor_pos }
+///     // ... implement other required methods
+/// }
+/// ```
+pub trait CanvasState {
+    // --- Core Navigation ---
+    
+    /// Get current field index (0-based)
+    fn current_field(&self) -> usize;
+    
+    /// Get current cursor position within the current field
+    fn current_cursor_pos(&self) -> usize;
+    
+    /// Set current field index (should clamp to valid range)
+    fn set_current_field(&mut self, index: usize);
+    
+    /// Set cursor position within current field (should clamp to valid range)
+    fn set_current_cursor_pos(&mut self, pos: usize);
+
+    // --- Mode Information ---
+    
+    /// Get current interaction mode (edit, read-only, highlight, etc.)
+    fn current_mode(&self) -> AppMode;
+
+    // --- Data Access ---
+    
+    /// Get immutable reference to current field's text
+    fn get_current_input(&self) -> &str;
+    
+    /// Get mutable reference to current field's text
+    fn get_current_input_mut(&mut self) -> &mut String;
+    
+    /// Get all input values as immutable references
+    fn inputs(&self) -> Vec<&String>;
+    
+    /// Get all field names/labels
+    fn fields(&self) -> Vec<&str>;
+
+    // --- State Management ---
+    
+    /// Check if there are unsaved changes
+    fn has_unsaved_changes(&self) -> bool;
+    
+    /// Mark whether there are unsaved changes
+    fn set_has_unsaved_changes(&mut self, changed: bool);
+
+    // --- Optional Overrides ---
+
+    /// Handle application-specific actions not covered by standard handlers
+    /// Return Some(message) if the action was handled, None to use standard handling
+    fn handle_feature_action(&mut self, _action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+        None // Default: no custom handling
+    }
+
+    /// Get display value for a field (may differ from actual value)
+    /// Used for things like password masking or computed display values
+    fn get_display_value_for_field(&self, index: usize) -> &str {
+        self.inputs()
+            .get(index)
+            .map(|s| s.as_str())
+            .unwrap_or("")
+    }
+
+    /// Check if a field has a custom display value
+    /// Return true if get_display_value_for_field returns something different than the actual value
+    fn has_display_override(&self, _index: usize) -> bool {
+        false
+    }
+}

canvas/src/canvas/theme.rs

@@ -0,0 +1,17 @@
+// canvas/src/gui/theme.rs
+
+#[cfg(feature = "gui")]
+use ratatui::style::Color;
+
+/// Theme trait that must be implemented by applications using the canvas GUI
+#[cfg(feature = "gui")]
+pub trait CanvasTheme {
+    fn bg(&self) -> Color;
+    fn fg(&self) -> Color;
+    fn border(&self) -> Color;
+    fn accent(&self) -> Color;
+    fn secondary(&self) -> Color;
+    fn highlight(&self) -> Color;
+    fn highlight_bg(&self) -> Color;
+    fn warning(&self) -> Color;
+}

canvas/src/lib.rs

@@ -0,0 +1,31 @@
+// src/lib.rs
+
+pub mod canvas;
+
+// Only include autocomplete module if feature is enabled
+#[cfg(feature = "autocomplete")]
+pub mod autocomplete;
+
+// Re-export the main API for easy access
+pub use canvas::actions::{CanvasAction, ActionResult, execute};
+pub use canvas::state::{CanvasState, ActionContext};
+pub use canvas::modes::{AppMode, ModeManager, HighlightState};
+
+#[cfg(feature = "gui")]
+pub use canvas::theme::CanvasTheme;
+
+#[cfg(feature = "gui")]
+pub use canvas::gui::render_canvas;
+
+// Re-export autocomplete API if feature is enabled
+#[cfg(feature = "autocomplete")]
+pub use autocomplete::{
+    AutocompleteCanvasState, 
+    AutocompleteState, 
+    SuggestionItem,
+    execute_with_autocomplete,
+    handle_autocomplete_feature_action,
+};
+
+#[cfg(all(feature = "gui", feature = "autocomplete"))]
+pub use autocomplete::render_autocomplete_dropdown;

canvas/view_docs.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+
+# Enhanced documentation viewer for your canvas library
+echo "=========================================="
+echo "CANVAS LIBRARY DOCUMENTATION"
+echo "=========================================="
+
+# Function to display module docs with colors
+show_module() {
+    local module=$1
+    local title=$2
+    
+    echo -e "\n\033[1;34m=== $title ===\033[0m"
+    echo -e "\033[33mFiles in $module:\033[0m"
+    find src/$module -name "*.rs" 2>/dev/null | sort
+    echo
+    
+    # Show doc comments for this module
+    find src/$module -name "*.rs" 2>/dev/null | while read file; do
+        if grep -q "///" "$file"; then
+            echo -e "\033[32m--- $file ---\033[0m"
+            grep -n "^\s*///" "$file" | sed 's/^\([0-9]*:\)\s*\/\/\/ /\1 /' | head -10
+            echo
+        fi
+    done
+}
+
+# Main modules
+show_module "canvas" "CANVAS SYSTEM"
+show_module "autocomplete" "AUTOCOMPLETE SYSTEM" 
+show_module "config" "CONFIGURATION SYSTEM"
+
+# Show lib.rs and other root files
+echo -e "\n\033[1;34m=== ROOT DOCUMENTATION ===\033[0m"
+if [ -f "src/lib.rs" ]; then
+    echo -e "\033[32m--- src/lib.rs ---\033[0m"
+    grep -n "^\s*///" src/lib.rs | sed 's/^\([0-9]*:\)\s*\/\/\/ /\1 /' 2>/dev/null
+fi
+
+if [ -f "src/dispatcher.rs" ]; then
+    echo -e "\033[32m--- src/dispatcher.rs ---\033[0m"
+    grep -n "^\s*///" src/dispatcher.rs | sed 's/^\([0-9]*:\)\s*\/\/\/ /\1 /' 2>/dev/null
+fi
+
+echo -e "\n\033[1;36m=========================================="
+echo "To view specific module documentation:"
+echo "  ./view_canvas_docs.sh canvas"
+echo "  ./view_canvas_docs.sh autocomplete" 
+echo "  ./view_canvas_docs.sh config"
+echo "==========================================\033[0m"
+
+# If specific module requested
+if [ $# -eq 1 ]; then
+    show_module "$1" "$(echo $1 | tr '[:lower:]' '[:upper:]') MODULE DETAILS"
+fi

client/.gitignore

@@ -0,0 +1 @@
+canvas_config.toml.txt

client/Cargo.toml

@@ -5,28 +5,36 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-anyhow = "1.0.98"
+anyhow = { workspace = true }
 async-trait = "0.1.88"
 common = { path = "../common" }
+canvas = { path = "../canvas", features = ["gui"] }
 
-crossterm = "0.28.1"
+ratatui = { workspace = true }
+crossterm = { workspace = true }
+prost-types = { workspace = true }
 dirs = "6.0.0"
 dotenvy = "0.15.7"
 lazy_static = "1.5.0"
 prost = "0.13.5"
-ratatui = { version = "0.29.0", features = ["crossterm"] }
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
 time = "0.3.41"
 tokio = { version = "1.44.2", features = ["full", "macros"] }
-toml = "0.8.20"
+toml = { workspace = true }
 tonic = "0.13.0"
 tracing = "0.1.41"
 tracing-subscriber = "0.3.19"
 tui-textarea = { version = "0.7.0", features = ["crossterm", "ratatui", "search"] }
 unicode-segmentation = "1.12.0"
-unicode-width = "0.2.0"
+unicode-width.workspace = true
 
 [features]
 default = []
 ui-debug = []
+
+[dev-dependencies]
+rstest = "0.25.0"
+tokio-test = "0.4.4"
+uuid = { version = "1.17.0", features = ["v4"] }
+futures = "0.3.31"

client/config.toml

@@ -2,9 +2,9 @@
 [keybindings]
 
 enter_command_mode = [":", "ctrl+;"]
-next_buffer = ["ctrl+l"]
-previous_buffer = ["ctrl+h"] 
-close_buffer = ["ctrl+k"]
+next_buffer = ["space+b+n"]
+previous_buffer = ["space+b+p"] 
+close_buffer = ["space+b+d"]
 
 [keybindings.general]
 move_up = ["k", "Up"]
@@ -17,12 +17,11 @@ toggle_buffer_list = ["ctrl+b"]
 next_field = ["Tab"]
 prev_field = ["Shift+Tab"]
 exit_table_scroll = ["esc"]
+open_search = ["ctrl+f"]
 
 [keybindings.common]
 save = ["ctrl+s"]
 quit = ["ctrl+q"]
-# !!!change to space b r in the future and from edit mode 
-revert = ["ctrl+r"]
 
 force_quit = ["ctrl+shift+q"]
 save_and_quit = ["ctrl+shift+s"]
@@ -30,6 +29,7 @@ move_up = ["Up"]
 move_down = ["Down"]
 toggle_sidebar = ["ctrl+t"]
 toggle_buffer_list = ["ctrl+b"]
+revert = ["space+b+r"]
 
 # MODE SPECIFIC
 # READ ONLY MODE
@@ -39,25 +39,45 @@ enter_edit_mode_after = ["a"]
 previous_entry = ["left","q"]
 next_entry = ["right","1"]
 
-move_left = ["h"]
-move_right = ["l"]
-move_up = ["k"]
-move_down = ["j"]
-move_word_next = ["w"]
-move_word_end = ["e"]
-move_word_prev = ["b"]
-move_word_end_prev = ["ge"]
-move_line_start = ["0"]
-move_line_end = ["$"]
-move_first_line = ["gg"]
-move_last_line = ["x"]
 enter_highlight_mode = ["v"]
 enter_highlight_mode_linewise = ["ctrl+v"]
 
+### AUTOGENERATED CANVAS CONFIG
+# Required
+move_up = ["k", "Up"]
+move_left = ["h", "Left"]
+move_right = ["l", "Right"]
+move_down = ["j", "Down"]
+# Optional
+move_line_end = ["$"]
+# move_word_next = ["w"]
+next_field = ["Tab"]
+move_word_prev = ["b"]
+move_word_end = ["e"]
+move_last_line = ["shift+g"]
+move_word_end_prev = ["ge"]
+move_line_start = ["0"]
+move_first_line = ["g+g"]
+prev_field = ["Shift+Tab"]
+
 [keybindings.highlight]
 exit_highlight_mode = ["esc"]
 enter_highlight_mode_linewise = ["ctrl+v"]
 
+### AUTOGENERATED CANVAS CONFIG
+# Required
+move_left = ["h", "Left"]
+move_right = ["l", "Right"]
+move_up = ["k", "Up"]
+move_down = ["j", "Down"]
+# Optional
+move_word_next = ["w"]
+move_line_start = ["0"]
+move_line_end = ["$"]
+move_word_prev = ["b"]
+move_word_end = ["e"]
+
+
 [keybindings.edit]
 # BIG CHANGES NOW EXIT HANDLES EITHER IF THOSE
 # exit_edit_mode = ["esc","ctrl+e"]
@@ -65,15 +85,30 @@ enter_highlight_mode_linewise = ["ctrl+v"]
 # select_suggestion = ["enter"]
 # next_field = ["enter"]
 enter_decider = ["enter"]
-prev_field = ["shift+enter"]
 exit = ["esc", "ctrl+e"]
-delete_char_forward = ["delete"]
-delete_char_backward = ["backspace"]
-move_left = ["left"]
-move_right = ["right"]
 suggestion_down = ["ctrl+n", "tab"]
 suggestion_up = ["ctrl+p", "shift+tab"]
 
+### AUTOGENERATED CANVAS CONFIG
+# Required
+move_right = ["Right", "l"]
+delete_char_backward = ["Backspace"]
+next_field = ["Tab", "Enter"]
+move_up = ["Up", "k"]
+move_down = ["Down", "j"]
+prev_field = ["Shift+Tab"]
+move_left = ["Left", "h"]
+# Optional
+move_last_line = ["Ctrl+End", "G"]
+delete_char_forward = ["Delete"]
+move_word_prev = ["Ctrl+Left", "b"]
+move_word_end = ["e"]
+move_word_end_prev = ["ge"]
+move_first_line = ["Ctrl+Home", "gg"]
+move_word_next = ["Ctrl+Right", "w"]
+move_line_start = ["Home", "0"]
+move_line_end = ["End", "$"]
+
 [keybindings.command]
 exit_command_mode = ["ctrl+g", "esc"]
 command_execute = ["enter"]
@@ -91,3 +126,9 @@ keybinding_mode = "vim"  # Options: "default", "vim", "emacs"
 [colors]
 theme = "dark" 
 # Options: "light", "dark", "high_contrast"
+
+
+
+
+
+

client/docs/canvas_add_functionality.md

@@ -0,0 +1,124 @@
+## How Canvas Library Custom Functionality Works
+
+### 1. **The Canvas Library Calls YOUR Custom Code First**
+
+When you call `ActionDispatcher::dispatch()`, here's what happens:
+
+```rust
+// Inside canvas library (canvas/src/actions/edit.rs):
+pub async fn execute_canvas_action<S: CanvasState>(
+    action: CanvasAction,
+    state: &mut S,
+    ideal_cursor_column: &mut usize,
+) -> Result<ActionResult> {
+    // 1. FIRST: Canvas library calls YOUR custom handler
+    if let Some(result) = state.handle_feature_action(&action, &context) {
+        return Ok(ActionResult::HandledByFeature(result)); // YOUR code handled it
+    }
+
+    // 2. ONLY IF your code returns None: Canvas handles generic actions
+    handle_generic_canvas_action(action, state, ideal_cursor_column).await
+}
+```
+
+### 2. **Your Extension Point: `handle_feature_action`**
+
+You add custom functionality by implementing `handle_feature_action` in your states:
+
+```rust
+// In src/state/pages/auth.rs
+impl CanvasState for LoginState {
+    // ... other methods ...
+
+    fn handle_feature_action(&mut self, action: &CanvasAction, context: &ActionContext) -> Option<String> {
+        match action {
+            // Custom login-specific actions
+            CanvasAction::Custom(action_str) if action_str == "submit_login" => {
+                if self.username.is_empty() || self.password.is_empty() {
+                    Some("Please fill in all required fields".to_string())
+                } else {
+                    // Trigger login process
+                    Some(format!("Logging in user: {}", self.username))
+                }
+            }
+            
+            CanvasAction::Custom(action_str) if action_str == "clear_form" => {
+                self.username.clear();
+                self.password.clear();
+                self.set_has_unsaved_changes(false);
+                Some("Login form cleared".to_string())
+            }
+
+            // Custom behavior for standard actions
+            CanvasAction::NextField => {
+                // Custom validation when moving between fields
+                if self.current_field == 0 && self.username.is_empty() {
+                    Some("Username cannot be empty".to_string())
+                } else {
+                    None // Let canvas library handle the normal field movement
+                }
+            }
+
+            // Let canvas library handle everything else
+            _ => None,
+        }
+    }
+}
+```
+
+### 3. **Multiple Ways to Add Custom Functionality**
+
+#### A) **Custom Actions via Config**
+```toml
+# In config.toml
+[keybindings.edit]
+submit_login = ["ctrl+enter"]
+clear_form = ["ctrl+r"]
+```
+
+#### B) **Override Standard Actions**
+```rust
+fn handle_feature_action(&mut self, action: &CanvasAction, context: &ActionContext) -> Option<String> {
+    match action {
+        CanvasAction::InsertChar('p') if self.current_field == 1 => {
+            // Custom behavior when typing 'p' in password field
+            Some("Password field - use secure input".to_string())
+        }
+        _ => None, // Let canvas handle normally
+    }
+}
+```
+
+#### C) **Context-Aware Logic**
+```rust
+fn handle_feature_action(&mut self, action: &CanvasAction, context: &ActionContext) -> Option<String> {
+    match action {
+        CanvasAction::MoveDown => {
+            // Custom logic based on current state
+            if context.current_field == 1 && context.current_input.len() < 8 {
+                Some("Password should be at least 8 characters".to_string())
+            } else {
+                None // Normal field movement
+            }
+        }
+        _ => None,
+    }
+}
+```
+
+## The Canvas Library Philosophy
+
+**Canvas Library = Generic behavior + Your extension points**
+
+- ✅ **Canvas handles**: Character insertion, cursor movement, field navigation, etc.
+- ✅ **You handle**: Validation, submission, clearing, app-specific logic
+- ✅ **You decide**: Return `Some(message)` to override, `None` to use canvas default
+
+## Summary
+
+You **don't communicate with the library elsewhere**. Instead:
+
+1. **Canvas library calls your code first** via `handle_feature_action`
+2. **Your code decides** whether to handle the action or let canvas handle it
+3. **Canvas library handles** generic form behavior when you return `None`
+

client/src/components/admin/add_logic.rs

@@ -3,7 +3,7 @@ use crate::config::colors::themes::Theme;
 use crate::state::app::highlight::HighlightState;
 use crate::state::app::state::AppState;
 use crate::state::pages::add_logic::{AddLogicFocus, AddLogicState};
-use crate::state::pages::canvas_state::CanvasState;
+use canvas::canvas::{render_canvas, CanvasState, HighlightState as CanvasHighlightState}; // Use canvas library
 use ratatui::{
     layout::{Alignment, Constraint, Direction, Layout, Rect},
     style::{Modifier, Style},
@@ -11,10 +11,18 @@ use ratatui::{
     widgets::{Block, BorderType, Borders, Paragraph},
     Frame,
 };
-use crate::components::handlers::canvas::render_canvas;
 use crate::components::common::{dialog, autocomplete}; // Added autocomplete
 use crate::config::binds::config::EditorKeybindingMode;
 
+// Helper function to convert between HighlightState types
+fn convert_highlight_state(local: &HighlightState) -> CanvasHighlightState {
+    match local {
+        HighlightState::Off => CanvasHighlightState::Off,
+        HighlightState::Characterwise { anchor } => CanvasHighlightState::Characterwise { anchor: *anchor },
+        HighlightState::Linewise { anchor_line } => CanvasHighlightState::Linewise { anchor_line: *anchor_line },
+    }
+}
+
 pub fn render_add_logic(
     f: &mut Frame,
     area: Rect,
@@ -152,40 +160,37 @@ pub fn render_add_logic(
     );
     f.render_widget(profile_text, top_info_area);
 
-    // Canvas
+    // Canvas - USING CANVAS LIBRARY
     let focus_on_canvas_inputs = matches!(
         add_logic_state.current_focus,
         AddLogicFocus::InputLogicName
             | AddLogicFocus::InputTargetColumn
             | AddLogicFocus::InputDescription
     );
-    // Call render_canvas and get the active_field_rect
+
+    let canvas_highlight_state = convert_highlight_state(highlight_state);
     let active_field_rect = render_canvas(
         f,
         canvas_area,
-        add_logic_state, // Pass the whole state as it impl CanvasState
-        &add_logic_state.fields(),
-        &add_logic_state.current_field(),
-        &add_logic_state.inputs(),
-        theme,
-        is_edit_mode && focus_on_canvas_inputs, // is_edit_mode for canvas fields
-        highlight_state,
+        add_logic_state,        // AddLogicState implements CanvasState
+        theme,                  // Theme implements CanvasTheme
+        is_edit_mode && focus_on_canvas_inputs,
+        &canvas_highlight_state,
     );
 
     // --- Render Autocomplete for Target Column ---
     // `is_edit_mode` here refers to the general edit mode of the EventHandler
     if is_edit_mode && add_logic_state.current_field() == 1 { // Target Column field
-        if let Some(suggestions) = add_logic_state.get_suggestions() { // Uses CanvasState impl
-            let selected = add_logic_state.get_selected_suggestion_index();
-            if !suggestions.is_empty() { // Only render if there are suggestions to show
+        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,
-                        suggestions,
-                        selected,
+                        &add_logic_state.target_column_suggestions,
+                        add_logic_state.selected_target_column_suggestion_index,
                     );
                 }
             }

client/src/components/admin/add_table.rs

@@ -3,8 +3,7 @@ use crate::config::colors::themes::Theme;
 use crate::state::app::highlight::HighlightState;
 use crate::state::app::state::AppState;
 use crate::state::pages::add_table::{AddTableFocus, AddTableState};
-use crate::state::pages::canvas_state::CanvasState;
-// use crate::state::pages::add_table::{ColumnDefinition, LinkDefinition}; // Not directly used here
+use canvas::canvas::{render_canvas, CanvasState, HighlightState as CanvasHighlightState};
 use ratatui::{
     layout::{Alignment, Constraint, Direction, Layout, Rect},
     style::{Modifier, Style},
@@ -12,16 +11,24 @@ use ratatui::{
     widgets::{Block, BorderType, Borders, Cell, Paragraph, Row, Table},
     Frame,
 };
-use crate::components::handlers::canvas::render_canvas;
 use crate::components::common::dialog;
 
+// Helper function to convert between HighlightState types
+fn convert_highlight_state(local: &HighlightState) -> CanvasHighlightState {
+    match local {
+        HighlightState::Off => CanvasHighlightState::Off,
+        HighlightState::Characterwise { anchor } => CanvasHighlightState::Characterwise { anchor: *anchor },
+        HighlightState::Linewise { anchor_line } => CanvasHighlightState::Linewise { anchor_line: *anchor_line },
+    }
+}
+
 /// Renders the Add New Table page layout, structuring the display of table information,
 /// input fields, and action buttons. Adapts layout based on terminal width.
 pub fn render_add_table(
     f: &mut Frame,
     area: Rect,
     theme: &Theme,
-    app_state: &AppState, // Currently unused, might be needed later
+    app_state: &AppState,
     add_table_state: &mut AddTableState,
     is_edit_mode: bool, // Determines if canvas inputs are in edit mode
     highlight_state: &HighlightState, // For text highlighting in canvas
@@ -349,17 +356,15 @@ pub fn render_add_table(
         &mut add_table_state.column_table_state,
     );
 
-    // --- Canvas Rendering (Column Definition Input) ---
+    // --- Canvas Rendering (Column Definition Input) - USING CANVAS LIBRARY ---
+    let canvas_highlight_state = convert_highlight_state(highlight_state);
     let _active_field_rect = render_canvas(
         f,
         canvas_area,
-        add_table_state,
-        &add_table_state.fields(),
-        &add_table_state.current_field(),
-        &add_table_state.inputs(),
-        theme,
+        add_table_state,        // AddTableState implements CanvasState
+        theme,                  // Theme implements CanvasTheme
         is_edit_mode && focus_on_canvas_inputs,
-        highlight_state,
+        &canvas_highlight_state,
     );
 
     // --- Button Style Helpers ---
@@ -557,7 +562,7 @@ pub fn render_add_table(
 
     // --- DIALOG ---
     // Render the dialog overlay if it's active
-    if app_state.ui.dialog.dialog_show { // Use the passed-in app_state
+    if app_state.ui.dialog.dialog_show {
         dialog::render_dialog(
             f,
             f.area(), // Render over the whole frame area

client/src/components/admin/admin_panel.rs

@@ -4,7 +4,7 @@ use crate::config::colors::themes::Theme;
 use crate::state::pages::auth::AuthState;
 use crate::state::app::state::AppState;
 use crate::state::pages::admin::AdminState;
-use common::proto::multieko2::table_definition::ProfileTreeResponse;
+use common::proto::komp_ac::table_definition::ProfileTreeResponse;
 use ratatui::{
     layout::{Constraint, Direction, Layout, Rect},
     style::Style,

client/src/components/auth/login.rs

@@ -13,6 +13,16 @@ use ratatui::{
     Frame,
 };
 use crate::state::app::highlight::HighlightState;
+use canvas::canvas::{render_canvas, HighlightState as CanvasHighlightState}; // Use canvas library's render function
+
+// Helper function to convert between HighlightState types
+fn convert_highlight_state(local: &HighlightState) -> CanvasHighlightState {
+    match local {
+        HighlightState::Off => CanvasHighlightState::Off,
+        HighlightState::Characterwise { anchor } => CanvasHighlightState::Characterwise { anchor: *anchor },
+        HighlightState::Linewise { anchor_line } => CanvasHighlightState::Linewise { anchor_line: *anchor_line },
+    }
+}
 
 pub fn render_login(
     f: &mut Frame,
@@ -48,17 +58,15 @@ pub fn render_login(
         ])
         .split(inner_area);
 
-    // --- FORM RENDERING ---
-    crate::components::handlers::canvas::render_canvas(
+    // --- FORM RENDERING (Using canvas library directly) ---
+    let canvas_highlight_state = convert_highlight_state(highlight_state);
+    render_canvas(
         f,
         chunks[0],
-        login_state,
-        &["Username/Email", "Password"],
-        &login_state.current_field,
-        &[&login_state.username, &login_state.password],
-        theme,
+        login_state,        // LoginState implements CanvasState
+        theme,              // Theme implements CanvasTheme
         is_edit_mode,
-        highlight_state,
+        &canvas_highlight_state,
     );
 
     // --- ERROR MESSAGE ---
@@ -71,7 +79,7 @@ pub fn render_login(
         );
     }
 
-    // --- BUTTONS ---
+    // --- BUTTONS (unchanged) ---
     let button_chunks = Layout::default()
         .direction(Direction::Horizontal)
         .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
@@ -105,11 +113,11 @@ pub fn render_login(
     );
 
     // Return Button
-    let return_button_index = 1; // Assuming Return is the second general element
+    let return_button_index = 1;
     let return_active = if app_state.ui.focus_outside_canvas {
         app_state.focused_button_index== return_button_index
     } else {
-        false // Not active if focus is in canvas or other modes
+        false
     };
     let mut return_style = Style::default().fg(theme.fg);
     let mut return_border = Style::default().fg(theme.border);
@@ -132,16 +140,14 @@ pub fn render_login(
     );
 
     // --- DIALOG ---
-    // Check the correct field name for showing the dialog
     if app_state.ui.dialog.dialog_show {
-        // Pass all 7 arguments correctly
         dialog::render_dialog(
             f,
             f.area(),
             theme,
             &app_state.ui.dialog.dialog_title,
             &app_state.ui.dialog.dialog_message,
-            &app_state.ui.dialog.dialog_buttons, // Pass buttons slice
+            &app_state.ui.dialog.dialog_buttons,
             app_state.ui.dialog.dialog_active_button_index,
             app_state.ui.dialog.is_loading,
         );

client/src/components/auth/register.rs

@@ -2,10 +2,9 @@
 
 use crate::{
     config::colors::themes::Theme,
-    state::pages::auth::RegisterState, // Use RegisterState
-    components::common::{dialog, autocomplete},    
+    state::pages::auth::RegisterState,
+    components::common::dialog,
     state::app::state::AppState,
-    state::pages::canvas_state::CanvasState,
     modes::handlers::mode_manager::AppMode,
 };
 use ratatui::{
@@ -15,12 +14,24 @@ use ratatui::{
     Frame,
 };
 use crate::state::app::highlight::HighlightState;
+use canvas::canvas::{render_canvas, HighlightState as CanvasHighlightState}; // Use canvas library's render function
+use canvas::autocomplete::gui::render_autocomplete_dropdown;
+use canvas::autocomplete::AutocompleteCanvasState;
+
+// Helper function to convert between HighlightState types
+fn convert_highlight_state(local: &HighlightState) -> CanvasHighlightState {
+    match local {
+        HighlightState::Off => CanvasHighlightState::Off,
+        HighlightState::Characterwise { anchor } => CanvasHighlightState::Characterwise { anchor: *anchor },
+        HighlightState::Linewise { anchor_line } => CanvasHighlightState::Linewise { anchor_line: *anchor_line },
+    }
+}
 
 pub fn render_register(
     f: &mut Frame,
     area: Rect,
     theme: &Theme,
-    state: &RegisterState, // Use RegisterState
+    state: &RegisterState,
     app_state: &AppState,
     is_edit_mode: bool,
     highlight_state: &HighlightState,
@@ -29,7 +40,7 @@ pub fn render_register(
         .borders(Borders::ALL)
         .border_type(BorderType::Plain)
         .border_style(Style::default().fg(theme.border))
-        .title(" Register ") // Update title
+        .title(" Register ")
         .style(Style::default().bg(theme.bg));
 
     f.render_widget(block, area);
@@ -39,7 +50,6 @@ pub fn render_register(
         vertical: 1,
     });
 
-    // Adjust constraints for 4 fields + error + buttons
     let chunks = Layout::default()
         .direction(Direction::Vertical)
         .constraints([
@@ -50,23 +60,15 @@ pub fn render_register(
         ])
         .split(inner_area);
 
-    // --- FORM RENDERING (Using render_canvas) ---
-    let active_field_rect = crate::components::handlers::canvas::render_canvas(
+    // --- FORM RENDERING (Using canvas library directly) ---
+    let canvas_highlight_state = convert_highlight_state(highlight_state);
+    let input_rect = render_canvas(
         f,
-        chunks[0], // Area for the canvas
-        state,     // The state object (RegisterState)
-        &[         // Field labels
-            "Username",
-            "Email*",
-            "Password*",
-            "Confirm Password",
-            "Role* (Tab)",
-        ],
-        &state.current_field(), // Pass current field index
-        &state.inputs().iter().map(|s| *s).collect::<Vec<&String>>(), // Pass inputs directly
-        theme,
+        chunks[0],
+        state,              // RegisterState implements CanvasState
+        theme,              // Theme implements CanvasTheme
         is_edit_mode,
-        highlight_state,
+        &canvas_highlight_state,
     );
 
     // --- HELP TEXT ---
@@ -75,7 +77,6 @@ pub fn render_register(
         .alignment(Alignment::Center);
     f.render_widget(help_text, chunks[1]);
 
-   
     // --- ERROR MESSAGE ---
     if let Some(err) = &state.error_message {
         f.render_widget(
@@ -107,7 +108,7 @@ pub fn render_register(
     }
 
     f.render_widget(
-        Paragraph::new("Register") // Update button text
+        Paragraph::new("Register")
             .style(register_style)
             .alignment(Alignment::Center)
             .block(
@@ -119,7 +120,7 @@ pub fn render_register(
         button_chunks[0],
     );
 
-    // Return Button (logic remains similar)
+    // Return Button
     let return_button_index = 1;
     let return_active = if app_state.ui.focus_outside_canvas {
         app_state.focused_button_index== return_button_index
@@ -146,19 +147,22 @@ pub fn render_register(
         button_chunks[1],
     );
 
-    // --- Render Autocomplete Dropdown (Draw AFTER buttons) ---
+    // --- AUTOCOMPLETE DROPDOWN (Using canvas library directly) ---
     if app_state.current_mode == AppMode::Edit {
-        if let Some(suggestions) = state.get_suggestions() {
-            let selected = state.get_selected_suggestion_index();
-            if !suggestions.is_empty() {
-                if let Some(input_rect) = active_field_rect {
-                    autocomplete::render_autocomplete_dropdown(f, input_rect, f.area(), theme, suggestions, selected);
-                }    
+        if let Some(autocomplete_state) = state.autocomplete_state() {
+            if let Some(input_rect) = input_rect {
+                render_autocomplete_dropdown(
+                    f,
+                    f.area(),        // Frame area
+                    input_rect,      // Current input field rect
+                    theme,           // Theme implements CanvasTheme
+                    autocomplete_state,
+                );
             }
         }
     }
 
-    // --- DIALOG --- (Keep dialog logic)
+    // --- DIALOG ---
     if app_state.ui.dialog.dialog_show {
         dialog::render_dialog(
             f,

client/src/components/common.rs

@@ -5,6 +5,7 @@ pub mod text_editor;
 pub mod background;
 pub mod dialog;
 pub mod autocomplete;
+pub mod search_palette;
 pub mod find_file_palette;
 
 pub use command_line::*;
@@ -13,4 +14,5 @@ pub use text_editor::*;
 pub use background::*;
 pub use dialog::*;
 pub use autocomplete::*;
+pub use search_palette::*;
 pub use find_file_palette::*;

client/src/components/common/autocomplete.rs

@@ -1,6 +1,8 @@
 // src/components/common/autocomplete.rs
 
 use crate::config::colors::themes::Theme;
+use crate::state::pages::form::FormState;
+use common::proto::komp_ac::search::search_response::Hit;
 use ratatui::{
     layout::Rect,
     style::{Color, Modifier, Style},
@@ -9,7 +11,8 @@ use ratatui::{
 };
 use unicode_width::UnicodeWidthStr;
 
-/// Renders an opaque dropdown list for autocomplete suggestions.
+/// Renders an opaque dropdown list for simple string-based suggestions.
+/// THIS IS THE RESTORED FUNCTION.
 pub fn render_autocomplete_dropdown(
     f: &mut Frame,
     input_rect: Rect,
@@ -21,39 +24,32 @@ pub fn render_autocomplete_dropdown(
     if suggestions.is_empty() {
         return;
     }
-    // --- Calculate Dropdown Size & Position ---
-    let max_suggestion_width = suggestions.iter().map(|s| s.width()).max().unwrap_or(0) as u16;
+    let max_suggestion_width =
+        suggestions.iter().map(|s| s.width()).max().unwrap_or(0) as u16;
     let horizontal_padding: u16 = 2;
     let dropdown_width = (max_suggestion_width + horizontal_padding).max(10);
     let dropdown_height = (suggestions.len() as u16).min(5);
 
     let mut dropdown_area = Rect {
-        x: input_rect.x, // Align horizontally with input
-        y: input_rect.y + 1, // Position directly below input
+        x: input_rect.x,
+        y: input_rect.y + 1,
         width: dropdown_width,
         height: dropdown_height,
     };
 
-    // --- Clamping Logic (prevent rendering off-screen) ---
-    // Clamp vertically (if it goes below the frame)
     if dropdown_area.bottom() > frame_area.height {
-        dropdown_area.y = input_rect.y.saturating_sub(dropdown_height); // Try rendering above
+        dropdown_area.y = input_rect.y.saturating_sub(dropdown_height);
     }
-    // Clamp horizontally (if it goes past the right edge)
     if dropdown_area.right() > frame_area.width {
         dropdown_area.x = frame_area.width.saturating_sub(dropdown_width);
     }
-    // Ensure x is not negative (if clamping pushes it left)
     dropdown_area.x = dropdown_area.x.max(0);
-    // Ensure y is not negative (if clamping pushes it up)
     dropdown_area.y = dropdown_area.y.max(0);
-    // --- End Clamping ---
 
-    // Render a solid background block first to ensure opacity
-    let background_block = Block::default().style(Style::default().bg(Color::DarkGray));
+    let background_block =
+        Block::default().style(Style::default().bg(Color::DarkGray));
     f.render_widget(background_block, dropdown_area);
 
-    // Create list items, ensuring each has a defined background
     let items: Vec<ListItem> = suggestions
         .iter()
         .enumerate()
@@ -61,30 +57,97 @@ pub fn render_autocomplete_dropdown(
             let is_selected = selected_index == Some(i);
             let s_width = s.width() as u16;
             let padding_needed = dropdown_width.saturating_sub(s_width);
-            let padded_s = format!("{}{}", s, " ".repeat(padding_needed as usize));
+            let padded_s =
+                format!("{}{}", s, " ".repeat(padding_needed as usize));
 
             ListItem::new(padded_s).style(if is_selected {
                 Style::default()
-                    .fg(theme.bg) // Text color on highlight
-                    .bg(theme.highlight) // Highlight background
+                    .fg(theme.bg)
+                    .bg(theme.highlight)
                     .add_modifier(Modifier::BOLD)
             } else {
-                // Style for non-selected items (matching background block)
-                Style::default()
-                    .fg(theme.fg) // Text color on gray
-                    .bg(Color::DarkGray) // Explicit gray background
+                Style::default().fg(theme.fg).bg(Color::DarkGray)
             })
         })
         .collect();
 
-    // Create the list widget (without its own block)
     let list = List::new(items);
+    let mut list_state = ListState::default();
+    list_state.select(selected_index);
 
-    // State for managing selection highlight (still needed for logic)
-    let mut profile_list_state = ListState::default();
-    profile_list_state.select(selected_index);
-
-    // Render the list statefully *over* the background block
-    f.render_stateful_widget(list, dropdown_area, &mut profile_list_state);
+    f.render_stateful_widget(list, dropdown_area, &mut list_state);
 }
 
+/// Renders an opaque dropdown list for rich `Hit`-based suggestions.
+/// RENAMED from render_rich_autocomplete_dropdown
+pub fn render_hit_autocomplete_dropdown(
+    f: &mut Frame,
+    input_rect: Rect,
+    frame_area: Rect,
+    theme: &Theme,
+    suggestions: &[Hit],
+    selected_index: Option<usize>,
+    form_state: &FormState,
+) {
+    if suggestions.is_empty() {
+        return;
+    }
+
+    let display_names: Vec<String> = suggestions
+        .iter()
+        .map(|hit| form_state.get_display_name_for_hit(hit))
+        .collect();
+
+    let max_suggestion_width =
+        display_names.iter().map(|s| s.width()).max().unwrap_or(0) as u16;
+    let horizontal_padding: u16 = 2;
+    let dropdown_width = (max_suggestion_width + horizontal_padding).max(10);
+    let dropdown_height = (suggestions.len() as u16).min(5);
+
+    let mut dropdown_area = Rect {
+        x: input_rect.x,
+        y: input_rect.y + 1,
+        width: dropdown_width,
+        height: dropdown_height,
+    };
+
+    if dropdown_area.bottom() > frame_area.height {
+        dropdown_area.y = input_rect.y.saturating_sub(dropdown_height);
+    }
+    if dropdown_area.right() > frame_area.width {
+        dropdown_area.x = frame_area.width.saturating_sub(dropdown_width);
+    }
+    dropdown_area.x = dropdown_area.x.max(0);
+    dropdown_area.y = dropdown_area.y.max(0);
+
+    let background_block =
+        Block::default().style(Style::default().bg(Color::DarkGray));
+    f.render_widget(background_block, dropdown_area);
+
+    let items: Vec<ListItem> = display_names
+        .iter()
+        .enumerate()
+        .map(|(i, s)| {
+            let is_selected = selected_index == Some(i);
+            let s_width = s.width() as u16;
+            let padding_needed = dropdown_width.saturating_sub(s_width);
+            let padded_s =
+                format!("{}{}", s, " ".repeat(padding_needed as usize));
+
+            ListItem::new(padded_s).style(if is_selected {
+                Style::default()
+                    .fg(theme.bg)
+                    .bg(theme.highlight)
+                    .add_modifier(Modifier::BOLD)
+            } else {
+                Style::default().fg(theme.fg).bg(Color::DarkGray)
+            })
+        })
+        .collect();
+
+    let list = List::new(items);
+    let mut list_state = ListState::default();
+    list_state.select(selected_index);
+
+    f.render_stateful_widget(list, dropdown_area, &mut list_state);
+}

client/src/components/common/search_palette.rs

@@ -0,0 +1,121 @@
+// src/components/common/search_palette.rs
+
+use crate::config::colors::themes::Theme;
+use crate::state::app::search::SearchState;
+use ratatui::{
+    layout::{Constraint, Direction, Layout, Rect},
+    style::{Modifier, Style},
+    text::{Line, Span},
+    widgets::{Block, Borders, Clear, List, ListItem, Paragraph},
+    Frame,
+};
+
+/// Renders the search palette dialog over the main UI.
+pub fn render_search_palette(
+    f: &mut Frame,
+    area: Rect,
+    theme: &Theme,
+    state: &SearchState,
+) {
+    // --- Dialog Area Calculation ---
+    let height = (area.height as f32 * 0.7).min(30.0) as u16;
+    let width = (area.width as f32 * 0.6).min(100.0) as u16;
+    let dialog_area = Rect {
+        x: area.x + (area.width - width) / 2,
+        y: area.y + (area.height - height) / 4,
+        width,
+        height,
+    };
+
+    f.render_widget(Clear, dialog_area); // Clear background
+
+    let block = Block::default()
+        .title(format!(" Search in '{}' ", state.table_name))
+        .borders(Borders::ALL)
+        .border_style(Style::default().fg(theme.accent));
+    f.render_widget(block.clone(), dialog_area);
+
+    // --- Inner Layout (Input + Results) ---
+    let inner_chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .margin(1)
+        .constraints([
+            Constraint::Length(3), // For input box
+            Constraint::Min(0),    // For results list
+        ])
+        .split(dialog_area);
+
+    // --- Render Input Box ---
+    let input_block = Block::default()
+        .title("Query")
+        .borders(Borders::ALL)
+        .border_style(Style::default().fg(theme.border));
+    let input_text = Paragraph::new(state.input.as_str())
+        .block(input_block)
+        .style(Style::default().fg(theme.fg));
+    f.render_widget(input_text, inner_chunks[0]);
+    // Set cursor position
+    f.set_cursor_position((
+        inner_chunks[0].x + state.cursor_position as u16 + 1,
+        inner_chunks[0].y + 1,
+    ));
+
+    // --- Render Results List ---
+    if state.is_loading {
+        let loading_p = Paragraph::new("Searching...")
+            .style(Style::default().fg(theme.fg).add_modifier(Modifier::ITALIC));
+        f.render_widget(loading_p, inner_chunks[1]);
+    } else {
+        let list_items: Vec<ListItem> = state
+            .results
+            .iter()
+            .map(|hit| {
+                // Parse the JSON string to make it readable
+                let content_summary = match serde_json::from_str::<
+                    serde_json::Value,
+                >(&hit.content_json)
+                {
+                    Ok(json) => {
+                        if let Some(obj) = json.as_object() {
+                            // Create a summary from the first few non-null string values
+                            obj.values()
+                                .filter_map(|v| v.as_str())
+                                .filter(|s| !s.is_empty())
+                                .take(3)
+                                .collect::<Vec<_>>()
+                                .join(" | ")
+                        } else {
+                            "Non-object JSON".to_string()
+                        }
+                    }
+                    Err(_) => "Invalid JSON content".to_string(),
+                };
+
+                let line = Line::from(vec![
+                    Span::styled(
+                        format!("{:<4.2} ", hit.score),
+                        Style::default().fg(theme.accent),
+                    ),
+                    Span::raw(content_summary),
+                ]);
+                ListItem::new(line)
+            })
+            .collect();
+
+        let results_list = List::new(list_items)
+            .block(Block::default().title("Results"))
+            .highlight_style(
+                Style::default()
+                    .bg(theme.highlight)
+                    .fg(theme.bg)
+                    .add_modifier(Modifier::BOLD),
+            )
+            .highlight_symbol(">> ");
+
+        // We need a mutable ListState to render the selection
+        let mut list_state =
+            ratatui::widgets::ListState::default().with_selected(Some(state.selected_index));
+
+        f.render_stateful_widget(results_list, inner_chunks[1], &mut list_state);
+    }
+}

client/src/components/common/status_line.rs

@@ -1,13 +1,14 @@
-// src/components/common/status_line.rs
+// client/src/components/common/status_line.rs
 use crate::config::colors::themes::Theme;
 use crate::state::app::state::AppState;
 use ratatui::{
     layout::Rect,
     style::Style,
-    text::{Line, Span},
+    text::{Line, Span, Text},
     widgets::Paragraph,
     Frame,
 };
+use ratatui::widgets::Wrap;
 use std::path::Path;
 use unicode_width::UnicodeWidthStr;
 
@@ -20,22 +21,39 @@ pub fn render_status_line(
     current_fps: f64,
     app_state: &AppState,
 ) {
-    // --- START FIX ---
-    // Ensure debug_text is always a &str, which implements UnicodeWidthStr.
     #[cfg(feature = "ui-debug")]
-    let debug_text = app_state.debug_info.as_str();
-    #[cfg(not(feature = "ui-debug"))]
-    let debug_text = "";
-    // --- END FIX ---
+    {
+        if let Some(debug_state) = &app_state.debug_state {
+            let paragraph = if debug_state.is_error {
+                // --- THIS IS THE CRITICAL LOGIC FOR ERRORS ---
+                // 1. Create a `Text` object, which can contain multiple lines.
+                let error_text = Text::from(debug_state.displayed_message.clone());
 
-    let debug_width = UnicodeWidthStr::width(debug_text);
-    let debug_separator_width = if !debug_text.is_empty() { UnicodeWidthStr::width(" | ") } else { 0 };
+                // 2. Create a Paragraph from the Text and TELL IT TO WRAP.
+                Paragraph::new(error_text)
+                    .wrap(Wrap { trim: true }) // This line makes the text break into new rows.
+                    .style(Style::default().bg(theme.highlight).fg(theme.bg))
+            } else {
+                // --- This is for normal, single-line info messages ---
+                Paragraph::new(debug_state.displayed_message.as_str())
+                    .style(Style::default().fg(theme.accent).bg(theme.bg))
+            };
+            f.render_widget(paragraph, area);
+        } else {
+            // Fallback for when debug state is None
+            let paragraph = Paragraph::new("").style(Style::default().bg(theme.bg));
+            f.render_widget(paragraph, area);
+        }
+        return; // Stop here and don't render the normal status line.
+    }
 
-    let program_info = format!("multieko2 v{}", env!("CARGO_PKG_VERSION"));
+    // --- The normal status line rendering logic (unchanged) ---
+    let program_info = format!("komp_ac v{}", env!("CARGO_PKG_VERSION"));
     let mode_text = if is_edit_mode { "[EDIT]" } else { "[READ-ONLY]" };
 
-    let home_dir =
-        dirs::home_dir().map(|p| p.to_string_lossy().into_owned()).unwrap_or_default();
+    let home_dir = dirs::home_dir()
+        .map(|p| p.to_string_lossy().into_owned())
+        .unwrap_or_default();
     let display_dir = if current_dir.starts_with(&home_dir) {
         current_dir.replacen(&home_dir, "~", 1)
     } else {
@@ -50,19 +68,30 @@ pub fn render_status_line(
     let separator = " | ";
     let separator_width = UnicodeWidthStr::width(separator);
 
-    let fixed_width_with_fps = mode_width + separator_width + separator_width +
-        program_info_width + separator_width + fps_width +
-        debug_separator_width + debug_width;
+    let fixed_width_with_fps = mode_width
+        + separator_width
+        + separator_width
+        + program_info_width
+        + separator_width
+        + fps_width;
+
     let show_fps = fixed_width_with_fps <= available_width;
 
     let remaining_width_for_dir = available_width.saturating_sub(
-        mode_width + separator_width +
-        separator_width + program_info_width +
-        (if show_fps { separator_width + fps_width } else { 0 }) +
-        debug_separator_width + debug_width,
+        mode_width
+            + separator_width
+            + separator_width
+            + program_info_width
+            + (if show_fps {
+                separator_width + fps_width
+            } else {
+                0
+            }),
     );
 
-    let dir_display_text_str = if UnicodeWidthStr::width(display_dir.as_str()) <= remaining_width_for_dir {
+    let dir_display_text_str = if UnicodeWidthStr::width(display_dir.as_str())
+        <= remaining_width_for_dir
+    {
         display_dir
     } else {
         let dir_name = Path::new(current_dir)
@@ -72,14 +101,18 @@ pub fn render_status_line(
         if UnicodeWidthStr::width(dir_name) <= remaining_width_for_dir {
             dir_name.to_string()
         } else {
-            dir_name.chars().take(remaining_width_for_dir).collect::<String>()
+            dir_name
+                .chars()
+                .take(remaining_width_for_dir)
+                .collect::<String>()
         }
     };
 
-    let mut current_content_width = mode_width + separator_width +
-                                    UnicodeWidthStr::width(dir_display_text_str.as_str()) +
-                                    separator_width + program_info_width +
-                                    debug_separator_width + debug_width;
+    let mut current_content_width = mode_width
+        + separator_width
+        + UnicodeWidthStr::width(dir_display_text_str.as_str())
+        + separator_width
+        + program_info_width;
     if show_fps {
         current_content_width += separator_width + fps_width;
     }
@@ -87,20 +120,24 @@ pub fn render_status_line(
     let mut line_spans = vec![
         Span::styled(mode_text, Style::default().fg(theme.accent)),
         Span::styled(separator, Style::default().fg(theme.border)),
-        Span::styled(dir_display_text_str.as_str(), Style::default().fg(theme.fg)),
+        Span::styled(
+            dir_display_text_str.as_str(),
+            Style::default().fg(theme.fg),
+        ),
         Span::styled(separator, Style::default().fg(theme.border)),
-        Span::styled(program_info.as_str(), Style::default().fg(theme.secondary)),
+        Span::styled(
+            program_info.as_str(),
+            Style::default().fg(theme.secondary),
+        ),
     ];
 
     if show_fps {
-        line_spans.push(Span::styled(separator, Style::default().fg(theme.border)));
-        line_spans.push(Span::styled(fps_text.as_str(), Style::default().fg(theme.secondary)));
-    }
-
-    #[cfg(feature = "ui-debug")]
-    {
-        line_spans.push(Span::styled(separator, Style::default().fg(theme.border)));
-        line_spans.push(Span::styled(debug_text, Style::default().fg(theme.accent)));
+        line_spans
+            .push(Span::styled(separator, Style::default().fg(theme.border)));
+        line_spans.push(Span::styled(
+            fps_text.as_str(),
+            Style::default().fg(theme.secondary),
+        ));
     }
 
     let padding_needed = available_width.saturating_sub(current_content_width);
@@ -111,8 +148,8 @@ pub fn render_status_line(
         ));
     }
 
-    let paragraph = Paragraph::new(Line::from(line_spans))
-        .style(Style::default().bg(theme.bg));
+    let paragraph =
+        Paragraph::new(Line::from(line_spans)).style(Style::default().bg(theme.bg));
 
     f.render_widget(paragraph, area);
 }

client/src/components/form/form.rs

@@ -1,36 +1,35 @@
 // src/components/form/form.rs
+use crate::components::common::autocomplete;
+use crate::config::colors::themes::Theme;
+use canvas::canvas::{CanvasState, render_canvas, HighlightState};
+use crate::state::pages::form::FormState;
 use ratatui::{
-    widgets::{Paragraph, Block, Borders},
-    layout::{Layout, Constraint, Direction, Rect, Margin, Alignment},
+    layout::{Alignment, Constraint, Direction, Layout, Margin, Rect},
     style::Style,
+    widgets::{Block, Borders, Paragraph},
     Frame,
 };
-use crate::config::colors::themes::Theme;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::app::highlight::HighlightState;
-use crate::components::handlers::canvas::render_canvas;
 
 pub fn render_form(
     f: &mut Frame,
     area: Rect,
-    form_state_param: &impl CanvasState,
+    form_state: &FormState,
     fields: &[&str],
     current_field_idx: &usize,
     inputs: &[&String],
-    table_name: &str, // This parameter receives the correct table name
+    table_name: &str,
     theme: &Theme,
     is_edit_mode: bool,
     highlight_state: &HighlightState,
     total_count: u64,
     current_position: u64,
 ) {
-    // Use the dynamic `table_name` parameter for the title instead of a hardcoded string.
     let card_title = format!(" {} ", table_name);
 
     let adresar_card = Block::default()
         .borders(Borders::ALL)
         .border_style(Style::default().fg(theme.border))
-        .title(card_title) // Use the dynamic title
+        .title(card_title)
         .style(Style::default().bg(theme.bg).fg(theme.fg));
 
     f.render_widget(adresar_card, area);
@@ -42,10 +41,7 @@ pub fn render_form(
 
     let main_layout = Layout::default()
         .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(1),
-            Constraint::Min(1),
-        ])
+        .constraints([Constraint::Length(1), Constraint::Min(1)])
         .split(inner_area);
 
     let count_position_text = if total_count == 0 && current_position == 1 {
@@ -54,24 +50,49 @@ pub fn render_form(
         format!("Total: {} | New Entry ({})", total_count, current_position)
     } else if total_count == 0 && current_position > 1 {
         format!("Total: 0 | New Entry ({})", current_position)
-    }
-    else {
-        format!("Total: {} | Position: {}/{}", total_count, current_position, total_count)
+    } else {
+        format!(
+            "Total: {} | Position: {}/{}",
+            total_count, current_position, total_count
+        )
     };
+    
     let count_para = Paragraph::new(count_position_text)
         .style(Style::default().fg(theme.fg))
         .alignment(Alignment::Left);
     f.render_widget(count_para, main_layout[0]);
 
-    render_canvas(
+    // Use the canvas library's render_canvas function
+    let active_field_rect = render_canvas(
         f,
         main_layout[1],
-        form_state_param,
-        fields,
-        current_field_idx,
-        inputs,
+        form_state,
         theme,
         is_edit_mode,
         highlight_state,
     );
+
+    // --- RENDER RICH AUTOCOMPLETE ONLY ---
+    if form_state.autocomplete_active {
+        if let Some(active_rect) = active_field_rect {
+            // Get selected index directly from form_state
+            let selected_index = form_state.selected_suggestion_index;
+
+            // Only render rich suggestions (your Hit objects)
+            if let Some(rich_suggestions) = form_state.get_rich_suggestions() {
+                if !rich_suggestions.is_empty() {
+                    autocomplete::render_hit_autocomplete_dropdown(
+                        f,
+                        active_rect,
+                        f.area(),
+                        theme,
+                        rich_suggestions,
+                        selected_index,
+                        form_state,
+                    );
+                }
+            }
+            // Removed simple suggestions - we only use rich ones now!
+        }
+    }
 }

client/src/components/handlers.rs

@@ -1,8 +1,6 @@
 // src/components/handlers.rs
-pub mod canvas;
 pub mod sidebar;
 pub mod buffer_list;
 
-pub use canvas::*;
 pub use sidebar::*;
 pub use buffer_list::*;

client/src/components/handlers/canvas.rs

@@ -1,194 +0,0 @@
-// src/components/handlers/canvas.rs
-use ratatui::{
-    widgets::{Paragraph, Block, Borders},
-    layout::{Layout, Constraint, Direction, Rect},
-    style::{Style, Modifier},
-    text::{Line, Span},
-    Frame,
-    prelude::Alignment,
-};
-use crate::config::colors::themes::Theme;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::app::highlight::HighlightState; // Ensure correct import path
-use std::cmp::{min, max};
-
-pub fn render_canvas(
-    f: &mut Frame,
-    area: Rect,
-    form_state: &impl CanvasState,
-    fields: &[&str],
-    current_field_idx: &usize,
-    inputs: &[&String],
-    theme: &Theme,
-    is_edit_mode: bool,
-    highlight_state: &HighlightState, // Using the enum state
-) -> Option<Rect> {
-    // ... (setup code remains the same) ...
-    let columns = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(30), Constraint::Percentage(70)])
-        .split(area);
-
-    let border_style = if form_state.has_unsaved_changes() {
-        Style::default().fg(theme.warning)
-    } else if is_edit_mode {
-        Style::default().fg(theme.accent)
-    } else {
-        Style::default().fg(theme.secondary)
-    };
-    let input_container = Block::default()
-        .borders(Borders::ALL)
-        .border_style(border_style)
-        .style(Style::default().bg(theme.bg));
-
-    let input_block = Rect {
-        x: columns[1].x,
-        y: columns[1].y,
-        width: columns[1].width,
-        height: fields.len() as u16 + 2,
-    };
-
-    f.render_widget(&input_container, input_block);
-
-    let input_area = input_container.inner(input_block);
-    let input_rows = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints(vec![Constraint::Length(1); fields.len()])
-        .split(input_area);
-
-    let mut active_field_input_rect = None;
-
-    // Render labels
-    for (i, field) in fields.iter().enumerate() {
-        let label = Paragraph::new(Line::from(Span::styled(
-            format!("{}:", field),
-            Style::default().fg(theme.fg)),
-        ));
-        f.render_widget(label, Rect {
-            x: columns[0].x,
-            y: input_block.y + 1 + i as u16,
-            width: columns[0].width,
-            height: 1,
-        });
-    }
-
-
-    // Render inputs and cursor
-    for (i, input) in inputs.iter().enumerate() {
-        let is_active = i == *current_field_idx;
-        let current_cursor_pos = form_state.current_cursor_pos();
-        let text = input.as_str();
-        let text_len = text.chars().count();
-
-        let line: Line;
-
-        // --- Use match on the highlight_state enum ---
-        match highlight_state {
-            HighlightState::Off => {
-                // Not in highlight mode, render normally
-                line = Line::from(Span::styled(
-                    text,
-                    if is_active { Style::default().fg(theme.highlight) } else { Style::default().fg(theme.fg) }
-                ));
-            }
-            HighlightState::Characterwise { anchor } => {
-                // --- Character-wise Highlight Logic ---
-                let (anchor_field, anchor_char) = *anchor;
-                let start_field = min(anchor_field, *current_field_idx);
-                let end_field = max(anchor_field, *current_field_idx);
-
-                // Use start_char and end_char consistently
-                let (start_char, end_char) = if anchor_field == *current_field_idx {
-                    (min(anchor_char, current_cursor_pos), max(anchor_char, current_cursor_pos))
-                } else if anchor_field < *current_field_idx {
-                    (anchor_char, current_cursor_pos)
-                } else {
-                    (current_cursor_pos, anchor_char)
-                };
-
-                let highlight_style = Style::default().fg(theme.highlight).bg(theme.highlight_bg).add_modifier(Modifier::BOLD);
-                let normal_style_in_highlight = Style::default().fg(theme.highlight);
-                let normal_style_outside = Style::default().fg(theme.fg);
-
-                if i >= start_field && i <= end_field {
-                    // This line is within the character-wise highlight range
-                    if start_field == end_field { // Case 1: Single Line Highlight
-                        // Use start_char and end_char here
-                        let clamped_start = start_char.min(text_len);
-                        let clamped_end = end_char.min(text_len); // Use text_len for slicing logic
-
-                        let before: String = text.chars().take(clamped_start).collect();
-                        let highlighted: String = text.chars().skip(clamped_start).take(clamped_end.saturating_sub(clamped_start) + 1).collect();
-                        // Define 'after' here
-                        let after: String = text.chars().skip(clamped_end + 1).collect();
-
-                        line = Line::from(vec![
-                            Span::styled(before, normal_style_in_highlight),
-                            Span::styled(highlighted, highlight_style),
-                            Span::styled(after, normal_style_in_highlight), // Use defined 'after'
-                        ]);
-                    } else if i == start_field { // Case 2: Multi-Line Highlight - Start Line
-                        // Use start_char here
-                        let safe_start = start_char.min(text_len);
-                        let before: String = text.chars().take(safe_start).collect();
-                        let highlighted: String = text.chars().skip(safe_start).collect();
-                        line = Line::from(vec![
-                            Span::styled(before, normal_style_in_highlight),
-                            Span::styled(highlighted, highlight_style),
-                        ]);
-                    } else if i == end_field { // Case 3: Multi-Line Highlight - End Line (Corrected index)
-                        // Use end_char here
-                        let safe_end_inclusive = if text_len > 0 { end_char.min(text_len - 1) } else { 0 };
-                        let highlighted: String = text.chars().take(safe_end_inclusive + 1).collect();
-                        let after: String = text.chars().skip(safe_end_inclusive + 1).collect();
-                        line = Line::from(vec![
-                            Span::styled(highlighted, highlight_style),
-                            Span::styled(after, normal_style_in_highlight),
-                        ]);
-                    } else { // Case 4: Multi-Line Highlight - Middle Line (Corrected index)
-                        line = Line::from(Span::styled(text, highlight_style)); // Highlight whole line
-                    }
-                } else { // Case 5: Line Outside Character-wise Highlight Range
-                    line = Line::from(Span::styled(
-                        text,
-                        // Use normal styling (active or inactive)
-                        if is_active { normal_style_in_highlight } else { normal_style_outside }
-                    ));
-                }
-            }
-            HighlightState::Linewise { anchor_line } => {
-                // --- Linewise Highlight Logic ---
-                let start_field = min(*anchor_line, *current_field_idx);
-                let end_field = max(*anchor_line, *current_field_idx);
-                let highlight_style = Style::default().fg(theme.highlight).bg(theme.highlight_bg).add_modifier(Modifier::BOLD);
-                let normal_style_in_highlight = Style::default().fg(theme.highlight);
-                let normal_style_outside = Style::default().fg(theme.fg);
-
-                if i >= start_field && i <= end_field {
-                    // Highlight the entire line
-                    line = Line::from(Span::styled(text, highlight_style));
-                } else {
-                    // Line outside linewise highlight range
-                    line = Line::from(Span::styled(
-                        text,
-                        // Use normal styling (active or inactive)
-                        if is_active { normal_style_in_highlight } else { normal_style_outside }
-                    ));
-                }
-            }
-        } // End match highlight_state
-
-        let input_display = Paragraph::new(line).alignment(Alignment::Left);
-        f.render_widget(input_display, input_rows[i]);
-
-        if is_active {
-            active_field_input_rect = Some(input_rows[i]);
-            let cursor_x = input_rows[i].x + form_state.current_cursor_pos() as u16;
-            let cursor_y = input_rows[i].y;
-            f.set_cursor_position((cursor_x, cursor_y));
-        }
-    }
-
-    active_field_input_rect
-}
-

client/src/components/handlers/sidebar.rs

@@ -6,7 +6,7 @@ use ratatui::{
     Frame,
 };
 use crate::config::colors::themes::Theme;
-use common::proto::multieko2::table_definition::{ProfileTreeResponse};
+use common::proto::komp_ac::table_definition::{ProfileTreeResponse};
 use ratatui::text::{Span, Line};
 use crate::components::utils::text::truncate_string;
 

client/src/components/intro/intro.rs

@@ -32,7 +32,7 @@ pub fn render_intro(f: &mut Frame, intro_state: &IntroState, area: Rect, theme:
 
     // Title
     let title = Line::from(vec![
-        Span::styled("multieko2", Style::default().fg(theme.highlight)),
+        Span::styled("komp_ac", Style::default().fg(theme.highlight)),
         Span::styled(" v", Style::default().fg(theme.fg)),
         Span::styled(env!("CARGO_PKG_VERSION"), Style::default().fg(theme.secondary)),
     ]);

client/src/config/binds/config.rs

@@ -251,51 +251,210 @@ impl Config {
         key: KeyCode,
         modifiers: KeyModifiers,
     ) -> bool {
-        // For multi-character bindings without modifiers, handle them in matches_key_sequence.
+        // Special handling for shift+character combinations
+        if binding.to_lowercase().starts_with("shift+") {
+            let parts: Vec<&str> = binding.split('+').collect();
+            if parts.len() == 2 && parts[1].len() == 1 {
+                let expected_lowercase = parts[1].chars().next().unwrap().to_lowercase().next().unwrap();
+                let expected_uppercase = expected_lowercase.to_uppercase().next().unwrap();
+                if let KeyCode::Char(actual_char) = key {
+                    if actual_char == expected_uppercase && modifiers.contains(KeyModifiers::SHIFT) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        // Handle Shift+Tab -> BackTab
+        if binding.to_lowercase() == "shift+tab" && key == KeyCode::BackTab && modifiers.is_empty() {
+            return true;
+        }
+
+        // Handle multi-character bindings (all standard keys without modifiers)
         if binding.len() > 1 && !binding.contains('+') {
             return match binding.to_lowercase().as_str() {
+                // Navigation keys
                 "left" => key == KeyCode::Left,
                 "right" => key == KeyCode::Right,
                 "up" => key == KeyCode::Up,
                 "down" => key == KeyCode::Down,
-                "esc" => key == KeyCode::Esc,
-                "enter" => key == KeyCode::Enter,
-                "delete" => key == KeyCode::Delete,
+                "home" => key == KeyCode::Home,
+                "end" => key == KeyCode::End,
+                "pageup" | "pgup" => key == KeyCode::PageUp,
+                "pagedown" | "pgdn" => key == KeyCode::PageDown,
+                
+                // Editing keys
+                "insert" | "ins" => key == KeyCode::Insert,
+                "delete" | "del" => key == KeyCode::Delete,
                 "backspace" => key == KeyCode::Backspace,
+                
+                // Tab keys
                 "tab" => key == KeyCode::Tab,
                 "backtab" => key == KeyCode::BackTab,
-                _ => false,
+                
+                // Special keys
+                "enter" | "return" => key == KeyCode::Enter,
+                "escape" | "esc" => key == KeyCode::Esc,
+                "space" => key == KeyCode::Char(' '),
+                
+                // Function keys F1-F24
+                "f1" => key == KeyCode::F(1),
+                "f2" => key == KeyCode::F(2),
+                "f3" => key == KeyCode::F(3),
+                "f4" => key == KeyCode::F(4),
+                "f5" => key == KeyCode::F(5),
+                "f6" => key == KeyCode::F(6),
+                "f7" => key == KeyCode::F(7),
+                "f8" => key == KeyCode::F(8),
+                "f9" => key == KeyCode::F(9),
+                "f10" => key == KeyCode::F(10),
+                "f11" => key == KeyCode::F(11),
+                "f12" => key == KeyCode::F(12),
+                "f13" => key == KeyCode::F(13),
+                "f14" => key == KeyCode::F(14),
+                "f15" => key == KeyCode::F(15),
+                "f16" => key == KeyCode::F(16),
+                "f17" => key == KeyCode::F(17),
+                "f18" => key == KeyCode::F(18),
+                "f19" => key == KeyCode::F(19),
+                "f20" => key == KeyCode::F(20),
+                "f21" => key == KeyCode::F(21),
+                "f22" => key == KeyCode::F(22),
+                "f23" => key == KeyCode::F(23),
+                "f24" => key == KeyCode::F(24),
+                
+                // Lock keys
+                "capslock" => key == KeyCode::CapsLock,
+                "scrolllock" => key == KeyCode::ScrollLock,
+                "numlock" => key == KeyCode::NumLock,
+                
+                // System keys
+                "printscreen" => key == KeyCode::PrintScreen,
+                "pause" => key == KeyCode::Pause,
+                "menu" => key == KeyCode::Menu,
+                "keypadbegin" => key == KeyCode::KeypadBegin,
+                
+                // Media keys
+                "mediaplay" => key == KeyCode::Media(crossterm::event::MediaKeyCode::Play),
+                "mediapause" => key == KeyCode::Media(crossterm::event::MediaKeyCode::Pause),
+                "mediaplaypause" => key == KeyCode::Media(crossterm::event::MediaKeyCode::PlayPause),
+                "mediareverse" => key == KeyCode::Media(crossterm::event::MediaKeyCode::Reverse),
+                "mediastop" => key == KeyCode::Media(crossterm::event::MediaKeyCode::Stop),
+                "mediafastforward" => key == KeyCode::Media(crossterm::event::MediaKeyCode::FastForward),
+                "mediarewind" => key == KeyCode::Media(crossterm::event::MediaKeyCode::Rewind),
+                "mediatracknext" => key == KeyCode::Media(crossterm::event::MediaKeyCode::TrackNext),
+                "mediatrackprevious" => key == KeyCode::Media(crossterm::event::MediaKeyCode::TrackPrevious),
+                "mediarecord" => key == KeyCode::Media(crossterm::event::MediaKeyCode::Record),
+                "medialowervolume" => key == KeyCode::Media(crossterm::event::MediaKeyCode::LowerVolume),
+                "mediaraisevolume" => key == KeyCode::Media(crossterm::event::MediaKeyCode::RaiseVolume),
+                "mediamutevolume" => key == KeyCode::Media(crossterm::event::MediaKeyCode::MuteVolume),
+                
+                // Multi-key sequences need special handling
+                "gg" => false, // This needs sequence handling
+                _ => {
+                    // Handle single characters and punctuation
+                    if binding.len() == 1 {
+                        if let Some(c) = binding.chars().next() {
+                            key == KeyCode::Char(c)
+                        } else {
+                            false
+                        }
+                    } else {
+                        false
+                    }
+                }
             };
         }
 
+        // Handle modifier combinations (like "Ctrl+F5", "Alt+Shift+A")
         let parts: Vec<&str> = binding.split('+').collect();
         let mut expected_modifiers = KeyModifiers::empty();
         let mut expected_key = None;
 
         for part in parts {
             match part.to_lowercase().as_str() {
-                "ctrl" => expected_modifiers |= KeyModifiers::CONTROL,
+                // Modifiers
+                "ctrl" | "control" => expected_modifiers |= KeyModifiers::CONTROL,
                 "shift" => expected_modifiers |= KeyModifiers::SHIFT,
                 "alt" => expected_modifiers |= KeyModifiers::ALT,
+                "super" | "windows" | "cmd" => expected_modifiers |= KeyModifiers::SUPER,
+                "hyper" => expected_modifiers |= KeyModifiers::HYPER,
+                "meta" => expected_modifiers |= KeyModifiers::META,
+                
+                // Navigation keys
                 "left" => expected_key = Some(KeyCode::Left),
                 "right" => expected_key = Some(KeyCode::Right),
                 "up" => expected_key = Some(KeyCode::Up),
                 "down" => expected_key = Some(KeyCode::Down),
-                "esc" => expected_key = Some(KeyCode::Esc),
-                "enter" => expected_key = Some(KeyCode::Enter),
-                "delete" => expected_key = Some(KeyCode::Delete),
+                "home" => expected_key = Some(KeyCode::Home),
+                "end" => expected_key = Some(KeyCode::End),
+                "pageup" | "pgup" => expected_key = Some(KeyCode::PageUp),
+                "pagedown" | "pgdn" => expected_key = Some(KeyCode::PageDown),
+                
+                // Editing keys
+                "insert" | "ins" => expected_key = Some(KeyCode::Insert),
+                "delete" | "del" => expected_key = Some(KeyCode::Delete),
                 "backspace" => expected_key = Some(KeyCode::Backspace),
+                
+                // Tab keys
                 "tab" => expected_key = Some(KeyCode::Tab),
                 "backtab" => expected_key = Some(KeyCode::BackTab),
+                
+                // Special keys
+                "enter" | "return" => expected_key = Some(KeyCode::Enter),
+                "escape" | "esc" => expected_key = Some(KeyCode::Esc),
+                "space" => expected_key = Some(KeyCode::Char(' ')),
+                
+                // Function keys
+                "f1" => expected_key = Some(KeyCode::F(1)),
+                "f2" => expected_key = Some(KeyCode::F(2)),
+                "f3" => expected_key = Some(KeyCode::F(3)),
+                "f4" => expected_key = Some(KeyCode::F(4)),
+                "f5" => expected_key = Some(KeyCode::F(5)),
+                "f6" => expected_key = Some(KeyCode::F(6)),
+                "f7" => expected_key = Some(KeyCode::F(7)),
+                "f8" => expected_key = Some(KeyCode::F(8)),
+                "f9" => expected_key = Some(KeyCode::F(9)),
+                "f10" => expected_key = Some(KeyCode::F(10)),
+                "f11" => expected_key = Some(KeyCode::F(11)),
+                "f12" => expected_key = Some(KeyCode::F(12)),
+                "f13" => expected_key = Some(KeyCode::F(13)),
+                "f14" => expected_key = Some(KeyCode::F(14)),
+                "f15" => expected_key = Some(KeyCode::F(15)),
+                "f16" => expected_key = Some(KeyCode::F(16)),
+                "f17" => expected_key = Some(KeyCode::F(17)),
+                "f18" => expected_key = Some(KeyCode::F(18)),
+                "f19" => expected_key = Some(KeyCode::F(19)),
+                "f20" => expected_key = Some(KeyCode::F(20)),
+                "f21" => expected_key = Some(KeyCode::F(21)),
+                "f22" => expected_key = Some(KeyCode::F(22)),
+                "f23" => expected_key = Some(KeyCode::F(23)),
+                "f24" => expected_key = Some(KeyCode::F(24)),
+                
+                // Lock keys
+                "capslock" => expected_key = Some(KeyCode::CapsLock),
+                "scrolllock" => expected_key = Some(KeyCode::ScrollLock),
+                "numlock" => expected_key = Some(KeyCode::NumLock),
+                
+                // System keys
+                "printscreen" => expected_key = Some(KeyCode::PrintScreen),
+                "pause" => expected_key = Some(KeyCode::Pause),
+                "menu" => expected_key = Some(KeyCode::Menu),
+                "keypadbegin" => expected_key = Some(KeyCode::KeypadBegin),
+                
+                // Special characters and colon (legacy support)
                 ":" => expected_key = Some(KeyCode::Char(':')),
+                
+                // Single character (letters, numbers, punctuation)
                 part => {
                     if part.len() == 1 {
-                        let c = part.chars().next().unwrap();
+                        if let Some(c) = part.chars().next() {
                             expected_key = Some(KeyCode::Char(c));
                         }
                     }
                 }
             }
+        }
 
         modifiers == expected_modifiers && Some(key) == expected_key
     }

client/src/config/binds/key_sequences.rs

@@ -149,14 +149,17 @@ fn parse_key_part(part: &str) -> Option<ParsedKey> {
     let mut code = None;
 
     if part.contains('+') {
-        // This handles modifiers like "ctrl+s"
+        // This handles modifiers like "ctrl+s", "super+shift+f5"
         let components: Vec<&str> = part.split('+').collect();
 
         for component in components {
             match component.to_lowercase().as_str() {
-                "ctrl" => modifiers |= KeyModifiers::CONTROL,
+                "ctrl" | "control" => modifiers |= KeyModifiers::CONTROL,
                 "shift" => modifiers |= KeyModifiers::SHIFT,
                 "alt" => modifiers |= KeyModifiers::ALT,
+                "super" | "windows" | "cmd" => modifiers |= KeyModifiers::SUPER,
+                "hyper" => modifiers |= KeyModifiers::HYPER,
+                "meta" => modifiers |= KeyModifiers::META,
                 _ => {
                     // Last component is the key
                     code = string_to_keycode(component);

client/src/config/colors/themes.rs

@@ -1,5 +1,6 @@
-// src/client/themes/colors.rs
+// src/config/colors/themes.rs
 use ratatui::style::Color;
+use canvas::canvas::CanvasTheme;
 
 #[derive(Debug, Clone)]
 pub struct Theme {
@@ -74,3 +75,37 @@ impl Default for Theme {
         Self::light() // Default to light theme
     }
 }
+
+impl CanvasTheme for Theme {
+    fn bg(&self) -> Color {
+        self.bg
+    }
+
+    fn fg(&self) -> Color {
+        self.fg
+    }
+
+    fn border(&self) -> Color {
+        self.border
+    }
+
+    fn accent(&self) -> Color {
+        self.accent
+    }
+
+    fn secondary(&self) -> Color {
+        self.secondary
+    }
+
+    fn highlight(&self) -> Color {
+        self.highlight
+    }
+
+    fn highlight_bg(&self) -> Color {
+        self.highlight_bg
+    }
+
+    fn warning(&self) -> Color {
+        self.warning
+    }
+}

client/src/config/storage/storage.rs

@@ -9,7 +9,7 @@ use tracing::{error, info};
 #[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
 
-pub const APP_NAME: &str = "multieko2_client";
+pub const APP_NAME: &str = "komp_ac_client";
 pub const TOKEN_FILE_NAME: &str = "auth.token";
 
 #[derive(Serialize, Deserialize, Debug, Clone)]

client/src/functions/modes.rs

@@ -1,9 +1,5 @@
 // src/functions/modes.rs
 
-pub mod read_only;
-pub mod edit;
 pub mod navigation;
 
-pub use read_only::*;
-pub use edit::*;
 pub use navigation::*;

client/src/functions/modes/edit.rs

@@ -1,6 +0,0 @@
-// src/functions/modes/edit.rs
-
-pub mod form_e;
-pub mod auth_e;
-pub mod add_table_e;
-pub mod add_logic_e;

client/src/functions/modes/edit/add_logic_e.rs

@@ -1,135 +0,0 @@
-// src/functions/modes/edit/add_logic_e.rs
-use crate::state::pages::add_logic::AddLogicState;
-use crate::state::pages::canvas_state::CanvasState;
-use anyhow::Result;
-use crossterm::event::{KeyCode, KeyEvent};
-
-pub async fn execute_edit_action(
-    action: &str,
-    key: KeyEvent, // Keep key for insert_char
-    state: &mut AddLogicState,
-    ideal_cursor_column: &mut usize,
-) -> Result<String> {
-    let mut message = String::new();
-
-    match action {
-        "next_field" => {
-            let current_field = state.current_field();
-            let next_field = (current_field + 1) % AddLogicState::INPUT_FIELD_COUNT;
-            state.set_current_field(next_field);
-            *ideal_cursor_column = state.current_cursor_pos();
-            message = format!("Focus on field {}", state.fields()[next_field]);
-        }
-        "prev_field" => {
-            let current_field = state.current_field();
-            let prev_field = if current_field == 0 {
-                AddLogicState::INPUT_FIELD_COUNT - 1
-            } else {
-                current_field - 1
-            };
-            state.set_current_field(prev_field);
-            *ideal_cursor_column = state.current_cursor_pos();
-            message = format!("Focus on field {}", state.fields()[prev_field]);
-        }
-        "delete_char_forward" => {
-            let current_pos = state.current_cursor_pos();
-            let current_input_mut = state.get_current_input_mut();
-            if current_pos < current_input_mut.len() {
-                current_input_mut.remove(current_pos);
-                state.set_has_unsaved_changes(true);
-                if state.current_field() == 1 { state.update_target_column_suggestions(); }
-            }
-        }
-        "delete_char_backward" => {
-            let current_pos = state.current_cursor_pos();
-            if current_pos > 0 {
-                let new_pos = current_pos - 1;
-                state.get_current_input_mut().remove(new_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-                state.set_has_unsaved_changes(true);
-                if state.current_field() == 1 { state.update_target_column_suggestions(); }
-            }
-        }
-        "move_left" => {
-            let current_pos = state.current_cursor_pos();
-            if current_pos > 0 {
-                let new_pos = current_pos - 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-        }
-        "move_right" => {
-            let current_pos = state.current_cursor_pos();
-            let input_len = state.get_current_input().len();
-            if current_pos < input_len {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-        }
-        "insert_char" => {
-            if let KeyCode::Char(c) = key.code {
-                let current_pos = state.current_cursor_pos();
-                state.get_current_input_mut().insert(current_pos, c);
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-                state.set_has_unsaved_changes(true);
-                if state.current_field() == 1 {
-                    state.update_target_column_suggestions();
-                }
-            }
-        }
-        "suggestion_down" => {
-            if state.in_target_column_suggestion_mode && !state.target_column_suggestions.is_empty() {
-                let current_selection = state.selected_target_column_suggestion_index.unwrap_or(0);
-                let next_selection = (current_selection + 1) % state.target_column_suggestions.len();
-                state.selected_target_column_suggestion_index = Some(next_selection);
-            }
-        }
-        "suggestion_up" => {
-             if state.in_target_column_suggestion_mode && !state.target_column_suggestions.is_empty() {
-                let current_selection = state.selected_target_column_suggestion_index.unwrap_or(0);
-                let prev_selection = if current_selection == 0 {
-                    state.target_column_suggestions.len() - 1
-                } else {
-                    current_selection - 1
-                };
-                state.selected_target_column_suggestion_index = Some(prev_selection);
-            }
-        }
-        "select_suggestion" => {
-            if state.in_target_column_suggestion_mode {
-                let mut selected_suggestion_text: Option<String> = None;
-
-                if let Some(selected_idx) = state.selected_target_column_suggestion_index {
-                    if let Some(suggestion) = state.target_column_suggestions.get(selected_idx) {
-                        selected_suggestion_text = Some(suggestion.clone());
-                    }
-                }
-
-                if let Some(suggestion_text) = selected_suggestion_text {
-                    state.target_column_input = suggestion_text.clone();
-                    state.target_column_cursor_pos = state.target_column_input.len();
-                    *ideal_cursor_column = state.target_column_cursor_pos;
-                    state.set_has_unsaved_changes(true);
-                    message = format!("Selected column: '{}'", suggestion_text);
-                }
-
-                state.in_target_column_suggestion_mode = false;
-                state.show_target_column_suggestions = false;
-                state.selected_target_column_suggestion_index = None;
-                state.update_target_column_suggestions();
-            } else {
-                let current_field = state.current_field();
-                let next_field = (current_field + 1) % AddLogicState::INPUT_FIELD_COUNT;
-                state.set_current_field(next_field);
-                *ideal_cursor_column = state.current_cursor_pos();
-                message = format!("Focus on field {}", state.fields()[next_field]);
-            }
-        }
-        _ => {}
-    }
-    Ok(message)
-}

client/src/functions/modes/edit/add_table_e.rs

@@ -1,341 +0,0 @@
-// src/functions/modes/edit/add_table_e.rs
-use crate::state::pages::add_table::AddTableState;
-use crate::state::pages::canvas_state::CanvasState; // Use trait
-use crossterm::event::{KeyCode, KeyEvent};
-use anyhow::Result;
-
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() {
-        CharType::Whitespace
-    } else if c.is_alphanumeric() {
-        CharType::Alphanumeric
-    } else {
-        CharType::Punctuation
-    }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos >= len {
-        return len;
-    }
-
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-
-    while pos < len && get_char_type(chars[pos]) == initial_type {
-        pos += 1;
-    }
-
-    while pos < len && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos += 1;
-    }
-
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.min(len - 1);
-
-    if get_char_type(chars[pos]) == CharType::Whitespace {
-        pos = find_next_word_start(text, pos);
-    }
-
-    if pos >= len {
-        return len.saturating_sub(1);
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type {
-        pos += 1;
-    }
-
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        return 0;
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    pos
-}
-
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        return 0;
-    }
-    if pos == 0 && get_char_type(chars[pos]) != CharType::Whitespace {
-        return 0;
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    while pos > 0 && get_char_type(chars[pos - 1]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos > 0 {
-        pos - 1
-    } else {
-        0
-    }
-}
-
-/// Executes edit actions for the AddTable view canvas.
-pub async fn execute_edit_action(
-    action: &str,
-    key: KeyEvent, // Needed for insert_char
-    state: &mut AddTableState,
-    ideal_cursor_column: &mut usize,
-    // Add other params like grpc_client if needed for future actions (e.g., validation)
-) -> Result<String> {
-    // Use the CanvasState trait methods implemented for AddTableState
-    match action {
-        "insert_char" => {
-            if let KeyCode::Char(c) = key.code {
-                let cursor_pos = state.current_cursor_pos();
-                let field_value = state.get_current_input_mut();
-                let mut chars: Vec<char> = field_value.chars().collect();
-                if cursor_pos <= chars.len() {
-                    chars.insert(cursor_pos, c);
-                    *field_value = chars.into_iter().collect();
-                    state.set_current_cursor_pos(cursor_pos + 1);
-                    state.set_has_unsaved_changes(true);
-                    *ideal_cursor_column = state.current_cursor_pos();
-                }
-            } else {
-                return Ok("Error: insert_char called without a char key.".to_string());
-            }
-            Ok("".to_string()) // No message needed for char insertion
-        }
-        "delete_char_backward" => {
-            if state.current_cursor_pos() > 0 {
-                let cursor_pos = state.current_cursor_pos();
-                let field_value = state.get_current_input_mut();
-                let mut chars: Vec<char> = field_value.chars().collect();
-                if cursor_pos <= chars.len() {
-                    chars.remove(cursor_pos - 1);
-                    *field_value = chars.into_iter().collect();
-                    let new_pos = cursor_pos - 1;
-                    state.set_current_cursor_pos(new_pos);
-                    state.set_has_unsaved_changes(true);
-                    *ideal_cursor_column = new_pos;
-                }
-            }
-            Ok("".to_string())
-        }
-        "delete_char_forward" => {
-            let cursor_pos = state.current_cursor_pos();
-            let field_value = state.get_current_input_mut();
-            let mut chars: Vec<char> = field_value.chars().collect();
-            if cursor_pos < chars.len() {
-                chars.remove(cursor_pos);
-                *field_value = chars.into_iter().collect();
-                state.set_has_unsaved_changes(true);
-                *ideal_cursor_column = cursor_pos;
-            }
-            Ok("".to_string())
-        }
-        "next_field" => {
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let last_field_index = num_fields - 1;
-                // Prevent cycling forward
-                if current_field < last_field_index {
-                    state.set_current_field(current_field + 1);
-                }
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
-            }
-            Ok("".to_string())
-        }
-        "prev_field" => {
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                if current_field > 0 {
-                    state.set_current_field(current_field - 1);
-                }
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
-            }
-            Ok("".to_string())
-        }
-        "move_left" => {
-            let new_pos = state.current_cursor_pos().saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            if current_pos < current_input.len() {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_up" => {
-            let current_field = state.current_field();
-            // Prevent moving up from the first field
-            if current_field > 0 {
-                let new_field = current_field - 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
-            }
-            Ok("ahoj".to_string())
-        }
-        "move_down" => {
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let last_field_index = num_fields - 1;
-                if current_field < last_field_index {
-                    let new_field = current_field + 1;
-                    state.set_current_field(new_field);
-                    let current_input = state.get_current_input();
-                    let max_pos = current_input.len();
-                    state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
-                }
-            }
-            Ok("".to_string())
-        }
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            Ok("".to_string())
-        }
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            let new_pos = current_input.len();
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_first_line" => {
-            if AddTableState::INPUT_FIELD_COUNT > 0 {
-                state.set_current_field(0);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
-            }
-            Ok("".to_string())
-        }
-        "move_last_line" => {
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields > 0 {
-                let new_field = num_fields - 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos((*ideal_cursor_column).min(max_pos));
-            }
-            Ok("".to_string())
-        }
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_next_word_start(current_input, state.current_cursor_pos());
-                let final_pos = new_pos.min(current_input.len());
-                state.set_current_cursor_pos(final_pos);
-                *ideal_cursor_column = final_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let current_pos = state.current_cursor_pos();
-                let new_pos = find_word_end(current_input, current_pos);
-
-                let final_pos = if new_pos == current_pos {
-                    find_word_end(current_input, new_pos + 1)
-                } else {
-                    new_pos
-                };
-
-                let max_valid_index = current_input.len().saturating_sub(1);
-                let clamped_pos = final_pos.min(max_valid_index);
-                state.set_current_cursor_pos(clamped_pos);
-                *ideal_cursor_column = clamped_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_start(current_input, state.current_cursor_pos());
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_end(current_input, state.current_cursor_pos());
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        // Actions handled by main event loop (mode changes, save, revert)
-        "exit_edit_mode" | "save" | "revert" => {
-            Ok("Action handled by main loop".to_string())
-        }
-        _ => Ok(format!("Unknown or unhandled edit action: {}", action)),
-    }
-}

client/src/functions/modes/edit/auth_e.rs

@@ -1,473 +0,0 @@
-// src/functions/modes/edit/auth_e.rs
-
-use crate::services::grpc_client::GrpcClient;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::pages::form::FormState;
-use crate::state::pages::auth::RegisterState;
-use crate::tui::functions::common::form::{revert, save};
-use crossterm::event::{KeyCode, KeyEvent};
-use std::any::Any;
-use anyhow::Result;
-
-pub async fn execute_common_action<S: CanvasState + Any>(
-    action: &str,
-    state: &mut S,
-    grpc_client: &mut GrpcClient,
-    current_position: &mut u64,
-    total_count: u64,
-) -> Result<String> {
-    match action {
-        "save" | "revert" => {
-            if !state.has_unsaved_changes() {
-                return Ok("No changes to save or revert.".to_string());
-            }
-            if let Some(form_state) =
-                (state as &mut dyn Any).downcast_mut::<FormState>()
-            {
-                match action {
-                    "save" => {
-                        let outcome = save(
-                            form_state,
-                            grpc_client,
-                        )
-                        .await?;
-                        let message = format!("Save successful: {:?}", outcome); // Simple message for now
-                        Ok(message)
-                    }
-                    "revert" => {
-                        revert(
-                            form_state,
-                            grpc_client,
-                        )
-                        .await
-                    }
-                    _ => unreachable!(),
-                }
-            } else {
-                Ok(format!(
-                    "Action '{}' not implemented for this state type.",
-                    action
-                ))
-            }
-        }
-        _ => Ok(format!("Common action '{}' not handled here.", action)),
-    }
-}
-
-pub async fn execute_edit_action<S: CanvasState + Any + Send>(
-    action: &str,
-    key: KeyEvent,
-    state: &mut S,
-    ideal_cursor_column: &mut usize,
-) -> Result<String> {
-    match action {
-        "insert_char" => {
-            if let KeyCode::Char(c) = key.code {
-                let cursor_pos = state.current_cursor_pos();
-                let field_value = state.get_current_input_mut();
-                let mut chars: Vec<char> = field_value.chars().collect();
-                if cursor_pos <= chars.len() {
-                    chars.insert(cursor_pos, c);
-                    *field_value = chars.into_iter().collect();
-                    state.set_current_cursor_pos(cursor_pos + 1);
-                    state.set_has_unsaved_changes(true);
-                    *ideal_cursor_column = state.current_cursor_pos();
-                }
-            } else {
-                return Ok("Error: insert_char called without a char key."
-                    .to_string());
-            }
-            Ok("working?".to_string())
-        }
-
-        "delete_char_backward" => {
-            if state.current_cursor_pos() > 0 {
-                let cursor_pos = state.current_cursor_pos();
-                let field_value = state.get_current_input_mut();
-                let mut chars: Vec<char> = field_value.chars().collect();
-                if cursor_pos <= chars.len() {
-                    chars.remove(cursor_pos - 1);
-                    *field_value = chars.into_iter().collect();
-                    let new_pos = cursor_pos - 1;
-                    state.set_current_cursor_pos(new_pos);
-                    state.set_has_unsaved_changes(true);
-                    *ideal_cursor_column = new_pos;
-                }
-            }
-            Ok("".to_string())
-        }
-
-        "delete_char_forward" => {
-            let cursor_pos = state.current_cursor_pos();
-            let field_value = state.get_current_input_mut();
-            let mut chars: Vec<char> = field_value.chars().collect();
-            if cursor_pos < chars.len() {
-                chars.remove(cursor_pos);
-                *field_value = chars.into_iter().collect();
-                state.set_has_unsaved_changes(true);
-                *ideal_cursor_column = cursor_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "next_field" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let new_field = (current_field + 1).min(num_fields - 1);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "prev_field" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let new_field = current_field.saturating_sub(1);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "move_left" => {
-            let new_pos = state.current_cursor_pos().saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            if current_pos < current_input.len() {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_up" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let new_field = current_field.saturating_sub(1);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "move_down" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let new_field = (state.current_field() + 1).min(num_fields - 1);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            Ok("".to_string())
-        }
-
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            let new_pos = current_input.len();
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-
-        "move_first_line" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                state.set_current_field(0);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("Moved to first field".to_string())
-        }
-
-        "move_last_line" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let new_field = num_fields - 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("Moved to last field".to_string())
-        }
-
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_next_word_start(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                let final_pos = new_pos.min(current_input.len());
-                state.set_current_cursor_pos(final_pos);
-                *ideal_cursor_column = final_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let current_pos = state.current_cursor_pos();
-                let new_pos = find_word_end(current_input, current_pos);
-
-                let final_pos = if new_pos == current_pos {
-                    find_word_end(current_input, new_pos + 1)
-                } else {
-                    new_pos
-                };
-
-                let max_valid_index = current_input.len().saturating_sub(1);
-                let clamped_pos = final_pos.min(max_valid_index);
-                state.set_current_cursor_pos(clamped_pos);
-                *ideal_cursor_column = clamped_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_start(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_end(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("Moved to previous word end".to_string())
-        }
-
-        // --- Autocomplete Actions ---
-        "suggestion_down" | "suggestion_up" | "select_suggestion" | "exit_suggestion_mode" => {
-            // Attempt to downcast to RegisterState to handle suggestion logic here
-            if let Some(register_state) = (state as &mut dyn Any).downcast_mut::<RegisterState>() {
-                // Only handle if it's the role field (index 4)
-                if register_state.current_field() == 4 {
-                    match action {
-                        "suggestion_down" if register_state.in_suggestion_mode => {
-                            let max_index = register_state.role_suggestions.len().saturating_sub(1);
-                            let current_index = register_state.selected_suggestion_index.unwrap_or(0);
-                            register_state.selected_suggestion_index = Some(if current_index >= max_index { 0 } else { current_index + 1 });
-                            Ok("Suggestion changed down".to_string())
-                        }
-                        "suggestion_up" if register_state.in_suggestion_mode => {
-                            let max_index = register_state.role_suggestions.len().saturating_sub(1);
-                            let current_index = register_state.selected_suggestion_index.unwrap_or(0);
-                            register_state.selected_suggestion_index = Some(if current_index == 0 { max_index } else { current_index.saturating_sub(1) });
-                            Ok("Suggestion changed up".to_string())
-                        }
-                        "select_suggestion" if register_state.in_suggestion_mode => {
-                            if let Some(index) = register_state.selected_suggestion_index {
-                                if let Some(selected_role) = register_state.role_suggestions.get(index).cloned() {
-                                    register_state.role = selected_role.clone(); // Update the role field
-                                    register_state.in_suggestion_mode = false; // Exit suggestion mode
-                                    register_state.show_role_suggestions = false; // Hide suggestions
-                                    register_state.selected_suggestion_index = None; // Clear selection
-                                    Ok(format!("Selected role: {}", selected_role)) // Return success message
-                                } else {
-                                    Ok("Selected suggestion index out of bounds.".to_string()) // Error case
-                                }
-                            } else {
-                                Ok("No suggestion selected".to_string())
-                            }
-                        }
-                        "exit_suggestion_mode" => { // Handle Esc or other conditions
-                            register_state.show_role_suggestions = false;
-                            register_state.selected_suggestion_index = None;
-                            register_state.in_suggestion_mode = false;
-                            Ok("Suggestions hidden".to_string())
-                        }
-                        _ => {
-                            // Action is suggestion-related but state doesn't match (e.g., not in suggestion mode)
-                            Ok("Suggestion action ignored: State mismatch.".to_string())
-                        }
-                    }
-                } else {
-                    // It's RegisterState, but not the role field
-                    Ok("Suggestion action ignored: Not on role field.".to_string())
-                 }
-            } else {
-                // Downcast failed - this action is only for RegisterState
-                Ok(format!("Action '{}' not applicable for this state type.", action))
-            }
-        }
-        // --- End Autocomplete Actions ---
-
-
-        _ => Ok(format!("Unknown or unhandled edit action: {}", action)),
-    }
-}
-
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() {
-        CharType::Whitespace
-    } else if c.is_alphanumeric() {
-        CharType::Alphanumeric
-    } else {
-        CharType::Punctuation
-    }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos >= len {
-        return len;
-    }
-
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-
-    while pos < len && get_char_type(chars[pos]) == initial_type {
-        pos += 1;
-    }
-
-    while pos < len && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos += 1;
-    }
-
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.min(len - 1);
-
-    if get_char_type(chars[pos]) == CharType::Whitespace {
-        pos = find_next_word_start(text, pos);
-    }
-
-    if pos >= len {
-        return len.saturating_sub(1);
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type {
-        pos += 1;
-    }
-
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        return 0;
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    pos
-}
-
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        return 0;
-    }
-    if pos == 0 && get_char_type(chars[pos]) != CharType::Whitespace {
-        return 0;
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    while pos > 0 && get_char_type(chars[pos - 1]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos > 0 {
-        pos - 1
-    } else {
-        0
-    }
-}

client/src/functions/modes/edit/form_e.rs

@@ -1,432 +0,0 @@
-// src/functions/modes/edit/form_e.rs
-
-use crate::services::grpc_client::GrpcClient;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::pages::form::FormState;
-use crate::tui::functions::common::form::{revert, save};
-use crate::tui::functions::common::form::SaveOutcome;
-use crate::modes::handlers::event::EventOutcome;
-use crossterm::event::{KeyCode, KeyEvent};
-use std::any::Any;
-use anyhow::Result;
-
-pub async fn execute_common_action<S: CanvasState + Any>(
-    action: &str,
-    state: &mut S,
-    grpc_client: &mut GrpcClient,
-) -> Result<EventOutcome> {
-    match action {
-        "save" | "revert" => {
-            if !state.has_unsaved_changes() {
-                return Ok(EventOutcome::Ok("No changes to save or revert.".to_string()));
-            }
-            if let Some(form_state) =
-                (state as &mut dyn Any).downcast_mut::<FormState>()
-            {
-                match action {
-                    "save" => {
-                        let save_result = save(
-                            form_state,
-                            grpc_client,
-                        ).await;
-                        
-                        match save_result {
-                            Ok(save_outcome) => {
-                                let message = match save_outcome {
-                                    SaveOutcome::NoChange => "No changes to save.".to_string(),
-                                    SaveOutcome::UpdatedExisting => "Entry updated.".to_string(),
-                                    SaveOutcome::CreatedNew(_) => "New entry created.".to_string(),
-                                };
-                                Ok(EventOutcome::DataSaved(save_outcome, message))
-                            }
-                            Err(e) => Err(e),
-                        }
-                    }
-                    "revert" => {
-                        let revert_result = revert(
-                            form_state,
-                            grpc_client,
-                        ).await;
-                        
-                        match revert_result {
-                            Ok(message) => Ok(EventOutcome::Ok(message)),
-                            Err(e) => Err(e),
-                        }
-                    }
-                    _ => unreachable!(),
-                }
-            } else {
-                Ok(EventOutcome::Ok(format!(
-                    "Action '{}' not implemented for this state type.",
-                    action
-                )))
-            }
-        }
-        _ => Ok(EventOutcome::Ok(format!("Common action '{}' not handled here.", action))),
-    }
-}
-
-pub async fn execute_edit_action<S: CanvasState>(
-    action: &str,
-    key: KeyEvent,
-    state: &mut S,
-    ideal_cursor_column: &mut usize,
-) -> Result<String> {
-    match action {
-        "insert_char" => {
-            if let KeyCode::Char(c) = key.code {
-                let cursor_pos = state.current_cursor_pos();
-                let field_value = state.get_current_input_mut();
-                let mut chars: Vec<char> = field_value.chars().collect();
-                if cursor_pos <= chars.len() {
-                    chars.insert(cursor_pos, c);
-                    *field_value = chars.into_iter().collect();
-                    state.set_current_cursor_pos(cursor_pos + 1);
-                    state.set_has_unsaved_changes(true);
-                    *ideal_cursor_column = state.current_cursor_pos();
-                }
-            } else {
-                return Ok("Error: insert_char called without a char key."
-                    .to_string());
-            }
-            Ok("".to_string())
-        }
-
-        "delete_char_backward" => {
-            if state.current_cursor_pos() > 0 {
-                let cursor_pos = state.current_cursor_pos();
-                let field_value = state.get_current_input_mut();
-                let mut chars: Vec<char> = field_value.chars().collect();
-                if cursor_pos <= chars.len() {
-                    chars.remove(cursor_pos - 1);
-                    *field_value = chars.into_iter().collect();
-                    let new_pos = cursor_pos - 1;
-                    state.set_current_cursor_pos(new_pos);
-                    state.set_has_unsaved_changes(true);
-                    *ideal_cursor_column = new_pos;
-                }
-            }
-            Ok("".to_string())
-        }
-
-        "delete_char_forward" => {
-            let cursor_pos = state.current_cursor_pos();
-            let field_value = state.get_current_input_mut();
-            let mut chars: Vec<char> = field_value.chars().collect();
-            if cursor_pos < chars.len() {
-                chars.remove(cursor_pos);
-                *field_value = chars.into_iter().collect();
-                state.set_has_unsaved_changes(true);
-                *ideal_cursor_column = cursor_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "next_field" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let new_field = (current_field + 1) % num_fields;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "prev_field" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let new_field = if current_field == 0 {
-                    num_fields - 1
-                } else {
-                    current_field - 1
-                };
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "move_left" => {
-            let new_pos = state.current_cursor_pos().saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            if current_pos < current_input.len() {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_up" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let current_field = state.current_field();
-                let new_field = current_field.saturating_sub(1);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "move_down" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let new_field = (state.current_field() + 1).min(num_fields - 1);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("".to_string())
-        }
-
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            Ok("".to_string())
-        }
-
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            let new_pos = current_input.len();
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-
-        "move_first_line" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                state.set_current_field(0);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("Moved to first field".to_string())
-        }
-
-        "move_last_line" => {
-            let num_fields = state.fields().len();
-            if num_fields > 0 {
-                let new_field = num_fields - 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_pos = current_input.len();
-                state.set_current_cursor_pos(
-                    (*ideal_cursor_column).min(max_pos),
-                );
-            }
-            Ok("Moved to last field".to_string())
-        }
-
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_next_word_start(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                let final_pos = new_pos.min(current_input.len());
-                state.set_current_cursor_pos(final_pos);
-                *ideal_cursor_column = final_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let current_pos = state.current_cursor_pos();
-                let new_pos = find_word_end(current_input, current_pos);
-
-                let final_pos = if new_pos == current_pos {
-                    find_word_end(current_input, new_pos + 1)
-                } else {
-                    new_pos
-                };
-
-                let max_valid_index = current_input.len().saturating_sub(1);
-                let clamped_pos = final_pos.min(max_valid_index);
-                state.set_current_cursor_pos(clamped_pos);
-                *ideal_cursor_column = clamped_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_start(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_end(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("Moved to previous word end".to_string())
-        }
-
-        _ => Ok(format!("Unknown or unhandled edit action: {}", action)),
-    }
-}
-
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() {
-        CharType::Whitespace
-    } else if c.is_alphanumeric() {
-        CharType::Alphanumeric
-    } else {
-        CharType::Punctuation
-    }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos >= len {
-        return len;
-    }
-
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-
-    while pos < len && get_char_type(chars[pos]) == initial_type {
-        pos += 1;
-    }
-
-    while pos < len && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos += 1;
-    }
-
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.min(len - 1);
-
-    if get_char_type(chars[pos]) == CharType::Whitespace {
-        pos = find_next_word_start(text, pos);
-    }
-
-    if pos >= len {
-        return len.saturating_sub(1);
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type {
-        pos += 1;
-    }
-
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        return 0;
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    pos
-}
-
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        return 0;
-    }
-    if pos == 0 && get_char_type(chars[pos]) != CharType::Whitespace {
-        return 0;
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    while pos > 0 && get_char_type(chars[pos - 1]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos > 0 {
-        pos - 1
-    } else {
-        0
-    }
-}

client/src/functions/modes/read_only.rs

@@ -1,6 +0,0 @@
-// src/functions/modes/read_only.rs
-
-pub mod auth_ro;
-pub mod form_ro;
-pub mod add_table_ro;
-pub mod add_logic_ro;

client/src/functions/modes/read_only/add_logic_ro.rs

@@ -1,235 +0,0 @@
-// src/functions/modes/read_only/add_logic_ro.rs
-use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::state::pages::add_logic::AddLogicState; // Changed
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::app::state::AppState;
-use anyhow::Result;
-
-// Word navigation helpers (get_char_type, find_next_word_start, etc.)
-// can be kept as they are generic.
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() { CharType::Whitespace }
-    else if c.is_alphanumeric() { CharType::Alphanumeric }
-    else { CharType::Punctuation }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos >= len { return len; }
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == initial_type { pos += 1; }
-    while pos < len && get_char_type(chars[pos]) == CharType::Whitespace { pos += 1; }
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 { return 0; }
-    let mut pos = current_pos.min(len - 1);
-    if get_char_type(chars[pos]) == CharType::Whitespace {
-        pos = find_next_word_start(text, pos);
-    }
-    if pos >= len { return len.saturating_sub(1); }
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type { pos += 1; }
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 { return 0; }
-    let mut pos = current_pos.saturating_sub(1);
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace { pos -= 1; }
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace { return 0; }
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type { pos -= 1; }
-    pos
-}
-
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-    let prev_start = find_prev_word_start(text, current_pos);
-    if prev_start == 0 { return 0; }
-    find_word_end(text, prev_start.saturating_sub(1))
-}
-
-
-/// Executes read-only actions for the AddLogic view canvas.
-pub async fn execute_action(
-    action: &str,
-    app_state: &mut AppState,
-    state: &mut AddLogicState,
-    ideal_cursor_column: &mut usize,
-    key_sequence_tracker: &mut KeySequenceTracker,
-    command_message: &mut String,
-) -> Result<String> {
-    match action {
-        "move_up" => {
-            key_sequence_tracker.reset();
-            let num_fields = AddLogicState::INPUT_FIELD_COUNT;
-            if num_fields == 0 { return Ok("No fields.".to_string()); }
-            let current_field = state.current_field();
-
-            if current_field > 0 {
-                let new_field = current_field - 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = if current_input.is_empty() { 0 } else { current_input.len().saturating_sub(1) };
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-            } else {
-                *command_message = "At top of form.".to_string();
-            }
-            Ok(command_message.clone())
-        }
-        "move_down" => {
-            key_sequence_tracker.reset();
-            let num_fields = AddLogicState::INPUT_FIELD_COUNT;
-            if num_fields == 0 { return Ok("No fields.".to_string()); }
-            let current_field = state.current_field();
-            let last_field_index = num_fields - 1;
-
-            if current_field < last_field_index {
-                let new_field = current_field + 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = if current_input.is_empty() { 0 } else { current_input.len().saturating_sub(1) };
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-            } else {
-                // Move focus outside canvas when moving down from the last field
-                // FIX: Go to ScriptContentPreview instead of SaveButton
-                app_state.ui.focus_outside_canvas = true;
-                state.last_canvas_field = 2;
-                state.current_focus = crate::state::pages::add_logic::AddLogicFocus::ScriptContentPreview; // FIXED!
-                *command_message = "Focus moved to script preview".to_string();
-            }
-            Ok(command_message.clone())
-        }
-        // ... (rest of the actions remain the same) ...
-        "move_first_line" => {
-            key_sequence_tracker.reset();
-            if AddLogicState::INPUT_FIELD_COUNT > 0 {
-                state.set_current_field(0);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = if current_input.is_empty() { 0 } else { current_input.len().saturating_sub(1) };
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_last_line" => {
-            key_sequence_tracker.reset();
-            let num_fields = AddLogicState::INPUT_FIELD_COUNT;
-            if num_fields > 0 {
-                let last_field_index = num_fields - 1;
-                state.set_current_field(last_field_index);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = if current_input.is_empty() { 0 } else { current_input.len().saturating_sub(1) };
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_left" => {
-            let current_pos = state.current_cursor_pos();
-            let new_pos = current_pos.saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            if !current_input.is_empty() && current_pos < current_input.len().saturating_sub(1) {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_next_word_start(current_input, state.current_cursor_pos());
-                let final_pos = new_pos.min(current_input.len().saturating_sub(1));
-                state.set_current_cursor_pos(final_pos);
-                *ideal_cursor_column = final_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let current_pos = state.current_cursor_pos();
-                let new_pos = find_word_end(current_input, current_pos);
-                let final_pos = if new_pos == current_pos && current_pos < current_input.len().saturating_sub(1) {
-                    find_word_end(current_input, current_pos + 1)
-                } else {
-                    new_pos
-                };
-                let max_valid_index = current_input.len().saturating_sub(1);
-                let clamped_pos = final_pos.min(max_valid_index);
-                state.set_current_cursor_pos(clamped_pos);
-                *ideal_cursor_column = clamped_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_start(current_input, state.current_cursor_pos());
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_end(current_input, state.current_cursor_pos());
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            Ok("".to_string())
-        }
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = current_input.len().saturating_sub(1);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            } else {
-                state.set_current_cursor_pos(0);
-                *ideal_cursor_column = 0;
-            }
-            Ok("".to_string())
-        }
-        "enter_edit_mode_before" | "enter_edit_mode_after" | "enter_command_mode" | "exit_highlight_mode" => {
-             key_sequence_tracker.reset();
-             Ok("Mode change handled by main loop".to_string())
-        }
-        _ => {
-             key_sequence_tracker.reset();
-             command_message.clear();
-             Ok(format!("Unknown read-only action: {}", action))
-        },
-    }
-}
-

client/src/functions/modes/read_only/add_table_ro.rs

@@ -1,267 +0,0 @@
-// src/functions/modes/read_only/add_table_ro.rs
-use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::state::pages::add_table::AddTableState;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::app::state::AppState;
-use anyhow::Result;
-
-// Re-use word navigation helpers if they are public or move them to a common module
-// For now, duplicating them here for simplicity. Consider refactoring later.
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() { CharType::Whitespace }
-    else if c.is_alphanumeric() { CharType::Alphanumeric }
-    else { CharType::Punctuation }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 || current_pos >= len { return len; }
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == initial_type { pos += 1; }
-    while pos < len && get_char_type(chars[pos]) == CharType::Whitespace { pos += 1; }
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 { return 0; }
-    let mut pos = current_pos.min(len - 1);
-    if get_char_type(chars[pos]) == CharType::Whitespace {
-        pos = find_next_word_start(text, pos);
-    }
-    if pos >= len { return len.saturating_sub(1); }
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type { pos += 1; }
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 { return 0; }
-    let mut pos = current_pos.saturating_sub(1);
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace { pos -= 1; }
-    if pos == 0 && get_char_type(chars[pos]) == CharType::Whitespace { return 0; }
-    let word_type = get_char_type(chars[pos]);
-    while pos > 0 && get_char_type(chars[pos - 1]) == word_type { pos -= 1; }
-    pos
-}
-
-// Note: find_prev_word_end might need adjustments based on desired behavior.
-// This version finds the end of the word *before* the previous word start.
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-    let prev_start = find_prev_word_start(text, current_pos);
-    if prev_start == 0 { return 0; }
-    // Find the end of the word that starts at prev_start - 1
-    find_word_end(text, prev_start.saturating_sub(1))
-}
-
-
-/// Executes read-only actions for the AddTable view canvas.
-pub async fn execute_action(
-    action: &str,
-    app_state: &mut AppState, // Needed for focus_outside_canvas
-    state: &mut AddTableState,
-    ideal_cursor_column: &mut usize,
-    key_sequence_tracker: &mut KeySequenceTracker,
-    command_message: &mut String, // Keep for potential messages
-) -> Result<String> {
-    // Use the CanvasState trait methods implemented for AddTableState
-    match action {
-        "move_up" => {
-            key_sequence_tracker.reset();
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields == 0 {
-                *command_message = "No fields.".to_string();
-                return Ok(command_message.clone());
-            }
-            let current_field = state.current_field(); // Gets the index (0, 1, or 2)
-
-            if current_field > 0 {
-                // This handles moving from field 2 -> 1, or 1 -> 0
-                let new_field = current_field - 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = current_input.len(); // Allow cursor at end
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos; // Update ideal column as cursor moved
-                *command_message = "".to_string(); // Clear message for successful internal navigation
-            } else {
-                // current_field is 0 (InputTableName), and user pressed Up.
-                // Forbid moving up. Do not change focus or cursor.
-                *command_message = "At top of form.".to_string();
-            }
-            Ok(command_message.clone())
-        }
-        "move_down" => {
-            key_sequence_tracker.reset();
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields == 0 {
-                *command_message = "No fields.".to_string();
-                return Ok(command_message.clone());
-            }
-            let current_field = state.current_field();
-            let last_field_index = num_fields - 1;
-
-            if current_field < last_field_index {
-                let new_field = current_field + 1;
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = current_input.len(); // Allow cursor at end
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos; // Update ideal column
-                *command_message = "".to_string();
-            } else {
-                // Move focus outside canvas when moving down from the last field
-                app_state.ui.focus_outside_canvas = true;
-                // Set focus to the first element outside canvas (AddColumnButton)
-                state.current_focus =
-                    crate::state::pages::add_table::AddTableFocus::AddColumnButton;
-                *command_message = "Focus moved below canvas".to_string();
-            }
-            Ok(command_message.clone())
-        }
-        // ... (other actions like "move_first_line", "move_left", etc. remain the same) ...
-        "move_first_line" => {
-            key_sequence_tracker.reset();
-            if AddTableState::INPUT_FIELD_COUNT > 0 {
-                state.set_current_field(0);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = current_input.len();
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos; // Update ideal column
-            }
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_last_line" => {
-            key_sequence_tracker.reset();
-            let num_fields = AddTableState::INPUT_FIELD_COUNT;
-            if num_fields > 0 {
-                let last_field_index = num_fields - 1;
-                state.set_current_field(last_field_index);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = current_input.len();
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos; // Update ideal column
-            }
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_left" => {
-            let current_pos = state.current_cursor_pos();
-            let new_pos = current_pos.saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            // Allow moving cursor one position past the end
-            if current_pos < current_input.len() {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            let new_pos = find_next_word_start(
-                current_input,
-                state.current_cursor_pos(),
-            );
-            let final_pos = new_pos.min(current_input.len()); // Allow cursor at end
-            state.set_current_cursor_pos(final_pos);
-            *ideal_cursor_column = final_pos;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            let new_pos = find_word_end(current_input, current_pos);
-            // If find_word_end returns current_pos, try starting search from next char
-            let final_pos =
-                if new_pos == current_pos && current_pos < current_input.len() {
-                    find_word_end(current_input, current_pos + 1)
-                } else {
-                    new_pos
-                };
-            let max_valid_index = current_input.len(); // Allow cursor at end
-            let clamped_pos = final_pos.min(max_valid_index);
-            state.set_current_cursor_pos(clamped_pos);
-            *ideal_cursor_column = clamped_pos;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            let new_pos = find_prev_word_start(
-                current_input,
-                state.current_cursor_pos(),
-            );
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            let new_pos = find_prev_word_end(
-                current_input,
-                state.current_cursor_pos(),
-            );
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            let new_pos = current_input.len(); // Allow cursor at end
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            *command_message = "".to_string();
-            Ok(command_message.clone())
-        }
-        // Actions handled by main event loop (mode changes)
-        "enter_edit_mode_before" | "enter_edit_mode_after"
-        | "enter_command_mode" | "exit_highlight_mode" => {
-            key_sequence_tracker.reset();
-            // These actions are primarily mode changes handled by the main event loop.
-            // The message here might be overridden by the main loop's message for mode change.
-            *command_message = "Mode change initiated".to_string();
-            Ok(command_message.clone())
-        }
-        _ => {
-            key_sequence_tracker.reset();
-            *command_message =
-                format!("Unknown read-only action: {}", action);
-            Ok(command_message.clone())
-        }
-    }
-}
-

client/src/functions/modes/read_only/auth_ro.rs

@@ -1,343 +0,0 @@
-// src/functions/modes/read_only/auth_ro.rs
-
-use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::app::state::AppState;
-use anyhow::Result;
-
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-pub async fn execute_action<S: CanvasState>(
-    action: &str,
-    app_state: &mut AppState,
-    state: &mut S,
-    ideal_cursor_column: &mut usize,
-    key_sequence_tracker: &mut KeySequenceTracker,
-    command_message: &mut String,
-) -> Result<String> {
-    match action {
-        "previous_entry" | "next_entry" => {
-            key_sequence_tracker.reset();
-            Ok(format!(
-                "Action '{}' should be handled by context-specific logic",
-                action
-            ))
-        }
-        "move_up" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate.".to_string());
-            }
-            let current_field = state.current_field();
-            let new_field = current_field.saturating_sub(1);
-            state.set_current_field(new_field);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-
-            Ok("move up from functions/modes/read_only/auth_ro.rs".to_string())
-        }
-        "move_down" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate.".to_string());
-            }
-            let current_field = state.current_field();
-            let last_field_index = num_fields - 1;
-
-            if current_field == last_field_index {
-                // Already on the last field, move focus outside
-                app_state.ui.focus_outside_canvas = true;
-                app_state.focused_button_index= 0;
-                key_sequence_tracker.reset();
-                Ok("Focus moved below canvas".to_string())
-            } else {
-                // Move to the next field within the canvas
-                let new_field = (current_field + 1).min(last_field_index);
-                state.set_current_field(new_field);
-                let current_input = state.get_current_input();
-                let max_cursor_pos = if current_input.is_empty() {
-                    0
-                } else {
-                    current_input.len().saturating_sub(1)
-                };
-                let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                state.set_current_cursor_pos(new_pos);
-                Ok("".to_string()) // Clear previous debug message
-            }
-        }
-        "move_first_line" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate to.".to_string());
-            }
-            state.set_current_field(0);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_last_line" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate to.".to_string());
-            }
-            let last_field_index = num_fields - 1;
-            state.set_current_field(last_field_index);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "exit_edit_mode" => {
-            key_sequence_tracker.reset();
-            command_message.clear();
-            Ok("".to_string())
-        }
-        "move_left" => {
-            let current_pos = state.current_cursor_pos();
-            let new_pos = current_pos.saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            if !current_input.is_empty()
-                && current_pos < current_input.len().saturating_sub(1)
-            {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos =
-                    find_next_word_start(current_input, state.current_cursor_pos());
-                let final_pos = new_pos.min(current_input.len().saturating_sub(1));
-                state.set_current_cursor_pos(final_pos);
-                *ideal_cursor_column = final_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let current_pos = state.current_cursor_pos();
-                let new_pos = find_word_end(current_input, current_pos);
-
-                let final_pos = if new_pos != current_pos {
-                    new_pos
-                } else {
-                    find_word_end(current_input, new_pos + 1)
-                };
-
-                let max_valid_index = current_input.len().saturating_sub(1);
-                let clamped_pos = final_pos.min(max_valid_index);
-                state.set_current_cursor_pos(clamped_pos);
-                *ideal_cursor_column = clamped_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_start(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_end(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("Moved to previous word end".to_string())
-        }
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            Ok("".to_string())
-        }
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = current_input.len().saturating_sub(1);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            } else {
-                state.set_current_cursor_pos(0);
-                *ideal_cursor_column = 0;
-            }
-            Ok("".to_string())
-        }
-        _ => {
-             key_sequence_tracker.reset();
-             Ok(format!("Unknown read-only action: {}", action))
-        },
-    }
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() {
-        CharType::Whitespace
-    } else if c.is_alphanumeric() {
-        CharType::Alphanumeric
-    } else {
-        CharType::Punctuation
-    }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() {
-        return 0;
-    }
-    let current_pos = current_pos.min(chars.len());
-
-    if current_pos == chars.len() {
-        return current_pos;
-    }
-
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-
-    while pos < chars.len() && get_char_type(chars[pos]) == initial_type {
-        pos += 1;
-    }
-
-    while pos < chars.len() && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos += 1;
-    }
-
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.min(len - 1);
-    let current_type = get_char_type(chars[pos]);
-    if current_type != CharType::Whitespace {
-        while pos < len && get_char_type(chars[pos]) == current_type {
-            pos += 1;
-        }
-        return pos.saturating_sub(1);
-    }
-
-    pos = find_next_word_start(text, pos);
-    if pos >= len {
-        return len.saturating_sub(1);
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type {
-        pos += 1;
-    }
-
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if get_char_type(chars[pos]) != CharType::Whitespace {
-        let word_type = get_char_type(chars[pos]);
-        while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-            pos -= 1;
-        }
-    }
-
-    if pos == 0 && get_char_type(chars[0]) == CharType::Whitespace {
-         0
-    } else {
-        pos
-    }
-}
-
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-     let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[0]) == CharType::Whitespace {
-        return 0;
-    }
-     if pos == 0 && get_char_type(chars[0]) != CharType::Whitespace {
-         return 0;
-     }
-
-    let word_type = get_char_type(chars[pos]);
-     while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    while pos > 0 && get_char_type(chars[pos - 1]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos > 0 {
-        pos - 1
-    } else {
-        0
-    }
-}

client/src/functions/modes/read_only/form_ro.rs

@@ -1,329 +0,0 @@
-// src/functions/modes/read_only/form_ro.rs
-
-use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::state::pages::canvas_state::CanvasState;
-use anyhow::Result;
-
-#[derive(PartialEq)]
-enum CharType {
-    Whitespace,
-    Alphanumeric,
-    Punctuation,
-}
-
-pub async fn execute_action<S: CanvasState>(
-    action: &str,
-    state: &mut S,
-    ideal_cursor_column: &mut usize,
-    key_sequence_tracker: &mut KeySequenceTracker,
-    command_message: &mut String,
-) -> Result<String> {
-    match action {
-        "previous_entry" | "next_entry" => {
-            key_sequence_tracker.reset();
-            Ok(format!(
-                "Action '{}' should be handled by context-specific logic",
-                action
-            ))
-        }
-        "move_up" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate.".to_string());
-            }
-            let current_field = state.current_field();
-            let new_field = current_field.saturating_sub(1);
-            state.set_current_field(new_field);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-            Ok("".to_string())
-        }
-        "move_down" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate.".to_string());
-            }
-            let current_field = state.current_field();
-            let new_field = (current_field + 1).min(num_fields - 1);
-            state.set_current_field(new_field);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-            Ok("".to_string())
-        }
-        "move_first_line" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate to.".to_string());
-            }
-            state.set_current_field(0);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_last_line" => {
-            key_sequence_tracker.reset();
-            let num_fields = state.fields().len();
-            if num_fields == 0 {
-                return Ok("No fields to navigate to.".to_string());
-            }
-            let last_field_index = num_fields - 1;
-            state.set_current_field(last_field_index);
-            let current_input = state.get_current_input();
-            let max_cursor_pos = if current_input.is_empty() {
-                0
-            } else {
-                current_input.len().saturating_sub(1)
-            };
-            let new_pos = (*ideal_cursor_column).min(max_cursor_pos);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "exit_edit_mode" => {
-            key_sequence_tracker.reset();
-            command_message.clear();
-            Ok("".to_string())
-        }
-        "move_left" => {
-            let current_pos = state.current_cursor_pos();
-            let new_pos = current_pos.saturating_sub(1);
-            state.set_current_cursor_pos(new_pos);
-            *ideal_cursor_column = new_pos;
-            Ok("".to_string())
-        }
-        "move_right" => {
-            let current_input = state.get_current_input();
-            let current_pos = state.current_cursor_pos();
-            if !current_input.is_empty()
-                && current_pos < current_input.len().saturating_sub(1)
-            {
-                let new_pos = current_pos + 1;
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_next" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos =
-                    find_next_word_start(current_input, state.current_cursor_pos());
-                let final_pos = new_pos.min(current_input.len().saturating_sub(1));
-                state.set_current_cursor_pos(final_pos);
-                *ideal_cursor_column = final_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let current_pos = state.current_cursor_pos();
-                let new_pos = find_word_end(current_input, current_pos);
-
-                let final_pos = if new_pos != current_pos {
-                    new_pos
-                } else {
-                    find_word_end(current_input, new_pos + 1)
-                };
-
-                let max_valid_index = current_input.len().saturating_sub(1);
-                let clamped_pos = final_pos.min(max_valid_index);
-                state.set_current_cursor_pos(clamped_pos);
-                *ideal_cursor_column = clamped_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_start(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("".to_string())
-        }
-        "move_word_end_prev" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = find_prev_word_end(
-                    current_input,
-                    state.current_cursor_pos(),
-                );
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            }
-            Ok("Moved to previous word end".to_string())
-        }
-        "move_line_start" => {
-            state.set_current_cursor_pos(0);
-            *ideal_cursor_column = 0;
-            Ok("".to_string())
-        }
-        "move_line_end" => {
-            let current_input = state.get_current_input();
-            if !current_input.is_empty() {
-                let new_pos = current_input.len().saturating_sub(1);
-                state.set_current_cursor_pos(new_pos);
-                *ideal_cursor_column = new_pos;
-            } else {
-                state.set_current_cursor_pos(0);
-                *ideal_cursor_column = 0;
-            }
-            Ok("".to_string())
-        }
-        _ => {
-             key_sequence_tracker.reset();
-             Ok(format!("Unknown read-only action: {}", action))
-        },
-    }
-}
-
-fn get_char_type(c: char) -> CharType {
-    if c.is_whitespace() {
-        CharType::Whitespace
-    } else if c.is_alphanumeric() {
-        CharType::Alphanumeric
-    } else {
-        CharType::Punctuation
-    }
-}
-
-fn find_next_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() {
-        return 0;
-    }
-    let current_pos = current_pos.min(chars.len());
-
-    if current_pos == chars.len() {
-        return current_pos;
-    }
-
-    let mut pos = current_pos;
-    let initial_type = get_char_type(chars[pos]);
-
-    while pos < chars.len() && get_char_type(chars[pos]) == initial_type {
-        pos += 1;
-    }
-
-    while pos < chars.len() && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos += 1;
-    }
-
-    pos
-}
-
-fn find_word_end(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    let len = chars.len();
-    if len == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.min(len - 1);
-    let current_type = get_char_type(chars[pos]);
-    if current_type != CharType::Whitespace {
-        while pos < len && get_char_type(chars[pos]) == current_type {
-            pos += 1;
-        }
-        return pos.saturating_sub(1);
-    }
-
-    pos = find_next_word_start(text, pos);
-    if pos >= len {
-        return len.saturating_sub(1);
-    }
-
-    let word_type = get_char_type(chars[pos]);
-    while pos < len && get_char_type(chars[pos]) == word_type {
-        pos += 1;
-    }
-
-    pos.saturating_sub(1).min(len.saturating_sub(1))
-}
-
-fn find_prev_word_start(text: &str, current_pos: usize) -> usize {
-    let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if get_char_type(chars[pos]) != CharType::Whitespace {
-        let word_type = get_char_type(chars[pos]);
-        while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-            pos -= 1;
-        }
-    }
-
-    if pos == 0 && get_char_type(chars[0]) == CharType::Whitespace {
-         0
-    } else {
-        pos
-    }
-}
-
-fn find_prev_word_end(text: &str, current_pos: usize) -> usize {
-     let chars: Vec<char> = text.chars().collect();
-    if chars.is_empty() || current_pos == 0 {
-        return 0;
-    }
-
-    let mut pos = current_pos.saturating_sub(1);
-
-    while pos > 0 && get_char_type(chars[pos]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos == 0 && get_char_type(chars[0]) == CharType::Whitespace {
-        return 0;
-    }
-     if pos == 0 && get_char_type(chars[0]) != CharType::Whitespace {
-         return 0;
-     }
-
-    let word_type = get_char_type(chars[pos]);
-     while pos > 0 && get_char_type(chars[pos - 1]) == word_type {
-        pos -= 1;
-    }
-
-    while pos > 0 && get_char_type(chars[pos - 1]) == CharType::Whitespace {
-        pos -= 1;
-    }
-
-    if pos > 0 {
-        pos - 1
-    } else {
-        0
-    }
-}

client/src/main.rs

@@ -1,5 +1,7 @@
 // client/src/main.rs
 use client::run_ui;
+#[cfg(feature = "ui-debug")]
+use client::utils::debug_logger::UiDebugWriter;
 use dotenvy::dotenv;
 use anyhow::Result;
 use tracing_subscriber;
@@ -7,9 +9,23 @@ use std::env;
 
 #[tokio::main]
 async fn main() -> Result<()> {
+    #[cfg(feature = "ui-debug")]
+    {
+        // If ui-debug is on, set up our custom writer.
+        let writer = UiDebugWriter::new();
+        tracing_subscriber::fmt()
+            .with_level(false) // Don't show INFO, ERROR, etc.
+            .with_target(false) // Don't show the module path.
+            .without_time() // This is the correct and simpler method.
+            .with_writer(move || writer.clone())
+            .init();
+    }
+    #[cfg(not(feature = "ui-debug"))]
+    {
         if env::var("ENABLE_TRACING").is_ok() {
             tracing_subscriber::fmt::init();
         }
+    }
 
     dotenv().ok();
     run_ui().await

client/src/modes/canvas/common_mode.rs

@@ -32,6 +32,7 @@ pub async fn handle_core_action(
                 Ok(EventOutcome::Ok(message))
             } else {
                 let save_outcome = form_save(
+                    app_state,
                     form_state,
                     grpc_client,
                 ).await.context("Register save action failed")?;
@@ -52,6 +53,7 @@ pub async fn handle_core_action(
                 login_save(auth_state, login_state, auth_client, app_state).await.context("Login save n quit action failed")?
             } else {
                 let save_outcome = form_save(
+                    app_state,
                     form_state,
                     grpc_client,
                 ).await?;

client/src/modes/canvas/edit.rs

@@ -1,20 +1,20 @@
 // src/modes/canvas/edit.rs
 use crate::config::binds::config::Config;
+use crate::modes::handlers::event::EventHandler;
 use crate::services::grpc_client::GrpcClient;
+use crate::state::app::state::AppState;
+use crate::state::pages::admin::AdminState;
 use crate::state::pages::{
     auth::{LoginState, RegisterState},
-    canvas_state::CanvasState,
+    form::FormState,
 };
-use crate::state::pages::form::FormState; // <<< ADD THIS LINE
-// AddLogicState is already imported
-// AddTableState is already imported
-use crate::state::pages::admin::AdminState;
-use crate::modes::handlers::event::EventOutcome;
-use crate::functions::modes::edit::{add_logic_e, auth_e, form_e, add_table_e};
-use crate::state::app::state::AppState;
+use canvas::canvas::CanvasState;
+use canvas::{canvas::CanvasAction, dispatcher::ActionDispatcher, canvas::ActionResult};
 use anyhow::Result;
-use crossterm::event::KeyEvent; // Removed KeyCode, KeyModifiers as they were unused
-use tracing::debug;
+use common::proto::komp_ac::search::search_response::Hit;
+use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+use tokio::sync::mpsc;
+use tracing::info;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum EditEventOutcome {
@@ -22,231 +22,479 @@ pub enum EditEventOutcome {
     ExitEditMode,
 }
 
+/// Helper function to spawn a non-blocking search task for autocomplete.
+async fn trigger_form_autocomplete_search(
+    form_state: &mut FormState,
+    grpc_client: &mut GrpcClient,
+    sender: mpsc::UnboundedSender<Vec<Hit>>,
+) {
+    if let Some(field_def) = form_state.fields.get(form_state.current_field) {
+        if field_def.is_link {
+            if let Some(target_table) = &field_def.link_target_table {
+                // 1. Update state for immediate UI feedback
+                form_state.autocomplete_loading = true;
+                form_state.autocomplete_active = true;
+                form_state.autocomplete_suggestions.clear();
+                form_state.selected_suggestion_index = None;
+
+                // 2. Clone everything needed for the background task
+                let query = form_state.get_current_input().to_string();
+                let table_to_search = target_table.clone();
+                let mut grpc_client_clone = grpc_client.clone();
+
+                info!(
+                    "[Autocomplete] Spawning search in '{}' for query: '{}'",
+                    table_to_search, query
+                );
+
+                // 3. Spawn the non-blocking task
+                tokio::spawn(async move {
+                    match grpc_client_clone
+                        .search_table(table_to_search, query)
+                        .await
+                    {
+                        Ok(response) => {
+                            // Send results back through the channel
+                            let _ = sender.send(response.hits);
+                        }
+                        Err(e) => {
+                            tracing::error!(
+                                "[Autocomplete] Search failed: {:?}",
+                                e
+                            );
+                            // Send an empty vec on error so the UI can stop loading
+                            let _ = sender.send(vec![]);
+                        }
+                    }
+                });
+            }
+        }
+    }
+}
+
+pub async fn handle_form_edit_with_canvas(
+    key_event: KeyEvent,
+    config: &Config,
+    form_state: &mut FormState,
+    ideal_cursor_column: &mut usize,
+) -> Result<String> {
+    // Try canvas action from key first
+    let canvas_config = canvas::config::CanvasConfig::load();
+    if let Some(action_name) = canvas_config.get_edit_action(key_event.code, key_event.modifiers) {
+        let canvas_action = CanvasAction::from_string(action_name);
+        match ActionDispatcher::dispatch(canvas_action, form_state, ideal_cursor_column).await {
+            Ok(ActionResult::Success(msg)) => {
+                return Ok(msg.unwrap_or_default());
+            }
+            Ok(ActionResult::HandledByFeature(msg)) => {
+                return Ok(msg);
+            }
+            Ok(ActionResult::Error(msg)) => {
+                return Ok(format!("Error: {}", msg));
+            }
+            Ok(ActionResult::RequiresContext(msg)) => {
+                return Ok(format!("Context needed: {}", msg));
+            }
+            Err(_) => {
+                // Fall through to try config mapping
+            }
+        }
+    }
+
+    // Try config-mapped action
+    if let Some(action_str) = config.get_edit_action_for_key(key_event.code, key_event.modifiers) {
+        let canvas_action = CanvasAction::from_string(&action_str);
+        match ActionDispatcher::dispatch(canvas_action, form_state, ideal_cursor_column).await {
+            Ok(ActionResult::Success(msg)) => {
+                return Ok(msg.unwrap_or_default());
+            }
+            Ok(ActionResult::HandledByFeature(msg)) => {
+                return Ok(msg);
+            }
+            Ok(ActionResult::Error(msg)) => {
+                return Ok(format!("Error: {}", msg));
+            }
+            Ok(ActionResult::RequiresContext(msg)) => {
+                return Ok(format!("Context needed: {}", msg));
+            }
+            Err(e) => {
+                return Ok(format!("Action failed: {}", e));
+            }
+        }
+    }
+
+    Ok(String::new())
+}
+
+/// Helper function to execute a specific action using canvas library
+async fn execute_canvas_action(
+    action: &str,
+    key: KeyEvent,
+    form_state: &mut FormState,
+    ideal_cursor_column: &mut usize,
+) -> Result<String> {
+    let canvas_action = CanvasAction::from_string(action);
+    match ActionDispatcher::dispatch(canvas_action, form_state, ideal_cursor_column).await {
+        Ok(ActionResult::Success(msg)) => Ok(msg.unwrap_or_default()),
+        Ok(ActionResult::HandledByFeature(msg)) => Ok(msg),
+        Ok(ActionResult::Error(msg)) => Ok(format!("Error: {}", msg)),
+        Ok(ActionResult::RequiresContext(msg)) => Ok(format!("Context needed: {}", msg)),
+        Err(e) => Ok(format!("Action failed: {}", e)),
+    }
+}
+
+/// FIXED: Unified canvas action handler with proper priority order for edit mode
+async fn handle_canvas_state_edit<S: CanvasState>(
+    key: KeyEvent,
+    config: &Config,
+    state: &mut S,
+    ideal_cursor_column: &mut usize,
+) -> Result<String> {
+    // println!("DEBUG: Key pressed: {:?}", key); // DEBUG
+
+    // PRIORITY 1: Character insertion in edit mode comes FIRST
+    if let KeyCode::Char(c) = key.code {
+        // Only insert if no modifiers or just shift (for uppercase)
+        if key.modifiers.is_empty() || key.modifiers == KeyModifiers::SHIFT {
+            // println!("DEBUG: Using character insertion priority for: {}", c); // DEBUG
+            let canvas_action = CanvasAction::InsertChar(c);
+            match ActionDispatcher::dispatch(canvas_action, state, ideal_cursor_column).await {
+                Ok(ActionResult::Success(msg)) => {
+                    return Ok(msg.unwrap_or_default());
+                }
+                Ok(ActionResult::HandledByFeature(msg)) => {
+                    return Ok(msg);
+                }
+                Ok(ActionResult::Error(msg)) => {
+                    return Ok(format!("Error: {}", msg));
+                }
+                Ok(ActionResult::RequiresContext(msg)) => {
+                    return Ok(format!("Context needed: {}", msg));
+                }
+                Err(e) => {
+                    // println!("DEBUG: Character insertion failed: {:?}, trying config", e);
+                    // Fall through to try config mappings
+                }
+            }
+        }
+    }
+
+    // PRIORITY 2: Check canvas config for special keys/combinations
+    let canvas_config = canvas::config::CanvasConfig::load();
+    if let Some(action_name) = canvas_config.get_edit_action(key.code, key.modifiers) {
+        // println!("DEBUG: Canvas config mapped to: {}", action_name); // DEBUG
+        let canvas_action = CanvasAction::from_string(action_name);
+
+        match ActionDispatcher::dispatch(canvas_action, state, ideal_cursor_column).await {
+            Ok(ActionResult::Success(msg)) => {
+                return Ok(msg.unwrap_or_default());
+            }
+            Ok(ActionResult::HandledByFeature(msg)) => {
+                return Ok(msg);
+            }
+            Ok(ActionResult::Error(msg)) => {
+                return Ok(format!("Error: {}", msg));
+            }
+            Ok(ActionResult::RequiresContext(msg)) => {
+                return Ok(format!("Context needed: {}", msg));
+            }
+            Err(_) => {
+                // println!("DEBUG: Canvas action failed, trying client config"); // DEBUG
+            }
+        }
+    } else {
+        // println!("DEBUG: No canvas config mapping found"); // DEBUG
+    }
+
+    // PRIORITY 3: Check client config ONLY for non-character keys or modified keys
+    if !matches!(key.code, KeyCode::Char(_)) || !key.modifiers.is_empty() {
+        if let Some(action_str) = config.get_edit_action_for_key(key.code, key.modifiers) {
+            // println!("DEBUG: Client config mapped to: {} (for non-char key)", action_str); // DEBUG
+            let canvas_action = CanvasAction::from_string(&action_str);
+            match ActionDispatcher::dispatch(canvas_action, state, ideal_cursor_column).await {
+                Ok(ActionResult::Success(msg)) => {
+                    return Ok(msg.unwrap_or_default());
+                }
+                Ok(ActionResult::HandledByFeature(msg)) => {
+                    return Ok(msg);
+                }
+                Ok(ActionResult::Error(msg)) => {
+                    return Ok(format!("Error: {}", msg));
+                }
+                Ok(ActionResult::RequiresContext(msg)) => {
+                    return Ok(format!("Context needed: {}", msg));
+                }
+                Err(e) => {
+                    return Ok(format!("Action failed: {}", e));
+                }
+            }
+        } else {
+             // println!("DEBUG: No client config mapping found for non-char key"); // DEBUG
+        }
+    } else {
+        // println!("DEBUG: Skipping client config for character key in edit mode"); // DEBUG
+    }
+
+    // println!("DEBUG: No action taken for key: {:?}", key); // DEBUG
+    Ok(String::new())
+}
+
+#[allow(clippy::too_many_arguments)]
 pub async fn handle_edit_event(
     key: KeyEvent,
     config: &Config,
-    form_state: &mut FormState, // Now FormState is in scope
+    form_state: &mut FormState,
     login_state: &mut LoginState,
     register_state: &mut RegisterState,
     admin_state: &mut AdminState,
-    ideal_cursor_column: &mut usize,
     current_position: &mut u64,
     total_count: u64,
-    grpc_client: &mut GrpcClient,
+    event_handler: &mut EventHandler,
     app_state: &AppState,
 ) -> Result<EditEventOutcome> {
-    // --- Global command mode check ---
-    if let Some("enter_command_mode") = config.get_action_for_key_in_mode(
-        &config.keybindings.global, // Assuming command mode can be entered globally
-        key.code,
-        key.modifiers,
-    ) {
-        // This check might be redundant if EventHandler already prevents entering Edit mode
-        // when command_mode is true. However, it's a safeguard.
+    // --- AUTOCOMPLETE-SPECIFIC KEY HANDLING ---
+    if app_state.ui.show_form && form_state.autocomplete_active {
+        if let Some(action) =
+            config.get_edit_action_for_key(key.code, key.modifiers)
+        {
+            match action {
+                "suggestion_down" => {
+                    if !form_state.autocomplete_suggestions.is_empty() {
+                        let current =
+                            form_state.selected_suggestion_index.unwrap_or(0);
+                        let next = (current + 1)
+                            % form_state.autocomplete_suggestions.len();
+                        form_state.selected_suggestion_index = Some(next);
+                    }
+                    return Ok(EditEventOutcome::Message(String::new()));
+                }
+                "suggestion_up" => {
+                    if !form_state.autocomplete_suggestions.is_empty() {
+                        let current =
+                            form_state.selected_suggestion_index.unwrap_or(0);
+                        let prev = if current == 0 {
+                            form_state.autocomplete_suggestions.len() - 1
+                        } else {
+                            current - 1
+                        };
+                        form_state.selected_suggestion_index = Some(prev);
+                    }
+                    return Ok(EditEventOutcome::Message(String::new()));
+                }
+                "exit" => {
+                    form_state.deactivate_autocomplete();
                     return Ok(EditEventOutcome::Message(
-            "Cannot enter command mode from edit mode here.".to_string(),
+                        "Autocomplete cancelled".to_string(),
                     ));
                 }
+                "enter_decider" => {
+                    if let Some(selected_idx) =
+                        form_state.selected_suggestion_index
+                    {
+                        if let Some(selection) = form_state
+                            .autocomplete_suggestions
+                            .get(selected_idx)
+                            .cloned()
+                        {
+                            // --- THIS IS THE CORE LOGIC CHANGE ---
 
-    // --- Common actions (save, revert) ---
-    if let Some(action) = config.get_action_for_key_in_mode(
-        &config.keybindings.common,
-        key.code,
-        key.modifiers,
-    ).as_deref() {
-        if matches!(action, "save" | "revert") {
-            let message_string: String = if app_state.ui.show_login {
-                auth_e::execute_common_action(action, login_state, grpc_client, current_position, total_count).await?
-            } else if app_state.ui.show_register {
-                auth_e::execute_common_action(action, register_state, grpc_client, current_position, total_count).await?
-            } else if app_state.ui.show_add_table {
-                // TODO: Implement common actions for AddTable if needed
-                format!("Action '{}' not implemented for Add Table in edit mode.", action)
-            } else if app_state.ui.show_add_logic {
-                // TODO: Implement common actions for AddLogic if needed
-                format!("Action '{}' not implemented for Add Logic in edit mode.", action)
-            } else { // Assuming Form view
-                let outcome = form_e::execute_common_action(action, form_state, grpc_client).await?;
-                match outcome {
-                    EventOutcome::Ok(msg) | EventOutcome::DataSaved(_, msg) => msg,
-                    _ => format!("Unexpected outcome from common action: {:?}", outcome),
+                            // 1. Get the friendly display name for the UI
+                            let display_name =
+                                form_state.get_display_name_for_hit(&selection);
+
+                            // 2. Store the REAL ID in the form's values
+                            let current_input =
+                                form_state.get_current_input_mut();
+                            *current_input = selection.id.to_string();
+
+                            // 3. Set the persistent display override in the map
+                            form_state.link_display_map.insert(
+                                form_state.current_field,
+                                display_name,
+                            );
+
+                            // 4. Finalize state
+                            form_state.deactivate_autocomplete();
+                            form_state.set_has_unsaved_changes(true);
+                            return Ok(EditEventOutcome::Message(
+                                "Selection made".to_string(),
+                            ));
                         }
+                    }
+                    form_state.deactivate_autocomplete();
+                    // Fall through to default 'enter' behavior
+                }
+                _ => {} // Let other keys fall through to the live search logic
+            }
+        }
+    }
+
+    // --- LIVE AUTOCOMPLETE TRIGGER LOGIC ---
+    let mut trigger_search = false;
+
+    if app_state.ui.show_form {
+        // Manual trigger
+        if let Some("trigger_autocomplete") =
+            config.get_edit_action_for_key(key.code, key.modifiers)
+        {
+            if !form_state.autocomplete_active {
+                trigger_search = true;
+            }
+        }
+        // Live search trigger while typing
+        else if form_state.autocomplete_active {
+            if let KeyCode::Char(_) | KeyCode::Backspace = key.code {
+                let action = if let KeyCode::Backspace = key.code {
+                    "delete_char_backward"
+                } else {
+                    "insert_char"
                 };
-            return Ok(EditEventOutcome::Message(message_string));
+                // FIXED: Use canvas library instead of form_e::execute_edit_action
+                execute_canvas_action(
+                    action,
+                    key,
+                    form_state,
+                    &mut event_handler.ideal_cursor_column,
+                )
+                .await?;
+                trigger_search = true;
+            }
         }
     }
 
-    // --- Edit-specific actions ---
-    if let Some(action_str) = config.get_edit_action_for_key(key.code, key.modifiers).as_deref() {
-        // --- Handle "enter_decider" (Enter key) ---
+    if trigger_search {
+        trigger_form_autocomplete_search(
+            form_state,
+            &mut event_handler.grpc_client,
+            event_handler.autocomplete_result_sender.clone(),
+        )
+        .await;
+        return Ok(EditEventOutcome::Message("Searching...".to_string()));
+    }
+
+    // --- GENERAL EDIT MODE EVENT HANDLING (IF NOT AUTOCOMPLETE) ---
+
+    if let Some(action_str) =
+        config.get_edit_action_for_key(key.code, key.modifiers)
+    {
+        // Handle Enter key (next field)
         if action_str == "enter_decider" {
-            let effective_action = if app_state.ui.show_register
-                && register_state.in_suggestion_mode
-                && register_state.current_field() == 4 { // Role field
-                "select_suggestion"
-            } else if app_state.ui.show_add_logic
-                && admin_state.add_logic_state.in_target_column_suggestion_mode
-                && admin_state.add_logic_state.current_field() == 1 { // Target Column field
-                "select_suggestion"
-            } else {
-                "next_field" // Default action for Enter
-            };
-
-            let msg = if app_state.ui.show_login {
-                auth_e::execute_edit_action(effective_action, key, login_state, ideal_cursor_column).await?
-            } else if app_state.ui.show_add_table {
-                add_table_e::execute_edit_action(effective_action, key, &mut admin_state.add_table_state, ideal_cursor_column).await?
-            } else if app_state.ui.show_add_logic {
-                add_logic_e::execute_edit_action(effective_action, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?
-            } else if app_state.ui.show_register {
-                auth_e::execute_edit_action(effective_action, key, register_state, ideal_cursor_column).await?
-            } else { // Form view
-                form_e::execute_edit_action(effective_action, key, form_state, ideal_cursor_column).await?
-            };
+            // FIXED: Use canvas library instead of form_e::execute_edit_action
+            let msg = execute_canvas_action(
+                "next_field",
+                key,
+                form_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?;
             return Ok(EditEventOutcome::Message(msg));
         }
 
-        // --- Handle "exit" (Escape key) ---
+        // Handle exiting edit mode
         if action_str == "exit" {
-            if app_state.ui.show_register && register_state.in_suggestion_mode {
-                let msg = auth_e::execute_edit_action("exit_suggestion_mode", key, register_state, ideal_cursor_column).await?;
-                return Ok(EditEventOutcome::Message(msg));
-            } else if app_state.ui.show_add_logic && admin_state.add_logic_state.in_target_column_suggestion_mode {
-                admin_state.add_logic_state.in_target_column_suggestion_mode = false;
-                admin_state.add_logic_state.show_target_column_suggestions = false;
-                admin_state.add_logic_state.selected_target_column_suggestion_index = None;
-                return Ok(EditEventOutcome::Message("Exited column suggestions".to_string()));
-            } else {
             return Ok(EditEventOutcome::ExitEditMode);
         }
-        }
 
-        // --- Autocomplete for AddLogicState Target Column ---
-        if app_state.ui.show_add_logic && admin_state.add_logic_state.current_field() == 1 { // Target Column field
-            if action_str == "suggestion_down" { // "Tab" is mapped to suggestion_down
-                if !admin_state.add_logic_state.in_target_column_suggestion_mode {
-                    // Attempt to open suggestions
-                    if let Some(profile_name) = admin_state.add_logic_state.profile_name.clone().into() {
-                        if let Some(table_name) = admin_state.add_logic_state.selected_table_name.clone() {
-                            debug!("Fetching table structure for autocomplete: Profile='{}', Table='{}'", profile_name, table_name);
-                            match grpc_client.get_table_structure(profile_name, table_name).await {
-                                Ok(ts_response) => {
-                                    admin_state.add_logic_state.table_columns_for_suggestions =
-                                        ts_response.columns.into_iter().map(|c| c.name).collect();
-                                    admin_state.add_logic_state.update_target_column_suggestions();
-                                    if !admin_state.add_logic_state.target_column_suggestions.is_empty() {
-                                        admin_state.add_logic_state.in_target_column_suggestion_mode = true;
-                                        // update_target_column_suggestions handles initial selection
-                                        return Ok(EditEventOutcome::Message("Column suggestions shown".to_string()));
-                                    } else {
-                                        return Ok(EditEventOutcome::Message("No column suggestions for current input".to_string()));
-                                    }
-                                }
-                                Err(e) => {
-                                    debug!("Error fetching table structure: {}", e);
-                                    admin_state.add_logic_state.table_columns_for_suggestions.clear(); // Clear old data on error
-                                    admin_state.add_logic_state.update_target_column_suggestions();
-                                    return Ok(EditEventOutcome::Message(format!("Error fetching columns: {}", e)));
-                                }
-                            }
-                        } else {
-                             return Ok(EditEventOutcome::Message("No table selected for column suggestions".to_string()));
-                        }
-                    } else { // Should not happen if AddLogic is properly initialized
-                        return Ok(EditEventOutcome::Message("Profile name missing for column suggestions".to_string()));
-                    }
-                } else { // Already in suggestion mode, navigate down
-                    let msg = add_logic_e::execute_edit_action(action_str, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?;
-                    return Ok(EditEventOutcome::Message(msg));
-                }
-            } else if admin_state.add_logic_state.in_target_column_suggestion_mode && action_str == "suggestion_up" {
-                 let msg = add_logic_e::execute_edit_action(action_str, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?;
-                return Ok(EditEventOutcome::Message(msg));
-            }
-        }
-
-        // --- Autocomplete for RegisterState Role Field ---
-        if app_state.ui.show_register && register_state.current_field() == 4 { // Role field
-            if !register_state.in_suggestion_mode && action_str == "suggestion_down" { // Tab
-                register_state.update_role_suggestions();
-                if !register_state.role_suggestions.is_empty() {
-                    register_state.in_suggestion_mode = true;
-                    // update_role_suggestions should handle initial selection
-                    return Ok(EditEventOutcome::Message("Role suggestions shown".to_string()));
-                } else {
-                    // If Tab doesn't open suggestions, it might fall through to "next_field"
-                    // or you might want specific behavior. For now, let it fall through.
-                }
-            }
-            if register_state.in_suggestion_mode && matches!(action_str, "suggestion_down" | "suggestion_up") {
-                let msg = auth_e::execute_edit_action(action_str, key, register_state, ideal_cursor_column).await?;
-                return Ok(EditEventOutcome::Message(msg));
-            }
-        }
-
-        // --- Dispatch other edit actions ---
+        // Handle all other edit actions - NOW USING CANVAS LIBRARY
         let msg = if app_state.ui.show_login {
-            auth_e::execute_edit_action(action_str, key, login_state, ideal_cursor_column).await?
+            // NEW: Use unified canvas handler instead of auth_e::execute_edit_action
+            handle_canvas_state_edit(
+                key,
+                config,
+                login_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         } else if app_state.ui.show_add_table {
-            add_table_e::execute_edit_action(action_str, key, &mut admin_state.add_table_state, ideal_cursor_column).await?
+            // NEW: Use unified canvas handler instead of add_table_e::execute_edit_action
+            handle_canvas_state_edit(
+                key,
+                config,
+                &mut admin_state.add_table_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         } else if app_state.ui.show_add_logic {
-            // If not a suggestion action handled above for AddLogic
-             if !(admin_state.add_logic_state.in_target_column_suggestion_mode && matches!(action_str, "suggestion_down" | "suggestion_up")) {
-                add_logic_e::execute_edit_action(action_str, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?
-            } else { String::new() /* Already handled */ }
+            // NEW: Use unified canvas handler instead of add_logic_e::execute_edit_action
+            handle_canvas_state_edit(
+                key,
+                config,
+                &mut admin_state.add_logic_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         } else if app_state.ui.show_register {
-            if !(register_state.in_suggestion_mode && matches!(action_str, "suggestion_down" | "suggestion_up")) {
-                auth_e::execute_edit_action(action_str, key, register_state, ideal_cursor_column).await?
-            } else { String::new() /* Already handled */ }
-        } else { // Form view
-            form_e::execute_edit_action(action_str, key, form_state, ideal_cursor_column).await?
+            // NEW: Use unified canvas handler instead of auth_e::execute_edit_action
+            handle_canvas_state_edit(
+                key,
+                config,
+                register_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
+        } else {
+            // FIXED: Use canvas library instead of form_e::execute_edit_action
+            execute_canvas_action(
+                action_str,
+                key,
+                form_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         };
         return Ok(EditEventOutcome::Message(msg));
     }
 
-    // --- Character insertion ---
-    // If character insertion happens while in suggestion mode, exit suggestion mode first.
-    let mut exited_suggestion_mode_for_typing = false;
-    if app_state.ui.show_register && register_state.in_suggestion_mode {
-        register_state.in_suggestion_mode = false;
-        register_state.show_role_suggestions = false;
-        register_state.selected_suggestion_index = None;
-        exited_suggestion_mode_for_typing = true;
-    }
-    if app_state.ui.show_add_logic && admin_state.add_logic_state.in_target_column_suggestion_mode {
-        admin_state.add_logic_state.in_target_column_suggestion_mode = false;
-        admin_state.add_logic_state.show_target_column_suggestions = false;
-        admin_state.add_logic_state.selected_target_column_suggestion_index = None;
-        exited_suggestion_mode_for_typing = true;
-    }
-
-    let mut char_insert_msg = if app_state.ui.show_login {
-        auth_e::execute_edit_action("insert_char", key, login_state, ideal_cursor_column).await?
+    // --- FALLBACK FOR CHARACTER INSERTION (IF NO OTHER BINDING MATCHED) ---
+    if let KeyCode::Char(_) = key.code {
+        let msg = if app_state.ui.show_login {
+            // NEW: Use unified canvas handler instead of auth_e::execute_edit_action
+            handle_canvas_state_edit(
+                key,
+                config,
+                login_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         } else if app_state.ui.show_add_table {
-        add_table_e::execute_edit_action("insert_char", key, &mut admin_state.add_table_state, ideal_cursor_column).await?
+            // NEW: Use unified canvas handler instead of add_table_e::execute_edit_action
+            handle_canvas_state_edit(
+                key,
+                config,
+                &mut admin_state.add_table_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         } else if app_state.ui.show_add_logic {
-        add_logic_e::execute_edit_action("insert_char", key, &mut admin_state.add_logic_state, ideal_cursor_column).await?
+            // NEW: Use unified canvas handler instead of add_logic_e::execute_edit_action
+            handle_canvas_state_edit(
+                key,
+                config,
+                &mut admin_state.add_logic_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         } else if app_state.ui.show_register {
-        auth_e::execute_edit_action("insert_char", key, register_state, ideal_cursor_column).await?
-    } else { // Form view
-        form_e::execute_edit_action("insert_char", key, form_state, ideal_cursor_column).await?
+            // NEW: Use unified canvas handler instead of auth_e::execute_edit_action
+            handle_canvas_state_edit(
+                key,
+                config,
+                register_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
+        } else {
+            // FIXED: Use canvas library instead of form_e::execute_edit_action
+            execute_canvas_action(
+                "insert_char",
+                key,
+                form_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         };
-
-    // After character insertion, update suggestions if applicable
-    if app_state.ui.show_register && register_state.current_field() == 4 {
-        register_state.update_role_suggestions();
-        // If we just exited suggestion mode by typing, don't immediately show them again unless Tab is pressed.
-        // However, update_role_suggestions will set show_role_suggestions if matches are found.
-        // This is fine, as the render logic checks in_suggestion_mode.
-    }
-    if app_state.ui.show_add_logic && admin_state.add_logic_state.current_field() == 1 {
-        admin_state.add_logic_state.update_target_column_suggestions();
+        return Ok(EditEventOutcome::Message(msg));
     }
 
-    if exited_suggestion_mode_for_typing && char_insert_msg.is_empty() {
-        char_insert_msg = "Suggestions hidden".to_string();
-    }
-
-
-    Ok(EditEventOutcome::Message(char_insert_msg))
+    Ok(EditEventOutcome::Message(String::new())) // No action taken
 }

client/src/modes/canvas/read_only.rs

@@ -3,16 +3,141 @@
 use crate::config::binds::config::Config;
 use crate::config::binds::key_sequences::KeySequenceTracker;
 use crate::services::grpc_client::GrpcClient;
-use crate::state::pages::{canvas_state::CanvasState, auth::RegisterState};
 use crate::state::pages::auth::LoginState;
+use crate::state::pages::auth::RegisterState;
 use crate::state::pages::form::FormState;
 use crate::state::pages::add_logic::AddLogicState;
 use crate::state::pages::add_table::AddTableState;
 use crate::state::app::state::AppState;
-use crate::functions::modes::read_only::{add_logic_ro, auth_ro, form_ro, add_table_ro};
+use canvas::{canvas::{CanvasAction, CanvasState, ActionResult}, dispatcher::ActionDispatcher};
 use crossterm::event::KeyEvent;
 use anyhow::Result;
 
+/// Helper function to dispatch canvas action for any CanvasState
+async fn dispatch_canvas_action<S: CanvasState>(
+    action: &str,
+    state: &mut S,
+    ideal_cursor_column: &mut usize,
+) -> String {
+    let canvas_action = CanvasAction::from_string(action);
+    match ActionDispatcher::dispatch(canvas_action, state, ideal_cursor_column).await {
+        Ok(ActionResult::Success(msg)) => msg.unwrap_or_default(),
+        Ok(ActionResult::HandledByFeature(msg)) => msg,
+        Ok(ActionResult::Error(msg)) => format!("Error: {}", msg),
+        Ok(ActionResult::RequiresContext(msg)) => format!("Context needed: {}", msg),
+        Err(e) => format!("Action failed: {}", e),
+    }
+}
+
+/// Helper function to dispatch canvas action to the appropriate state based on UI
+async fn dispatch_to_active_state(
+    action: &str,
+    app_state: &AppState,
+    form_state: &mut FormState,
+    login_state: &mut LoginState,
+    register_state: &mut RegisterState,
+    add_table_state: &mut AddTableState,
+    add_logic_state: &mut AddLogicState,
+    ideal_cursor_column: &mut usize,
+) -> String {
+    if app_state.ui.show_add_table {
+        dispatch_canvas_action(action, add_table_state, ideal_cursor_column).await
+    } else if app_state.ui.show_add_logic {
+        dispatch_canvas_action(action, add_logic_state, ideal_cursor_column).await
+    } else if app_state.ui.show_register {
+        dispatch_canvas_action(action, register_state, ideal_cursor_column).await
+    } else if app_state.ui.show_login {
+        dispatch_canvas_action(action, login_state, ideal_cursor_column).await
+    } else {
+        dispatch_canvas_action(action, form_state, ideal_cursor_column).await
+    }
+}
+
+/// Helper function to handle context-specific actions that need special treatment
+async fn handle_context_action(
+    action: &str,
+    app_state: &AppState,
+    form_state: &mut FormState,
+    grpc_client: &mut GrpcClient,
+    ideal_cursor_column: &mut usize,
+) -> Result<Option<String>> {
+    const CONTEXT_ACTIONS_FORM: &[&str] = &[
+        "previous_entry",
+        "next_entry",
+    ];
+    const CONTEXT_ACTIONS_LOGIN: &[&str] = &[
+        "previous_entry",
+        "next_entry",
+    ];
+
+    if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
+        Ok(Some(crate::tui::functions::form::handle_action(
+            action,
+            form_state,
+            grpc_client,
+            ideal_cursor_column,
+        ).await?))
+    } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
+        Ok(Some(crate::tui::functions::login::handle_action(action).await?))
+    } else {
+        Ok(None) // Not a context action, use regular canvas dispatch
+    }
+}
+
+pub async fn handle_form_readonly_with_canvas(
+    key_event: KeyEvent,
+    config: &Config,
+    form_state: &mut FormState,
+    ideal_cursor_column: &mut usize,
+) -> Result<String> {
+    // Try canvas action from key first
+    let canvas_config = canvas::config::CanvasConfig::load();
+    if let Some(action_name) = canvas_config.get_read_only_action(key_event.code, key_event.modifiers) {
+        let canvas_action = CanvasAction::from_string(action_name);
+        match ActionDispatcher::dispatch(canvas_action, form_state, ideal_cursor_column).await {
+            Ok(ActionResult::Success(msg)) => {
+                return Ok(msg.unwrap_or_default());
+            }
+            Ok(ActionResult::HandledByFeature(msg)) => {
+                return Ok(msg);
+            }
+            Ok(ActionResult::Error(msg)) => {
+                return Ok(format!("Error: {}", msg));
+            }
+            Ok(ActionResult::RequiresContext(msg)) => {
+                return Ok(format!("Context needed: {}", msg));
+            }
+            Err(_) => {
+                // Fall through to try config mapping
+            }
+        }
+    }
+
+    // Try config-mapped action
+    if let Some(action_str) = config.get_read_only_action_for_key(key_event.code, key_event.modifiers) {
+        let canvas_action = CanvasAction::from_string(&action_str);
+        match ActionDispatcher::dispatch(canvas_action, form_state, ideal_cursor_column).await {
+            Ok(ActionResult::Success(msg)) => {
+                return Ok(msg.unwrap_or_default());
+            }
+            Ok(ActionResult::HandledByFeature(msg)) => {
+                return Ok(msg);
+            }
+            Ok(ActionResult::Error(msg)) => {
+                return Ok(format!("Error: {}", msg));
+            }
+            Ok(ActionResult::RequiresContext(msg)) => {
+                return Ok(format!("Context needed: {}", msg));
+            }
+            Err(e) => {
+                return Ok(format!("Action failed: {}", e));
+            }
+        }
+    }
+
+    Ok(String::new())
+}
+
 pub async fn handle_read_only_event(
     app_state: &mut AppState,
     key: KeyEvent,
@@ -35,94 +160,75 @@ pub async fn handle_read_only_event(
     }
 
     if config.is_enter_edit_mode_after(key.code, key.modifiers) {
-        // Determine target state to adjust cursor
-        let target_state: &mut dyn CanvasState = if app_state.ui.show_login { login_state }
-            else if app_state.ui.show_add_logic { add_logic_state }
-            else if app_state.ui.show_register { register_state }
-            else if app_state.ui.show_add_table { add_table_state }
-            else { form_state };
-        let current_input = target_state.get_current_input();
-        let current_pos = target_state.current_cursor_pos();
-
+        // Determine target state to adjust cursor - all states now use CanvasState trait
+        if app_state.ui.show_login {
+            let current_input = login_state.get_current_input();
+            let current_pos = login_state.current_cursor_pos();
             if !current_input.is_empty() && current_pos < current_input.len() {
-            target_state.set_current_cursor_pos(current_pos + 1);
-            *ideal_cursor_column = target_state.current_cursor_pos();
+                login_state.set_current_cursor_pos(current_pos + 1);
+                *ideal_cursor_column = login_state.current_cursor_pos();
             }
+        } else if app_state.ui.show_add_logic {
+            let current_input = add_logic_state.get_current_input();
+            let current_pos = add_logic_state.current_cursor_pos();
+            if !current_input.is_empty() && current_pos < current_input.len() {
+                add_logic_state.set_current_cursor_pos(current_pos + 1);
+                *ideal_cursor_column = add_logic_state.current_cursor_pos();
+            }
+        } else if app_state.ui.show_register {
+            let current_input = register_state.get_current_input();
+            let current_pos = register_state.current_cursor_pos();
+            if !current_input.is_empty() && current_pos < current_input.len() {
+                register_state.set_current_cursor_pos(current_pos + 1);
+                *ideal_cursor_column = register_state.current_cursor_pos();
+            }
+        } else if app_state.ui.show_add_table {
+            let current_input = add_table_state.get_current_input();
+            let current_pos = add_table_state.current_cursor_pos();
+            if !current_input.is_empty() && current_pos < current_input.len() {
+                add_table_state.set_current_cursor_pos(current_pos + 1);
+                *ideal_cursor_column = add_table_state.current_cursor_pos();
+            }
+        } else {
+            // Handle FormState
+            let current_input = form_state.get_current_input();
+            let current_pos = form_state.current_cursor_pos();
+            if !current_input.is_empty() && current_pos < current_input.len() {
+                form_state.set_current_cursor_pos(current_pos + 1);
+                *ideal_cursor_column = form_state.current_cursor_pos();
+            }
+        }
+
         *edit_mode_cooldown = true;
         *command_message = "Entering Edit mode (after cursor)".to_string();
         return Ok((false, command_message.clone()));
     }
 
-    const CONTEXT_ACTIONS_FORM: &[&str] = &[
-        "previous_entry",
-        "next_entry",
-    ];
-    const CONTEXT_ACTIONS_LOGIN: &[&str] = &[
-        "previous_entry",
-        "next_entry",
-    ];
-
     if key.modifiers.is_empty() {
         key_sequence_tracker.add_key(key.code);
         let sequence = key_sequence_tracker.get_sequence();
 
         if let Some(action) = config.matches_key_sequence_generalized(&sequence).as_deref() {
-            let result = if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
-                crate::tui::functions::form::handle_action(
+            // Try context-specific actions first, otherwise use canvas dispatch
+            let result = if let Some(context_result) = handle_context_action(
                 action,
+                app_state,
                 form_state,
                 grpc_client,
                 ideal_cursor_column,
-                )
-                .await?
-            } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
-                crate::tui::functions::login::handle_action(action).await?
-            } else if app_state.ui.show_add_table {
-                add_table_ro::execute_action(
+            ).await? {
+                context_result
+            } else {
+                dispatch_to_active_state(
                     action,
                     app_state,
+                    form_state,
+                    login_state,
+                    register_state,
                     add_table_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                ).await?
-            } else if app_state.ui.show_add_logic {
-                add_logic_ro::execute_action(
-                    action,
-                    app_state,
                     add_logic_state,
                     ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                ).await?
-            } else if app_state.ui.show_register{
-                auth_ro::execute_action(
-                    action,
-                    app_state,
-                    register_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                ).await?
-            } else if app_state.ui.show_login {
-                auth_ro::execute_action(
-                    action,
-                    app_state,
-                    login_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                )
-                .await?
-            } else {
-                form_ro::execute_action(
-                    action,
-                    form_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                )
-                .await?
+                ).await
             };
             key_sequence_tracker.reset();
             return Ok((false, result));
@@ -134,62 +240,26 @@ pub async fn handle_read_only_event(
 
         if sequence.len() == 1 && !config.is_key_sequence_prefix(&sequence) {
             if let Some(action) = config.get_read_only_action_for_key(key.code, key.modifiers).as_deref() {
-                let result = if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
-                    crate::tui::functions::form::handle_action(
+                // Try context-specific actions first, otherwise use canvas dispatch
+                let result = if let Some(context_result) = handle_context_action(
                     action,
+                    app_state,
                     form_state,
                     grpc_client,
                     ideal_cursor_column,
-                    )
-                    .await?
-                } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
-                    crate::tui::functions::login::handle_action(action).await?
-                } else if app_state.ui.show_add_table {
-                    add_table_ro::execute_action(
+                ).await? {
+                    context_result
+                } else {
+                    dispatch_to_active_state(
                         action,
                         app_state,
+                        form_state,
+                        login_state,
+                        register_state,
                         add_table_state,
-                        ideal_cursor_column,
-                        key_sequence_tracker,
-                        command_message,
-                    ).await?
-                } else if app_state.ui.show_add_logic {
-                    add_logic_ro::execute_action(
-                        action,
-                        app_state,
                         add_logic_state,
                         ideal_cursor_column,
-                        key_sequence_tracker,
-                        command_message,
-                    ).await?
-                } else if app_state.ui.show_register {
-                    auth_ro::execute_action(
-                        action,
-                        app_state,
-                        register_state,
-                        ideal_cursor_column,
-                        key_sequence_tracker,
-                        command_message,
-                    ).await?
-                } else if app_state.ui.show_login {
-                    auth_ro::execute_action(
-                        action,
-                        app_state,
-                        login_state,
-                        ideal_cursor_column,
-                        key_sequence_tracker,
-                        command_message,
-                    )
-                    .await?
-                } else {
-                    form_ro::execute_action(
-                        action,
-                        form_state,
-                        ideal_cursor_column,
-                        key_sequence_tracker,
-                        command_message,
-                    )
-                    .await?
+                    ).await
                 };
                 key_sequence_tracker.reset();
                 return Ok((false, result));
@@ -200,62 +270,26 @@ pub async fn handle_read_only_event(
         key_sequence_tracker.reset();
 
         if let Some(action) = config.get_read_only_action_for_key(key.code, key.modifiers).as_deref() {
-            let result = if app_state.ui.show_form && CONTEXT_ACTIONS_FORM.contains(&action) {
-                crate::tui::functions::form::handle_action(
+            // Try context-specific actions first, otherwise use canvas dispatch
+            let result = if let Some(context_result) = handle_context_action(
                 action,
+                app_state,
                 form_state,
                 grpc_client,
                 ideal_cursor_column,
-                )
-                .await?
-            } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
-                crate::tui::functions::login::handle_action(action).await?
-            } else if app_state.ui.show_add_table {
-                add_table_ro::execute_action(
+            ).await? {
+                context_result
+            } else {
+                dispatch_to_active_state(
                     action,
                     app_state,
+                    form_state,
+                    login_state,
+                    register_state,
                     add_table_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                ).await?
-            } else if app_state.ui.show_add_logic {
-                add_logic_ro::execute_action(
-                    action,
-                    app_state,
                     add_logic_state,
                     ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                ).await?
-            } else if app_state.ui.show_register {
-                auth_ro::execute_action(
-                    action,
-                    app_state,
-                    register_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                ).await?
-            } else if app_state.ui.show_login {
-                auth_ro::execute_action(
-                    action,
-                    app_state,
-                    login_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                )
-                .await?
-            } else {
-                form_ro::execute_action(
-                    action,
-                    form_state,
-                    ideal_cursor_column,
-                    key_sequence_tracker,
-                    command_message,
-                )
-                .await?
+                ).await
             };
             return Ok((false, result));
         }

client/src/modes/common/command_mode.rs

@@ -15,7 +15,7 @@ use anyhow::Result;
 pub async fn handle_command_event(
     key: KeyEvent,
     config: &Config,
-    app_state: &AppState,
+    app_state: &mut AppState,
     login_state: &LoginState,
     register_state: &RegisterState,
     form_state: &mut FormState,
@@ -74,7 +74,7 @@ pub async fn handle_command_event(
 async fn process_command(
     config: &Config,
     form_state: &mut FormState,
-    app_state: &AppState,
+    app_state: &mut AppState,
     login_state: &LoginState,
     register_state: &RegisterState,
     command_input: &mut String,
@@ -117,6 +117,7 @@ async fn process_command(
         },
         "save" => {
             let outcome = save(
+                app_state,
                 form_state,
                 grpc_client,
             ).await?;

client/src/modes/common/commands.rs

@@ -2,7 +2,7 @@
 use crate::tui::terminal::core::TerminalCore;
 use crate::state::app::state::AppState;
 use crate::state::pages::{form::FormState, auth::LoginState, auth::RegisterState};
-use crate::state::pages::canvas_state::CanvasState;
+use canvas::canvas::CanvasState;
 use anyhow::Result;
 
 pub struct CommandHandler;

client/src/modes/general/command_navigation.rs

@@ -2,7 +2,7 @@
 use crate::config::binds::config::Config;
 use crate::modes::handlers::event::EventOutcome;
 use anyhow::Result;
-use common::proto::multieko2::table_definition::ProfileTreeResponse;
+use common::proto::komp_ac::table_definition::ProfileTreeResponse;
 use crossterm::event::{KeyCode, KeyEvent};
 use std::collections::{HashMap, HashSet};
 

client/src/modes/general/navigation.rs

@@ -8,10 +8,10 @@ use crate::state::pages::auth::LoginState;
 use crate::state::pages::auth::RegisterState;
 use crate::state::pages::intro::IntroState;
 use crate::state::pages::admin::AdminState;
-use crate::state::pages::canvas_state::CanvasState;
 use crate::ui::handlers::context::UiContext;
 use crate::modes::handlers::event::EventOutcome;
 use crate::modes::general::command_navigation::{handle_command_navigation_event, NavigationState};
+use canvas::canvas::CanvasState;
 use anyhow::Result;
 
 pub async fn handle_navigation_event(

client/src/modes/handlers.rs

@@ -1,3 +1,3 @@
-// src/client/modes/handlers.rs
+// src/modes/handlers.rs
 pub mod event;
 pub mod mode_manager;

client/src/services/auth.rs

@@ -1,6 +1,6 @@
 // src/services/auth.rs
 use tonic::transport::Channel;
-use common::proto::multieko2::auth::{
+use common::proto::komp_ac::auth::{
     auth_service_client::AuthServiceClient,
     LoginRequest, LoginResponse,
     RegisterRequest, AuthResponse,

client/src/services/grpc_client.rs

@@ -1,63 +1,65 @@
 // src/services/grpc_client.rs
 
-use tonic::transport::Channel;
-use common::proto::multieko2::common::{CountResponse, Empty};
-use common::proto::multieko2::table_structure::table_structure_service_client::TableStructureServiceClient;
-use common::proto::multieko2::table_structure::{GetTableStructureRequest, TableStructureResponse};
-use common::proto::multieko2::table_definition::{
+use common::proto::komp_ac::common::Empty;
+use common::proto::komp_ac::table_structure::table_structure_service_client::TableStructureServiceClient;
+use common::proto::komp_ac::table_structure::{GetTableStructureRequest, TableStructureResponse};
+use common::proto::komp_ac::table_definition::{
     table_definition_client::TableDefinitionClient,
     PostTableDefinitionRequest, ProfileTreeResponse, TableDefinitionResponse,
 };
-use common::proto::multieko2::table_script::{
+use common::proto::komp_ac::table_script::{
     table_script_client::TableScriptClient,
     PostTableScriptRequest, TableScriptResponse,
 };
-use common::proto::multieko2::tables_data::{
+use common::proto::komp_ac::tables_data::{
     tables_data_client::TablesDataClient,
     GetTableDataByPositionRequest,
+    GetTableDataRequest,          // ADD THIS
     GetTableDataResponse,
+    DeleteTableDataRequest,       // ADD THIS
+    DeleteTableDataResponse,      // ADD THIS
     GetTableDataCountRequest,
     PostTableDataRequest, PostTableDataResponse, PutTableDataRequest,
     PutTableDataResponse,
 };
-use anyhow::{Context, Result}; // Added Context
-use std::collections::HashMap; // NEW
+use common::proto::komp_ac::search::{
+    searcher_client::SearcherClient, SearchRequest, SearchResponse,
+};
+use anyhow::{Context, Result};
+use std::collections::HashMap;
+use tonic::transport::Channel;
+use prost_types::Value;
 
 #[derive(Clone)]
 pub struct GrpcClient {
     table_structure_client: TableStructureServiceClient<Channel>,
     table_definition_client: TableDefinitionClient<Channel>,
     table_script_client: TableScriptClient<Channel>,
-    tables_data_client: TablesDataClient<Channel>, // NEW
+    tables_data_client: TablesDataClient<Channel>,
+    search_client: SearcherClient<Channel>,
 }
 
 impl GrpcClient {
     pub async fn new() -> Result<Self> {
-        let table_structure_client = TableStructureServiceClient::connect(
-            "http://[::1]:50051",
-        )
+        let channel = Channel::from_static("http://[::1]:50051")
+            .connect()
             .await
-        .context("Failed to connect to TableStructureService")?;
-        let table_definition_client = TableDefinitionClient::connect(
-            "http://[::1]:50051",
-        )
-        .await
-        .context("Failed to connect to TableDefinitionService")?;
-        let table_script_client =
-            TableScriptClient::connect("http://[::1]:50051")
-                .await
-                .context("Failed to connect to TableScriptService")?;
-        let tables_data_client =
-            TablesDataClient::connect("http://[::1]:50051")
-                .await
-                .context("Failed to connect to TablesDataService")?; // NEW
+            .context("Failed to create gRPC channel")?;
+
+        let table_structure_client =
+            TableStructureServiceClient::new(channel.clone());
+        let table_definition_client =
+            TableDefinitionClient::new(channel.clone());
+        let table_script_client = TableScriptClient::new(channel.clone());
+        let tables_data_client = TablesDataClient::new(channel.clone());
+        let search_client = SearcherClient::new(channel.clone());
 
         Ok(Self {
-            // adresar_client, // REMOVE
             table_structure_client,
             table_definition_client,
             table_script_client,
-            tables_data_client, // NEW
+            tables_data_client,
+            search_client,
         })
     }
 
@@ -117,7 +119,7 @@ impl GrpcClient {
         Ok(response.into_inner())
     }
 
-    // NEW Methods for TablesData service
+    // Existing TablesData methods
     pub async fn get_table_data_count(
         &mut self,
         profile_name: String,
@@ -156,11 +158,53 @@ impl GrpcClient {
         Ok(response.into_inner())
     }
 
+    // ADD THIS: Missing get_table_data method
+    pub async fn get_table_data(
+        &mut self,
+        profile_name: String,
+        table_name: String,
+        id: i64,
+    ) -> Result<GetTableDataResponse> {
+        let grpc_request = GetTableDataRequest {
+            profile_name,
+            table_name,
+            id,
+        };
+        let request = tonic::Request::new(grpc_request);
+        let response = self
+            .tables_data_client
+            .get_table_data(request)
+            .await
+            .context("gRPC GetTableData call failed")?;
+        Ok(response.into_inner())
+    }
+
+    // ADD THIS: Missing delete_table_data method
+    pub async fn delete_table_data(
+        &mut self,
+        profile_name: String,
+        table_name: String,
+        record_id: i64,
+    ) -> Result<DeleteTableDataResponse> {
+        let grpc_request = DeleteTableDataRequest {
+            profile_name,
+            table_name,
+            record_id,
+        };
+        let request = tonic::Request::new(grpc_request);
+        let response = self
+            .tables_data_client
+            .delete_table_data(request)
+            .await
+            .context("gRPC DeleteTableData call failed")?;
+        Ok(response.into_inner())
+    }
+
     pub async fn post_table_data(
         &mut self,
         profile_name: String,
         table_name: String,
-        data: HashMap<String, String>,
+        data: HashMap<String, Value>,
     ) -> Result<PostTableDataResponse> {
         let grpc_request = PostTableDataRequest {
             profile_name,
@@ -181,7 +225,7 @@ impl GrpcClient {
         profile_name: String,
         table_name: String,
         id: i64,
-        data: HashMap<String, String>,
+        data: HashMap<String, Value>,
     ) -> Result<PutTableDataResponse> {
         let grpc_request = PutTableDataRequest {
             profile_name,
@@ -197,4 +241,17 @@ impl GrpcClient {
             .context("gRPC PutTableData call failed")?;
         Ok(response.into_inner())
     }
+
+    pub async fn search_table(
+        &mut self,
+        table_name: String,
+        query: String,
+    ) -> Result<SearchResponse> {
+        let request = tonic::Request::new(SearchRequest { table_name, query });
+        let response = self
+            .search_client
+            .search_table(request)
+            .await?;
+        Ok(response.into_inner())
+    }
 }

client/src/services/ui_service.rs

@@ -1,20 +1,104 @@
 // src/services/ui_service.rs
 
 use crate::services::grpc_client::GrpcClient;
-use crate::state::pages::form::FormState;
-use crate::tui::functions::common::form::SaveOutcome;
-use crate::state::pages::add_logic::AddLogicState;
 use crate::state::app::state::AppState;
+use crate::state::pages::add_logic::AddLogicState;
+use crate::state::pages::form::{FieldDefinition, FormState};
+use crate::tui::functions::common::form::SaveOutcome;
 use crate::utils::columns::filter_user_columns;
-use anyhow::{Context, Result};
+use anyhow::{anyhow, Context, Result};
+use std::sync::Arc;
 
 pub struct UiService;
 
 impl UiService {
+    pub async fn load_table_view(
+        grpc_client: &mut GrpcClient,
+        app_state: &mut AppState,
+        profile_name: &str,
+        table_name: &str,
+    ) -> Result<FormState> {
+        // 1. & 2. Fetch and Cache Schema - UNCHANGED
+        let table_structure = grpc_client
+            .get_table_structure(profile_name.to_string(), table_name.to_string())
+            .await
+            .context(format!(
+                "Failed to get table structure for {}.{}",
+                profile_name, table_name
+            ))?;
+        let cache_key = format!("{}.{}", profile_name, table_name);
+        app_state
+            .schema_cache
+            .insert(cache_key, Arc::new(table_structure.clone()));
+        tracing::info!("Schema for '{}.{}' cached.", profile_name, table_name);
+
+        // --- START: FINAL, SIMPLIFIED, CORRECT LOGIC ---
+
+        // 3a. Create definitions for REGULAR fields first.
+        let mut fields: Vec<FieldDefinition> = table_structure
+            .columns
+            .iter()
+            .filter(|col| {
+                !col.is_primary_key
+                    && col.name != "deleted"
+                    && col.name != "created_at"
+                    && !col.name.ends_with("_id") // Filter out ALL potential links
+            })
+            .map(|col| FieldDefinition {
+                display_name: col.name.clone(),
+                data_key: col.name.clone(),
+                is_link: false,
+                link_target_table: None,
+            })
+            .collect();
+
+        // 3b. Now, find and APPEND definitions for LINK fields based on the `_id` convention.
+        let link_fields: Vec<FieldDefinition> = table_structure
+            .columns
+            .iter()
+            .filter(|col| col.name.ends_with("_id")) // Find all foreign key columns
+            .map(|col| {
+                // The table we link to is derived from the column name.
+                // e.g., "test_diacritics_id" -> "test_diacritics"
+                let target_table_base = col
+                    .name
+                    .strip_suffix("_id")
+                    .unwrap_or(&col.name);
+
+                // Find the full table name from the profile tree for display.
+                // e.g., "test_diacritics" -> "2025_test_diacritics"
+                let full_target_table_name = app_state
+                    .profile_tree
+                    .profiles
+                    .iter()
+                    .find(|p| p.name == profile_name)
+                    .and_then(|p| p.tables.iter().find(|t| t.name.ends_with(target_table_base)))
+                    .map_or(target_table_base.to_string(), |t| t.name.clone());
+
+                FieldDefinition {
+                    display_name: full_target_table_name.clone(),
+                    data_key: col.name.clone(), // The actual FK column name
+                    is_link: true,
+                    link_target_table: Some(full_target_table_name),
+                }
+            })
+            .collect();
+
+        fields.extend(link_fields); // Append the link fields to the end
+
+        // --- END: FINAL, SIMPLIFIED, CORRECT LOGIC ---
+
+        Ok(FormState::new(
+            profile_name.to_string(),
+            table_name.to_string(),
+            fields,
+        ))
+    }
+
     pub async fn initialize_add_logic_table_data(
         grpc_client: &mut GrpcClient,
         add_logic_state: &mut AddLogicState,
-        profile_tree: &common::proto::multieko2::table_definition::ProfileTreeResponse,
+        profile_tree: &common::proto::komp_ac::table_definition::ProfileTreeResponse,
     ) -> Result<String> {
         let profile_name_clone_opt = Some(add_logic_state.profile_name.clone());
         let table_name_opt_clone = add_logic_state.selected_table_name.clone();
@@ -92,6 +176,7 @@ impl UiService {
         }
     }
 
+    // TODO REFACTOR (maybe)
     pub async fn initialize_app_state_and_form(
         grpc_client: &mut GrpcClient,
         app_state: &mut AppState,
@@ -100,48 +185,38 @@ impl UiService {
             .get_profile_tree()
             .await
             .context("Failed to get profile tree")?;
+
         app_state.profile_tree = profile_tree;
 
-        // Determine initial table to load (e.g., first table of first profile, or a default)
-        let initial_profile_name = app_state
+        // Find first profile that contains tables
+        let (initial_profile_name, initial_table_name) = app_state
             .profile_tree
             .profiles
-            .first()
-            .map(|p| p.name.clone())
-            .unwrap_or_else(|| "default".to_string());
-
-        let initial_table_name = app_state
-            .profile_tree
-            .profiles
-            .first()
-            .and_then(|p| p.tables.first().map(|t| t.name.clone()))
-            .unwrap_or_else(|| "2025_company_data1".to_string()); // Fallback if no tables
+            .iter()
+            .find(|profile| !profile.tables.is_empty())
+            .and_then(|profile| {
+                profile.tables.first().map(|table| {
+                    (profile.name.clone(), table.name.clone())
+                })
+            })
+            .ok_or_else(|| anyhow!("No profiles with tables found. Create a table first."))?;
 
         app_state.set_current_view_table(
             initial_profile_name.clone(),
             initial_table_name.clone(),
         );
 
-        let table_structure = grpc_client
-            .get_table_structure(
-                initial_profile_name.clone(),
-                initial_table_name.clone(),
+        let form_state = Self::load_table_view(
+            grpc_client,
+            app_state,
+            &initial_profile_name,
+            &initial_table_name,
         )
-            .await
-            .context(format!(
-                "Failed to get initial table structure for {}.{}",
-                initial_profile_name, initial_table_name
-            ))?;
+        .await?;
 
-        let column_names: Vec<String> = table_structure
-            .columns
-            .iter()
-            .map(|col| col.name.clone())
-            .collect();
+        let field_names = form_state.fields.iter().map(|f| f.display_name.clone()).collect();
 
-        let filtered_columns = filter_user_columns(column_names);
-
-        Ok((initial_profile_name, initial_table_name, filtered_columns))
+        Ok((initial_profile_name, initial_table_name, field_names))
     }
 
     pub async fn fetch_and_set_table_count(

client/src/state/app.rs

@@ -2,4 +2,5 @@
 
 pub mod state;
 pub mod buffer;
+pub mod search;
 pub mod highlight;

client/src/state/app/search.rs

@@ -0,0 +1,56 @@
+// src/state/app/search.rs
+
+use common::proto::komp_ac::search::search_response::Hit;
+
+/// Holds the complete state for the search palette.
+pub struct SearchState {
+    /// The name of the table being searched.
+    pub table_name: String,
+    /// The current text entered by the user.
+    pub input: String,
+    /// The position of the cursor within the input text.
+    pub cursor_position: usize,
+    /// The search results returned from the server.
+    pub results: Vec<Hit>,
+    /// The index of the currently selected search result.
+    pub selected_index: usize,
+    /// A flag to indicate if a search is currently in progress.
+    pub is_loading: bool,
+}
+
+impl SearchState {
+    /// Creates a new SearchState for a given table.
+    pub fn new(table_name: String) -> Self {
+        Self {
+            table_name,
+            input: String::new(),
+            cursor_position: 0,
+            results: Vec::new(),
+            selected_index: 0,
+            is_loading: false,
+        }
+    }
+
+    /// Moves the selection to the next item, wrapping around if at the end.
+    pub fn next_result(&mut self) {
+        if !self.results.is_empty() {
+            let next = self.selected_index + 1;
+            self.selected_index = if next >= self.results.len() {
+                0 // Wrap to the start
+            } else {
+                next
+            };
+        }
+    }
+
+    /// Moves the selection to the previous item, wrapping around if at the beginning.
+    pub fn previous_result(&mut self) {
+        if !self.results.is_empty() {
+            self.selected_index = if self.selected_index == 0 {
+                self.results.len() - 1 // Wrap to the end
+            } else {
+                self.selected_index - 1
+            };
+        }
+    }
+}

client/src/state/app/state.rs

@@ -1,11 +1,19 @@
-// src/state/state.rs
+// src/state/app/state.rs
 
-use std::env;
-use common::proto::multieko2::table_definition::ProfileTreeResponse;
-use crate::modes::handlers::mode_manager::AppMode;
-use crate::ui::handlers::context::DialogPurpose;
 use anyhow::Result;
+use common::proto::komp_ac::table_definition::ProfileTreeResponse;
+// NEW: Import the types we need for the cache
+use common::proto::komp_ac::table_structure::TableStructureResponse;
+use crate::modes::handlers::mode_manager::AppMode;
+use crate::state::app::search::SearchState;
+use crate::ui::handlers::context::DialogPurpose;
+use std::collections::HashMap;
+use std::env;
+use std::sync::Arc;
+#[cfg(feature = "ui-debug")]
+use std::time::Instant;
 
+// --- DialogState and UiState are unchanged ---
 pub struct DialogState {
     pub dialog_show: bool,
     pub dialog_title: String,
@@ -26,10 +34,19 @@ pub struct UiState {
     pub show_form: bool,
     pub show_login: bool,
     pub show_register: bool,
+    pub show_search_palette: bool,
     pub focus_outside_canvas: bool,
     pub dialog: DialogState,
 }
 
+#[cfg(feature = "ui-debug")]
+#[derive(Debug, Clone)]
+pub struct DebugState {
+    pub displayed_message: String,
+    pub is_error: bool,
+    pub display_start_time: Instant,
+}
+
 pub struct AppState {
     // Core editor state
     pub current_dir: String,
@@ -39,21 +56,24 @@ pub struct AppState {
     pub current_view_profile_name: Option<String>,
     pub current_view_table_name: Option<String>,
 
+    // NEW: The "Rulebook" cache. We use Arc for efficient sharing.
+    pub schema_cache: HashMap<String, Arc<TableStructureResponse>>,
+
     pub focused_button_index: usize,
     pub pending_table_structure_fetch: Option<(String, String)>,
 
+    pub search_state: Option<SearchState>,
+
     // UI preferences
     pub ui: UiState,
 
     #[cfg(feature = "ui-debug")]
-    pub debug_info: String,
+    pub debug_state: Option<DebugState>,
 }
 
 impl AppState {
     pub fn new() -> Result<Self> {
-        let current_dir = env::current_dir()?
-            .to_string_lossy()
-            .to_string();
+        let current_dir = env::current_dir()?.to_string_lossy().to_string();
         Ok(AppState {
             current_dir,
             profile_tree: ProfileTreeResponse::default(),
@@ -61,15 +81,19 @@ impl AppState {
             current_view_profile_name: None,
             current_view_table_name: None,
             current_mode: AppMode::General,
+            schema_cache: HashMap::new(), // NEW: Initialize the cache
             focused_button_index: 0,
             pending_table_structure_fetch: None,
+            search_state: None,
             ui: UiState::default(),
 
             #[cfg(feature = "ui-debug")]
-            debug_info: String::new(),
+            debug_state: None,
         })
     }
 
+    // --- ALL YOUR EXISTING METHODS ARE UNTOUCHED ---
+
     pub fn update_mode(&mut self, mode: AppMode) {
         self.current_mode = mode;
     }
@@ -79,9 +103,6 @@ impl AppState {
         self.current_view_table_name = Some(table_name);
     }
 
-    // Add dialog helper methods
-    /// Shows a dialog with the given title, message, and buttons.
-    /// The first button (index 0) is active by default.
     pub fn show_dialog(
         &mut self,
         title: &str,
@@ -99,19 +120,17 @@ impl AppState {
         self.ui.focus_outside_canvas = true;
     }
 
-    /// Shows a dialog specifically for loading states.
     pub fn show_loading_dialog(&mut self, title: &str, message: &str) {
         self.ui.dialog.dialog_title = title.to_string();
         self.ui.dialog.dialog_message = message.to_string();
-        self.ui.dialog.dialog_buttons.clear(); // No buttons during loading
+        self.ui.dialog.dialog_buttons.clear();
         self.ui.dialog.dialog_active_button_index = 0;
-        self.ui.dialog.purpose = None; // Purpose is set when loading finishes
+        self.ui.dialog.purpose = None;
         self.ui.dialog.is_loading = true;
         self.ui.dialog.dialog_show = true;
-        self.ui.focus_outside_canvas = true; // Keep focus management consistent
+        self.ui.focus_outside_canvas = true;
     }
 
-    /// Updates the content of an existing dialog, typically after loading.
     pub fn update_dialog_content(
         &mut self,
         message: &str,
@@ -121,16 +140,12 @@ impl AppState {
         if self.ui.dialog.dialog_show {
             self.ui.dialog.dialog_message = message.to_string();
             self.ui.dialog.dialog_buttons = buttons;
-            self.ui.dialog.dialog_active_button_index = 0; // Reset focus
+            self.ui.dialog.dialog_active_button_index = 0;
             self.ui.dialog.purpose = Some(purpose);
-            self.ui.dialog.is_loading = false; // Loading finished
-                                               // Keep dialog_show = true
-                                               // Keep focus_outside_canvas = true
+            self.ui.dialog.is_loading = false;
         }
     }
 
-
-    /// Hides the dialog and clears its content.
     pub fn hide_dialog(&mut self) {
         self.ui.dialog.dialog_show = false;
         self.ui.dialog.dialog_title.clear();
@@ -142,30 +157,27 @@ impl AppState {
         self.ui.dialog.is_loading = false;
     }
 
-    /// Sets the active button index, wrapping around if necessary.
     pub fn next_dialog_button(&mut self) {
         if !self.ui.dialog.dialog_buttons.is_empty() {
             let next_index = (self.ui.dialog.dialog_active_button_index + 1)
                 % self.ui.dialog.dialog_buttons.len();
-            self.ui.dialog.dialog_active_button_index = next_index; // Use new name
+            self.ui.dialog.dialog_active_button_index = next_index;
         }
     }
 
-    /// Sets the active button index, wrapping around if necessary.
     pub fn previous_dialog_button(&mut self) {
         if !self.ui.dialog.dialog_buttons.is_empty() {
             let len = self.ui.dialog.dialog_buttons.len();
             let prev_index =
                 (self.ui.dialog.dialog_active_button_index + len - 1) % len;
-            self.ui.dialog.dialog_active_button_index = prev_index; // Use new name
+            self.ui.dialog.dialog_active_button_index = prev_index;
         }
     }
 
-    /// Gets the label of the currently active button, if any.
     pub fn get_active_dialog_button_label(&self) -> Option<&str> {
         self.ui.dialog
-            .dialog_buttons // Use new name
-            .get(self.ui.dialog.dialog_active_button_index) // Use new name
+            .dialog_buttons
+            .get(self.ui.dialog.dialog_active_button_index)
             .map(|s| s.as_str())
     }
 }
@@ -182,13 +194,13 @@ impl Default for UiState {
             show_login: false,
             show_register: false,
             show_buffer_list: true,
+            show_search_palette: false, // ADDED
             focus_outside_canvas: false,
             dialog: DialogState::default(),
         }
     }
 }
 
-// Update the Default implementation for DialogState itself
 impl Default for DialogState {
     fn default() -> Self {
         Self {

client/src/state/pages.rs

@@ -6,4 +6,3 @@ pub mod admin;
 pub mod intro;
 pub mod add_table;
 pub mod add_logic;
-pub mod canvas_state;

client/src/state/pages/add_logic.rs

@@ -1,6 +1,6 @@
 // src/state/pages/add_logic.rs
 use crate::config::binds::config::{EditorConfig, EditorKeybindingMode};
-use crate::state::pages::canvas_state::CanvasState;
+use canvas::canvas::{CanvasState, ActionContext, CanvasAction, AppMode};
 use crate::components::common::text_editor::{TextEditor, VimState};
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -54,6 +54,7 @@ pub struct AddLogicState {
     // New fields for same-profile table names and column autocomplete
     pub same_profile_table_names: Vec<String>, // Tables from same profile only
     pub script_editor_awaiting_column_autocomplete: Option<String>, // Table name waiting for column fetch
+    pub app_mode: AppMode,
 }
 
 impl AddLogicState {
@@ -91,6 +92,7 @@ impl AddLogicState {
 
             same_profile_table_names: Vec::new(),
             script_editor_awaiting_column_autocomplete: None,
+            app_mode: AppMode::Edit,
         }
     }
 
@@ -225,67 +227,68 @@ impl AddLogicState {
         self.script_editor_trigger_position = None;
         self.script_editor_filter_text.clear();
     }
+
+    /// Helper method to validate and save logic
+    pub fn save_logic(&mut self) -> Option<String> {
+        if self.logic_name_input.trim().is_empty() {
+            return Some("Logic name is required".to_string());
+        }
+
+        if self.target_column_input.trim().is_empty() {
+            return Some("Target column is required".to_string());
+        }
+
+        let script_content = {
+            let editor_borrow = self.script_content_editor.borrow();
+            editor_borrow.lines().join("\n")
+        };
+
+        if script_content.trim().is_empty() {
+            return Some("Script content is required".to_string());
+        }
+
+        // Here you would typically save to database/storage
+        // For now, just clear the form and mark as saved
+        self.has_unsaved_changes = false;
+        Some(format!("Logic '{}' saved successfully", self.logic_name_input.trim()))
+    }
+
+    /// Helper method to clear the form
+    pub fn clear_form(&mut self) -> Option<String> {
+        let profile = self.profile_name.clone();
+        let table_id = self.selected_table_id;
+        let table_name = self.selected_table_name.clone();
+        let editor_config = EditorConfig::default(); // You might want to preserve the actual config
+        
+        *self = Self::new(&editor_config);
+        self.profile_name = profile;
+        self.selected_table_id = table_id;
+        self.selected_table_name = table_name;
+        
+        Some("Form cleared".to_string())
+    }
 }
 
 impl Default for AddLogicState {
     fn default() -> Self {
-        Self::new(&EditorConfig::default())
+        let mut state = Self::new(&EditorConfig::default());
+        state.app_mode = AppMode::Edit;
+        state
     }
 }
 
+// Implement external library's CanvasState for AddLogicState
 impl CanvasState for AddLogicState {
     fn current_field(&self) -> usize {
         match self.current_focus {
             AddLogicFocus::InputLogicName => 0,
             AddLogicFocus::InputTargetColumn => 1,
             AddLogicFocus::InputDescription => 2,
+            // If focus is elsewhere, return the last canvas field used
             _ => self.last_canvas_field,
         }
     }
 
-    fn current_cursor_pos(&self) -> usize {
-        match self.current_focus {
-            AddLogicFocus::InputLogicName => self.logic_name_cursor_pos,
-            AddLogicFocus::InputTargetColumn => self.target_column_cursor_pos,
-            AddLogicFocus::InputDescription => self.description_cursor_pos,
-            _ => 0,
-        }
-    }
-
-    fn has_unsaved_changes(&self) -> bool {
-        self.has_unsaved_changes
-    }
-
-    fn inputs(&self) -> Vec<&String> {
-        vec![
-            &self.logic_name_input,
-            &self.target_column_input,
-            &self.description_input,
-        ]
-    }
-
-    fn get_current_input(&self) -> &str {
-        match self.current_focus {
-            AddLogicFocus::InputLogicName => &self.logic_name_input,
-            AddLogicFocus::InputTargetColumn => &self.target_column_input,
-            AddLogicFocus::InputDescription => &self.description_input,
-            _ => "",
-        }
-    }
-
-    fn get_current_input_mut(&mut self) -> &mut String {
-        match self.current_focus {
-            AddLogicFocus::InputLogicName => &mut self.logic_name_input,
-            AddLogicFocus::InputTargetColumn => &mut self.target_column_input,
-            AddLogicFocus::InputDescription => &mut self.description_input,
-            _ => &mut self.logic_name_input,
-        }
-    }
-
-    fn fields(&self) -> Vec<&str> {
-        vec!["Logic Name", "Target Column", "Description"]
-    }
-
     fn set_current_field(&mut self, index: usize) {
         let new_focus = match index {
             0 => AddLogicFocus::InputLogicName,
@@ -303,6 +306,15 @@ impl CanvasState for AddLogicState {
         }
     }
 
+    fn current_cursor_pos(&self) -> usize {
+        match self.current_focus {
+            AddLogicFocus::InputLogicName => self.logic_name_cursor_pos,
+            AddLogicFocus::InputTargetColumn => self.target_column_cursor_pos,
+            AddLogicFocus::InputDescription => self.description_cursor_pos,
+            _ => 0,
+        }
+    }
+
     fn set_current_cursor_pos(&mut self, pos: usize) {
         match self.current_focus {
             AddLogicFocus::InputLogicName => {
@@ -318,29 +330,121 @@ impl CanvasState for AddLogicState {
         }
     }
 
+    fn get_current_input(&self) -> &str {
+        match self.current_focus {
+            AddLogicFocus::InputLogicName => &self.logic_name_input,
+            AddLogicFocus::InputTargetColumn => &self.target_column_input,
+            AddLogicFocus::InputDescription => &self.description_input,
+            _ => "", // Should not happen if called correctly
+        }
+    }
+
+    fn get_current_input_mut(&mut self) -> &mut String {
+        match self.current_focus {
+            AddLogicFocus::InputLogicName => &mut self.logic_name_input,
+            AddLogicFocus::InputTargetColumn => &mut self.target_column_input,
+            AddLogicFocus::InputDescription => &mut self.description_input,
+            _ => &mut self.logic_name_input, // Fallback
+        }
+    }
+
+    fn inputs(&self) -> Vec<&String> {
+        vec![
+            &self.logic_name_input,
+            &self.target_column_input,
+            &self.description_input,
+        ]
+    }
+
+    fn fields(&self) -> Vec<&str> {
+        vec!["Logic Name", "Target Column", "Description"]
+    }
+
+    fn has_unsaved_changes(&self) -> bool {
+        self.has_unsaved_changes
+    }
+
     fn set_has_unsaved_changes(&mut self, changed: bool) {
         self.has_unsaved_changes = changed;
     }
 
-    fn get_suggestions(&self) -> Option<&[String]> {
-        if self.current_field() == 1
-            && self.in_target_column_suggestion_mode
-            && self.show_target_column_suggestions
-        {
-            Some(&self.target_column_suggestions)
+    fn handle_feature_action(&mut self, action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+        match action {
+            // Handle saving logic script
+            CanvasAction::Custom(action_str) if action_str == "save_logic" => {
+                self.save_logic()
+            }
+
+            // Handle clearing the form
+            CanvasAction::Custom(action_str) if action_str == "clear_form" => {
+                self.clear_form()
+            }
+
+            // Handle target column autocomplete activation
+            CanvasAction::Custom(action_str) if action_str == "activate_autocomplete" => {
+                if self.current_field() == 1 { // Target Column field
+                    self.in_target_column_suggestion_mode = true;
+                    self.update_target_column_suggestions();
+                    Some("Autocomplete activated".to_string())
                 } else {
                     None
                 }
             }
 
-    fn get_selected_suggestion_index(&self) -> Option<usize> {
-        if self.current_field() == 1
-            && self.in_target_column_suggestion_mode
-            && self.show_target_column_suggestions
-        {
-            self.selected_target_column_suggestion_index
-        } else {
+            // Handle target column suggestion selection
+            CanvasAction::Custom(action_str) if action_str == "select_suggestion" => {
+                if self.current_field() == 1 && self.in_target_column_suggestion_mode {
+                    if let Some(selected_idx) = self.selected_target_column_suggestion_index {
+                        if let Some(suggestion) = self.target_column_suggestions.get(selected_idx) {
+                            self.target_column_input = suggestion.clone();
+                            self.target_column_cursor_pos = suggestion.len();
+                            self.in_target_column_suggestion_mode = false;
+                            self.show_target_column_suggestions = false;
+                            self.has_unsaved_changes = true;
+                            return Some(format!("Selected: {}", suggestion));
+                        }
+                    }
+                }
                 None
             }
+
+            // Custom validation when moving between fields
+            CanvasAction::NextField => {
+                match self.current_field() {
+                    0 => { // Logic Name field
+                        if self.logic_name_input.trim().is_empty() {
+                            Some("Logic name cannot be empty".to_string())
+                        } else {
+                            None // Let canvas library handle the normal field movement
+                        }
+                    }
+                    1 => { // Target Column field
+                        // Update suggestions when entering target column field
+                        self.update_target_column_suggestions();
+                        None
+                    }
+                    _ => None,
+                }
+            }
+
+            // Handle character insertion with validation
+            CanvasAction::InsertChar(c) => {
+                if self.current_field() == 1 { // Target Column field
+                    // Update suggestions after character insertion
+                    // Note: Canvas library will handle the actual insertion
+                    // This is just for triggering suggestion updates
+                    None // Let canvas handle insertion, then we'll update suggestions
+                } else {
+                    None // Let canvas handle normally
+                }
+            }
+
+            // Let canvas library handle everything else
+            _ => None,
+        }
+    }
+
+    fn current_mode(&self) -> AppMode {
+        self.app_mode
     }
 }

client/src/state/pages/add_table.rs

@@ -1,5 +1,5 @@
 // src/state/pages/add_table.rs
-use crate::state::pages::canvas_state::CanvasState;
+use canvas::canvas::{CanvasState, ActionContext, CanvasAction, AppMode};
 use ratatui::widgets::TableState;
 use serde::{Deserialize, Serialize};
 
@@ -63,11 +63,11 @@ pub struct AddTableState {
     pub column_name_cursor_pos: usize,
     pub column_type_cursor_pos: usize,
     pub has_unsaved_changes: bool,
+    pub app_mode: AppMode,
 }
 
 impl Default for AddTableState {
     fn default() -> Self {
-        // Initialize with some dummy data for demonstration
         AddTableState {
             profile_name: "default".to_string(),
             table_name: String::new(),
@@ -86,22 +86,98 @@ impl Default for AddTableState {
             column_name_cursor_pos: 0,
             column_type_cursor_pos: 0,
             has_unsaved_changes: false,
+            app_mode: AppMode::Edit,
         }
     }
 }
 
 impl AddTableState {
     pub const INPUT_FIELD_COUNT: usize = 3;
+
+    /// Helper method to add a column from current inputs
+    pub fn add_column_from_inputs(&mut self) -> Option<String> {
+        if self.column_name_input.trim().is_empty() || self.column_type_input.trim().is_empty() {
+            return Some("Both column name and type are required".to_string());
         }
 
-// Implement CanvasState for the input fields
+        // Check for duplicate column names
+        if self.columns.iter().any(|col| col.name == self.column_name_input.trim()) {
+            return Some("Column name already exists".to_string());
+        }
+
+        // Add the column
+        self.columns.push(ColumnDefinition {
+            name: self.column_name_input.trim().to_string(),
+            data_type: self.column_type_input.trim().to_string(),
+            selected: false,
+        });
+
+        // Clear inputs and reset focus to column name for next entry
+        self.column_name_input.clear();
+        self.column_type_input.clear();
+        self.column_name_cursor_pos = 0;
+        self.column_type_cursor_pos = 0;
+        self.current_focus = AddTableFocus::InputColumnName;
+        self.last_canvas_field = 1;
+        self.has_unsaved_changes = true;
+
+        Some(format!("Column '{}' added successfully", self.columns.last().unwrap().name))
+    }
+
+    /// Helper method to delete selected items
+    pub fn delete_selected_items(&mut self) -> Option<String> {
+        let mut deleted_items = Vec::new();
+
+        // Remove selected columns
+        let initial_column_count = self.columns.len();
+        self.columns.retain(|col| {
+            if col.selected {
+                deleted_items.push(format!("column '{}'", col.name));
+                false
+            } else {
+                true
+            }
+        });
+
+        // Remove selected indexes
+        let initial_index_count = self.indexes.len();
+        self.indexes.retain(|idx| {
+            if idx.selected {
+                deleted_items.push(format!("index '{}'", idx.name));
+                false
+            } else {
+                true
+            }
+        });
+
+        // Remove selected links
+        let initial_link_count = self.links.len();
+        self.links.retain(|link| {
+            if link.selected {
+                deleted_items.push(format!("link to '{}'", link.linked_table_name));
+                false
+            } else {
+                true
+            }
+        });
+
+        if deleted_items.is_empty() {
+            Some("No items selected for deletion".to_string())
+        } else {
+            self.has_unsaved_changes = true;
+            Some(format!("Deleted: {}", deleted_items.join(", ")))
+        }
+    }
+}
+
+// Implement external library's CanvasState for AddTableState
 impl CanvasState for AddTableState {
     fn current_field(&self) -> usize {
         match self.current_focus {
             AddTableFocus::InputTableName => 0,
             AddTableFocus::InputColumnName => 1,
             AddTableFocus::InputColumnType => 2,
-            // If focus is elsewhere, default to the first field for canvas rendering logic
+            // If focus is elsewhere, return the last canvas field used
             _ => self.last_canvas_field,
         }
     }
@@ -115,37 +191,6 @@ impl CanvasState for AddTableState {
         }
     }
 
-    fn has_unsaved_changes(&self) -> bool {
-        self.has_unsaved_changes
-    }
-
-    fn inputs(&self) -> Vec<&String> {
-        vec![&self.table_name_input, &self.column_name_input, &self.column_type_input]
-    }
-
-    fn get_current_input(&self) -> &str {
-        match self.current_focus {
-            AddTableFocus::InputTableName => &self.table_name_input,
-            AddTableFocus::InputColumnName => &self.column_name_input,
-            AddTableFocus::InputColumnType => &self.column_type_input,
-            _ => "", // Should not happen if called correctly
-        }
-    }
-
-    fn get_current_input_mut(&mut self) -> &mut String {
-        match self.current_focus {
-            AddTableFocus::InputTableName => &mut self.table_name_input,
-            AddTableFocus::InputColumnName => &mut self.column_name_input,
-            AddTableFocus::InputColumnType => &mut self.column_type_input,
-            _ => &mut self.table_name_input,
-        }
-    }
-
-    fn fields(&self) -> Vec<&str> {
-        // These must match the order used in render_add_table
-        vec!["Table name", "Name", "Type"]
-    }
-
     fn set_current_field(&mut self, index: usize) {
         // Update both current focus and last canvas field
         self.current_focus = match index {
@@ -174,17 +219,88 @@ impl CanvasState for AddTableState {
         }
     }
 
+    fn get_current_input(&self) -> &str {
+        match self.current_focus {
+            AddTableFocus::InputTableName => &self.table_name_input,
+            AddTableFocus::InputColumnName => &self.column_name_input,
+            AddTableFocus::InputColumnType => &self.column_type_input,
+            _ => "", // Should not happen if called correctly
+        }
+    }
+
+    fn get_current_input_mut(&mut self) -> &mut String {
+        match self.current_focus {
+            AddTableFocus::InputTableName => &mut self.table_name_input,
+            AddTableFocus::InputColumnName => &mut self.column_name_input,
+            AddTableFocus::InputColumnType => &mut self.column_type_input,
+            _ => &mut self.table_name_input, // Fallback
+        }
+    }
+
+    fn inputs(&self) -> Vec<&String> {
+        vec![&self.table_name_input, &self.column_name_input, &self.column_type_input]
+    }
+
+    fn fields(&self) -> Vec<&str> {
+        // These must match the order used in render_add_table
+        vec!["Table name", "Name", "Type"]
+    }
+
+    fn has_unsaved_changes(&self) -> bool {
+        self.has_unsaved_changes
+    }
+
     fn set_has_unsaved_changes(&mut self, changed: bool) {
         self.has_unsaved_changes = changed;
     }
 
-    // --- Autocomplete Support (Not needed for this form yet) ---
-    fn get_suggestions(&self) -> Option<&[String]> {
-        None
+    fn handle_feature_action(&mut self, action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+        match action {
+            // Handle adding column when user presses Enter on the Add button or uses specific action
+            CanvasAction::Custom(action_str) if action_str == "add_column" => {
+                self.add_column_from_inputs()
             }
 
-    fn get_selected_suggestion_index(&self) -> Option<usize> {
-        None
+            // Handle table saving
+            CanvasAction::Custom(action_str) if action_str == "save_table" => {
+                if self.table_name_input.trim().is_empty() {
+                    Some("Table name is required".to_string())
+                } else if self.columns.is_empty() {
+                    Some("At least one column is required".to_string())
+                } else {
+                    Some(format!("Saving table: {}", self.table_name_input))
                 }
             }
 
+            // Handle deleting selected items
+            CanvasAction::Custom(action_str) if action_str == "delete_selected" => {
+                self.delete_selected_items()
+            }
+
+            // Handle canceling (clear form)
+            CanvasAction::Custom(action_str) if action_str == "cancel" => {
+                // Reset to defaults but keep profile_name
+                let profile = self.profile_name.clone();
+                *self = Self::default();
+                self.profile_name = profile;
+                Some("Form cleared".to_string())
+            }
+
+            // Custom validation when moving between fields
+            CanvasAction::NextField => {
+                // When leaving table name field, update the table_name for display
+                if self.current_field() == 0 && !self.table_name_input.trim().is_empty() {
+                    self.table_name = self.table_name_input.trim().to_string();
+                }
+                None // Let canvas library handle the normal field movement
+            }
+
+            // Let canvas library handle everything else
+            _ => None,
+        }
+    }
+
+    fn current_mode(&self) -> AppMode {
+        self.app_mode
+    }
+}

client/src/state/pages/auth.rs

@@ -1,5 +1,6 @@
 // src/state/pages/auth.rs
-use crate::state::pages::canvas_state::CanvasState;
+use canvas::canvas::{CanvasState, ActionContext, CanvasAction, AppMode};
+use canvas::autocomplete::{AutocompleteCanvasState, AutocompleteState, SuggestionItem};
 use lazy_static::lazy_static;
 
 lazy_static! {
@@ -21,7 +22,6 @@ pub struct AuthState {
 }
 
 /// Represents the state of the Login form UI
-#[derive(Default)]
 pub struct LoginState {
     pub username: String,
     pub password: String,
@@ -30,10 +30,26 @@ pub struct LoginState {
     pub current_cursor_pos: usize,
     pub has_unsaved_changes: bool,
     pub login_request_pending: bool,
+    pub app_mode: AppMode,
+}
+
+impl Default for LoginState {
+    fn default() -> Self {
+        Self {
+            username: String::new(),
+            password: String::new(),
+            error_message: None,
+            current_field: 0,
+            current_cursor_pos: 0,
+            has_unsaved_changes: false,
+            login_request_pending: false,
+            app_mode: AppMode::Edit,
+        }
+    }
 }
 
 /// Represents the state of the Registration form UI
-#[derive(Default, Clone)]
+#[derive(Clone)]
 pub struct RegisterState {
     pub username: String,
     pub email: String,
@@ -44,42 +60,12 @@ pub struct RegisterState {
     pub current_field: usize,
     pub current_cursor_pos: usize,
     pub has_unsaved_changes: bool,
-    pub show_role_suggestions: bool,
-    pub role_suggestions: Vec<String>,
-    pub selected_suggestion_index: Option<usize>,
-    pub in_suggestion_mode: bool,
+    pub autocomplete: AutocompleteState<String>,
+    pub app_mode: AppMode,
 }
 
-impl AuthState {
-    /// Creates a new empty AuthState (unauthenticated)
-    pub fn new() -> Self {
-        Self {
-            auth_token: None,
-            user_id: None,
-            role: None,
-            decoded_username: None,
-        }
-    }
-}
-
-impl LoginState {
-    /// Creates a new empty LoginState
-    pub fn new() -> Self {
-        Self {
-            username: String::new(),
-            password: String::new(),
-            error_message: None,
-            current_field: 0,
-            current_cursor_pos: 0,
-            has_unsaved_changes: false,
-            login_request_pending: false,
-        }
-    }
-}
-
-impl RegisterState {
-    /// Creates a new empty RegisterState
-    pub fn new() -> Self {
+impl Default for RegisterState {
+    fn default() -> Self {
         Self {
             username: String::new(),
             email: String::new(),
@@ -90,45 +76,67 @@ impl RegisterState {
             current_field: 0,
             current_cursor_pos: 0,
             has_unsaved_changes: false,
-            show_role_suggestions: false,
-            role_suggestions: Vec::new(),
-            selected_suggestion_index: None,
-            in_suggestion_mode: false,
+            autocomplete: AutocompleteState::new(),
+            app_mode: AppMode::Edit,
+        }
     }
 }
 
-    /// Updates role suggestions based on current input
-    pub fn update_role_suggestions(&mut self) {
-        let current_input = self.role.to_lowercase();
-        self.role_suggestions = AVAILABLE_ROLES
+impl AuthState {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+impl LoginState {
+    pub fn new() -> Self {
+        Self {
+            app_mode: AppMode::Edit,
+            ..Default::default()
+        }
+    }
+}
+
+impl RegisterState {
+    pub fn new() -> Self {
+        let mut state = Self {
+            autocomplete: AutocompleteState::new(),
+            app_mode: AppMode::Edit,
+            ..Default::default()
+        };
+        
+        // Initialize autocomplete with role suggestions
+        let suggestions: Vec<SuggestionItem<String>> = AVAILABLE_ROLES
             .iter()
-            .filter(|role| role.to_lowercase().contains(&current_input))
-            .cloned()
+            .map(|role| SuggestionItem::simple(role.clone(), role.clone()))
             .collect();
-        self.show_role_suggestions = !self.role_suggestions.is_empty();
+        
+        // Set suggestions but keep inactive initially
+        state.autocomplete.set_suggestions(suggestions);
+        state.autocomplete.is_active = false; // Not active by default
+        
+        state
     }
 }
 
+// Implement external library's CanvasState for LoginState
 impl CanvasState for LoginState {
     fn current_field(&self) -> usize {
         self.current_field
     }
 
     fn current_cursor_pos(&self) -> usize {
-        let len = match self.current_field {
-            0 => self.username.len(),
-            1 => self.password.len(),
-            _ => 0,
-        };
-        self.current_cursor_pos.min(len)
+        self.current_cursor_pos
     }
 
-    fn has_unsaved_changes(&self) -> bool {
-        self.has_unsaved_changes
+    fn set_current_field(&mut self, index: usize) {
+        if index < 2 {
+            self.current_field = index;
+        }
     }
 
-    fn inputs(&self) -> Vec<&String> {
-        vec![&self.username, &self.password]
+    fn set_current_cursor_pos(&mut self, pos: usize) {
+        self.current_cursor_pos = pos;
     }
 
     fn get_current_input(&self) -> &str {
@@ -147,73 +155,65 @@ impl CanvasState for LoginState {
         }
     }
 
+    fn inputs(&self) -> Vec<&String> {
+        vec![&self.username, &self.password]
+    }
+
     fn fields(&self) -> Vec<&str> {
         vec!["Username/Email", "Password"]
     }
 
-    fn set_current_field(&mut self, index: usize) {
-        if index < 2 {
-            self.current_field = index;
-            let len = match self.current_field {
-                0 => self.username.len(),
-                1 => self.password.len(),
-                _ => 0,
-            };
-            self.current_cursor_pos = self.current_cursor_pos.min(len);
-        }
-    }
-
-    fn set_current_cursor_pos(&mut self, pos: usize) {
-        let len = match self.current_field {
-            0 => self.username.len(),
-            1 => self.password.len(),
-            _ => 0,
-        };
-        self.current_cursor_pos = pos.min(len);
-    }
-
-    fn set_has_unsaved_changes(&mut self, changed: bool) {
-        self.has_unsaved_changes = changed;
-    }
-
-    fn get_suggestions(&self) -> Option<&[String]> {
-        None
-    }
-
-    fn get_selected_suggestion_index(&self) -> Option<usize> {
-        None
-    }
-}
-
-impl CanvasState for RegisterState {
-    fn current_field(&self) -> usize {
-        self.current_field
-    }
-
-    fn current_cursor_pos(&self) -> usize {
-        let len = match self.current_field {
-            0 => self.username.len(),
-            1 => self.email.len(),
-            2 => self.password.len(),
-            3 => self.password_confirmation.len(),
-            4 => self.role.len(),
-            _ => 0,
-        };
-        self.current_cursor_pos.min(len)
-    }
-
     fn has_unsaved_changes(&self) -> bool {
         self.has_unsaved_changes
     }
 
-    fn inputs(&self) -> Vec<&String> {
-        vec![
-            &self.username,
-            &self.email,
-            &self.password,
-            &self.password_confirmation,
-            &self.role,
-        ]
+    fn set_has_unsaved_changes(&mut self, changed: bool) {
+        self.has_unsaved_changes = changed;
+    }
+
+    fn handle_feature_action(&mut self, action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+        match action {
+            CanvasAction::Custom(action_str) if action_str == "submit" => {
+                if !self.username.is_empty() && !self.password.is_empty() {
+                    Some(format!("Submitting login for: {}", self.username))
+                } else {
+                    Some("Please fill in all required fields".to_string())
+                }
+            }
+            _ => None,
+        }
+    }
+
+    fn current_mode(&self) -> AppMode {
+        self.app_mode
+    }
+}
+
+// Implement external library's CanvasState for RegisterState
+impl CanvasState for RegisterState {
+    fn current_field(&self) -> usize {
+        self.current_field
+    }
+
+    fn current_cursor_pos(&self) -> usize {
+        self.current_cursor_pos
+    }
+
+    fn set_current_field(&mut self, index: usize) {
+        if index < 5 {
+            self.current_field = index;
+            
+            // Auto-activate autocomplete when moving to role field (index 4)
+            if index == 4 && !self.autocomplete.is_active {
+                self.activate_autocomplete();
+            } else if index != 4 && self.autocomplete.is_active {
+                self.deactivate_autocomplete();
+            }
+        }
+    }
+
+    fn set_current_cursor_pos(&mut self, pos: usize) {
+        self.current_cursor_pos = pos;
     }
 
     fn get_current_input(&self) -> &str {
@@ -238,6 +238,16 @@ impl CanvasState for RegisterState {
         }
     }
 
+    fn inputs(&self) -> Vec<&String> {
+        vec![
+            &self.username,
+            &self.email,
+            &self.password,
+            &self.password_confirmation,
+            &self.role,
+        ]
+    }
+
     fn fields(&self) -> Vec<&str> {
         vec![
             "Username",
@@ -248,50 +258,103 @@ impl CanvasState for RegisterState {
         ]
     }
 
-    fn set_current_field(&mut self, index: usize) {
-        if index < 5 {
-            self.current_field = index;
-            let len = match self.current_field {
-                0 => self.username.len(),
-                1 => self.email.len(),
-                2 => self.password.len(),
-                3 => self.password_confirmation.len(),
-                4 => self.role.len(),
-                _ => 0,
-            };
-            self.current_cursor_pos = self.current_cursor_pos.min(len);
-        }
-    }
-
-    fn set_current_cursor_pos(&mut self, pos: usize) {
-        let len = match self.current_field {
-            0 => self.username.len(),
-            1 => self.email.len(),
-            2 => self.password.len(),
-            3 => self.password_confirmation.len(),
-            4 => self.role.len(),
-            _ => 0,
-        };
-        self.current_cursor_pos = pos.min(len);
+    fn has_unsaved_changes(&self) -> bool {
+        self.has_unsaved_changes
     }
 
     fn set_has_unsaved_changes(&mut self, changed: bool) {
         self.has_unsaved_changes = changed;
     }
 
-    fn get_suggestions(&self) -> Option<&[String]> {
-        if self.current_field == 4 && self.in_suggestion_mode && self.show_role_suggestions {
-            Some(&self.role_suggestions)
+    fn handle_feature_action(&mut self, action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+        match action {
+            CanvasAction::Custom(action_str) if action_str == "submit" => {
+                if !self.username.is_empty() {
+                    Some(format!("Submitting registration for: {}", self.username))
+                } else {
+                    Some("Username is required".to_string())
+                }
+            }
+            _ => None,
+        }
+    }
+
+    fn current_mode(&self) -> AppMode {
+        self.app_mode
+    }
+}
+
+// Add autocomplete support for RegisterState
+impl AutocompleteCanvasState for RegisterState {
+    type SuggestionData = String;
+
+    fn supports_autocomplete(&self, field_index: usize) -> bool {
+        field_index == 4 // Only role field supports autocomplete
+    }
+
+    fn autocomplete_state(&self) -> Option<&AutocompleteState<Self::SuggestionData>> {
+        Some(&self.autocomplete)
+    }
+
+    fn autocomplete_state_mut(&mut self) -> Option<&mut AutocompleteState<Self::SuggestionData>> {
+        Some(&mut self.autocomplete)
+    }
+
+    fn activate_autocomplete(&mut self) {
+        let current_field = self.current_field();
+        if self.supports_autocomplete(current_field) {
+            self.autocomplete.activate(current_field);
+            
+            // Re-filter suggestions based on current input
+            let current_input = self.role.to_lowercase();
+            let filtered_suggestions: Vec<SuggestionItem<String>> = AVAILABLE_ROLES
+                .iter()
+                .filter(|role| role.to_lowercase().contains(&current_input))
+                .map(|role| SuggestionItem::simple(role.clone(), role.clone()))
+                .collect();
+            
+            self.autocomplete.set_suggestions(filtered_suggestions);
+        }
+    }
+
+    fn deactivate_autocomplete(&mut self) {
+        self.autocomplete.deactivate();
+    }
+
+    fn is_autocomplete_active(&self) -> bool {
+        self.autocomplete.is_active
+    }
+
+    fn is_autocomplete_ready(&self) -> bool {
+        self.autocomplete.is_ready()
+    }
+
+    fn apply_autocomplete_selection(&mut self) -> Option<String> {
+        // First, get the data we need and clone it to avoid borrowing conflicts
+        let selection_info = self.autocomplete.get_selected().map(|selected| {
+            (selected.value_to_store.clone(), selected.display_text.clone())
+        });
+
+        // Now do the mutable operations
+        if let Some((value, display_text)) = selection_info {
+            self.role = value;
+            self.set_has_unsaved_changes(true);
+            self.deactivate_autocomplete();
+            Some(format!("Selected role: {}", display_text))
         } else {
             None
         }
     }
 
-    fn get_selected_suggestion_index(&self) -> Option<usize> {
-        if self.current_field == 4 && self.in_suggestion_mode && self.show_role_suggestions {
-            self.selected_suggestion_index
-        } else {
-            None
+    fn set_autocomplete_suggestions(&mut self, suggestions: Vec<SuggestionItem<Self::SuggestionData>>) {
+        if let Some(state) = self.autocomplete_state_mut() {
+            state.set_suggestions(suggestions);
+        }
+    }
+
+    fn set_autocomplete_loading(&mut self, loading: bool) {
+        if let Some(state) = self.autocomplete_state_mut() {
+            state.is_loading = loading;
         }
     }
 }

client/src/state/pages/canvas_state.rs

@@ -1,20 +0,0 @@
-// src/state/canvas_state.rs
-
-
-pub trait CanvasState {
-    fn current_field(&self) -> usize;
-    fn current_cursor_pos(&self) -> usize;
-    fn has_unsaved_changes(&self) -> bool;
-    fn inputs(&self) -> Vec<&String>;
-    fn get_current_input(&self) -> &str;
-    fn get_current_input_mut(&mut self) -> &mut String;
-    fn fields(&self) -> Vec<&str>;
-
-    fn set_current_field(&mut self, index: usize);
-    fn set_current_cursor_pos(&mut self, pos: usize);
-    fn set_has_unsaved_changes(&mut self, changed: bool);
-
-    // --- Autocomplete Support ---
-    fn get_suggestions(&self) -> Option<&[String]>;
-    fn get_selected_suggestion_index(&self) -> Option<usize>;
-}

client/src/state/pages/form.rs

@@ -1,49 +1,118 @@
 // src/state/pages/form.rs
 
-use std::collections::HashMap; // NEW
 use crate::config::colors::themes::Theme;
+use canvas::canvas::{CanvasState, CanvasAction, ActionContext, HighlightState, AppMode};
+use common::proto::komp_ac::search::search_response::Hit;
 use ratatui::layout::Rect;
 use ratatui::Frame;
-use crate::state::app::highlight::HighlightState;
-use crate::state::pages::canvas_state::CanvasState;
+use std::collections::HashMap;
 
+fn json_value_to_string(value: &serde_json::Value) -> String {
+    match value {
+        serde_json::Value::String(s) => s.clone(),
+        serde_json::Value::Number(n) => n.to_string(),
+        serde_json::Value::Bool(b) => b.to_string(),
+        _ => String::new(),
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct FieldDefinition {
+    pub display_name: String,
+    pub data_key: String,
+    pub is_link: bool,
+    pub link_target_table: Option<String>,
+}
+
+#[derive(Clone)]
 pub struct FormState {
     pub id: i64,
-    // NEW fields for dynamic table context
     pub profile_name: String,
     pub table_name: String,
     pub total_count: u64,
-    pub current_position: u64, // 1-based index, 0 or total_count + 1 for new entry
-
-    pub fields: Vec<String>, // Already dynamic, which is good
+    pub current_position: u64,
+    pub fields: Vec<FieldDefinition>,
     pub values: Vec<String>,
     pub current_field: usize,
     pub has_unsaved_changes: bool,
     pub current_cursor_pos: usize,
+    pub autocomplete_active: bool,
+    pub autocomplete_suggestions: Vec<Hit>,
+    pub selected_suggestion_index: Option<usize>,
+    pub autocomplete_loading: bool,
+    pub link_display_map: HashMap<usize, String>,
+    pub app_mode: AppMode,
 }
 
 impl FormState {
-    /// Creates a new, empty FormState for a given table.
-    /// The position defaults to 1, representing either the first record
-    /// or the position for a new entry if the table is empty.
+    // Add this method
+    pub fn deactivate_autocomplete(&mut self) {
+        self.autocomplete_active = false;
+        self.autocomplete_suggestions.clear();
+        self.selected_suggestion_index = None;
+        self.autocomplete_loading = false;
+    }
+
     pub fn new(
         profile_name: String,
         table_name: String,
-        fields: Vec<String>,
+        fields: Vec<FieldDefinition>,
     ) -> Self {
         let values = vec![String::new(); fields.len()];
         FormState {
-            id: 0, // Default to 0, indicating a new or unloaded record
+            id: 0,
             profile_name,
             table_name,
-            total_count: 0, // Will be fetched after initialization
-            // FIX: Default to 1. A position of 0 is an invalid state.
+            total_count: 0,
             current_position: 1,
             fields,
             values,
             current_field: 0,
             has_unsaved_changes: false,
             current_cursor_pos: 0,
+            autocomplete_active: false,
+            autocomplete_suggestions: Vec::new(),
+            selected_suggestion_index: None,
+            autocomplete_loading: false,
+            link_display_map: HashMap::new(),
+            app_mode: AppMode::Edit,
+        }
+    }
+
+    pub fn get_display_name_for_hit(&self, hit: &Hit) -> String {
+        if let Ok(content_map) =
+            serde_json::from_str::<HashMap<String, serde_json::Value>>(
+                &hit.content_json,
+            )
+        {
+            const IGNORED_KEYS: &[&str] = &["id", "deleted", "created_at"];
+            let mut keys: Vec<_> = content_map
+                .keys()
+                .filter(|k| !IGNORED_KEYS.contains(&k.as_str()))
+                .cloned()
+                .collect();
+            keys.sort();
+
+            let values: Vec<_> = keys
+                .iter()
+                .map(|key| {
+                    content_map
+                        .get(key)
+                        .map(json_value_to_string)
+                        .unwrap_or_default()
+                })
+                .filter(|s| !s.is_empty())
+                .take(1)
+                .collect();
+
+            let display_part = values.first().cloned().unwrap_or_default();
+            if display_part.is_empty() {
+                format!("ID: {}", hit.id)
+            } else {
+                format!("{} | ID: {}", display_part, hit.id)
+            }
+        } else {
+            format!("ID: {} (parse error)", hit.id)
         }
     }
 
@@ -53,16 +122,16 @@ impl FormState {
         area: Rect,
         theme: &Theme,
         is_edit_mode: bool,
-        highlight_state: &HighlightState,
+        highlight_state: &HighlightState, // Now using canvas::HighlightState
     ) {
         let fields_str_slice: Vec<&str> =
-            self.fields.iter().map(|s| s.as_str()).collect();
+            self.fields().iter().map(|s| *s).collect();
         let values_str_slice: Vec<&String> = self.values.iter().collect();
 
         crate::components::form::form::render_form(
             f,
             area,
-            self, // Pass self as CanvasState
+            self,
             &fields_str_slice,
             &self.current_field,
             &values_str_slice,
@@ -75,20 +144,19 @@ impl FormState {
         );
     }
 
-    /// Resets the form to a state for creating a new entry.
-    /// It clears all values and sets the position to be one after the last record.
     pub fn reset_to_empty(&mut self) {
         self.id = 0;
         self.values.iter_mut().for_each(|v| v.clear());
         self.current_field = 0;
         self.current_cursor_pos = 0;
         self.has_unsaved_changes = false;
-        // Set the position for a new entry.
         if self.total_count > 0 {
             self.current_position = self.total_count + 1;
         } else {
-            self.current_position = 1; // If table is empty, new record is at position 1
+            self.current_position = 1;
         }
+        self.deactivate_autocomplete();
+        self.link_display_map.clear();
     }
 
     pub fn get_current_input(&self) -> &str {
@@ -99,31 +167,28 @@ impl FormState {
     }
 
     pub fn get_current_input_mut(&mut self) -> &mut String {
+        self.link_display_map.remove(&self.current_field);
         self.values
             .get_mut(self.current_field)
             .expect("Invalid current_field index")
     }
 
-    /// Updates the form's values from a data response and sets its position.
-    /// This is the single source of truth for populating the form after a data fetch.
     pub fn update_from_response(
         &mut self,
         response_data: &HashMap<String, String>,
-        // FIX: Add new_position to make this method authoritative.
         new_position: u64,
     ) {
-        // Create a new vector for the values, ensuring they are in the correct order.
-        self.values = self.fields.iter().map(|field_from_schema| {
-            // For each field from our schema, find the corresponding key in the
-            // response data by doing a case-insensitive comparison.
-            response_data
+        self.values = self
+            .fields
             .iter()
-                .find(|(key_from_data, _)| key_from_data.eq_ignore_ascii_case(field_from_schema))
-                .map(|(_, value)| value.clone()) // If found, clone its value.
-                .unwrap_or_default() // If not found, use an empty string.
-        }).collect();
+            .map(|field_def| {
+                response_data
+                    .get(&field_def.data_key)
+                    .cloned()
+                    .unwrap_or_default()
+            })
+            .collect();
 
-        // Now, do the same case-insensitive lookup for the 'id' field.
         let id_str_opt = response_data
             .iter()
             .find(|(k, _)| k.eq_ignore_ascii_case("id"))
@@ -133,18 +198,49 @@ impl FormState {
             if let Ok(parsed_id) = id_str.parse::<i64>() {
                 self.id = parsed_id;
             } else {
-                tracing::error!( "Failed to parse 'id' field '{}' for table {}.{}", id_str, self.profile_name, self.table_name);
+                tracing::error!(
+                    "Failed to parse 'id' field '{}' for table {}.{}",
+                    id_str,
+                    self.profile_name,
+                    self.table_name
+                );
                 self.id = 0;
             }
         } else {
             self.id = 0;
         }
 
-        // FIX: Set the position from the provided parameter.
         self.current_position = new_position;
         self.has_unsaved_changes = false;
         self.current_field = 0;
         self.current_cursor_pos = 0;
+        self.deactivate_autocomplete();
+        self.link_display_map.clear();
+    }
+
+    // NEW: Keep the rich suggestions methods for compatibility
+    pub fn get_rich_suggestions(&self) -> Option<&[Hit]> {
+        if self.autocomplete_active {
+            Some(&self.autocomplete_suggestions)
+        } else {
+            None
+        }
+    }
+
+    pub fn activate_rich_suggestions(&mut self, suggestions: Vec<Hit>) {
+        self.autocomplete_suggestions = suggestions;
+        self.autocomplete_active = !self.autocomplete_suggestions.is_empty();
+        self.selected_suggestion_index = if self.autocomplete_active { Some(0) } else { None };
+        self.autocomplete_loading = false;
+    }
+
+    // NEW: Add these methods to change modes
+    pub fn set_edit_mode(&mut self) {
+        self.app_mode = AppMode::Edit;
+    }
+
+    pub fn set_readonly_mode(&mut self) {
+        self.app_mode = AppMode::ReadOnly;
     }
 }
 
@@ -166,23 +262,25 @@ impl CanvasState for FormState {
     }
 
     fn get_current_input(&self) -> &str {
-        // Re-use the struct's own method
         FormState::get_current_input(self)
     }
 
     fn get_current_input_mut(&mut self) -> &mut String {
-        // Re-use the struct's own method
         FormState::get_current_input_mut(self)
     }
 
     fn fields(&self) -> Vec<&str> {
-        self.fields.iter().map(|s| s.as_str()).collect()
+        self.fields
+            .iter()
+            .map(|f| f.display_name.as_str())
+            .collect()
     }
 
     fn set_current_field(&mut self, index: usize) {
         if index < self.fields.len() {
             self.current_field = index;
         }
+        self.deactivate_autocomplete();
     }
 
     fn set_current_cursor_pos(&mut self, pos: usize) {
@@ -193,11 +291,48 @@ impl CanvasState for FormState {
         self.has_unsaved_changes = changed;
     }
 
-    fn get_suggestions(&self) -> Option<&[String]> {
+    // --- FEATURE-SPECIFIC ACTION HANDLING ---
+    fn handle_feature_action(&mut self, action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+        match action {
+            CanvasAction::SelectSuggestion => {
+                if let Some(selected_idx) = self.selected_suggestion_index {
+                    if let Some(hit) = self.autocomplete_suggestions.get(selected_idx).cloned() {
+                        // Extract the value from the selected suggestion
+                        if let Ok(content_map) = serde_json::from_str::<HashMap<String, serde_json::Value>>(&hit.content_json) {
+                            let current_field_def = &self.fields[self.current_field];
+                            if let Some(value) = content_map.get(&current_field_def.data_key) {
+                                let new_value = json_value_to_string(value);
+                                let display_name = self.get_display_name_for_hit(&hit);
+                                *self.get_current_input_mut() = new_value.clone();
+                                self.set_current_cursor_pos(new_value.len());
+                                self.set_has_unsaved_changes(true);
+                                self.deactivate_autocomplete();
+                                return Some(format!("Selected: {}", display_name));
+                            }
+                        }
+                    }
+                }
                 None
             }
+            _ => None, // Let canvas handle other actions
+        }
+    }
 
-    fn get_selected_suggestion_index(&self) -> Option<usize> {
-        None
+    fn get_display_value_for_field(&self, index: usize) -> &str {
+        if let Some(display_text) = self.link_display_map.get(&index) {
+            return display_text.as_str();
+        }
+        self.inputs()
+            .get(index)
+            .map(|s| s.as_str())
+            .unwrap_or("")
+    }
+
+    fn has_display_override(&self, index: usize) -> bool {
+        self.link_display_map.contains_key(&index)
+    }
+
+    fn current_mode(&self) -> AppMode {
+        self.app_mode
     }
 }

client/src/tui/functions/common/add_table.rs

@@ -4,7 +4,7 @@ use crate::state::pages::add_table::{
 };
 use crate::services::GrpcClient;
 use anyhow::{anyhow, Result};
-use common::proto::multieko2::table_definition::{
+use common::proto::komp_ac::table_definition::{
     PostTableDefinitionRequest,
     ColumnDefinition as ProtoColumnDefinition,
     TableLink as ProtoTableLink,

client/src/tui/functions/common/form.rs

@@ -1,19 +1,22 @@
 // src/tui/functions/common/form.rs
 
 use crate::services::grpc_client::GrpcClient;
+use crate::state::app::state::AppState; // NEW: Import AppState
 use crate::state::pages::form::FormState;
-use anyhow::{Context, Result}; // Added Context
-use std::collections::HashMap; // NEW
+use crate::utils::data_converter; // NEW: Import our translator
+use anyhow::{anyhow, Context, Result};
+use std::collections::HashMap;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum SaveOutcome {
     NoChange,
     UpdatedExisting,
-    CreatedNew(i64), // Keep the ID
+    CreatedNew(i64),
 }
 
-// MODIFIED save function
+// MODIFIED save function signature and logic
 pub async fn save(
+    app_state: &AppState, // NEW: Pass in AppState
     form_state: &mut FormState,
     grpc_client: &mut GrpcClient,
 ) -> Result<SaveOutcome> {
@@ -21,42 +24,64 @@ pub async fn save(
         return Ok(SaveOutcome::NoChange);
     }
 
-    let data_map: HashMap<String, String> = form_state.fields.iter()
+    // --- NEW: VALIDATION & CONVERSION STEP ---
+    let cache_key =
+        format!("{}.{}", form_state.profile_name, form_state.table_name);
+    let schema = match app_state.schema_cache.get(&cache_key) {
+        Some(s) => s,
+        None => {
+            return Err(anyhow!(
+                "Schema for table '{}' not found in cache. Cannot save.",
+                form_state.table_name
+            ));
+        }
+    };
+
+    let data_map: HashMap<String, String> = form_state
+        .fields
+        .iter()
         .zip(form_state.values.iter())
-        .map(|(field, value)| (field.clone(), value.clone()))
+        .map(|(field_def, value)| (field_def.data_key.clone(), value.clone()))
         .collect();
 
+    // Use our new translator. It returns a user-friendly error on failure.
+    let converted_data =
+        match data_converter::convert_and_validate_data(&data_map, schema) {
+            Ok(data) => data,
+            Err(user_error) => return Err(anyhow!(user_error)),
+        };
+    // --- END OF NEW STEP ---
+
     let outcome: SaveOutcome;
-
-    let is_new_entry = form_state.id == 0 || (form_state.total_count > 0 && form_state.current_position > form_state.total_count) || (form_state.total_count == 0 && form_state.current_position == 1) ;
-
+    let is_new_entry = form_state.id == 0
+        || (form_state.total_count > 0
+            && form_state.current_position > form_state.total_count)
+        || (form_state.total_count == 0 && form_state.current_position == 1);
 
     if is_new_entry {
         let response = grpc_client
             .post_table_data(
                 form_state.profile_name.clone(),
                 form_state.table_name.clone(),
-                data_map,
+                converted_data, // Use the validated & converted data
             )
             .await
             .context("Failed to post new table data")?;
 
         if response.success {
             form_state.id = response.inserted_id;
-            // After creating a new entry, total_count increases, and current_position becomes this new total_count
             form_state.total_count += 1;
             form_state.current_position = form_state.total_count;
             outcome = SaveOutcome::CreatedNew(response.inserted_id);
         } else {
-            return Err(anyhow::anyhow!(
+            return Err(anyhow!(
                 "Server failed to insert data: {}",
                 response.message
             ));
         }
     } else {
-        // This assumes form_state.id is valid for an existing record
         if form_state.id == 0 {
-            return Err(anyhow::anyhow!(
+            return Err(anyhow!(
                 "Cannot update record: ID is 0, but not classified as new entry."
             ));
         }
@@ -65,7 +90,7 @@ pub async fn save(
                 form_state.profile_name.clone(),
                 form_state.table_name.clone(),
                 form_state.id,
-                data_map,
+                converted_data, // Use the validated & converted data
             )
             .await
             .context("Failed to put (update) table data")?;
@@ -73,7 +98,7 @@ pub async fn save(
         if response.success {
             outcome = SaveOutcome::UpdatedExisting;
         } else {
-            return Err(anyhow::anyhow!(
+            return Err(anyhow!(
                 "Server failed to update data: {}",
                 response.message
             ));

client/src/tui/functions/common/login.rs

@@ -6,9 +6,9 @@ use crate::state::pages::auth::LoginState;
 use crate::state::app::state::AppState;
 use crate::state::app::buffer::{AppView, BufferState};
 use crate::config::storage::storage::{StoredAuthData, save_auth_data};
-use crate::state::pages::canvas_state::CanvasState;
 use crate::ui::handlers::context::DialogPurpose;
-use common::proto::multieko2::auth::LoginResponse;
+use common::proto::komp_ac::auth::LoginResponse;
+use canvas::canvas::CanvasState;
 use anyhow::{Context, Result};
 use tokio::spawn;
 use tokio::sync::mpsc;

client/src/tui/functions/common/register.rs

@@ -4,11 +4,11 @@ use crate::services::auth::AuthClient;
 use crate::state::{
     pages::auth::RegisterState,
     app::state::AppState,
-    pages::canvas_state::CanvasState,
 };
 use crate::ui::handlers::context::DialogPurpose;
 use crate::state::app::buffer::{AppView, BufferState};
-use common::proto::multieko2::auth::AuthResponse;
+use common::proto::komp_ac::auth::AuthResponse;
+use canvas::canvas::CanvasState;
 use anyhow::Context;
 use tokio::spawn;
 use tokio::sync::mpsc;

client/src/tui/functions/form.rs

@@ -1,7 +1,7 @@
 // src/tui/functions/form.rs
-use crate::state::pages::canvas_state::CanvasState;
 use crate::state::pages::form::FormState;
 use crate::services::grpc_client::GrpcClient;
+use canvas::canvas::CanvasState;
 use anyhow::{anyhow, Result};
 
 pub async fn handle_action(

client/src/ui/handlers/render.rs

@@ -1,34 +1,45 @@
-// client/src/ui/handlers/render.rs
+// src/ui/handlers/render.rs
 
 use crate::components::{
+    admin::add_logic::render_add_logic,
+    admin::render_add_table,
+    auth::{login::render_login, register::render_register},
+    common::dialog::render_dialog,
+    common::find_file_palette,
+    common::search_palette::render_search_palette,
+    handlers::sidebar::{self, calculate_sidebar_layout},
+    intro::intro::render_intro,
     render_background,
     render_buffer_list,
     render_command_line,
     render_status_line,
-    intro::intro::render_intro,
-    handlers::sidebar::{self, calculate_sidebar_layout},
-    form::form::render_form,
-    admin::render_add_table,
-    admin::add_logic::render_add_logic,
-    auth::{login::render_login, register::render_register},
-    common::find_file_palette,
 };
 use crate::config::colors::themes::Theme;
+use crate::modes::general::command_navigation::NavigationState;
+use canvas::canvas::CanvasState;
+use crate::state::app::buffer::BufferState;
+use crate::state::app::highlight::HighlightState as LocalHighlightState;
+use canvas::canvas::HighlightState as CanvasHighlightState;
+use crate::state::app::state::AppState;
+use crate::state::pages::admin::AdminState;
+use crate::state::pages::auth::AuthState;
+use crate::state::pages::auth::LoginState;
+use crate::state::pages::auth::RegisterState;
+use crate::state::pages::form::FormState;
+use crate::state::pages::intro::IntroState;
 use ratatui::{
     layout::{Constraint, Direction, Layout},
     Frame,
 };
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::pages::form::FormState;
-use crate::state::pages::auth::AuthState;
-use crate::state::pages::auth::LoginState;
-use crate::state::pages::auth::RegisterState;
-use crate::state::pages::intro::IntroState;
-use crate::state::app::buffer::BufferState;
-use crate::state::app::state::AppState;
-use crate::state::pages::admin::AdminState;
-use crate::state::app::highlight::HighlightState;
-use crate::modes::general::command_navigation::NavigationState;
+
+// Helper function to convert between HighlightState types
+fn convert_highlight_state(local: &LocalHighlightState) -> CanvasHighlightState {
+    match local {
+        LocalHighlightState::Off => CanvasHighlightState::Off,
+        LocalHighlightState::Characterwise { anchor } => CanvasHighlightState::Characterwise { anchor: *anchor },
+        LocalHighlightState::Linewise { anchor_line } => CanvasHighlightState::Linewise { anchor_line: *anchor_line },
+    }
+}
 
 #[allow(clippy::too_many_arguments)]
 pub fn render_ui(
@@ -42,7 +53,7 @@ pub fn render_ui(
     buffer_state: &BufferState,
     theme: &Theme,
     is_event_handler_edit_mode: bool,
-    highlight_state: &HighlightState,
+    highlight_state: &LocalHighlightState, // Keep using local version
     event_handler_command_input: &str,
     event_handler_command_mode_active: bool,
     event_handler_command_message: &str,
@@ -53,16 +64,27 @@ pub fn render_ui(
 ) {
     render_background(f, f.area(), theme);
 
+    // --- START DYNAMIC LAYOUT LOGIC ---
+    let mut status_line_height = 1;
+    #[cfg(feature = "ui-debug")]
+    {
+        if let Some(debug_state) = &app_state.debug_state {
+            if debug_state.is_error {
+                status_line_height = 4;
+            }
+        }
+    }
+    // --- END DYNAMIC LAYOUT LOGIC ---
+
     const PALETTE_OPTIONS_HEIGHT_FOR_LAYOUT: u16 = 15;
 
-    let mut bottom_area_constraints: Vec<Constraint> = vec![Constraint::Length(1)];
-
+    let mut bottom_area_constraints: Vec<Constraint> = vec![Constraint::Length(status_line_height)];
     let command_palette_area_height = if navigation_state.active {
         1 + PALETTE_OPTIONS_HEIGHT_FOR_LAYOUT
     } else if event_handler_command_mode_active {
         1
     } else {
-        0 // Neither is active
+        0
     };
 
     if command_palette_area_height > 0 {
@@ -75,7 +97,6 @@ pub fn render_ui(
     }
     main_layout_constraints.extend(bottom_area_constraints);
 
-
     let root_chunks = Layout::default()
         .direction(Direction::Vertical)
         .constraints(main_layout_constraints)
@@ -106,77 +127,97 @@ pub fn render_ui(
         None
     };
 
-
     if app_state.ui.show_intro {
         render_intro(f, intro_state, main_content_area, theme);
     } else if app_state.ui.show_register {
         render_register(
-            f, main_content_area, theme, register_state, app_state,
-            register_state.current_field() < 4,
-            highlight_state,
+            f,
+            main_content_area,
+            theme,
+            register_state,
+            app_state,
+            register_state.current_field() < 4, // Now using CanvasState trait method
+            highlight_state, // Uses local version
         );
     } else if app_state.ui.show_add_table {
         render_add_table(
-            f, main_content_area, theme, app_state, &mut admin_state.add_table_state,
+            f,
+            main_content_area,
+            theme,
+            app_state,
+            &mut admin_state.add_table_state,
             is_event_handler_edit_mode,
-            highlight_state,
+            highlight_state, // Uses local version
         );
     } else if app_state.ui.show_add_logic {
         render_add_logic(
-            f, main_content_area, theme, app_state, &mut admin_state.add_logic_state,
-            is_event_handler_edit_mode, highlight_state,
+            f,
+            main_content_area,
+            theme,
+            app_state,
+            &mut admin_state.add_logic_state,
+            is_event_handler_edit_mode,
+            highlight_state, // Uses local version
         );
     } else if app_state.ui.show_login {
         render_login(
-            f, main_content_area, theme, login_state, app_state,
-            login_state.current_field() < 2,
-            highlight_state,
+            f,
+            main_content_area,
+            theme,
+            login_state,
+            app_state,
+            login_state.current_field() < 2, // Now using CanvasState trait method
+            highlight_state, // Uses local version
         );
     } else if app_state.ui.show_admin {
         crate::components::admin::admin_panel::render_admin_panel(
-            f, app_state, auth_state, admin_state, main_content_area, theme,
-            &app_state.profile_tree, &app_state.selected_profile,
+            f,
+            app_state,
+            auth_state,
+            admin_state,
+            main_content_area,
+            theme,
+            &app_state.profile_tree,
+            &app_state.selected_profile,
         );
-
     } else if app_state.ui.show_form {
-        let (sidebar_area, form_actual_area) = calculate_sidebar_layout(
-            app_state.ui.show_sidebar, main_content_area
-        );
+        let (sidebar_area, form_actual_area) =
+            calculate_sidebar_layout(app_state.ui.show_sidebar, main_content_area);
         if let Some(sidebar_rect) = sidebar_area {
             sidebar::render_sidebar(
-                f, sidebar_rect, theme, &app_state.profile_tree, &app_state.selected_profile
+                f,
+                sidebar_rect,
+                theme,
+                &app_state.profile_tree,
+                &app_state.selected_profile,
             );
         }
         let available_width = form_actual_area.width;
         let form_render_area = if available_width >= 80 {
-            Layout::default().direction(Direction::Horizontal)
+            Layout::default()
+                .direction(Direction::Horizontal)
                 .constraints([Constraint::Min(0), Constraint::Length(80), Constraint::Min(0)])
                 .split(form_actual_area)[1]
         } else {
-            Layout::default().direction(Direction::Horizontal)
-                .constraints([Constraint::Min(0), Constraint::Length(available_width), Constraint::Min(0)])
+            Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([
+                    Constraint::Min(0),
+                    Constraint::Length(available_width),
+                    Constraint::Min(0),
+                ])
                 .split(form_actual_area)[1]
         };
-        let fields_vec: Vec<&str> = form_state.fields.iter().map(AsRef::as_ref).collect();
-        let values_vec: Vec<&String> = form_state.values.iter().collect();
 
-        // --- START FIX ---
-        // Add the missing `&form_state.table_name` argument to this function call.
-        render_form(
+        // CHANGED: Convert local HighlightState to canvas HighlightState for FormState
+        let canvas_highlight_state = convert_highlight_state(highlight_state);
+        form_state.render(
             f,
             form_render_area,
-            form_state,
-            &fields_vec,
-            &form_state.current_field,
-            &values_vec,
-            &form_state.table_name, // <-- THIS ARGUMENT WAS MISSING
             theme,
             is_event_handler_edit_mode,
-            highlight_state,
-            form_state.total_count,
-            form_state.current_position,
+            &canvas_highlight_state, // Use converted version
         );
-        // --- END FIX ---
     }
 
     if let Some(area) = buffer_list_area {
@@ -193,23 +234,41 @@ pub fn render_ui(
         app_state,
     );
 
-    if let Some(palette_or_command_area) = command_render_area { // Use the calculated area
+    if let Some(palette_or_command_area) = command_render_area {
         if navigation_state.active {
             find_file_palette::render_find_file_palette(
                 f,
-                palette_or_command_area, // Use the correct area
+                palette_or_command_area,
                 theme,
-                navigation_state, // Pass the navigation_state directly
+                navigation_state,
             );
         } else if event_handler_command_mode_active {
             render_command_line(
                 f,
-                palette_or_command_area, // Use the correct area
+                palette_or_command_area,
                 event_handler_command_input,
-                true, // Assuming it's always active when this branch is hit
+                true,
                 theme,
                 event_handler_command_message,
             );
         }
     }
+
+    // This block now correctly handles drawing popups over any view.
+    if app_state.ui.show_search_palette {
+        if let Some(search_state) = &app_state.search_state {
+            render_search_palette(f, f.area(), theme, search_state);
+        }
+    } else if app_state.ui.dialog.dialog_show {
+        render_dialog(
+            f,
+            f.area(),
+            theme,
+            &app_state.ui.dialog.dialog_title,
+            &app_state.ui.dialog.dialog_message,
+            &app_state.ui.dialog.dialog_buttons,
+            app_state.ui.dialog.dialog_active_button_index,
+            app_state.ui.dialog.is_loading,
+        );
+    }
 }

client/src/ui/handlers/ui.rs

@@ -8,8 +8,8 @@ use crate::config::storage::storage::load_auth_data;
 use crate::modes::common::commands::CommandHandler;
 use crate::modes::handlers::event::{EventHandler, EventOutcome};
 use crate::modes::handlers::mode_manager::{AppMode, ModeManager};
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::pages::form::FormState;
+use canvas::canvas::CanvasState; // Only external library import
+use crate::state::pages::form::{FormState, FieldDefinition};
 use crate::state::pages::auth::AuthState;
 use crate::state::pages::auth::LoginState;
 use crate::state::pages::auth::RegisterState;
@@ -27,13 +27,18 @@ use crate::ui::handlers::context::DialogPurpose;
 use crate::tui::functions::common::login;
 use crate::tui::functions::common::register;
 use crate::utils::columns::filter_user_columns;
-use std::time::Instant;
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result};
 use crossterm::cursor::SetCursorStyle;
 use crossterm::event as crossterm_event;
 use tracing::{error, info, warn};
 use tokio::sync::mpsc;
+use std::time::{Instant, Duration};
+#[cfg(feature = "ui-debug")]
+use crate::state::app::state::DebugState;
+#[cfg(feature = "ui-debug")]
+use crate::utils::debug_logger::pop_next_debug_message;
 
+// Rest of the file remains the same...
 pub async fn run_ui() -> Result<()> {
     let config = Config::load().context("Failed to load configuration")?;
     let theme = Theme::from_str(&config.colors.theme);
@@ -51,6 +56,7 @@ pub async fn run_ui() -> Result<()> {
         register_result_sender.clone(),
         save_table_result_sender.clone(),
         save_logic_result_sender.clone(),
+        grpc_client.clone(),
     )
     .await
     .context("Failed to create event handler")?;
@@ -87,12 +93,20 @@ pub async fn run_ui() -> Result<()> {
             .await
             .context("Failed to initialize app state and form")?;
 
-    let filtered_columns = filter_user_columns(initial_columns_from_service);
+    let initial_field_defs: Vec<FieldDefinition> = filter_user_columns(initial_columns_from_service)
+        .into_iter()
+        .map(|col_name| FieldDefinition {
+            display_name: col_name.clone(),
+            data_key: col_name,
+            is_link: false,
+            link_target_table: None,
+        })
+        .collect();
 
     let mut form_state = FormState::new(
         initial_profile.clone(),
         initial_table.clone(),
-        filtered_columns,
+        initial_field_defs,
     );
 
     UiService::fetch_and_set_table_count(&mut grpc_client, &mut form_state)
@@ -126,6 +140,51 @@ pub async fn run_ui() -> Result<()> {
     loop {
         let position_before_event = form_state.current_position;
         let mut event_processed = false;
+
+        // --- CHANNEL RECEIVERS ---
+
+        // For main search palette
+        match event_handler.search_result_receiver.try_recv() {
+            Ok(hits) => {
+                info!("--- 4. Main loop received message from channel. ---");
+                if let Some(search_state) = app_state.search_state.as_mut() {
+                    search_state.results = hits;
+                    search_state.is_loading = false;
+                }
+                needs_redraw = true;
+            }
+            Err(mpsc::error::TryRecvError::Empty) => {
+            }
+            Err(mpsc::error::TryRecvError::Disconnected) => {
+                error!("Search result channel disconnected!");
+            }
+        }
+
+        // --- ADDED: For live form autocomplete ---
+        match event_handler.autocomplete_result_receiver.try_recv() {
+            Ok(hits) => {
+                if form_state.autocomplete_active {
+                    form_state.autocomplete_suggestions = hits;
+                    form_state.autocomplete_loading = false;
+                    if !form_state.autocomplete_suggestions.is_empty() {
+                        form_state.selected_suggestion_index = Some(0);
+                    } else {
+                        form_state.selected_suggestion_index = None;
+                    }
+                    event_handler.command_message = format!("Found {} suggestions.", form_state.autocomplete_suggestions.len());
+                }
+                needs_redraw = true;
+            }
+            Err(mpsc::error::TryRecvError::Empty) => {}
+            Err(mpsc::error::TryRecvError::Disconnected) => {
+                error!("Autocomplete result channel disconnected!");
+            }
+        }
+
+
+        if app_state.ui.show_search_palette {
+            needs_redraw = true;
+        }
         if crossterm_event::poll(std::time::Duration::from_millis(1))? {
             let event = event_reader.read_event().context("Failed to read terminal event")?;
             event_processed = true;
@@ -133,7 +192,6 @@ pub async fn run_ui() -> Result<()> {
                 event,
                 &config,
                 &mut terminal,
-                &mut grpc_client,
                 &mut command_handler,
                 &mut form_state,
                 &mut auth_state,
@@ -289,6 +347,9 @@ pub async fn run_ui() -> Result<()> {
             }
         }
 
+        // Continue with the rest of the function...
+        // (The rest remains the same, but now CanvasState trait methods are available)
+        
         if app_state.ui.show_form {
             let current_view_profile = app_state.current_view_profile_name.clone();
             let current_view_table = app_state.current_view_table_name.clone();
@@ -305,27 +366,18 @@ pub async fn run_ui() -> Result<()> {
                     );
                     needs_redraw = true;
 
-                    match grpc_client
-                        .get_table_structure(prof_name.clone(), tbl_name.clone())
+                    match UiService::load_table_view(
+                        &mut grpc_client,
+                        &mut app_state,
+                        prof_name,
+                        tbl_name,
+                    )
                     .await
                     {
-                        Ok(structure_response) => {
-                            let new_columns: Vec<String> = structure_response
-                                .columns
-                                .iter()
-                                .map(|c| c.name.clone())
-                                .collect();
-
-                            let filtered_columns = filter_user_columns(new_columns);
-                            form_state = FormState::new(
-                                prof_name.clone(),
-                                tbl_name.clone(),
-                                filtered_columns,
-                            );
-
+                        Ok(mut new_form_state) => {
                             if let Err(e) = UiService::fetch_and_set_table_count(
                                 &mut grpc_client,
-                                &mut form_state,
+                                &mut new_form_state,
                             )
                             .await
                             {
@@ -334,10 +386,10 @@ pub async fn run_ui() -> Result<()> {
                                     vec!["OK".to_string()],
                                     DialogPurpose::LoginFailed,
                                 );
-                            } else if form_state.total_count > 0 {
+                            } else if new_form_state.total_count > 0 {
                                 if let Err(e) = UiService::load_table_data_by_position(
                                     &mut grpc_client,
-                                    &mut form_state,
+                                    &mut new_form_state,
                                 )
                                 .await
                                 {
@@ -350,17 +402,18 @@ pub async fn run_ui() -> Result<()> {
                                     app_state.hide_dialog();
                                 }
                             } else {
-                                form_state.reset_to_empty();
+                                new_form_state.reset_to_empty();
                                 app_state.hide_dialog();
                             }
 
+                            form_state = new_form_state;
                             prev_view_profile_name = current_view_profile;
                             prev_view_table_name = current_view_table;
                             table_just_switched = true;
                         }
                         Err(e) => {
                             app_state.update_dialog_content(
-                                &format!("Error fetching table structure: {}", e),
+                                &format!("Error loading table: {}", e),
                                 vec!["OK".to_string()],
                                 DialogPurpose::LoginFailed,
                             );
@@ -375,6 +428,9 @@ 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.
+        
         if let Some((profile_name, table_name)) = app_state.pending_table_structure_fetch.take() {
             if app_state.ui.show_add_logic {
                 if admin_state.add_logic_state.profile_name == profile_name &&
@@ -499,10 +555,20 @@ pub async fn run_ui() -> Result<()> {
 
         #[cfg(feature = "ui-debug")]
         {
-            app_state.debug_info = format!(
-                "Redraw -> event: {}, needs_redraw: {}, pos_changed: {}",
-                event_processed, needs_redraw, position_changed
-            );
+            let can_display_next = match &app_state.debug_state {
+                Some(current) => current.display_start_time.elapsed() >= Duration::from_secs(2),
+                None => true,
+            };
+
+            if can_display_next {
+                if let Some((new_message, is_error)) = pop_next_debug_message() {
+                    app_state.debug_state = Some(DebugState {
+                        displayed_message: new_message,
+                        is_error,
+                        display_start_time: Instant::now(),
+                    });
+                }
+            }
         }
 
         if event_processed || needs_redraw || position_changed {

client/src/utils/data_converter.rs

@@ -0,0 +1,50 @@
+// src/utils/data_converter.rs
+
+use common::proto::komp_ac::table_structure::TableStructureResponse;
+use prost_types::{value::Kind, NullValue, Value};
+use std::collections::HashMap;
+
+pub fn convert_and_validate_data(
+    data: &HashMap<String, String>,
+    schema: &TableStructureResponse,
+) -> Result<HashMap<String, Value>, String> {
+    let type_map: HashMap<_, _> = schema
+        .columns
+        .iter()
+        .map(|col| (col.name.as_str(), col.data_type.as_str()))
+        .collect();
+
+    data.iter()
+        .map(|(key, str_value)| {
+            let expected_type = type_map.get(key.as_str()).unwrap_or(&"TEXT");
+
+            let kind = if str_value.is_empty() {
+                // TODO: Use the correct enum variant
+                Kind::NullValue(NullValue::NullValue.into())
+            } else {
+                // Attempt to parse the string based on the expected type
+                match *expected_type {
+                    "BOOL" => match str_value.to_lowercase().parse::<bool>() {
+                        Ok(v) => Kind::BoolValue(v),
+                        Err(_) => return Err(format!("Invalid boolean for '{}': must be 'true' or 'false'", key)),
+                    },
+                    "INT8" | "INT4" | "INT2" | "SERIAL" | "BIGSERIAL" => {
+                        match str_value.parse::<f64>() {
+                            Ok(v) => Kind::NumberValue(v),
+                            Err(_) => return Err(format!("Invalid number for '{}': must be a whole number", key)),
+                        }
+                    }
+                    "NUMERIC" | "FLOAT4" | "FLOAT8" => match str_value.parse::<f64>() {
+                        Ok(v) => Kind::NumberValue(v),
+                        Err(_) => return Err(format!("Invalid decimal for '{}': must be a number", key)),
+                    },
+                    "TIMESTAMPTZ" | "DATE" | "TIME" | "TEXT" | "VARCHAR" | "UUID" => {
+                        Kind::StringValue(str_value.clone())
+                    }
+                    _ => Kind::StringValue(str_value.clone()),
+                }
+            };
+            Ok((key.clone(), Value { kind: Some(kind) }))
+        })
+        .collect()
+}

client/src/utils/debug_logger.rs

@@ -0,0 +1,46 @@
+// client/src/utils/debug_logger.rs
+use lazy_static::lazy_static;
+use std::collections::VecDeque; // <-- FIX: Import VecDeque
+use std::io;
+use std::sync::{Arc, Mutex}; // <-- FIX: Import Mutex
+
+lazy_static! {
+    static ref UI_DEBUG_BUFFER: Arc<Mutex<VecDeque<(String, bool)>>> =
+        Arc::new(Mutex::new(VecDeque::from([(String::from("Logger initialized..."), false)])));
+}
+
+#[derive(Clone)]
+pub struct UiDebugWriter;
+
+impl Default for UiDebugWriter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl UiDebugWriter {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl io::Write for UiDebugWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let mut buffer = UI_DEBUG_BUFFER.lock().unwrap();
+        let message = String::from_utf8_lossy(buf);
+        let trimmed_message = message.trim().to_string();
+        let is_error = trimmed_message.starts_with("ERROR");
+        // Add the new message to the back of the queue
+        buffer.push_back((trimmed_message, is_error));
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+// A public function to pop the next message from the front of the queue.
+pub fn pop_next_debug_message() -> Option<(String, bool)> {
+    UI_DEBUG_BUFFER.lock().unwrap().pop_front()
+}