registering canvas functions now instead of internal state

.envrc

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

.gitignore

@@ -2,3 +2,5 @@
 .env
 /tantivy_indexes
 server/tantivy_indexes
+steel_decimal/tests/property_tests.proptest-regressions
+.direnv/

Cargo.toml

@@ -1,17 +1,17 @@
 [workspace]
-members = ["client", "server", "common", "search"]
+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]
@@ -24,6 +24,7 @@ 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"] }
@@ -39,4 +40,16 @@ 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,27 @@
+[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 }
+toml = { workspace = true }
+serde = { workspace = true }
+unicode-width.workspace = true
+
+[dev-dependencies]
+tokio-test = "0.4.4"
+
+[features]
+default = []
+gui = ["ratatui"]

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/canvas_config.toml

@@ -0,0 +1,56 @@
+# canvas_config.toml - Complete Canvas Configuration
+
+[behavior]
+wrap_around_fields = true
+auto_save_on_field_change = false
+word_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+max_suggestions = 6
+
+[appearance]
+cursor_style = "block"  # "block", "bar", "underline"
+show_field_numbers = false
+highlight_current_field = true
+
+# Read-only mode keybindings (vim-style)
+[keybindings.read_only]
+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 = ["shift+g"]
+next_field = ["Tab"]
+prev_field = ["Shift+Tab"]
+
+# Edit mode keybindings
+[keybindings.edit]
+delete_char_backward = ["Backspace"]
+delete_char_forward = ["Delete"]
+move_left = ["Left"]
+move_right = ["Right"]
+move_up = ["Up"]
+move_down = ["Down"]
+move_line_start = ["Home"]
+move_line_end = ["End"]
+move_word_next = ["Ctrl+Right"]
+move_word_prev = ["Ctrl+Left"]
+next_field = ["Tab"]
+prev_field = ["Shift+Tab"]
+
+# Suggestion/autocomplete keybindings
+[keybindings.suggestions]
+suggestion_up = ["Up", "Ctrl+p"]
+suggestion_down = ["Down", "Ctrl+n"]
+select_suggestion = ["Enter", "Tab"]
+exit_suggestions = ["Esc"]
+
+# Global keybindings (work in both modes)
+[keybindings.global]
+move_up = ["Up"]
+move_down = ["Down"]

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,93 @@
+// src/autocomplete/actions.rs
+
+use crate::canvas::state::{CanvasState, ActionContext};
+use crate::autocomplete::state::AutocompleteCanvasState;
+use crate::canvas::actions::types::{CanvasAction, ActionResult};
+use crate::canvas::actions::edit::handle_generic_canvas_action;  // Import the core function
+use anyhow::Result;
+
+/// Version for states that implement rich autocomplete
+pub async fn execute_canvas_action_with_autocomplete<S: CanvasState + AutocompleteCanvasState>(
+    action: CanvasAction,
+    state: &mut S,
+    ideal_cursor_column: &mut usize,
+) -> Result<ActionResult> {
+    // 1. Try feature-specific handler 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));
+    }
+
+    // 2. Handle rich autocomplete actions
+    if let Some(result) = handle_rich_autocomplete_action(&action, state)? {
+        return Ok(result);
+    }
+
+    // 3. Handle generic canvas actions
+    handle_generic_canvas_action(action, state, ideal_cursor_column).await
+}
+
+/// Handle rich autocomplete actions for AutocompleteCanvasState
+fn handle_rich_autocomplete_action<S: CanvasState + AutocompleteCanvasState>(
+    action: &CanvasAction,
+    state: &mut S,
+) -> Result<Option<ActionResult>> {
+    match action {
+        CanvasAction::TriggerAutocomplete => {
+            if state.supports_autocomplete(state.current_field()) {
+                state.activate_autocomplete();
+                Ok(Some(ActionResult::success_with_message("Autocomplete activated - fetching suggestions...")))
+            } else {
+                Ok(Some(ActionResult::error("Autocomplete not supported for this field")))
+            }
+        }
+
+        CanvasAction::SuggestionDown => {
+            if state.is_autocomplete_ready() {
+                if let Some(autocomplete_state) = state.autocomplete_state_mut() {
+                    autocomplete_state.select_next();
+                    return Ok(Some(ActionResult::success()));
+                }
+            }
+            Ok(None)
+        }
+
+        CanvasAction::SuggestionUp => {
+            if state.is_autocomplete_ready() {
+                if let Some(autocomplete_state) = state.autocomplete_state_mut() {
+                    autocomplete_state.select_previous();
+                    return Ok(Some(ActionResult::success()));
+                }
+            }
+            Ok(None)
+        }
+
+        CanvasAction::SelectSuggestion => {
+            if state.is_autocomplete_ready() {
+                if let Some(message) = state.apply_autocomplete_selection() {
+                    return Ok(Some(ActionResult::success_with_message(message)));
+                } else {
+                    return Ok(Some(ActionResult::error("No suggestion selected")));
+                }
+            }
+            Ok(None)
+        }
+
+        CanvasAction::ExitSuggestions => {
+            if state.is_autocomplete_active() {
+                state.deactivate_autocomplete();
+                Ok(Some(ActionResult::success_with_message("Autocomplete cancelled")))
+            } else {
+                Ok(None)
+            }
+        }
+
+        _ => Ok(None),
+    }
+}

canvas/src/autocomplete/gui.rs

@@ -0,0 +1,191 @@
+// canvas/src/autocomplete/gui.rs
+
+#[cfg(feature = "gui")]
+use ratatui::{
+    layout::{Alignment, Rect},
+    style::{Modifier, Style},
+    widgets::{Block, Borders, List, ListItem, ListState, Paragraph},
+    Frame,
+};
+
+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>(
+    f: &mut Frame,
+    frame_area: Rect,
+    input_rect: Rect,
+    theme: &T,
+    autocomplete_state: &AutocompleteState<impl Clone + Send + 'static>,
+) {
+    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>(
+    f: &mut Frame,
+    frame_area: Rect,
+    input_rect: Rect,
+    theme: &T,
+    autocomplete_state: &AutocompleteState<impl Clone + Send + 'static>,
+) {
+    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,10 @@
+// src/autocomplete/mod.rs
+pub mod types;
+pub mod gui;
+pub mod state;
+pub mod actions;
+
+// Re-export autocomplete types
+pub use types::{SuggestionItem, AutocompleteState};
+pub use state::AutocompleteCanvasState;
+pub use actions::execute_canvas_action_with_autocomplete;

canvas/src/autocomplete/state.rs

@@ -0,0 +1,96 @@
+// canvas/src/state.rs
+
+use crate::canvas::state::CanvasState;
+
+/// OPTIONAL extension trait for states that want rich autocomplete functionality.
+/// Only implement this if you need the new autocomplete features.
+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
+    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
+    }
+
+    /// CLIENT API: Activate autocomplete for current field
+    fn activate_autocomplete(&mut self) {
+        let current_field = self.current_field(); // Get field first
+        if let Some(state) = self.autocomplete_state_mut() {
+            state.activate(current_field); // Then use it
+        }
+    }
+
+    /// CLIENT API: Deactivate autocomplete
+    fn deactivate_autocomplete(&mut self) {
+        if let Some(state) = self.autocomplete_state_mut() {
+            state.deactivate();
+        }
+    }
+
+    /// CLIENT API: Set suggestions (called after 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);
+        }
+    }
+
+    /// CLIENT API: Set loading state
+    fn set_autocomplete_loading(&mut self, loading: bool) {
+        if let Some(state) = self.autocomplete_state_mut() {
+            state.is_loading = loading;
+        }
+    }
+
+    /// Check if autocomplete is currently active
+    fn is_autocomplete_active(&self) -> bool {
+        self.autocomplete_state()
+            .map(|state| state.is_active)
+            .unwrap_or(false)
+    }
+
+    /// Check if autocomplete is ready for interaction
+    fn is_autocomplete_ready(&self) -> bool {
+        self.autocomplete_state()
+            .map(|state| state.is_ready())
+            .unwrap_or(false)
+    }
+
+    /// INTERNAL: Apply selected autocomplete value to current field
+    fn apply_autocomplete_selection(&mut self) -> Option<String> {
+        // First, get the selected value and display text (if any)
+        let selection_info = if let Some(state) = self.autocomplete_state() {
+            state.get_selected().map(|selected| {
+                (selected.value_to_store.clone(), selected.display_text.clone())
+            })
+        } else {
+            None
+        };
+
+        // Apply the selection if we have one
+        if let Some((value, display)) = selection_info {
+            // Apply the value to current field
+            *self.get_current_input_mut() = value;
+            self.set_has_unsaved_changes(true);
+
+            // Deactivate autocomplete
+            if let Some(state_mut) = self.autocomplete_state_mut() {
+                state_mut.deactivate();
+            }
+
+            Some(format!("Selected: {}", display))
+        } else {
+            None
+        }
+    }
+}

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/edit.rs

@@ -0,0 +1,378 @@
+// canvas/src/actions/edit.rs
+
+use crate::canvas::state::{CanvasState, ActionContext};
+use crate::canvas::actions::types::{CanvasAction, ActionResult};
+use anyhow::Result;
+
+/// Execute a typed canvas action on any CanvasState implementation
+pub async fn execute_canvas_action<S: CanvasState>(
+    action: CanvasAction,
+    state: &mut S,
+    ideal_cursor_column: &mut usize,
+) -> Result<ActionResult> {
+    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));
+    }
+
+    handle_generic_canvas_action(action, state, ideal_cursor_column).await
+}
+
+/// Handle core canvas actions with full type safety
+pub async fn handle_generic_canvas_action<S: CanvasState>(
+    action: CanvasAction,
+    state: &mut S,
+    ideal_cursor_column: &mut usize,
+) -> Result<ActionResult> {
+    match action {
+        CanvasAction::InsertChar(c) => {
+            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();
+                Ok(ActionResult::success())
+            } else {
+                Ok(ActionResult::error("Invalid cursor position for character insertion"))
+            }
+        }
+
+        CanvasAction::DeleteBackward => {
+            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(ActionResult::success())
+        }
+
+        CanvasAction::DeleteForward => {
+            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(ActionResult::success())
+        }
+
+        CanvasAction::NextField => {
+            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(ActionResult::success())
+        }
+
+        CanvasAction::PrevField => {
+            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(ActionResult::success())
+        }
+
+        CanvasAction::MoveLeft => {
+            let new_pos = state.current_cursor_pos().saturating_sub(1);
+            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();
+            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(ActionResult::success())
+        }
+
+        CanvasAction::MoveUp => {
+            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(ActionResult::success())
+        }
+
+        CanvasAction::MoveDown => {
+            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(ActionResult::success())
+        }
+
+        CanvasAction::MoveLineStart => {
+            state.set_current_cursor_pos(0);
+            *ideal_cursor_column = 0;
+            Ok(ActionResult::success())
+        }
+
+        CanvasAction::MoveLineEnd => {
+            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(ActionResult::success())
+        }
+
+        CanvasAction::MoveFirstLine => {
+            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(ActionResult::success_with_message("Moved to first field"))
+        }
+
+        CanvasAction::MoveLastLine => {
+            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(ActionResult::success_with_message("Moved to last field"))
+        }
+
+        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 = new_pos.min(current_input.len());
+                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 = 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(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_with_message("Moved to previous word end"))
+        }
+
+        CanvasAction::Custom(action_str) => {
+            Ok(ActionResult::error(format!("Unknown or unhandled custom action: {}", action_str)))
+        }
+
+        // Autocomplete actions are handled by the autocomplete module
+        CanvasAction::TriggerAutocomplete | CanvasAction::SuggestionUp | CanvasAction::SuggestionDown |
+        CanvasAction::SelectSuggestion | CanvasAction::ExitSuggestions => {
+            Ok(ActionResult::error("Autocomplete actions should be handled by autocomplete module"))
+        }
+    }
+}
+
+// Word movement helper functions
+#[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
+    }
+}

canvas/src/canvas/actions/mod.rs

@@ -0,0 +1,7 @@
+// canvas/src/canvas/actions/mod.rs
+pub mod types;
+pub mod edit;
+
+// Re-export the main types for convenience
+pub use types::{CanvasAction, ActionResult};
+pub use edit::execute_canvas_action;  // Remove execute_edit_action

canvas/src/canvas/actions/types.rs

@@ -0,0 +1,237 @@
+// canvas/src/actions/types.rs
+
+use crossterm::event::KeyCode;
+
+/// All possible canvas actions, type-safe and exhaustive
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CanvasAction {
+    // Character input
+    InsertChar(char),
+
+    // Deletion
+    DeleteBackward,
+    DeleteForward,
+
+    // Basic cursor movement
+    MoveLeft,
+    MoveRight,
+    MoveUp,
+    MoveDown,
+
+    // Line movement
+    MoveLineStart,
+    MoveLineEnd,
+    MoveFirstLine,
+    MoveLastLine,
+
+    // Word movement
+    MoveWordNext,
+    MoveWordEnd,
+    MoveWordPrev,
+    MoveWordEndPrev,
+
+    // Field navigation
+    NextField,
+    PrevField,
+
+    // AUTOCOMPLETE ACTIONS (NEW)
+    /// Manually trigger autocomplete for current field
+    TriggerAutocomplete,
+    /// Move to next suggestion
+    SuggestionUp,
+    /// Move to previous suggestion  
+    SuggestionDown,
+    /// Select the currently highlighted suggestion
+    SelectSuggestion,
+    /// Cancel/exit autocomplete mode
+    ExitSuggestions,
+
+    // Custom actions (escape hatch for feature-specific behavior)
+    Custom(String),
+}
+
+impl CanvasAction {
+    /// Convert a string action to typed action (for backwards compatibility during migration)
+    pub fn from_string(action: &str) -> Self {
+        match action {
+            "insert_char" => {
+                // This is a bit tricky - we need the char from context
+                // For now, we'll use Custom until we refactor the call sites
+                Self::Custom(action.to_string())
+            }
+            "delete_char_backward" => Self::DeleteBackward,
+            "delete_char_forward" => Self::DeleteForward,
+            "move_left" => Self::MoveLeft,
+            "move_right" => Self::MoveRight,
+            "move_up" => Self::MoveUp,
+            "move_down" => Self::MoveDown,
+            "move_line_start" => Self::MoveLineStart,
+            "move_line_end" => Self::MoveLineEnd,
+            "move_first_line" => Self::MoveFirstLine,
+            "move_last_line" => Self::MoveLastLine,
+            "move_word_next" => Self::MoveWordNext,
+            "move_word_end" => Self::MoveWordEnd,
+            "move_word_prev" => Self::MoveWordPrev,
+            "move_word_end_prev" => Self::MoveWordEndPrev,
+            "next_field" => Self::NextField,
+            "prev_field" => Self::PrevField,
+            // Autocomplete actions
+            "trigger_autocomplete" => Self::TriggerAutocomplete,
+            "suggestion_up" => Self::SuggestionUp,
+            "suggestion_down" => Self::SuggestionDown,
+            "select_suggestion" => Self::SelectSuggestion,
+            "exit_suggestions" => Self::ExitSuggestions,
+            _ => Self::Custom(action.to_string()),
+        }
+    }
+
+    /// Get string representation (for logging, debugging)
+    pub fn as_str(&self) -> &str {
+        match self {
+            Self::InsertChar(_) => "insert_char",
+            Self::DeleteBackward => "delete_char_backward",
+            Self::DeleteForward => "delete_char_forward",
+            Self::MoveLeft => "move_left",
+            Self::MoveRight => "move_right",
+            Self::MoveUp => "move_up",
+            Self::MoveDown => "move_down",
+            Self::MoveLineStart => "move_line_start",
+            Self::MoveLineEnd => "move_line_end",
+            Self::MoveFirstLine => "move_first_line",
+            Self::MoveLastLine => "move_last_line",
+            Self::MoveWordNext => "move_word_next",
+            Self::MoveWordEnd => "move_word_end",
+            Self::MoveWordPrev => "move_word_prev",
+            Self::MoveWordEndPrev => "move_word_end_prev",
+            Self::NextField => "next_field",
+            Self::PrevField => "prev_field",
+            // Autocomplete actions
+            Self::TriggerAutocomplete => "trigger_autocomplete",
+            Self::SuggestionUp => "suggestion_up",
+            Self::SuggestionDown => "suggestion_down",
+            Self::SelectSuggestion => "select_suggestion",
+            Self::ExitSuggestions => "exit_suggestions",
+            Self::Custom(s) => s,
+        }
+    }
+
+    /// Create action from KeyCode for common cases
+    pub fn from_key(key: KeyCode) -> Option<Self> {
+        match key {
+            KeyCode::Char(c) => Some(Self::InsertChar(c)),
+            KeyCode::Backspace => Some(Self::DeleteBackward),
+            KeyCode::Delete => Some(Self::DeleteForward),
+            KeyCode::Left => Some(Self::MoveLeft),
+            KeyCode::Right => Some(Self::MoveRight),
+            KeyCode::Up => Some(Self::MoveUp),
+            KeyCode::Down => Some(Self::MoveDown),
+            KeyCode::Home => Some(Self::MoveLineStart),
+            KeyCode::End => Some(Self::MoveLineEnd),
+            KeyCode::Tab => Some(Self::NextField),
+            KeyCode::BackTab => Some(Self::PrevField),
+            _ => None,
+        }
+    }
+
+    /// Check if this action modifies content
+    pub fn is_modifying(&self) -> bool {
+        matches!(self,
+            Self::InsertChar(_) |
+            Self::DeleteBackward |
+            Self::DeleteForward |
+            Self::SelectSuggestion
+        )
+    }
+
+    /// Check if this action moves the cursor
+    pub fn is_movement(&self) -> bool {
+        matches!(self,
+            Self::MoveLeft | Self::MoveRight | Self::MoveUp | Self::MoveDown |
+            Self::MoveLineStart | Self::MoveLineEnd | Self::MoveFirstLine | Self::MoveLastLine |
+            Self::MoveWordNext | Self::MoveWordEnd | Self::MoveWordPrev | Self::MoveWordEndPrev |
+            Self::NextField | Self::PrevField
+        )
+    }
+
+    /// Check if this is a suggestion-related action
+    pub fn is_suggestion(&self) -> bool {
+        matches!(self,
+            Self::TriggerAutocomplete | Self::SuggestionUp | Self::SuggestionDown |
+            Self::SelectSuggestion | Self::ExitSuggestions
+        )
+    }
+}
+
+/// Result of executing a canvas action
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ActionResult {
+    /// Action completed successfully, optional message for user feedback
+    Success(Option<String>),
+    /// Action was handled by custom feature logic
+    HandledByFeature(String),
+    /// Action requires additional context or cannot be performed
+    RequiresContext(String),
+    /// Action failed with error message
+    Error(String),
+}
+
+impl ActionResult {
+    pub fn success() -> Self {
+        Self::Success(None)
+    }
+
+    pub fn success_with_message(msg: impl Into<String>) -> Self {
+        Self::Success(Some(msg.into()))
+    }
+
+    pub fn error(msg: impl Into<String>) -> Self {
+        Self::Error(msg.into())
+    }
+
+    pub fn is_success(&self) -> bool {
+        matches!(self, Self::Success(_) | Self::HandledByFeature(_))
+    }
+
+    pub fn message(&self) -> Option<&str> {
+        match self {
+            Self::Success(msg) => msg.as_deref(),
+            Self::HandledByFeature(msg) => Some(msg),
+            Self::RequiresContext(msg) => Some(msg),
+            Self::Error(msg) => Some(msg),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_action_from_string() {
+        assert_eq!(CanvasAction::from_string("move_left"), CanvasAction::MoveLeft);
+        assert_eq!(CanvasAction::from_string("delete_char_backward"), CanvasAction::DeleteBackward);
+        assert_eq!(CanvasAction::from_string("trigger_autocomplete"), CanvasAction::TriggerAutocomplete);
+        assert_eq!(CanvasAction::from_string("unknown"), CanvasAction::Custom("unknown".to_string()));
+    }
+
+    #[test]
+    fn test_action_from_key() {
+        assert_eq!(CanvasAction::from_key(KeyCode::Char('a')), Some(CanvasAction::InsertChar('a')));
+        assert_eq!(CanvasAction::from_key(KeyCode::Left), Some(CanvasAction::MoveLeft));
+        assert_eq!(CanvasAction::from_key(KeyCode::Backspace), Some(CanvasAction::DeleteBackward));
+        assert_eq!(CanvasAction::from_key(KeyCode::F(1)), None);
+    }
+
+    #[test]
+    fn test_action_properties() {
+        assert!(CanvasAction::InsertChar('a').is_modifying());
+        assert!(!CanvasAction::MoveLeft.is_modifying());
+
+        assert!(CanvasAction::MoveLeft.is_movement());
+        assert!(!CanvasAction::InsertChar('a').is_movement());
+
+        assert!(CanvasAction::SuggestionUp.is_suggestion());
+        assert!(CanvasAction::TriggerAutocomplete.is_suggestion());
+        assert!(!CanvasAction::MoveLeft.is_suggestion());
+    }
+}

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,17 @@
+// src/canvas/mod.rs
+pub mod actions;
+pub mod modes; 
+pub mod gui;
+pub mod theme;
+pub mod state;
+
+// Re-export commonly used canvas types
+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,52 @@
+// canvas/src/state.rs
+
+use crate::canvas::actions::CanvasAction;
+
+/// Context passed to feature-specific action handlers
+#[derive(Debug)]
+pub struct ActionContext {
+    pub key_code: Option<crossterm::event::KeyCode>, // Kept for backwards compatibility
+    pub ideal_cursor_column: usize,
+    pub current_input: String,
+    pub current_field: usize,
+}
+
+/// Core trait that any form-like state must implement to work with the canvas system.
+/// This enables the same mode behaviors (edit, read-only, highlight) to work across
+/// any implementation - login forms, data entry forms, configuration screens, etc.
+pub trait CanvasState {
+    // --- Core Navigation ---
+    fn current_field(&self) -> usize;
+    fn current_cursor_pos(&self) -> usize;
+    fn set_current_field(&mut self, index: usize);
+    fn set_current_cursor_pos(&mut self, pos: usize);
+
+    // --- Data Access ---
+    fn get_current_input(&self) -> &str;
+    fn get_current_input_mut(&mut self) -> &mut String;
+    fn inputs(&self) -> Vec<&String>;
+    fn fields(&self) -> Vec<&str>;
+
+    // --- State Management ---
+    fn has_unsaved_changes(&self) -> bool;
+    fn set_has_unsaved_changes(&mut self, changed: bool);
+
+    // --- Feature-specific action handling ---
+
+    /// Feature-specific action handling (NEW: Type-safe)
+    fn handle_feature_action(&mut self, _action: &CanvasAction, _context: &ActionContext) -> Option<String> {
+        None // Default: no feature-specific handling
+    }
+
+    // --- Display Overrides (for links, computed values, etc.) ---
+    fn get_display_value_for_field(&self, index: usize) -> &str {
+        self.inputs()
+            .get(index)
+            .map(|s| s.as_str())
+            .unwrap_or("")
+    }
+
+    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/config.rs

@@ -0,0 +1,480 @@
+// canvas/src/config.rs
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use crossterm::event::{KeyCode, KeyModifiers};
+use anyhow::{Context, Result};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CanvasConfig {
+    #[serde(default)]
+    pub keybindings: CanvasKeybindings,
+    #[serde(default)]
+    pub behavior: CanvasBehavior,
+    #[serde(default)]
+    pub appearance: CanvasAppearance,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct CanvasKeybindings {
+    #[serde(default)]
+    pub read_only: HashMap<String, Vec<String>>,
+    #[serde(default)]
+    pub edit: HashMap<String, Vec<String>>,
+    #[serde(default)]
+    pub suggestions: HashMap<String, Vec<String>>,
+    #[serde(default)]
+    pub global: HashMap<String, Vec<String>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CanvasBehavior {
+    #[serde(default = "default_wrap_around")]
+    pub wrap_around_fields: bool,
+    #[serde(default = "default_auto_save")]
+    pub auto_save_on_field_change: bool,
+    #[serde(default = "default_word_chars")]
+    pub word_chars: String,
+    #[serde(default = "default_suggestion_limit")]
+    pub max_suggestions: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CanvasAppearance {
+    #[serde(default = "default_cursor_style")]
+    pub cursor_style: String, // "block", "bar", "underline"
+    #[serde(default = "default_show_field_numbers")]
+    pub show_field_numbers: bool,
+    #[serde(default = "default_highlight_current_field")]
+    pub highlight_current_field: bool,
+}
+
+// Default values
+fn default_wrap_around() -> bool { true }
+fn default_auto_save() -> bool { false }
+fn default_word_chars() -> String { "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_".to_string() }
+fn default_suggestion_limit() -> usize { 10 }
+fn default_cursor_style() -> String { "block".to_string() }
+fn default_show_field_numbers() -> bool { false }
+fn default_highlight_current_field() -> bool { true }
+
+impl Default for CanvasBehavior {
+    fn default() -> Self {
+        Self {
+            wrap_around_fields: default_wrap_around(),
+            auto_save_on_field_change: default_auto_save(),
+            word_chars: default_word_chars(),
+            max_suggestions: default_suggestion_limit(),
+        }
+    }
+}
+
+impl Default for CanvasAppearance {
+    fn default() -> Self {
+        Self {
+            cursor_style: default_cursor_style(),
+            show_field_numbers: default_show_field_numbers(),
+            highlight_current_field: default_highlight_current_field(),
+        }
+    }
+}
+
+impl Default for CanvasConfig {
+    fn default() -> Self {
+        Self {
+            keybindings: CanvasKeybindings::with_vim_defaults(),
+            behavior: CanvasBehavior::default(),
+            appearance: CanvasAppearance::default(),
+        }
+    }
+}
+
+impl CanvasKeybindings {
+    pub fn with_vim_defaults() -> Self {
+        let mut keybindings = Self::default();
+
+        // Read-only mode (vim-style navigation)
+        keybindings.read_only.insert("move_left".to_string(), vec!["h".to_string()]);
+        keybindings.read_only.insert("move_right".to_string(), vec!["l".to_string()]);
+        keybindings.read_only.insert("move_up".to_string(), vec!["k".to_string()]);
+        keybindings.read_only.insert("move_down".to_string(), vec!["j".to_string()]);
+        keybindings.read_only.insert("move_word_next".to_string(), vec!["w".to_string()]);
+        keybindings.read_only.insert("move_word_end".to_string(), vec!["e".to_string()]);
+        keybindings.read_only.insert("move_word_prev".to_string(), vec!["b".to_string()]);
+        keybindings.read_only.insert("move_word_end_prev".to_string(), vec!["ge".to_string()]);
+        keybindings.read_only.insert("move_line_start".to_string(), vec!["0".to_string()]);
+        keybindings.read_only.insert("move_line_end".to_string(), vec!["$".to_string()]);
+        keybindings.read_only.insert("move_first_line".to_string(), vec!["gg".to_string()]);
+        keybindings.read_only.insert("move_last_line".to_string(), vec!["G".to_string()]);
+        keybindings.read_only.insert("next_field".to_string(), vec!["Tab".to_string()]);
+        keybindings.read_only.insert("prev_field".to_string(), vec!["Shift+Tab".to_string()]);
+
+        // Edit mode
+        keybindings.edit.insert("delete_char_backward".to_string(), vec!["Backspace".to_string()]);
+        keybindings.edit.insert("delete_char_forward".to_string(), vec!["Delete".to_string()]);
+        keybindings.edit.insert("move_left".to_string(), vec!["Left".to_string()]);
+        keybindings.edit.insert("move_right".to_string(), vec!["Right".to_string()]);
+        keybindings.edit.insert("move_up".to_string(), vec!["Up".to_string()]);
+        keybindings.edit.insert("move_down".to_string(), vec!["Down".to_string()]);
+        keybindings.edit.insert("move_line_start".to_string(), vec!["Home".to_string()]);
+        keybindings.edit.insert("move_line_end".to_string(), vec!["End".to_string()]);
+        keybindings.edit.insert("move_word_next".to_string(), vec!["Ctrl+Right".to_string()]);
+        keybindings.edit.insert("move_word_prev".to_string(), vec!["Ctrl+Left".to_string()]);
+        keybindings.edit.insert("next_field".to_string(), vec!["Tab".to_string()]);
+        keybindings.edit.insert("prev_field".to_string(), vec!["Shift+Tab".to_string()]);
+
+        // Suggestions
+        keybindings.suggestions.insert("suggestion_up".to_string(), vec!["Up".to_string(), "Ctrl+p".to_string()]);
+        keybindings.suggestions.insert("suggestion_down".to_string(), vec!["Down".to_string(), "Ctrl+n".to_string()]);
+        keybindings.suggestions.insert("select_suggestion".to_string(), vec!["Enter".to_string(), "Tab".to_string()]);
+        keybindings.suggestions.insert("exit_suggestions".to_string(), vec!["Esc".to_string()]);
+
+        // Global (works in both modes)
+        keybindings.global.insert("move_up".to_string(), vec!["Up".to_string()]);
+        keybindings.global.insert("move_down".to_string(), vec!["Down".to_string()]);
+
+        keybindings
+    }
+
+    pub fn with_emacs_defaults() -> Self {
+        let mut keybindings = Self::default();
+
+        // Emacs-style bindings
+        keybindings.read_only.insert("move_left".to_string(), vec!["Ctrl+b".to_string()]);
+        keybindings.read_only.insert("move_right".to_string(), vec!["Ctrl+f".to_string()]);
+        keybindings.read_only.insert("move_up".to_string(), vec!["Ctrl+p".to_string()]);
+        keybindings.read_only.insert("move_down".to_string(), vec!["Ctrl+n".to_string()]);
+        keybindings.read_only.insert("move_word_next".to_string(), vec!["Alt+f".to_string()]);
+        keybindings.read_only.insert("move_word_prev".to_string(), vec!["Alt+b".to_string()]);
+        keybindings.read_only.insert("move_line_start".to_string(), vec!["Ctrl+a".to_string()]);
+        keybindings.read_only.insert("move_line_end".to_string(), vec!["Ctrl+e".to_string()]);
+
+        keybindings.edit.insert("delete_char_backward".to_string(), vec!["Ctrl+h".to_string(), "Backspace".to_string()]);
+        keybindings.edit.insert("delete_char_forward".to_string(), vec!["Ctrl+d".to_string(), "Delete".to_string()]);
+
+        keybindings
+    }
+}
+
+impl CanvasConfig {
+    /// Load from canvas_config.toml or fallback to vim defaults
+    pub fn load() -> Self {
+        // Try to load canvas_config.toml from current directory
+        if let Ok(config) = Self::from_file(std::path::Path::new("canvas_config.toml")) {
+            return config;
+        }
+        
+        // Fallback to vim defaults
+        Self::default()
+    }
+
+    /// Load from TOML string
+    pub fn from_toml(toml_str: &str) -> Result<Self> {
+        toml::from_str(toml_str)
+            .with_context(|| "Failed to parse canvas config TOML")
+    }
+
+    /// Load from file
+    pub fn from_file(path: &std::path::Path) -> Result<Self> {
+        let contents = std::fs::read_to_string(path)
+            .with_context(|| format!("Failed to read config file: {:?}", path))?;
+        Self::from_toml(&contents)
+    }
+
+    /// Get action for key in read-only mode
+    pub fn get_read_only_action(&self, key: KeyCode, modifiers: KeyModifiers) -> Option<&str> {
+        self.get_action_in_mode(&self.keybindings.read_only, key, modifiers)
+            .or_else(|| self.get_action_in_mode(&self.keybindings.global, key, modifiers))
+    }
+
+    /// Get action for key in edit mode
+    pub fn get_edit_action(&self, key: KeyCode, modifiers: KeyModifiers) -> Option<&str> {
+        self.get_action_in_mode(&self.keybindings.edit, key, modifiers)
+            .or_else(|| self.get_action_in_mode(&self.keybindings.global, key, modifiers))
+    }
+
+    /// Get action for key in suggestions mode
+    pub fn get_suggestion_action(&self, key: KeyCode, modifiers: KeyModifiers) -> Option<&str> {
+        self.get_action_in_mode(&self.keybindings.suggestions, key, modifiers)
+    }
+
+    /// Get action for key (mode-aware)
+    pub fn get_action_for_key(&self, key: KeyCode, modifiers: KeyModifiers, is_edit_mode: bool, has_suggestions: bool) -> Option<&str> {
+        // Suggestions take priority when active
+        if has_suggestions {
+            if let Some(action) = self.get_suggestion_action(key, modifiers) {
+                return Some(action);
+            }
+        }
+
+        // Then check mode-specific
+        if is_edit_mode {
+            self.get_edit_action(key, modifiers)
+        } else {
+            self.get_read_only_action(key, modifiers)
+        }
+    }
+
+    fn get_action_in_mode<'a>(&self, mode_bindings: &'a HashMap<String, Vec<String>>, key: KeyCode, modifiers: KeyModifiers) -> Option<&'a str> {
+        for (action, bindings) in mode_bindings {
+            for binding in bindings {
+                if self.matches_keybinding(binding, key, modifiers) {
+                    return Some(action);
+                }
+            }
+        }
+        None
+    }
+
+    fn matches_keybinding(&self, binding: &str, key: KeyCode, modifiers: KeyModifiers) -> bool {
+        // 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,
+                "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,
+                
+                // 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 (may not work reliably in all terminals)
+                "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 (rarely supported but included for completeness)
+                "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),
+                
+                // Modifier keys (these work better as part of combinations)
+                "leftshift" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::LeftShift),
+                "leftcontrol" | "leftctrl" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::LeftControl),
+                "leftalt" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::LeftAlt),
+                "leftsuper" | "leftwindows" | "leftcmd" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::LeftSuper),
+                "lefthyper" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::LeftHyper),
+                "leftmeta" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::LeftMeta),
+                "rightshift" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::RightShift),
+                "rightcontrol" | "rightctrl" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::RightControl),
+                "rightalt" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::RightAlt),
+                "rightsuper" | "rightwindows" | "rightcmd" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::RightSuper),
+                "righthyper" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::RightHyper),
+                "rightmeta" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::RightMeta),
+                "isolevel3shift" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::IsoLevel3Shift),
+                "isolevel5shift" => key == KeyCode::Modifier(crossterm::event::ModifierKeyCode::IsoLevel5Shift),
+                
+                // 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() {
+                // 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),
+                "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),
+                
+                // Single character (letters, numbers, punctuation)
+                part => {
+                    if part.len() == 1 {
+                        if let Some(c) = part.chars().next() {
+                            expected_key = Some(KeyCode::Char(c));
+                        }
+                    }
+                }
+            }
+        }
+
+        modifiers == expected_modifiers && Some(key) == expected_key
+    }
+
+    /// Convenience method to create vim preset
+    pub fn vim_preset() -> Self {
+        Self {
+            keybindings: CanvasKeybindings::with_vim_defaults(),
+            behavior: CanvasBehavior::default(),
+            appearance: CanvasAppearance::default(),
+        }
+    }
+    
+    /// Convenience method to create emacs preset
+    pub fn emacs_preset() -> Self {
+        Self {
+            keybindings: CanvasKeybindings::with_emacs_defaults(),
+            behavior: CanvasBehavior::default(),
+            appearance: CanvasAppearance::default(),
+        }
+    }
+
+    /// Debug method to print loaded keybindings
+    pub fn debug_keybindings(&self) {
+        println!("📋 Canvas keybindings loaded:");
+        println!("  Read-only: {} actions", self.keybindings.read_only.len());
+        println!("  Edit: {} actions", self.keybindings.edit.len());
+        println!("  Suggestions: {} actions", self.keybindings.suggestions.len());
+        println!("  Global: {} actions", self.keybindings.global.len());
+    }
+}
+
+// Re-export for convenience
+pub use crate::canvas::actions::CanvasAction;
+pub use crate::dispatcher::ActionDispatcher;

canvas/src/dispatcher.rs

@@ -0,0 +1,180 @@
+// canvas/src/dispatcher.rs
+
+use crate::canvas::state::CanvasState;
+use crate::canvas::actions::{CanvasAction, ActionResult, execute_canvas_action};
+
+/// High-level action dispatcher that coordinates between different action types
+pub struct ActionDispatcher;
+
+impl ActionDispatcher {
+    /// Dispatch any action to the appropriate handler
+    pub async fn dispatch<S: CanvasState>(
+        action: CanvasAction,
+        state: &mut S,
+        ideal_cursor_column: &mut usize,
+    ) -> anyhow::Result<ActionResult> {
+        execute_canvas_action(action, state, ideal_cursor_column).await
+    }
+
+    /// Quick action dispatch from KeyCode
+    pub async fn dispatch_key<S: CanvasState>(
+        key: crossterm::event::KeyCode,
+        state: &mut S,
+        ideal_cursor_column: &mut usize,
+    ) -> anyhow::Result<Option<ActionResult>> {
+        if let Some(action) = CanvasAction::from_key(key) {
+            let result = Self::dispatch(action, state, ideal_cursor_column).await?;
+            Ok(Some(result))
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Batch dispatch multiple actions
+    pub async fn dispatch_batch<S: CanvasState>(
+        actions: Vec<CanvasAction>,
+        state: &mut S,
+        ideal_cursor_column: &mut usize,
+    ) -> anyhow::Result<Vec<ActionResult>> {
+        let mut results = Vec::new();
+        for action in actions {
+            let result = Self::dispatch(action, state, ideal_cursor_column).await?;
+            let is_success = result.is_success(); // Check success before moving
+            results.push(result);
+
+            // Stop on first error
+            if !is_success {
+                break;
+            }
+        }
+        Ok(results)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::actions::CanvasAction;
+
+    // Simple test implementation
+    struct TestFormState {
+        current_field: usize,
+        cursor_pos: usize,
+        inputs: Vec<String>,
+        field_names: Vec<String>,
+        has_changes: bool,
+    }
+
+    impl TestFormState {
+        fn new() -> Self {
+            Self {
+                current_field: 0,
+                cursor_pos: 0,
+                inputs: vec!["".to_string(), "".to_string()],
+                field_names: vec!["username".to_string(), "password".to_string()],
+                has_changes: false,
+            }
+        }
+    }
+
+    impl CanvasState for TestFormState {
+        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.inputs[self.current_field] }
+        fn get_current_input_mut(&mut self) -> &mut String { &mut self.inputs[self.current_field] }
+        fn inputs(&self) -> Vec<&String> { self.inputs.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; }
+
+        // Custom action handling for testing
+        fn handle_feature_action(&mut self, action: &CanvasAction, _context: &crate::state::ActionContext) -> Option<String> {
+            match action {
+                CanvasAction::Custom(s) if s == "test_custom" => {
+                    Some("Custom action handled".to_string())
+                }
+                _ => None,
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn test_typed_action_dispatch() {
+        let mut state = TestFormState::new();
+        let mut ideal_cursor = 0;
+
+        // Test character insertion
+        let result = ActionDispatcher::dispatch(
+            CanvasAction::InsertChar('a'),
+            &mut state,
+            &mut ideal_cursor,
+        ).await.unwrap();
+
+        assert!(result.is_success());
+        assert_eq!(state.get_current_input(), "a");
+        assert_eq!(state.cursor_pos, 1);
+        assert!(state.has_changes);
+    }
+
+    #[tokio::test]
+    async fn test_key_dispatch() {
+        let mut state = TestFormState::new();
+        let mut ideal_cursor = 0;
+
+        let result = ActionDispatcher::dispatch_key(
+            crossterm::event::KeyCode::Char('b'),
+            &mut state,
+            &mut ideal_cursor,
+        ).await.unwrap();
+
+        assert!(result.is_some());
+        assert!(result.unwrap().is_success());
+        assert_eq!(state.get_current_input(), "b");
+    }
+
+    #[tokio::test]
+    async fn test_custom_action() {
+        let mut state = TestFormState::new();
+        let mut ideal_cursor = 0;
+
+        let result = ActionDispatcher::dispatch(
+            CanvasAction::Custom("test_custom".to_string()),
+            &mut state,
+            &mut ideal_cursor,
+        ).await.unwrap();
+
+        match result {
+            ActionResult::HandledByFeature(msg) => {
+                assert_eq!(msg, "Custom action handled");
+            }
+            _ => panic!("Expected HandledByFeature result"),
+        }
+    }
+
+    #[tokio::test]
+    async fn test_batch_dispatch() {
+        let mut state = TestFormState::new();
+        let mut ideal_cursor = 0;
+
+        let actions = vec![
+            CanvasAction::InsertChar('h'),
+            CanvasAction::InsertChar('i'),
+            CanvasAction::MoveLeft,
+            CanvasAction::InsertChar('e'),
+        ];
+
+        let results = ActionDispatcher::dispatch_batch(
+            actions,
+            &mut state,
+            &mut ideal_cursor,
+        ).await.unwrap();
+
+        assert_eq!(results.len(), 4);
+        assert!(results.iter().all(|r| r.is_success()));
+        assert_eq!(state.get_current_input(), "hei");
+    }
+}

canvas/src/lib.rs

@@ -0,0 +1,5 @@
+// src/lib.rs
+pub mod canvas;
+pub mod autocomplete;
+pub mod config;
+pub mod dispatcher;

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/canvas_config.toml

@@ -0,0 +1,57 @@
+# canvas_config.toml - Complete Canvas Configuration
+
+[behavior]
+wrap_around_fields = true
+auto_save_on_field_change = false
+word_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+max_suggestions = 6
+
+[appearance]
+cursor_style = "block"  # "block", "bar", "underline"
+show_field_numbers = false
+highlight_current_field = true
+
+# Read-only mode keybindings (vim-style)
+[keybindings.read_only]
+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 = ["shift+g"]
+next_field = ["Tab"]
+prev_field = ["Shift+Tab"]
+
+# Edit mode keybindings
+[keybindings.edit]
+delete_char_backward = ["Backspace"]
+delete_char_forward = ["Delete"]
+move_left = ["Left"]
+move_right = ["Right"]
+move_up = ["Up"]
+move_down = ["Down"]
+move_line_start = ["Home"]
+move_line_end = ["End"]
+move_word_next = ["Ctrl+Right"]
+move_word_prev = ["Ctrl+Left"]
+next_field = ["Tab"]
+prev_field = ["Shift+Tab"]
+
+# Suggestion/autocomplete keybindings
+[keybindings.suggestions]
+suggestion_up = ["Up", "Ctrl+p"]
+suggestion_down = ["Down", "Ctrl+n"]
+select_suggestion = ["Enter", "Tab"]
+exit_suggestions = ["Esc"]
+trigger_autocomplete = ["Tab"]
+
+# Global keybindings (work in both modes)
+[keybindings.global]
+move_up = ["Up"]
+move_down = ["Down"]

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"]
@@ -22,8 +22,6 @@ 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"]
@@ -31,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
@@ -70,11 +69,10 @@ prev_field = ["shift+enter"]
 exit = ["esc", "ctrl+e"]
 delete_char_forward = ["delete"]
 delete_char_backward = ["backspace"]
-move_left = [""]
+move_left = ["left"]
 move_right = ["right"]
 suggestion_down = ["ctrl+n", "tab"]
 suggestion_up = ["ctrl+p", "shift+tab"]
-trigger_autocomplete = ["left"]
 
 [keybindings.command]
 exit_command_mode = ["ctrl+g", "esc"]

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/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)])
@@ -83,7 +91,7 @@ pub fn render_login(
         app_state.focused_button_index== login_button_index
     } else {
         false
-    };    
+    };
     let mut login_style = Style::default().fg(theme.fg);
     let mut login_border = Style::default().fg(theme.border);
     if login_active {
@@ -105,12 +113,12 @@ 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);
     if return_active {
@@ -132,17 +140,15 @@ 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_active_button_index, 
+            &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/autocomplete.rs

@@ -1,30 +1,18 @@
 // src/components/common/autocomplete.rs
 
-use common::proto::multieko2::search::search_response::Hit;
 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},
     widgets::{Block, List, ListItem, ListState},
     Frame,
 };
-use std::collections::HashMap;
 use unicode_width::UnicodeWidthStr;
 
-/// Converts a serde_json::Value into a displayable String.
-/// Handles String, Number, and Bool variants. Returns an empty string for Null and others.
-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(),
-        // Return an empty string for Null, Array, or Object so we can filter them out.
-        _ => String::new(),
-    }
-}
-
 /// Renders an opaque dropdown list for simple string-based suggestions.
-/// This function remains unchanged.
+/// THIS IS THE RESTORED FUNCTION.
 pub fn render_autocomplete_dropdown(
     f: &mut Frame,
     input_rect: Rect,
@@ -84,22 +72,22 @@ pub fn render_autocomplete_dropdown(
         .collect();
 
     let list = List::new(items);
-    let mut profile_list_state = ListState::default();
-    profile_list_state.select(selected_index);
+    let mut list_state = ListState::default();
+    list_state.select(selected_index);
 
-    f.render_stateful_widget(list, dropdown_area, &mut profile_list_state);
+    f.render_stateful_widget(list, dropdown_area, &mut list_state);
 }
 
-// --- MODIFIED FUNCTION FOR RICH SUGGESTIONS ---
 /// Renders an opaque dropdown list for rich `Hit`-based suggestions.
-/// Displays the value of the first meaningful column, followed by the Hit ID.
-pub fn render_rich_autocomplete_dropdown(
+/// 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;
@@ -107,50 +95,9 @@ pub fn render_rich_autocomplete_dropdown(
 
     let display_names: Vec<String> = suggestions
         .iter()
-        .map(|hit| {
-            // Use serde_json::Value to handle mixed types (string, null, etc.)
-            if let Ok(content_map) =
-                serde_json::from_str::<HashMap<String, serde_json::Value>>(
-                    &hit.content_json,
-                )
-            {
-                // Define keys to ignore for a cleaner display
-                const IGNORED_KEYS: &[&str] = &["id", "deleted", "created_at"];
-
-                // Get keys, filter out ignored ones, and sort for consistency
-                let mut keys: Vec<_> = content_map
-                    .keys()
-                    .filter(|k| !IGNORED_KEYS.contains(&k.as_str()))
-                    .cloned()
-                    .collect();
-                keys.sort();
-
-                // Get only the first non-empty value from the sorted keys
-                let values: Vec<_> = keys
-                    .iter()
-                    .map(|key| {
-                        content_map
-                            .get(key)
-                            .map(json_value_to_string)
-                            .unwrap_or_default()
-                    })
-                    .filter(|s| !s.is_empty()) // Filter out null/empty values
-                    .take(1) // Changed from take(2) to take(1)
-                    .collect();
-
-                let display_part = values.first().cloned().unwrap_or_default(); // Get the first value
-                if display_part.is_empty() {
-                    format!("ID: {}", hit.id)
-                } else {
-                    format!("{} | ID: {}", display_part, hit.id) // ID at the end
-                }
-            } else {
-                format!("ID: {} (parse error)", hit.id)
-            }
-        })
+        .map(|hit| form_state.get_display_name_for_hit(hit))
         .collect();
 
-    // --- Calculate Dropdown Size & Position ---
     let max_suggestion_width =
         display_names.iter().map(|s| s.width()).max().unwrap_or(0) as u16;
     let horizontal_padding: u16 = 2;
@@ -164,7 +111,6 @@ pub fn render_rich_autocomplete_dropdown(
         height: dropdown_height,
     };
 
-    // --- Clamping Logic ---
     if dropdown_area.bottom() > frame_area.height {
         dropdown_area.y = input_rect.y.saturating_sub(dropdown_height);
     }
@@ -174,7 +120,6 @@ pub fn render_rich_autocomplete_dropdown(
     dropdown_area.x = dropdown_area.x.max(0);
     dropdown_area.y = dropdown_area.y.max(0);
 
-    // --- Rendering Logic ---
     let background_block =
         Block::default().style(Style::default().bg(Color::DarkGray));
     f.render_widget(background_block, dropdown_area);

client/src/components/common/search_palette.rs

@@ -55,10 +55,10 @@ pub fn render_search_palette(
         .style(Style::default().fg(theme.fg));
     f.render_widget(input_text, inner_chunks[0]);
     // Set cursor position
-    f.set_cursor(
+    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 {

client/src/components/common/status_line.rs

@@ -5,9 +5,10 @@ use ratatui::{
     layout::Rect,
     style::Style,
     text::{Line, Span, Text},
-    widgets::{Paragraph, Wrap}, // Make sure Wrap is imported
+    widgets::Paragraph,
     Frame,
 };
+use ratatui::widgets::Wrap;
 use std::path::Path;
 use unicode_width::UnicodeWidthStr;
 
@@ -47,7 +48,7 @@ pub fn render_status_line(
     }
 
     // --- The normal status line rendering logic (unchanged) ---
-    let program_info = format!("multieko2 v{}", env!("CARGO_PKG_VERSION"));
+    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()

client/src/components/form/form.rs

@@ -1,10 +1,8 @@
 // src/components/form/form.rs
-use crate::components::common::autocomplete; // <--- ADD THIS IMPORT
-use crate::components::handlers::canvas::render_canvas;
+use crate::components::common::autocomplete;
 use crate::config::colors::themes::Theme;
-use crate::state::app::highlight::HighlightState;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::pages::form::FormState; // <--- CHANGE THIS IMPORT
+use canvas::canvas::{CanvasState, render_canvas, HighlightState};
+use crate::state::pages::form::FormState;
 use ratatui::{
     layout::{Alignment, Constraint, Direction, Layout, Margin, Rect},
     style::Style,
@@ -15,7 +13,7 @@ use ratatui::{
 pub fn render_form(
     f: &mut Frame,
     area: Rect,
-    form_state: &FormState, // <--- CHANGE THIS to the concrete type
+    form_state: &FormState,
     fields: &[&str],
     current_field_idx: &usize,
     inputs: &[&String],
@@ -58,57 +56,43 @@ pub fn render_form(
             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]);
 
-    // Get the active field's rect from render_canvas
+    // Use the canvas library's render_canvas function
     let active_field_rect = render_canvas(
         f,
         main_layout[1],
         form_state,
-        fields,
-        current_field_idx,
-        inputs,
         theme,
         is_edit_mode,
         highlight_state,
     );
 
-    // --- NEW: RENDER AUTOCOMPLETE ---
+    // --- RENDER RICH AUTOCOMPLETE ONLY ---
     if form_state.autocomplete_active {
-        // Use the Rect of the active field that render_canvas found for us.
         if let Some(active_rect) = active_field_rect {
-            let selected_index = form_state.get_selected_suggestion_index();
+            // Get selected index directly from form_state
+            let selected_index = form_state.selected_suggestion_index;
 
-            // THE DECIDER LOGIC:
-            // 1. Check for rich suggestions first.
+            // Only render rich suggestions (your Hit objects)
             if let Some(rich_suggestions) = form_state.get_rich_suggestions() {
                 if !rich_suggestions.is_empty() {
-                    autocomplete::render_rich_autocomplete_dropdown(
-                        f,
-                        active_rect,
-                        f.area(), // Use f.area() for clamping, not f.size()
-                        theme,
-                        rich_suggestions,
-                        selected_index,
-                    );
-                }
-            }
-            // 2. Fallback to simple suggestions if rich ones aren't available.
-            else if let Some(simple_suggestions) = form_state.get_suggestions() {
-                if !simple_suggestions.is_empty() {
-                    autocomplete::render_autocomplete_dropdown(
+                    autocomplete::render_hit_autocomplete_dropdown(
                         f,
                         active_rect,
                         f.area(),
                         theme,
-                        simple_suggestions,
+                        rich_suggestions,
                         selected_index,
+                        form_state,
                     );
                 }
             }
+            // Removed simple suggestions - we only use rich ones now!
         }
     }
 }

client/src/components/handlers/canvas.rs

@@ -1,35 +1,99 @@
 // src/components/handlers/canvas.rs
+
 use ratatui::{
-    widgets::{Paragraph, Block, Borders},
-    layout::{Layout, Constraint, Direction, Rect},
-    style::{Style, Modifier},
+    layout::{Alignment, Constraint, Direction, Layout, Rect},
+    style::{Modifier, Style},
     text::{Line, Span},
+    widgets::{Block, Borders, Paragraph},
     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};
+use crate::state::app::highlight::HighlightState;
+use crate::state::pages::canvas_state::CanvasState as LegacyCanvasState;
+use canvas::canvas::CanvasState as LibraryCanvasState;
+use std::cmp::{max, min};
 
+/// Render canvas for legacy CanvasState (AddTableState, LoginState, RegisterState, AddLogicState)
 pub fn render_canvas(
     f: &mut Frame,
     area: Rect,
-    form_state: &impl CanvasState,
+    form_state: &impl LegacyCanvasState,
     fields: &[&str],
     current_field_idx: &usize,
     inputs: &[&String],
     theme: &Theme,
     is_edit_mode: bool,
-    highlight_state: &HighlightState, // Using the enum state
+    highlight_state: &HighlightState,
 ) -> Option<Rect> {
-    // ... (setup code remains the same) ...
+    render_canvas_impl(
+        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),
+    )
+}
+
+/// Render canvas for library CanvasState (FormState)
+pub fn render_canvas_library(
+    f: &mut Frame,
+    area: Rect,
+    form_state: &impl LibraryCanvasState,
+    fields: &[&str],
+    current_field_idx: &usize,
+    inputs: &[&String],
+    theme: &Theme,
+    is_edit_mode: bool,
+    highlight_state: &HighlightState,
+) -> Option<Rect> {
+    render_canvas_impl(
+        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),
+    )
+}
+
+/// Internal implementation shared by both render functions
+fn render_canvas_impl<F1, F2>(
+    f: &mut Frame,
+    area: Rect,
+    fields: &[&str],
+    current_field_idx: &usize,
+    inputs: &[&String],
+    theme: &Theme,
+    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,
+{
     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() {
+    let border_style = if has_unsaved_changes {
         Style::default().fg(theme.warning)
     } else if is_edit_mode {
         Style::default().fg(theme.accent)
@@ -58,46 +122,46 @@ pub fn render_canvas(
 
     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,
-        });
+            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() {
+    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();
 
+        // Use the provided closure to get display value
+        let text = get_display_value(i);
+        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) }
+                    &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 {
@@ -111,24 +175,20 @@ pub fn render_canvas(
                 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
+                    if start_field == end_field {
                         let clamped_start = start_char.min(text_len);
-                        let clamped_end = end_char.min(text_len); // Use text_len for slicing logic
+                        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();
-                        // 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'
+                            Span::styled(after, normal_style_in_highlight),
                         ]);
-                    } else if i == start_field { // Case 2: Multi-Line Highlight - Start Line
-                        // Use start_char here
+                    } else if i == start_field {
                         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();
@@ -136,8 +196,7 @@ pub fn render_canvas(
                             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
+                    } else if i == end_field {
                         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();
@@ -145,19 +204,17 @@ pub fn render_canvas(
                             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 {
+                        line = Line::from(Span::styled(&text, highlight_style));
                     }
-                } else { // Case 5: Line Outside Character-wise Highlight Range
+                } else {
                     line = Line::from(Span::styled(
-                        text,
-                        // Use normal styling (active or inactive)
+                        &text,
                         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);
@@ -165,25 +222,30 @@ pub fn render_canvas(
                 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));
+                    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)
+                        &text,
                         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;
+
+            // Use the provided closure to check for display override
+            let cursor_x = if has_display_override(i) {
+                // If an override exists, place the cursor at the end.
+                input_rows[i].x + text.chars().count() as u16
+            } else {
+                // Otherwise, use the real cursor position.
+                input_rows[i].x + current_cursor_pos as u16
+            };
             let cursor_y = input_rows[i].y;
             f.set_cursor_position((cursor_x, cursor_y));
         }
@@ -191,4 +253,3 @@ pub fn render_canvas(
 
     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,47 +251,206 @@ 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();
-                        expected_key = Some(KeyCode::Char(c));
+                        if let Some(c) = part.chars().next() {
+                            expected_key = Some(KeyCode::Char(c));
+                        }
                     }
                 }
             }

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/edit/auth_e.rs

@@ -1,11 +1,13 @@
 // 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::state::app::state::AppState;
 use crate::tui::functions::common::form::{revert, save};
 use crossterm::event::{KeyCode, KeyEvent};
+use canvas::autocomplete::AutocompleteCanvasState;
+use canvas::canvas::CanvasState;
 use std::any::Any;
 use anyhow::Result;
 
@@ -13,6 +15,7 @@ pub async fn execute_common_action<S: CanvasState + Any>(
     action: &str,
     state: &mut S,
     grpc_client: &mut GrpcClient,
+    app_state: &AppState,
     current_position: &mut u64,
     total_count: u64,
 ) -> Result<String> {
@@ -27,6 +30,7 @@ pub async fn execute_common_action<S: CanvasState + Any>(
                 match action {
                     "save" => {
                         let outcome = save(
+                            app_state,
                             form_state,
                             grpc_client,
                         )
@@ -292,53 +296,42 @@ pub async fn execute_edit_action<S: CanvasState + Any + Send>(
         "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 {
+                // Only handle if it's the role field (index 4) and autocomplete is active
+                if register_state.current_field() == 4 && register_state.is_autocomplete_active() {
                     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_down" => {
+                            if let Some(autocomplete_state) = register_state.autocomplete_state_mut() {
+                                autocomplete_state.select_next();
+                                Ok("Suggestion changed down".to_string())
+                            } else {
+                                Ok("No autocomplete state".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())
+                        "suggestion_up" => {
+                            if let Some(autocomplete_state) = register_state.autocomplete_state_mut() {
+                                autocomplete_state.select_previous();
+                                Ok("Suggestion changed up".to_string())
+                            } else {
+                                Ok("No autocomplete state".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
-                                }
+                        "select_suggestion" => {
+                            if let Some(message) = register_state.apply_autocomplete_selection() {
+                                Ok(message)
                             } 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;
+                        "exit_suggestion_mode" => {
+                            register_state.deactivate_autocomplete();
                             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())
-                        }
+                        _ => 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())
-                 }
+                    Ok("Suggestion action ignored: Not on role field or autocomplete not active.".to_string())
+                }
             } else {
-                // Downcast failed - this action is only for RegisterState
                 Ok(format!("Action '{}' not applicable for this state type.", action))
             }
         }

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

@@ -1,12 +1,13 @@
 // 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::state::app::state::AppState;
 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 canvas::canvas::CanvasState;
 use std::any::Any;
 use anyhow::Result;
 
@@ -14,6 +15,7 @@ pub async fn execute_common_action<S: CanvasState + Any>(
     action: &str,
     state: &mut S,
     grpc_client: &mut GrpcClient,
+    app_state: &AppState,
 ) -> Result<EventOutcome> {
     match action {
         "save" | "revert" => {
@@ -26,6 +28,7 @@ pub async fn execute_common_action<S: CanvasState + Any>(
                 match action {
                     "save" => {
                         let save_result = save(
+                            app_state,
                             form_state,
                             grpc_client,
                         ).await;

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

@@ -1,8 +1,8 @@
 // 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 canvas::canvas::CanvasState;
 use anyhow::Result;
 
 #[derive(PartialEq)]

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

@@ -1,7 +1,7 @@
 // src/functions/modes/read_only/form_ro.rs
 
 use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::state::pages::canvas_state::CanvasState;
+use canvas::canvas::CanvasState;
 use anyhow::Result;
 
 #[derive(PartialEq)]

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,7 +1,7 @@
 // src/modes/canvas/edit.rs
 use crate::config::binds::config::Config;
 use crate::functions::modes::edit::{
-    add_logic_e, add_table_e, auth_e, form_e,
+    add_logic_e, add_table_e, form_e,
 };
 use crate::modes::handlers::event::EventHandler;
 use crate::services::grpc_client::GrpcClient;
@@ -9,14 +9,15 @@ 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 canvas::canvas::CanvasState;
+use canvas::{canvas::CanvasAction, dispatcher::ActionDispatcher, canvas::ActionResult};
 use anyhow::Result;
-use common::proto::multieko2::search::search_response::Hit;
+use common::proto::komp_ac::search::search_response::Hit;
 use crossterm::event::{KeyCode, KeyEvent};
 use tokio::sync::mpsc;
-use tracing::{debug, info};
+use tracing::info;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum EditEventOutcome {
@@ -74,6 +75,111 @@ async fn trigger_form_autocomplete_search(
     }
 }
 
+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
+    if let Some(canvas_action) = CanvasAction::from_key(key_event.code) {
+        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())
+}
+
+/// NEW: Unified canvas action handler for any CanvasState (LoginState, RegisterState, etc.)
+/// This replaces the old auth_e::execute_edit_action calls with the new canvas library
+async fn handle_canvas_state_edit<S: CanvasState>(
+    key: KeyEvent,
+    config: &Config,
+    state: &mut S,
+    ideal_cursor_column: &mut usize,
+) -> Result<String> {
+    // Try direct key mapping first (same pattern as FormState)
+    if let Some(canvas_action) = CanvasAction::from_key(key.code) {
+        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(_) => {
+                // Fall through to try config mapping
+            }
+        }
+    }
+
+    // Try config-mapped action (same pattern as FormState)
+    if let Some(action_str) = config.get_edit_action_for_key(key.code, key.modifiers) {
+        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));
+            }
+        }
+    }
+
+    Ok(String::new())
+}
 
 #[allow(clippy::too_many_arguments)]
 pub async fn handle_edit_event(
@@ -132,13 +238,24 @@ pub async fn handle_edit_event(
                             .get(selected_idx)
                             .cloned()
                         {
+                            // --- THIS IS THE CORE LOGIC CHANGE ---
+
+                            // 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();
-                            let new_cursor_pos = current_input.len();
-                            form_state.set_current_cursor_pos(new_cursor_pos);
-                            // FIX: Access ideal_cursor_column through event_handler
-                            event_handler.ideal_cursor_column = new_cursor_pos;
+
+                            // 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(
@@ -220,12 +337,12 @@ pub async fn handle_edit_event(
             return Ok(EditEventOutcome::ExitEditMode);
         }
 
-        // Handle all other edit actions
+        // Handle all other edit actions - NOW USING CANVAS LIBRARY
         let msg = if app_state.ui.show_login {
-            // FIX: Pass &mut event_handler.ideal_cursor_column
-            auth_e::execute_edit_action(
-                action_str,
+            // 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,
             )
@@ -249,10 +366,10 @@ pub async fn handle_edit_event(
             )
             .await?
         } else if app_state.ui.show_register {
-            // FIX: Pass &mut event_handler.ideal_cursor_column
-            auth_e::execute_edit_action(
-                action_str,
+            // 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,
             )
@@ -273,10 +390,10 @@ pub async fn handle_edit_event(
     // --- FALLBACK FOR CHARACTER INSERTION (IF NO OTHER BINDING MATCHED) ---
     if let KeyCode::Char(_) = key.code {
         let msg = if app_state.ui.show_login {
-            // FIX: Pass &mut event_handler.ideal_cursor_column
-            auth_e::execute_edit_action(
-                "insert_char",
+            // 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,
             )
@@ -300,10 +417,10 @@ pub async fn handle_edit_event(
             )
             .await?
         } else if app_state.ui.show_register {
-            // FIX: Pass &mut event_handler.ideal_cursor_column
-            auth_e::execute_edit_action(
-                "insert_char",
+            // 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,
             )

client/src/modes/canvas/read_only.rs

@@ -3,16 +3,70 @@
 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::canvas_state::CanvasState as LocalCanvasState;
 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;
 
+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
+    if let Some(canvas_action) = CanvasAction::from_key(key_event.code) {
+        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,
@@ -36,18 +90,46 @@ 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();
 
-        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();
+        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() {
+                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 (uses library CanvasState)
+            use canvas::canvas::CanvasState as LibraryCanvasState;  // Import at the top of the function
+            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()));

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,4 @@
-// src/client/modes/handlers.rs
+// src/modes/handlers.rs
 pub mod event;
+pub mod event_helper;
 pub mod mode_manager;

client/src/modes/handlers/event.rs

@@ -15,8 +15,12 @@ use crate::modes::{
     general::{dialog, navigation},
     handlers::mode_manager::{AppMode, ModeManager},
 };
+use crate::state::pages::canvas_state::CanvasState as LegacyCanvasState;
 use crate::services::auth::AuthClient;
 use crate::services::grpc_client::GrpcClient;
+use canvas::{canvas::CanvasAction, dispatcher::ActionDispatcher};
+use canvas::canvas::CanvasState as LibraryCanvasState;
+use super::event_helper::*;
 use crate::state::{
     app::{
         buffer::{AppView, BufferState},
@@ -42,7 +46,7 @@ use crate::tui::{
 use crate::ui::handlers::context::UiContext;
 use crate::ui::handlers::rat_state::UiStateHandler;
 use anyhow::Result;
-use common::proto::multieko2::search::search_response::Hit;
+use common::proto::komp_ac::search::search_response::Hit;
 use crossterm::cursor::SetCursorStyle;
 use crossterm::event::{Event, KeyCode, KeyEvent};
 use tokio::sync::mpsc;
@@ -573,55 +577,106 @@ impl EventHandler {
                 }
 
                 AppMode::ReadOnly => {
-                    if config.get_read_only_action_for_key(key_code, modifiers) == Some("enter_highlight_mode_linewise") && ModeManager::can_enter_highlight_mode(current_mode) {
-                        let current_field_index = if app_state.ui.show_login { login_state.current_field() } else if app_state.ui.show_register { register_state.current_field() } else { form_state.current_field() };
-                        self.highlight_state = HighlightState::Linewise { anchor_line: current_field_index };
+                    // Handle highlight mode transitions
+                    if config.get_read_only_action_for_key(key_code, modifiers) == Some("enter_highlight_mode_linewise")
+                        && ModeManager::can_enter_highlight_mode(current_mode)
+                    {
+                        let current_field_index = get_current_field_for_state(
+                            app_state,
+                            login_state,
+                            register_state,
+                            form_state
+                        );
+                        self.highlight_state = HighlightState::Linewise {
+                            anchor_line: current_field_index
+                        };
                         self.command_message = "-- LINE HIGHLIGHT --".to_string();
                         return Ok(EventOutcome::Ok(self.command_message.clone()));
-                    } else if config.get_read_only_action_for_key(key_code, modifiers) == Some("enter_highlight_mode") && ModeManager::can_enter_highlight_mode(current_mode) {
-                        let current_field_index = if app_state.ui.show_login { login_state.current_field() } else if app_state.ui.show_register { register_state.current_field() } else { form_state.current_field() };
-                        let current_cursor_pos = if app_state.ui.show_login { login_state.current_cursor_pos() } else if app_state.ui.show_register { register_state.current_cursor_pos() } else { form_state.current_cursor_pos() };
+                    }
+                    else if config.get_read_only_action_for_key(key_code, modifiers) == Some("enter_highlight_mode")
+                        && ModeManager::can_enter_highlight_mode(current_mode)
+                    {
+                        let current_field_index = get_current_field_for_state(
+                            app_state,
+                            login_state,
+                            register_state,
+                            form_state
+                        );
+                        let current_cursor_pos = get_current_cursor_pos_for_state(
+                            app_state,
+                            login_state,
+                            register_state,
+                            form_state
+                        );
                         let anchor = (current_field_index, current_cursor_pos);
                         self.highlight_state = HighlightState::Characterwise { anchor };
                         self.command_message = "-- HIGHLIGHT --".to_string();
                         return Ok(EventOutcome::Ok(self.command_message.clone()));
-                    } else if config.get_read_only_action_for_key(key_code, modifiers).as_deref() == Some("enter_edit_mode_before") && ModeManager::can_enter_edit_mode(current_mode) {
+                    }
+
+                    // Handle edit mode transitions
+                    else if config.get_read_only_action_for_key(key_code, modifiers).as_deref() == Some("enter_edit_mode_before")
+                        && ModeManager::can_enter_edit_mode(current_mode)
+                    {
                         self.is_edit_mode = true;
                         self.edit_mode_cooldown = true;
                         self.command_message = "Edit mode".to_string();
                         terminal.set_cursor_style(SetCursorStyle::BlinkingBar)?;
                         return Ok(EventOutcome::Ok(self.command_message.clone()));
-                    } else if config.get_read_only_action_for_key(key_code, modifiers).as_deref() == Some("enter_edit_mode_after") && ModeManager::can_enter_edit_mode(current_mode) {
-                        let current_input = if app_state.ui.show_login || app_state.ui.show_register { login_state.get_current_input() } else { form_state.get_current_input() };
-                        let current_cursor_pos = if app_state.ui.show_login || app_state.ui.show_register { login_state.current_cursor_pos() } else { form_state.current_cursor_pos() };
+                    }
+                    else if config.get_read_only_action_for_key(key_code, modifiers).as_deref() == Some("enter_edit_mode_after")
+                        && ModeManager::can_enter_edit_mode(current_mode)
+                    {
+                        let current_input = get_current_input_for_state(
+                            app_state,
+                            login_state,
+                            register_state,
+                            form_state
+                        );
+                        let current_cursor_pos = get_cursor_pos_for_mixed_state(
+                            app_state,
+                            login_state,
+                            form_state
+                        );
+
+                        // Move cursor forward if possible
                         if !current_input.is_empty() && current_cursor_pos < current_input.len() {
-                            if app_state.ui.show_login || app_state.ui.show_register {
-                                login_state.set_current_cursor_pos(current_cursor_pos + 1);
-                                self.ideal_cursor_column = login_state.current_cursor_pos();
-                            } else {
-                                form_state.set_current_cursor_pos(current_cursor_pos + 1);
-                                self.ideal_cursor_column = form_state.current_cursor_pos();
-                            }
+                            let new_cursor_pos = current_cursor_pos + 1;
+                            set_current_cursor_pos_for_state(
+                                app_state,
+                                login_state,
+                                register_state,
+                                form_state,
+                                new_cursor_pos
+                            );
+                            self.ideal_cursor_column = get_current_cursor_pos_for_state(
+                                app_state,
+                                login_state,
+                                register_state,
+                                form_state
+                            );
                         }
+
                         self.is_edit_mode = true;
                         self.edit_mode_cooldown = true;
                         app_state.ui.focus_outside_canvas = false;
                         self.command_message = "Edit mode (after cursor)".to_string();
                         terminal.set_cursor_style(SetCursorStyle::BlinkingBar)?;
                         return Ok(EventOutcome::Ok(self.command_message.clone()));
-                    } else if config.get_read_only_action_for_key(key_code, modifiers) == Some("enter_command_mode") && ModeManager::can_enter_command_mode(current_mode) {
+                    }
+                    else if config.get_read_only_action_for_key(key_code, modifiers) == Some("enter_command_mode")
+                        && ModeManager::can_enter_command_mode(current_mode)
+                    {
                         self.command_mode = true;
                         self.command_input.clear();
                         self.command_message.clear();
                         return Ok(EventOutcome::Ok(String::new()));
                     }
 
-                    if let Some(action) =
-                        config.get_common_action(key_code, modifiers)
-                    {
+                    // Handle common actions (save, quit, etc.)
+                    if let Some(action) = config.get_common_action(key_code, modifiers) {
                         match action {
-                            "save" | "force_quit" | "save_and_quit"
-                            | "revert" => {
+                            "save" | "force_quit" | "save_and_quit" | "revert" => {
                                 return common_mode::handle_core_action(
                                     action,
                                     form_state,
@@ -639,23 +694,36 @@ impl EventHandler {
                         }
                     }
 
-                    let (_should_exit, message) =
-                        read_only::handle_read_only_event(
-                            app_state,
+                    // Try canvas action for form first (NEW: Canvas library integration)
+                    if app_state.ui.show_form {
+                        if let Ok(Some(canvas_message)) = self.handle_form_canvas_action(
                             key_event,
                             config,
                             form_state,
-                            login_state,
-                            register_state,
-                            &mut admin_state.add_table_state,
-                            &mut admin_state.add_logic_state,
-                            &mut self.key_sequence_tracker,
-                            &mut self.grpc_client, // <-- FIX 1
-                            &mut self.command_message,
-                            &mut self.edit_mode_cooldown,
-                            &mut self.ideal_cursor_column,
-                        )
-                        .await?;
+                            false, // not edit mode
+                        ).await {
+                            return Ok(EventOutcome::Ok(canvas_message));
+                        }
+                    }
+
+                    // Fallback to legacy read-only event handling
+                    let (_should_exit, message) = read_only::handle_read_only_event(
+                        app_state,
+                        key_event,
+                        config,
+                        form_state,
+                        login_state,
+                        register_state,
+                        &mut admin_state.add_table_state,
+                        &mut admin_state.add_logic_state,
+                        &mut self.key_sequence_tracker,
+                        &mut self.grpc_client,
+                        &mut self.command_message,
+                        &mut self.edit_mode_cooldown,
+                        &mut self.ideal_cursor_column,
+                    )
+                    .await?;
+
                     return Ok(EventOutcome::Ok(message));
                 }
 
@@ -695,12 +763,10 @@ impl EventHandler {
                 }
 
                 AppMode::Edit => {
-                    if let Some(action) =
-                        config.get_common_action(key_code, modifiers)
-                    {
+                    // Handle common actions (save, quit, etc.)
+                    if let Some(action) = config.get_common_action(key_code, modifiers) {
                         match action {
-                            "save" | "force_quit" | "save_and_quit"
-                            | "revert" => {
+                            "save" | "force_quit" | "save_and_quit" | "revert" => {
                                 return common_mode::handle_core_action(
                                     action,
                                     form_state,
@@ -718,9 +784,25 @@ impl EventHandler {
                         }
                     }
 
+                    // Try canvas action for form first (NEW: Canvas library integration)
+                    if app_state.ui.show_form {
+                        if let Ok(Some(canvas_message)) = self.handle_form_canvas_action(
+                            key_event,
+                            config,
+                            form_state,
+                            true, // edit mode
+                        ).await {
+                            if !canvas_message.is_empty() {
+                                self.command_message = canvas_message.clone();
+                            }
+                            return Ok(EventOutcome::Ok(canvas_message));
+                        }
+                    }
+
+                    // Handle legacy edit events
                     let mut current_position = form_state.current_position;
                     let total_count = form_state.total_count;
-                    // --- MODIFIED: Pass `self` instead of `grpc_client` ---
+
                     let edit_result = edit::handle_edit_event(
                         key_event,
                         config,
@@ -739,30 +821,62 @@ impl EventHandler {
                         Ok(edit::EditEventOutcome::ExitEditMode) => {
                             self.is_edit_mode = false;
                             self.edit_mode_cooldown = true;
-                            let has_changes = if app_state.ui.show_login { login_state.has_unsaved_changes() } else if app_state.ui.show_register { register_state.has_unsaved_changes() } else { form_state.has_unsaved_changes() };
-                            self.command_message = if has_changes { "Exited edit mode (unsaved changes remain)".to_string() } else { "Read-only mode".to_string() };
+
+                            // Check for unsaved changes across all states
+                            let has_changes = get_has_unsaved_changes_for_state(
+                                app_state,
+                                login_state,
+                                register_state,
+                                form_state
+                            );
+
+                            // Set appropriate message based on changes
+                            self.command_message = if has_changes {
+                                "Exited edit mode (unsaved changes remain)".to_string()
+                            } else {
+                                "Read-only mode".to_string()
+                            };
+
                             terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
-                            let current_input = if app_state.ui.show_login { login_state.get_current_input() } else if app_state.ui.show_register { register_state.get_current_input() } else { form_state.get_current_input() };
-                            let current_cursor_pos = if app_state.ui.show_login { login_state.current_cursor_pos() } else if app_state.ui.show_register { register_state.current_cursor_pos() } else { form_state.current_cursor_pos() };
+
+                            // Get current input and cursor position
+                            let current_input = get_current_input_for_state(
+                                app_state,
+                                login_state,
+                                register_state,
+                                form_state
+                            );
+                            let current_cursor_pos = get_current_cursor_pos_for_state(
+                                app_state,
+                                login_state,
+                                register_state,
+                                form_state
+                            );
+
+                            // Adjust cursor if it's beyond the input length
                             if !current_input.is_empty() && current_cursor_pos >= current_input.len() {
                                 let new_pos = current_input.len() - 1;
-                                let target_state: &mut dyn CanvasState = if app_state.ui.show_login { login_state } else if app_state.ui.show_register { register_state } else { form_state };
-                                target_state.set_current_cursor_pos(new_pos);
+                                set_current_cursor_pos_for_state(
+                                    app_state,
+                                    login_state,
+                                    register_state,
+                                    form_state,
+                                    new_pos
+                                );
                                 self.ideal_cursor_column = new_pos;
                             }
-                            return Ok(EventOutcome::Ok(
-                                self.command_message.clone(),
-                            ));
+
+                            return Ok(EventOutcome::Ok(self.command_message.clone()));
                         }
+
                         Ok(edit::EditEventOutcome::Message(msg)) => {
                             if !msg.is_empty() {
                                 self.command_message = msg;
                             }
                             self.key_sequence_tracker.reset();
-                            return Ok(EventOutcome::Ok(
-                                self.command_message.clone(),
-                            ));
+                            return Ok(EventOutcome::Ok(self.command_message.clone()));
                         }
+
                         Err(e) => {
                             return Err(e.into());
                         }
@@ -906,4 +1020,180 @@ impl EventHandler {
     fn is_processed_command(&self, command: &str) -> bool {
         matches!(command, "w" | "q" | "q!" | "wq" | "r")
     }
+
+    async fn handle_form_canvas_action(
+        &mut self,
+        key_event: KeyEvent,
+        _config: &Config, // Not used anymore - canvas has its own config
+        form_state: &mut FormState,
+        is_edit_mode: bool,
+    ) -> Result<Option<String>> {
+        // Load canvas config (canvas_config.toml or vim defaults)
+        let canvas_config = canvas::config::CanvasConfig::load();
+
+        // Handle suggestion actions first if suggestions are active
+        if form_state.autocomplete_active {
+            if let Some(action_str) = canvas_config.get_suggestion_action(key_event.code, key_event.modifiers) {
+                let canvas_action = CanvasAction::from_string(&action_str);
+                match ActionDispatcher::dispatch(canvas_action, form_state, &mut self.ideal_cursor_column).await {
+                    Ok(result) => return Ok(Some(result.message().unwrap_or("").to_string())),
+                    Err(_) => return Ok(Some("Suggestion action failed".to_string())),
+                }
+            }
+
+            // Fallback hardcoded suggestion handling
+            match key_event.code {
+                KeyCode::Up => {
+                    if let Ok(result) = ActionDispatcher::dispatch(
+                        CanvasAction::SuggestionUp,
+                        form_state,
+                        &mut self.ideal_cursor_column,
+                    ).await {
+                        return Ok(Some(result.message().unwrap_or("").to_string()));
+                    }
+                }
+                KeyCode::Down => {
+                    if let Ok(result) = ActionDispatcher::dispatch(
+                        CanvasAction::SuggestionDown,
+                        form_state,
+                        &mut self.ideal_cursor_column,
+                    ).await {
+                        return Ok(Some(result.message().unwrap_or("").to_string()));
+                    }
+                }
+                KeyCode::Enter => {
+                    if let Ok(result) = ActionDispatcher::dispatch(
+                        CanvasAction::SelectSuggestion,
+                        form_state,
+                        &mut self.ideal_cursor_column,
+                    ).await {
+                        return Ok(Some(result.message().unwrap_or("").to_string()));
+                    }
+                }
+                KeyCode::Esc => {
+                    if let Ok(result) = ActionDispatcher::dispatch(
+                        CanvasAction::ExitSuggestions,
+                        form_state,
+                        &mut self.ideal_cursor_column,
+                    ).await {
+                        return Ok(Some(result.message().unwrap_or("").to_string()));
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        // FIXED: Use canvas config instead of client config
+        let action_str = canvas_config.get_action_for_key(
+            key_event.code,
+            key_event.modifiers,
+            is_edit_mode,
+            form_state.autocomplete_active
+        );
+
+        if let Some(action_str) = action_str {
+            // Filter out mode transition actions - let legacy handlers deal with these
+            if Self::is_mode_transition_action(action_str) {
+                return Ok(None); // Let legacy handler handle mode transitions
+            }
+
+            let canvas_action = CanvasAction::from_string(&action_str);
+            match ActionDispatcher::dispatch(
+                canvas_action,
+                form_state,
+                &mut self.ideal_cursor_column,
+            ).await {
+                Ok(result) => {
+                    return Ok(Some(result.message().unwrap_or("").to_string()));
+                }
+                Err(_) => {
+                    return Ok(Some("Canvas action failed".to_string()));
+                }
+            }
+        }
+
+        // Fallback to automatic key handling for edit mode
+        if is_edit_mode {
+            if let Some(canvas_action) = CanvasAction::from_key(key_event.code) {
+                match ActionDispatcher::dispatch(
+                    canvas_action,
+                    form_state,
+                    &mut self.ideal_cursor_column,
+                ).await {
+                    Ok(result) => {
+                        return Ok(Some(result.message().unwrap_or("").to_string()));
+                    }
+                    Err(_) => {
+                        return Ok(Some("Auto action failed".to_string()));
+                    }
+                }
+            }
+        } else {
+            // In read-only mode, only handle non-character keys
+            let canvas_action = match key_event.code {
+                // Only handle special keys that don't conflict with vim bindings
+                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::Tab => Some(CanvasAction::NextField),
+                KeyCode::BackTab => Some(CanvasAction::PrevField),
+                KeyCode::Delete => Some(CanvasAction::DeleteForward),
+                KeyCode::Backspace => Some(CanvasAction::DeleteBackward),
+                _ => None,
+            };
+
+            if let Some(canvas_action) = canvas_action {
+                match ActionDispatcher::dispatch(
+                    canvas_action,
+                    form_state,
+                    &mut self.ideal_cursor_column,
+                ).await {
+                    Ok(result) => {
+                        return Ok(Some(result.message().unwrap_or("").to_string()));
+                    }
+                    Err(_) => {
+                        return Ok(Some("Action failed".to_string()));
+                    }
+                }
+            }
+        }
+
+        Ok(None)
+    }
+
+    // ADDED: Helper function to identify mode transition actions
+    fn is_mode_transition_action(action: &str) -> bool {
+        matches!(action,
+            "exit" |
+            "exit_edit_mode" |
+            "enter_edit_mode_before" |
+            "enter_edit_mode_after" |
+            "enter_command_mode" |
+            "exit_command_mode" |
+            "enter_highlight_mode" |
+            "enter_highlight_mode_linewise" |
+            "exit_highlight_mode" |
+            "save" |
+            "quit" |
+            "force_quit" |
+            "save_and_quit" |
+            "revert" |
+            "enter_decider" |  // This is also handled specially by legacy system
+            "trigger_autocomplete" |  // This is handled specially by legacy system
+            "suggestion_up" |  // These are handled above in suggestion logic
+            "suggestion_down" |
+            "previous_entry" |  // Navigation between records
+            "next_entry" |
+            "toggle_sidebar" |
+            "toggle_buffer_list" |
+            "next_buffer" |
+            "previous_buffer" |
+            "close_buffer" |
+            "open_search" |
+            "find_file_palette_toggle"
+        )
+    }
 }

client/src/modes/handlers/event_helper.rs

@@ -0,0 +1,105 @@
+
+// src/modes/handlers/event_helper.rs
+//! Helper functions to handle the differences between legacy and library CanvasState traits
+
+use crate::state::app::state::AppState;
+use crate::state::pages::{
+    form::FormState,
+    auth::{LoginState, RegisterState},
+};
+use crate::state::pages::canvas_state::CanvasState as LegacyCanvasState;
+use canvas::canvas::CanvasState as LibraryCanvasState;
+
+/// Get the current field index from the appropriate state based on which UI is active
+pub fn get_current_field_for_state(
+    app_state: &AppState,
+    login_state: &LoginState,
+    register_state: &RegisterState,
+    form_state: &FormState,
+) -> usize {
+    if app_state.ui.show_login {
+        login_state.current_field() // Uses LegacyCanvasState
+    } else if app_state.ui.show_register {
+        register_state.current_field() // Uses LegacyCanvasState
+    } else {
+        form_state.current_field() // Uses LibraryCanvasState
+    }
+}
+
+/// Get the current cursor position from the appropriate state based on which UI is active
+pub fn get_current_cursor_pos_for_state(
+    app_state: &AppState,
+    login_state: &LoginState,
+    register_state: &RegisterState,
+    form_state: &FormState,
+) -> usize {
+    if app_state.ui.show_login {
+        login_state.current_cursor_pos() // Uses LegacyCanvasState
+    } else if app_state.ui.show_register {
+        register_state.current_cursor_pos() // Uses LegacyCanvasState
+    } else {
+        form_state.current_cursor_pos() // Uses LibraryCanvasState
+    }
+}
+
+/// Check if the appropriate state has unsaved changes based on which UI is active
+pub fn get_has_unsaved_changes_for_state(
+    app_state: &AppState,
+    login_state: &LoginState,
+    register_state: &RegisterState,
+    form_state: &FormState,
+) -> bool {
+    if app_state.ui.show_login {
+        login_state.has_unsaved_changes() // Uses LegacyCanvasState
+    } else if app_state.ui.show_register {
+        register_state.has_unsaved_changes() // Uses LegacyCanvasState
+    } else {
+        form_state.has_unsaved_changes() // Uses LibraryCanvasState
+    }
+}
+
+/// Get the current input from the appropriate state based on which UI is active
+pub fn get_current_input_for_state<'a>(
+    app_state: &AppState,
+    login_state: &'a LoginState,
+    register_state: &'a RegisterState,
+    form_state: &'a FormState,
+) -> &'a str {
+    if app_state.ui.show_login {
+        login_state.get_current_input() // Uses LegacyCanvasState
+    } else if app_state.ui.show_register {
+        register_state.get_current_input() // Uses LegacyCanvasState
+    } else {
+        form_state.get_current_input() // Uses LibraryCanvasState
+    }
+}
+
+/// Set the cursor position for the appropriate state based on which UI is active
+pub fn set_current_cursor_pos_for_state(
+    app_state: &AppState,
+    login_state: &mut LoginState,
+    register_state: &mut RegisterState,
+    form_state: &mut FormState,
+    pos: usize,
+) {
+    if app_state.ui.show_login {
+        login_state.set_current_cursor_pos(pos); // Uses LegacyCanvasState
+    } else if app_state.ui.show_register {
+        register_state.set_current_cursor_pos(pos); // Uses LegacyCanvasState
+    } else {
+        form_state.set_current_cursor_pos(pos); // Uses LibraryCanvasState
+    }
+}
+
+/// Get cursor position for mixed login/register vs form logic
+pub fn get_cursor_pos_for_mixed_state(
+    app_state: &AppState,
+    login_state: &LoginState,
+    form_state: &FormState,
+) -> usize {
+    if app_state.ui.show_login || app_state.ui.show_register {
+        login_state.current_cursor_pos() // Uses LegacyCanvasState
+    } else {
+        form_state.current_cursor_pos() // Uses LibraryCanvasState
+    }
+}

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,30 +1,34 @@
 // 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 common::proto::multieko2::search::{
+use common::proto::komp_ac::search::{
     searcher_client::SearcherClient, SearchRequest, SearchResponse,
 };
-use anyhow::{Context, Result}; // Added Context
-use std::collections::HashMap; // NEW
+use anyhow::{Context, Result};
+use std::collections::HashMap;
+use tonic::transport::Channel;
+use prost_types::Value;
 
 #[derive(Clone)]
 pub struct GrpcClient {
@@ -48,7 +52,6 @@ impl GrpcClient {
             TableDefinitionClient::new(channel.clone());
         let table_script_client = TableScriptClient::new(channel.clone());
         let tables_data_client = TablesDataClient::new(channel.clone());
-        // NEW: Instantiate the search client
         let search_client = SearcherClient::new(channel.clone());
 
         Ok(Self {
@@ -56,7 +59,7 @@ impl GrpcClient {
             table_definition_client,
             table_script_client,
             tables_data_client,
-            search_client, // NEW
+            search_client,
         })
     }
 
@@ -116,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,
@@ -155,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,
@@ -180,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,

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(),
-            )
-            .await
-            .context(format!(
-                "Failed to get initial table structure for {}.{}",
-                initial_profile_name, initial_table_name
-            ))?;
+        let form_state = Self::load_table_view(
+            grpc_client,
+            app_state,
+            &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/search.rs

@@ -1,6 +1,6 @@
 // src/state/app/search.rs
 
-use common::proto::multieko2::search::search_response::Hit;
+use common::proto::komp_ac::search::search_response::Hit;
 
 /// Holds the complete state for the search palette.
 pub struct SearchState {

client/src/state/app/state.rs

@@ -1,15 +1,19 @@
 // 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 crate::state::app::search::SearchState; // ADDED
 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;
 
-// --- YOUR EXISTING DIALOGSTATE IS UNTOUCHED ---
+// --- DialogState and UiState are unchanged ---
 pub struct DialogState {
     pub dialog_show: bool,
     pub dialog_title: String,
@@ -30,7 +34,7 @@ pub struct UiState {
     pub show_form: bool,
     pub show_login: bool,
     pub show_register: bool,
-    pub show_search_palette: bool, // ADDED
+    pub show_search_palette: bool,
     pub focus_outside_canvas: bool,
     pub dialog: DialogState,
 }
@@ -52,10 +56,12 @@ 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)>,
 
-    // ADDED: State for the search palette
     pub search_state: Option<SearchState>,
 
     // UI preferences
@@ -67,9 +73,7 @@ pub struct AppState {
 
 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(),
@@ -77,9 +81,10 @@ 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, // ADDED
+            search_state: None,
             ui: UiState::default(),
 
             #[cfg(feature = "ui-debug")]

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};
+use canvas::autocomplete::{AutocompleteCanvasState, AutocompleteState, SuggestionItem};
 use lazy_static::lazy_static;
 
 lazy_static! {
@@ -44,91 +45,61 @@ 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,
+    // NEW: Replace old autocomplete with external library's system
+    pub autocomplete: AutocompleteState<String>,
 }
 
 impl AuthState {
-    /// Creates a new empty AuthState (unauthenticated)
     pub fn new() -> Self {
-        Self {
-            auth_token: None,
-            user_id: None,
-            role: None,
-            decoded_username: None,
-        }
+        Self::default()
     }
 }
 
 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,
-        }
+        Self::default()
     }
 }
 
 impl RegisterState {
-    /// Creates a new empty RegisterState
     pub fn new() -> Self {
-        Self {
-            username: String::new(),
-            email: String::new(),
-            password: String::new(),
-            password_confirmation: String::new(),
-            role: String::new(),
-            error_message: None,
-            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,
-        }
-    }
-
-    /// 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
+        let mut state = Self {
+            autocomplete: AutocompleteState::new(),
+            ..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 +118,61 @@ 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,
+        }
+    }
+}
+
+// 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 +197,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 +217,99 @@ 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,
+        }
+    }
+}
+
+// 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,8 +1,9 @@
 // src/state/pages/canvas_state.rs
 
-use common::proto::multieko2::search::search_response::Hit;
+use common::proto::komp_ac::search::search_response::Hit;
 
 pub trait CanvasState {
+    // --- Existing methods (unchanged) ---
     fn current_field(&self) -> usize;
     fn current_cursor_pos(&self) -> usize;
     fn has_unsaved_changes(&self) -> bool;
@@ -10,15 +11,22 @@ pub trait CanvasState {
     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>;
     fn get_rich_suggestions(&self) -> Option<&[Hit]> {
         None
     }
+
+    fn get_display_value_for_field(&self, index: usize) -> &str {
+        self.inputs()
+            .get(index)
+            .map(|s| s.as_str())
+            .unwrap_or("")
+    }
+    fn has_display_override(&self, _index: usize) -> bool {
+        false
+    }
 }

client/src/state/pages/form.rs

@@ -1,20 +1,27 @@
 // src/state/pages/form.rs
 
 use crate::config::colors::themes::Theme;
-use crate::state::app::highlight::HighlightState;
-use crate::state::pages::canvas_state::CanvasState;
-use common::proto::multieko2::search::search_response::Hit; // Import Hit
+use canvas::canvas::{CanvasState, CanvasAction, ActionContext, HighlightState};
+use common::proto::komp_ac::search::search_response::Hit;
 use ratatui::layout::Rect;
 use ratatui::Frame;
 use std::collections::HashMap;
 
-// A struct to bridge the display name (label) to the data key from the server.
+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>,                       
+    pub link_target_table: Option<String>,
 }
 
 #[derive(Clone)]
@@ -29,15 +36,22 @@ pub struct FormState {
     pub current_field: usize,
     pub has_unsaved_changes: bool,
     pub current_cursor_pos: usize,
-
-    // --- MODIFIED AUTOCOMPLETE STATE ---
     pub autocomplete_active: bool,
-    pub autocomplete_suggestions: Vec<Hit>, // Changed to use the Hit struct
+    pub autocomplete_suggestions: Vec<Hit>,
     pub selected_suggestion_index: Option<usize>,
-    pub autocomplete_loading: bool, // To show a loading indicator
+    pub autocomplete_loading: bool,
+    pub link_display_map: HashMap<usize, String>,
 }
 
 impl FormState {
+    // 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,
@@ -55,11 +69,48 @@ impl FormState {
             current_field: 0,
             has_unsaved_changes: false,
             current_cursor_pos: 0,
-            // --- INITIALIZE NEW STATE ---
             autocomplete_active: false,
             autocomplete_suggestions: Vec::new(),
             selected_suggestion_index: None,
-            autocomplete_loading: false, // Initialize loading state
+            autocomplete_loading: false,
+            link_display_map: HashMap::new(),
+        }
+    }
+
+    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)
         }
     }
 
@@ -69,7 +120,7 @@ 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).collect();
@@ -78,7 +129,7 @@ impl FormState {
         crate::components::form::form::render_form(
             f,
             area,
-            self, // <--- This now correctly passes the concrete &FormState
+            self,
             &fields_str_slice,
             &self.current_field,
             &values_str_slice,
@@ -102,7 +153,8 @@ impl FormState {
         } else {
             self.current_position = 1;
         }
-        self.deactivate_autocomplete(); // Deactivate on reset
+        self.deactivate_autocomplete();
+        self.link_display_map.clear();
     }
 
     pub fn get_current_input(&self) -> &str {
@@ -113,6 +165,7 @@ 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")
@@ -159,15 +212,23 @@ impl FormState {
         self.has_unsaved_changes = false;
         self.current_field = 0;
         self.current_cursor_pos = 0;
-        self.deactivate_autocomplete(); // Deactivate on update
+        self.deactivate_autocomplete();
+        self.link_display_map.clear();
     }
 
-    // --- NEW HELPER METHOD ---
-    /// Deactivates autocomplete and clears its state.
-    pub fn deactivate_autocomplete(&mut self) {
-        self.autocomplete_active = false;
-        self.autocomplete_suggestions.clear();
-        self.selected_suggestion_index = None;
+    // 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;
     }
 }
@@ -208,7 +269,6 @@ impl CanvasState for FormState {
         if index < self.fields.len() {
             self.current_field = index;
         }
-        // Deactivate autocomplete when changing fields
         self.deactivate_autocomplete();
     }
 
@@ -220,27 +280,44 @@ impl CanvasState for FormState {
         self.has_unsaved_changes = changed;
     }
 
-    // --- MODIFIED: Implement autocomplete trait methods ---
-
-    /// Returns None because this state uses rich suggestions.
-    fn get_suggestions(&self) -> Option<&[String]> {
-        None
-    }
-
-    /// Returns rich suggestions.
-    fn get_rich_suggestions(&self) -> Option<&[Hit]> {
-        if self.autocomplete_active {
-            Some(&self.autocomplete_suggestions)
-        } else {
-            None
+    // --- 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> {
-        if self.autocomplete_active {
-            self.selected_suggestion_index
-        } else {
-            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)
     }
 }

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_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

@@ -7,7 +7,6 @@ use crate::components::{
     common::dialog::render_dialog,
     common::find_file_palette,
     common::search_palette::render_search_palette,
-    form::form::render_form,
     handlers::sidebar::{self, calculate_sidebar_layout},
     intro::intro::render_intro,
     render_background,
@@ -17,9 +16,11 @@ use crate::components::{
 };
 use crate::config::colors::themes::Theme;
 use crate::modes::general::command_navigation::NavigationState;
-use crate::state::pages::canvas_state::CanvasState;
+use crate::state::pages::canvas_state::CanvasState as LocalCanvasState; // Keep local one with alias
+use canvas::canvas::CanvasState; // Import external library's CanvasState trait
 use crate::state::app::buffer::BufferState;
-use crate::state::app::highlight::HighlightState;
+use crate::state::app::highlight::HighlightState as LocalHighlightState; // CHANGED: Alias local version
+use canvas::canvas::HighlightState as CanvasHighlightState; // CHANGED: Import canvas version with alias
 use crate::state::app::state::AppState;
 use crate::state::pages::admin::AdminState;
 use crate::state::pages::auth::AuthState;
@@ -32,6 +33,15 @@ use ratatui::{
     Frame,
 };
 
+// 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(
     f: &mut Frame,
@@ -44,7 +54,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,
@@ -69,7 +79,6 @@ pub fn render_ui(
 
     const PALETTE_OPTIONS_HEIGHT_FOR_LAYOUT: u16 = 15;
 
-
     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
@@ -128,8 +137,8 @@ pub fn render_ui(
             theme,
             register_state,
             app_state,
-            register_state.current_field() < 4,
-            highlight_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(
@@ -139,7 +148,7 @@ pub fn render_ui(
             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(
@@ -149,7 +158,7 @@ pub fn render_ui(
             app_state,
             &mut admin_state.add_logic_state,
             is_event_handler_edit_mode,
-            highlight_state,
+            highlight_state, // Uses local version
         );
     } else if app_state.ui.show_login {
         render_login(
@@ -158,8 +167,8 @@ pub fn render_ui(
             theme,
             login_state,
             app_state,
-            login_state.current_field() < 2,
-            highlight_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(
@@ -200,13 +209,15 @@ pub fn render_ui(
                 ])
                 .split(form_actual_area)[1]
         };
-        
+
+        // 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,
             theme,
             is_event_handler_edit_mode,
-            highlight_state,
+            &canvas_highlight_state, // Use converted version
         );
     }
 

client/src/ui/handlers/ui.rs

@@ -8,7 +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::canvas_state::CanvasState as LocalCanvasState; // Keep local one with alias
+use canvas::canvas::CanvasState; // Import external library's CanvasState trait
 use crate::state::pages::form::{FormState, FieldDefinition}; // Import FieldDefinition
 use crate::state::pages::auth::AuthState;
 use crate::state::pages::auth::LoginState;
@@ -27,17 +28,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 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::{Duration, Instant};
+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);
@@ -346,6 +348,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();
@@ -362,66 +367,18 @@ pub async fn run_ui() -> Result<()> {
                     );
                     needs_redraw = true;
 
-                    match grpc_client
-                        .get_table_structure(prof_name.clone(), tbl_name.clone())
-                        .await
+                    match UiService::load_table_view(
+                        &mut grpc_client,
+                        &mut app_state,
+                        prof_name,
+                        tbl_name,
+                    )
+                    .await
                     {
-                        Ok(structure_response) => {
-                            // --- START OF MODIFIED LOGIC ---
-                            let all_columns: Vec<String> = structure_response
-                                .columns
-                                .iter()
-                                .map(|c| c.name.clone())
-                                .collect();
-
-                            let mut field_definitions: Vec<FieldDefinition> =
-                                filter_user_columns(all_columns)
-                                    .into_iter()
-                                    .filter(|col_name| !col_name.ends_with("_id"))
-                                    .map(|col_name| FieldDefinition {
-                                        display_name: col_name.clone(),
-                                        data_key: col_name,
-                                        is_link: false,
-                                        link_target_table: None, // Regular fields have no target
-                                    })
-                                    .collect();
-
-                            let linked_tables: Vec<String> = app_state
-                                .profile_tree
-                                .profiles
-                                .iter()
-                                .find(|p| p.name == *prof_name)
-                                .and_then(|profile| {
-                                    profile.tables.iter().find(|t| t.name == *tbl_name)
-                                })
-                                .map_or(vec![], |table| table.depends_on.clone());
-
-                            for linked_table_name in linked_tables {
-                                let base_name = linked_table_name
-                                    .split_once('_')
-                                    .map_or(linked_table_name.as_str(), |(_, rest)| rest);
-                                let data_key = format!("{}_id", base_name);
-                                let display_name = linked_table_name.clone(); // Clone for use below
-
-                                field_definitions.push(FieldDefinition {
-                                    display_name,
-                                    data_key,
-                                    is_link: true,
-                                    // --- POPULATE THE NEW FIELD ---
-                                    link_target_table: Some(linked_table_name),
-                                });
-                            }
-                            // --- END OF MODIFIED LOGIC ---
-
-                            form_state = FormState::new(
-                                prof_name.clone(),
-                                tbl_name.clone(),
-                                field_definitions, // This now contains the complete definitions
-                            );
-
+                        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
                             {
@@ -430,10 +387,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
                                 {
@@ -446,18 +403,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,
                             );
@@ -472,6 +429,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 &&

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/mod.rs

@@ -2,5 +2,8 @@
 
 pub mod columns;
 pub mod debug_logger;
+pub mod data_converter;
+
 pub use columns::*;
 pub use debug_logger::*;
+pub use data_converter::*;

client/tests/form/gui/form_tests.rs

@@ -0,0 +1,263 @@
+// client/tests/form_tests.rs
+use rstest::{fixture, rstest};
+use std::collections::HashMap;
+use client::state::pages::form::{FormState, FieldDefinition};
+use canvas::state::CanvasState
+use client::state::pages::canvas_state::CanvasState;
+
+#[fixture]
+fn test_form_state() -> FormState {
+    let fields = vec![
+        FieldDefinition {
+            display_name: "Company".to_string(),
+            data_key: "firma".to_string(),
+            is_link: false,
+            link_target_table: None,
+        },
+        FieldDefinition {
+            display_name: "Phone".to_string(),
+            data_key: "telefon".to_string(),
+            is_link: false,
+            link_target_table: None,
+        },
+        FieldDefinition {
+            display_name: "Email".to_string(),
+            data_key: "email".to_string(),
+            is_link: false,
+            link_target_table: None,
+        },
+    ];
+    
+    FormState::new("test_profile".to_string(), "test_table".to_string(), fields)
+}
+
+#[fixture]
+fn test_form_data() -> HashMap<String, String> {
+    let mut data = HashMap::new();
+    data.insert("firma".to_string(), "Test Company".to_string());
+    data.insert("telefon".to_string(), "+421123456789".to_string());
+    data.insert("email".to_string(), "test@example.com".to_string());
+    data
+}
+
+#[rstest]
+fn test_form_state_creation(test_form_state: FormState) {
+    assert_eq!(test_form_state.profile_name, "test_profile");
+    assert_eq!(test_form_state.table_name, "test_table");
+    assert_eq!(test_form_state.fields.len(), 3);
+    assert_eq!(test_form_state.current_field(), 0);
+    assert!(!test_form_state.has_unsaved_changes());
+}
+
+#[rstest]
+fn test_form_field_navigation(mut test_form_state: FormState) {
+    // Test initial field
+    assert_eq!(test_form_state.current_field(), 0);
+    
+    // Test navigation to next field
+    test_form_state.set_current_field(1);
+    assert_eq!(test_form_state.current_field(), 1);
+    
+    // Test navigation to last field
+    test_form_state.set_current_field(2);
+    assert_eq!(test_form_state.current_field(), 2);
+    
+    // Test invalid field (should not crash)
+    test_form_state.set_current_field(999);
+    assert_eq!(test_form_state.current_field(), 2); // Should stay at valid field
+}
+
+#[rstest]
+fn test_form_data_entry(mut test_form_state: FormState) {
+    // Test entering data in first field
+    *test_form_state.get_current_input_mut() = "Test Company".to_string();
+    test_form_state.set_has_unsaved_changes(true);
+    
+    assert_eq!(test_form_state.get_current_input(), "Test Company");
+    assert!(test_form_state.has_unsaved_changes());
+}
+
+#[rstest]
+fn test_form_field_switching_with_data(mut test_form_state: FormState) {
+    // Enter data in first field
+    *test_form_state.get_current_input_mut() = "Company Name".to_string();
+    
+    // Switch to second field
+    test_form_state.set_current_field(1);
+    *test_form_state.get_current_input_mut() = "+421123456789".to_string();
+    
+    // Switch back to first field
+    test_form_state.set_current_field(0);
+    assert_eq!(test_form_state.get_current_input(), "Company Name");
+    
+    // Switch to second field again
+    test_form_state.set_current_field(1);
+    assert_eq!(test_form_state.get_current_input(), "+421123456789");
+}
+
+#[rstest]
+fn test_form_reset_functionality(mut test_form_state: FormState) {
+    // Add some data
+    test_form_state.set_current_field(0);
+    *test_form_state.get_current_input_mut() = "Test Company".to_string();
+    test_form_state.set_current_field(1);
+    *test_form_state.get_current_input_mut() = "+421123456789".to_string();
+    test_form_state.set_has_unsaved_changes(true);
+    test_form_state.id = 123;
+    test_form_state.current_position = 5;
+    
+    // Reset the form
+    test_form_state.reset_to_empty();
+    
+    // Verify reset
+    assert_eq!(test_form_state.id, 0);
+    assert!(!test_form_state.has_unsaved_changes());
+    assert_eq!(test_form_state.current_field(), 0);
+    
+    // Check all fields are empty
+    for i in 0..test_form_state.fields.len() {
+        test_form_state.set_current_field(i);
+        assert!(test_form_state.get_current_input().is_empty());
+    }
+}
+
+#[rstest]
+fn test_form_update_from_response(mut test_form_state: FormState, test_form_data: HashMap<String, String>) {
+    let position = 3;
+    
+    // Update form with response data
+    test_form_state.update_from_response(&test_form_data, position);
+    
+    // Verify data was loaded
+    assert_eq!(test_form_state.current_position, position);
+    assert!(!test_form_state.has_unsaved_changes());
+    assert_eq!(test_form_state.current_field(), 0);
+    
+    // Check field values
+    test_form_state.set_current_field(0);
+    assert_eq!(test_form_state.get_current_input(), "Test Company");
+    
+    test_form_state.set_current_field(1);
+    assert_eq!(test_form_state.get_current_input(), "+421123456789");
+    
+    test_form_state.set_current_field(2);
+    assert_eq!(test_form_state.get_current_input(), "test@example.com");
+}
+
+#[rstest]
+fn test_form_cursor_position(mut test_form_state: FormState) {
+    // Test initial cursor position
+    assert_eq!(test_form_state.current_cursor_pos(), 0);
+    
+    // Add some text
+    *test_form_state.get_current_input_mut() = "Test Company".to_string();
+    
+    // Test cursor positioning
+    test_form_state.set_current_cursor_pos(5);
+    assert_eq!(test_form_state.current_cursor_pos(), 5);
+    
+    // Test cursor bounds
+    test_form_state.set_current_cursor_pos(999);
+    // Should be clamped to text length
+    assert!(test_form_state.current_cursor_pos() <= "Test Company".len());
+}
+
+#[rstest]
+fn test_form_field_display_names(test_form_state: FormState) {
+    let field_names = test_form_state.fields();
+    
+    assert_eq!(field_names.len(), 3);
+    assert_eq!(field_names[0], "Company");
+    assert_eq!(field_names[1], "Phone");
+    assert_eq!(field_names[2], "Email");
+}
+
+#[rstest]
+fn test_form_inputs_vector(mut test_form_state: FormState) {
+    // Add data to fields
+    test_form_state.set_current_field(0);
+    *test_form_state.get_current_input_mut() = "Company A".to_string();
+    
+    test_form_state.set_current_field(1);
+    *test_form_state.get_current_input_mut() = "123456789".to_string();
+    
+    test_form_state.set_current_field(2);
+    *test_form_state.get_current_input_mut() = "test@test.com".to_string();
+    
+    // Get inputs vector
+    let inputs = test_form_state.inputs();
+    
+    assert_eq!(inputs.len(), 3);
+    assert_eq!(inputs[0], "Company A");
+    assert_eq!(inputs[1], "123456789");
+    assert_eq!(inputs[2], "test@test.com");
+}
+
+#[rstest]
+fn test_form_position_management(mut test_form_state: FormState) {
+    // Test initial position
+    assert_eq!(test_form_state.current_position, 1);
+    assert_eq!(test_form_state.total_count, 0);
+    
+    // Set some values
+    test_form_state.total_count = 10;
+    test_form_state.current_position = 5;
+    
+    assert_eq!(test_form_state.current_position, 5);
+    assert_eq!(test_form_state.total_count, 10);
+    
+    // Test reset affects position
+    test_form_state.reset_to_empty();
+    assert_eq!(test_form_state.current_position, 11); // total_count + 1
+}
+
+#[rstest]
+fn test_form_autocomplete_state(mut test_form_state: FormState) {
+    // Test initial autocomplete state
+    assert!(!test_form_state.autocomplete_active);
+    assert!(test_form_state.autocomplete_suggestions.is_empty());
+    assert!(test_form_state.selected_suggestion_index.is_none());
+    
+    // Test deactivating autocomplete
+    test_form_state.autocomplete_active = true;
+    test_form_state.deactivate_autocomplete();
+    
+    assert!(!test_form_state.autocomplete_active);
+    assert!(test_form_state.autocomplete_suggestions.is_empty());
+    assert!(test_form_state.selected_suggestion_index.is_none());
+    assert!(!test_form_state.autocomplete_loading);
+}
+
+#[rstest]
+fn test_form_empty_data_handling(mut test_form_state: FormState) {
+    let empty_data = HashMap::new();
+    
+    // Update with empty data
+    test_form_state.update_from_response(&empty_data, 1);
+    
+    // All fields should be empty
+    for i in 0..test_form_state.fields.len() {
+        test_form_state.set_current_field(i);
+        assert!(test_form_state.get_current_input().is_empty());
+    }
+}
+
+#[rstest]
+fn test_form_partial_data_handling(mut test_form_state: FormState) {
+    let mut partial_data = HashMap::new();
+    partial_data.insert("firma".to_string(), "Partial Company".to_string());
+    // Intentionally missing telefon and email
+    
+    test_form_state.update_from_response(&partial_data, 1);
+    
+    // First field should have data
+    test_form_state.set_current_field(0);
+    assert_eq!(test_form_state.get_current_input(), "Partial Company");
+    
+    // Other fields should be empty
+    test_form_state.set_current_field(1);
+    assert!(test_form_state.get_current_input().is_empty());
+    
+    test_form_state.set_current_field(2);
+    assert!(test_form_state.get_current_input().is_empty());
+}

client/tests/form/gui/mod.rs

@@ -0,0 +1 @@
+pub mod form_tests;

client/tests/form/mod.rs

@@ -0,0 +1,2 @@
+pub mod gui;
+pub mod requests;

client/tests/form/requests/form_request_tests2.rs

@@ -0,0 +1,267 @@
+// ========================================================================
+// ROBUST WORKFLOW AND INTEGRATION TESTS
+// ========================================================================
+
+#[rstest]
+#[tokio::test]
+async fn test_partial_update_preserves_other_fields(
+    #[future] populated_test_context: FormTestContext,
+) {
+    let mut context = populated_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // 1. Create a record with multiple fields
+    let mut initial_data = context.create_test_form_data();
+    let original_email = "preserve.this@email.com";
+    initial_data.insert(
+        "email".to_string(),
+        create_string_value(original_email),
+    );
+
+    let post_res = context
+        .client
+        .post_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            initial_data,
+        )
+        .await
+        .expect("Setup: Failed to create record for partial update test");
+    let created_id = post_res.inserted_id;
+    println!("Partial Update Test: Created record ID {}", created_id);
+
+    // 2. Update only ONE field
+    let mut partial_update = HashMap::new();
+    let updated_firma = "Partially Updated Inc.";
+    partial_update.insert(
+        "firma".to_string(),
+        create_string_value(updated_firma),
+    );
+
+    context
+        .client
+        .put_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            created_id,
+            partial_update,
+        )
+        .await
+        .expect("Partial update failed");
+    println!("Partial Update Test: Updated only 'firma' field");
+
+    // 3. Get the record back and verify ALL fields
+    let get_res = context
+        .client
+        .get_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            created_id,
+        )
+        .await
+        .expect("Failed to get record after partial update");
+
+    let final_data = get_res.data;
+    assert_eq!(
+        final_data.get("firma").unwrap(),
+        updated_firma,
+        "The 'firma' field should be updated"
+    );
+    assert_eq!(
+        final_data.get("email").unwrap(),
+        original_email,
+        "The 'email' field should have been preserved"
+    );
+    println!("Partial Update Test: Verified other fields were preserved. OK.");
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_data_edge_cases_and_unicode(
+    #[future] form_test_context: FormTestContext,
+) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    let edge_case_strings = vec![
+        ("Unicode", "José María González, Москва, 北京市"),
+        ("Emoji", "🚀 Tech Company 🌟"),
+        ("Quotes", "Quote\"Test'Apostrophe"),
+        ("Symbols", "Price: $1,000.50 (50% off!)"),
+        ("Empty", ""),
+        ("Whitespace", "   "),
+    ];
+
+    for (case_name, test_string) in edge_case_strings {
+        let mut data = HashMap::new();
+        data.insert("firma".to_string(), create_string_value(test_string));
+        data.insert(
+            "kz".to_string(),
+            create_string_value(&format!("EDGE-{}", case_name)),
+        );
+
+        let post_res = context
+            .client
+            .post_table_data(
+                context.profile_name.clone(),
+                context.table_name.clone(),
+                data,
+            )
+            .await
+            .expect(&format!("POST should succeed for case: {}", case_name));
+        let created_id = post_res.inserted_id;
+
+        let get_res = context
+            .client
+            .get_table_data(
+                context.profile_name.clone(),
+                context.table_name.clone(),
+                created_id,
+            )
+            .await
+            .expect(&format!(
+                "GET should succeed for case: {}",
+                case_name
+            ));
+
+        assert_eq!(
+            get_res.data.get("firma").unwrap(),
+            test_string,
+            "Data should be identical after round-trip for case: {}",
+            case_name
+        );
+        println!("Edge Case Test: '{}' passed.", case_name);
+    }
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_numeric_and_null_edge_cases(
+    #[future] form_test_context: FormTestContext,
+) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // 1. Test NULL value
+    let mut null_data = HashMap::new();
+    null_data.insert(
+        "firma".to_string(),
+        create_string_value("Company With Null Phone"),
+    );
+    null_data.insert("telefon".to_string(), create_null_value());
+    let post_res_null = context
+        .client
+        .post_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            null_data,
+        )
+        .await
+        .expect("POST with NULL value should succeed");
+    let get_res_null = context
+        .client
+        .get_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            post_res_null.inserted_id,
+        )
+        .await
+        .unwrap();
+    // Depending on DB, NULL may come back as empty string or be absent.
+    // The important part is that the operation doesn't fail.
+    assert!(
+        get_res_null.data.get("telefon").unwrap_or(&"".to_string()).is_empty(),
+        "NULL value should result in an empty or absent field"
+    );
+    println!("Edge Case Test: NULL value handled correctly. OK.");
+
+    // 2. Test Zero value for a numeric field (assuming 'age' is numeric)
+    let mut zero_data = HashMap::new();
+    zero_data.insert(
+        "firma".to_string(),
+        create_string_value("Newborn Company"),
+    );
+    // Assuming 'age' is a field in your actual table definition
+    // zero_data.insert("age".to_string(), create_number_value(0.0));
+    // let post_res_zero = context.client.post_table_data(...).await.expect("POST with zero should succeed");
+    // ... then get and verify it's "0"
+    println!("Edge Case Test: Zero value test skipped (uncomment if 'age' field exists).");
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_concurrent_updates_on_same_record(
+    #[future] populated_test_context: FormTestContext,
+) {
+    let mut context = populated_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // 1. Create a single record to be updated by all tasks
+    let initial_data = context.create_minimal_form_data();
+    let post_res = context
+        .client
+        .post_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            initial_data,
+        )
+        .await
+        .expect("Setup: Failed to create record for concurrency test");
+    let record_id = post_res.inserted_id;
+    println!("Concurrency Test: Target record ID is {}", record_id);
+
+    // 2. Spawn multiple concurrent UPDATE operations
+    let mut handles = Vec::new();
+    let num_concurrent_tasks = 5;
+    let mut final_values = Vec::new();
+
+    for i in 0..num_concurrent_tasks {
+        let mut client_clone = context.client.clone();
+        let profile_name = context.profile_name.clone();
+        let table_name = context.table_name.clone();
+        let final_value = format!("Concurrent Update {}", i);
+        final_values.push(final_value.clone());
+
+        let handle = tokio::spawn(async move {
+            let mut update_data = HashMap::new();
+            update_data.insert(
+                "firma".to_string(),
+                create_string_value(&final_value),
+            );
+            client_clone
+                .put_table_data(profile_name, table_name, record_id, update_data)
+                .await
+        });
+        handles.push(handle);
+    }
+
+    // 3. Wait for all tasks to complete and check for panics
+    let results = futures::future::join_all(handles).await;
+    assert!(
+        results.iter().all(|r| r.is_ok()),
+        "No concurrent task should panic"
+    );
+    println!("Concurrency Test: All update tasks completed without panicking.");
+
+    // 4. Get the final state of the record
+    let final_get_res = context
+        .client
+        .get_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            record_id,
+        )
+        .await
+        .expect("Should be able to get the record after concurrent updates");
+
+    let final_firma = final_get_res.data.get("firma").unwrap();
+    assert!(
+        final_values.contains(final_firma),
+        "The final state '{}' must be one of the states set by the tasks",
+        final_firma
+    );
+    println!(
+        "Concurrency Test: Final state is '{}', which is a valid outcome. OK.",
+        final_firma
+    );
+}

client/tests/form/requests/form_request_tests3.rs

@@ -0,0 +1,727 @@
+// form_request_tests3.rs - Comprehensive and Robust Testing
+
+// ========================================================================
+// STEEL SCRIPT VALIDATION TESTS (HIGHEST PRIORITY)
+// ========================================================================
+
+#[rstest]
+#[tokio::test]
+async fn test_steel_script_validation_success(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // Test with data that should pass script validation
+    // Assuming there's a script that validates 'kz' field to start with "KZ" and be 5 chars
+    let mut valid_data = HashMap::new();
+    valid_data.insert("firma".to_string(), create_string_value("Script Test Company"));
+    valid_data.insert("kz".to_string(), create_string_value("KZ123"));
+    valid_data.insert("telefon".to_string(), create_string_value("+421123456789"));
+
+    let result = context.client.post_table_data(
+        context.profile_name.clone(),
+        context.table_name.clone(),
+        valid_data,
+    ).await;
+
+    match result {
+        Ok(response) => {
+            assert!(response.success, "Valid data should pass script validation");
+            println!("Script Validation Test: Valid data passed - ID {}", response.inserted_id);
+        }
+        Err(e) => {
+            if let Some(status) = e.downcast_ref::<Status>() {
+                if status.code() == tonic::Code::Unavailable {
+                    println!("Script validation test skipped - backend not available");
+                    return;
+                }
+                // If there are no scripts configured, this might still work
+                println!("Script validation test: {}", status.message());
+            }
+        }
+    }
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_steel_script_validation_failure(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // Test with data that should fail script validation
+    let invalid_script_data = vec![
+        ("TooShort", "KZ12"),         // Too short
+        ("TooLong", "KZ12345"),       // Too long  
+        ("WrongPrefix", "AB123"),     // Wrong prefix
+        ("NoPrefix", "12345"),        // No prefix
+        ("Empty", ""),                // Empty
+    ];
+
+    for (test_case, invalid_kz) in invalid_script_data {
+        let mut invalid_data = HashMap::new();
+        invalid_data.insert("firma".to_string(), create_string_value("Script Fail Company"));
+        invalid_data.insert("kz".to_string(), create_string_value(invalid_kz));
+
+        let result = context.client.post_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            invalid_data,
+        ).await;
+
+        match result {
+            Ok(_) => {
+                println!("Script Validation Test: {} passed (no validation script configured)", test_case);
+            }
+            Err(e) => {
+                if let Some(status) = e.downcast_ref::<Status>() {
+                    assert_eq!(status.code(), tonic::Code::InvalidArgument, 
+                              "Script validation failure should return InvalidArgument for case: {}", test_case);
+                    println!("Script Validation Test: {} correctly failed - {}", test_case, status.message());
+                }
+            }
+        }
+    }
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_steel_script_validation_on_update(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // 1. Create a valid record first
+    let mut initial_data = HashMap::new();
+    initial_data.insert("firma".to_string(), create_string_value("Update Script Test"));
+    initial_data.insert("kz".to_string(), create_string_value("KZ123"));
+
+    let post_result = context.client.post_table_data(
+        context.profile_name.clone(),
+        context.table_name.clone(),
+        initial_data,
+    ).await;
+
+    if let Ok(post_response) = post_result {
+        let record_id = post_response.inserted_id;
+
+        // 2. Try to update with invalid data
+        let mut invalid_update = HashMap::new();
+        invalid_update.insert("kz".to_string(), create_string_value("INVALID"));
+
+        let update_result = context.client.put_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            record_id,
+            invalid_update,
+        ).await;
+
+        match update_result {
+            Ok(_) => {
+                println!("Script Validation on Update: No validation script configured for updates");
+            }
+            Err(e) => {
+                if let Some(status) = e.downcast_ref::<Status>() {
+                    assert_eq!(status.code(), tonic::Code::InvalidArgument,
+                              "Update with invalid data should fail script validation");
+                    println!("Script Validation on Update: Correctly rejected invalid update");
+                }
+            }
+        }
+    }
+}
+
+// ========================================================================
+// COMPREHENSIVE DATA TYPE TESTS
+// ========================================================================
+
+#[rstest]
+#[tokio::test]
+async fn test_boolean_data_type(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // Test valid boolean values
+    let boolean_test_cases = vec![
+        ("true", true),
+        ("false", false),
+    ];
+
+    for (case_name, bool_value) in boolean_test_cases {
+        let mut data = HashMap::new();
+        data.insert("firma".to_string(), create_string_value("Boolean Test Company"));
+        // Assuming there's a boolean field called 'active' 
+        data.insert("active".to_string(), create_bool_value(bool_value));
+
+        let result = context.client.post_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            data,
+        ).await;
+
+        match result {
+            Ok(response) => {
+                println!("Boolean Test: {} value succeeded", case_name);
+                
+                // Verify the value round-trip
+                if let Ok(get_response) = context.client.get_table_data(
+                    context.profile_name.clone(),
+                    context.table_name.clone(),
+                    response.inserted_id,
+                ).await {
+                    if let Some(retrieved_value) = get_response.data.get("active") {
+                        println!("Boolean Test: {} round-trip value: {}", case_name, retrieved_value);
+                    }
+                }
+            }
+            Err(e) => {
+                println!("Boolean Test: {} failed (field may not exist): {}", case_name, e);
+            }
+        }
+    }
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_numeric_data_types(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // Test various numeric values
+    let numeric_test_cases = vec![
+        ("Zero", 0.0),
+        ("Positive", 123.45),
+        ("Negative", -67.89),
+        ("Large", 999999.99),
+        ("SmallDecimal", 0.01),
+    ];
+
+    for (case_name, numeric_value) in numeric_test_cases {
+        let mut data = HashMap::new();
+        data.insert("firma".to_string(), create_string_value("Numeric Test Company"));
+        // Assuming there's a numeric field called 'price' or 'amount'
+        data.insert("amount".to_string(), create_number_value(numeric_value));
+
+        let result = context.client.post_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            data,
+        ).await;
+
+        match result {
+            Ok(response) => {
+                println!("Numeric Test: {} ({}) succeeded", case_name, numeric_value);
+                
+                // Verify round-trip
+                if let Ok(get_response) = context.client.get_table_data(
+                    context.profile_name.clone(),
+                    context.table_name.clone(),
+                    response.inserted_id,
+                ).await {
+                    if let Some(retrieved_value) = get_response.data.get("amount") {
+                        println!("Numeric Test: {} round-trip value: {}", case_name, retrieved_value);
+                    }
+                }
+            }
+            Err(e) => {
+                println!("Numeric Test: {} failed (field may not exist): {}", case_name, e);
+            }
+        }
+    }
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_timestamp_data_type(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // Test various timestamp formats
+    let timestamp_test_cases = vec![
+        ("ISO8601", "2024-01-15T10:30:00Z"),
+        ("WithTimezone", "2024-01-15T10:30:00+01:00"),
+        ("WithMilliseconds", "2024-01-15T10:30:00.123Z"),
+    ];
+
+    for (case_name, timestamp_str) in timestamp_test_cases {
+        let mut data = HashMap::new();
+        data.insert("firma".to_string(), create_string_value("Timestamp Test Company"));
+        // Assuming there's a timestamp field called 'created_at'
+        data.insert("created_at".to_string(), create_string_value(timestamp_str));
+
+        let result = context.client.post_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            data,
+        ).await;
+
+        match result {
+            Ok(response) => {
+                println!("Timestamp Test: {} succeeded", case_name);
+                
+                // Verify round-trip
+                if let Ok(get_response) = context.client.get_table_data(
+                    context.profile_name.clone(),
+                    context.table_name.clone(),
+                    response.inserted_id,
+                ).await {
+                    if let Some(retrieved_value) = get_response.data.get("created_at") {
+                        println!("Timestamp Test: {} round-trip value: {}", case_name, retrieved_value);
+                    }
+                }
+            }
+            Err(e) => {
+                println!("Timestamp Test: {} failed (field may not exist): {}", case_name, e);
+            }
+        }
+    }
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_invalid_data_types(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // Test invalid data type combinations
+    let invalid_type_cases = vec![
+        ("StringForNumber", "amount", create_string_value("not-a-number")),
+        ("NumberForBoolean", "active", create_number_value(123.0)),
+        ("StringForBoolean", "active", create_string_value("maybe")),
+        ("InvalidTimestamp", "created_at", create_string_value("not-a-date")),
+    ];
+
+    for (case_name, field_name, invalid_value) in invalid_type_cases {
+        let mut data = HashMap::new();
+        data.insert("firma".to_string(), create_string_value("Invalid Type Test"));
+        data.insert(field_name.to_string(), invalid_value);
+
+        let result = context.client.post_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            data,
+        ).await;
+
+        match result {
+            Ok(_) => {
+                println!("Invalid Type Test: {} passed (no type validation or field doesn't exist)", case_name);
+            }
+            Err(e) => {
+                if let Some(status) = e.downcast_ref::<Status>() {
+                    assert_eq!(status.code(), tonic::Code::InvalidArgument,
+                              "Invalid data type should return InvalidArgument for case: {}", case_name);
+                    println!("Invalid Type Test: {} correctly rejected - {}", case_name, status.message());
+                }
+            }
+        }
+    }
+}
+
+// ========================================================================
+// FOREIGN KEY RELATIONSHIP TESTS
+// ========================================================================
+
+#[rstest]
+#[tokio::test]
+async fn test_foreign_key_valid_relationship(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // 1. Create a parent record first (e.g., company)
+    let mut parent_data = HashMap::new();
+    parent_data.insert("firma".to_string(), create_string_value("Parent Company"));
+
+    let parent_result = context.client.post_table_data(
+        context.profile_name.clone(),
+        "companies".to_string(), // Assuming companies table exists
+        parent_data,
+    ).await;
+
+    if let Ok(parent_response) = parent_result {
+        let parent_id = parent_response.inserted_id;
+
+        // 2. Create a child record that references the parent
+        let mut child_data = HashMap::new();
+        child_data.insert("name".to_string(), create_string_value("Child Record"));
+        child_data.insert("company_id".to_string(), create_number_value(parent_id as f64));
+
+        let child_result = context.client.post_table_data(
+            context.profile_name.clone(),
+            "contacts".to_string(), // Assuming contacts table exists
+            child_data,
+        ).await;
+
+        match child_result {
+            Ok(child_response) => {
+                assert!(child_response.success, "Valid foreign key relationship should succeed");
+                println!("Foreign Key Test: Valid relationship created - Parent ID: {}, Child ID: {}", 
+                        parent_id, child_response.inserted_id);
+            }
+            Err(e) => {
+                println!("Foreign Key Test: Failed (tables may not exist or no FK constraint): {}", e);
+            }
+        }
+    } else {
+        println!("Foreign Key Test: Could not create parent record");
+    }
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_foreign_key_invalid_relationship(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // Try to create a child record with non-existent parent ID
+    let mut invalid_child_data = HashMap::new();
+    invalid_child_data.insert("name".to_string(), create_string_value("Orphan Record"));
+    invalid_child_data.insert("company_id".to_string(), create_number_value(99999.0)); // Non-existent ID
+
+    let result = context.client.post_table_data(
+        context.profile_name.clone(),
+        "contacts".to_string(),
+        invalid_child_data,
+    ).await;
+
+    match result {
+        Ok(_) => {
+            println!("Foreign Key Test: Invalid relationship passed (no FK constraint configured)");
+        }
+        Err(e) => {
+            if let Some(status) = e.downcast_ref::<Status>() {
+                // Could be InvalidArgument or NotFound depending on implementation
+                assert!(matches!(status.code(), tonic::Code::InvalidArgument | tonic::Code::NotFound),
+                       "Invalid foreign key should return InvalidArgument or NotFound");
+                println!("Foreign Key Test: Invalid relationship correctly rejected - {}", status.message());
+            }
+        }
+    }
+}
+
+// ========================================================================
+// DELETED RECORD INTERACTION TESTS
+// ========================================================================
+
+#[rstest]
+#[tokio::test]
+async fn test_update_deleted_record_behavior(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // 1. Create a record
+    let initial_data = context.create_test_form_data();
+    let post_result = context.client.post_table_data(
+        context.profile_name.clone(),
+        context.table_name.clone(),
+        initial_data,
+    ).await;
+
+    if let Ok(post_response) = post_result {
+        let record_id = post_response.inserted_id;
+        println!("Deleted Record Test: Created record ID {}", record_id);
+
+        // 2. Delete the record (soft delete)
+        let delete_result = context.client.delete_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            record_id,
+        ).await;
+
+        assert!(delete_result.is_ok(), "Delete should succeed");
+        println!("Deleted Record Test: Soft-deleted record {}", record_id);
+
+        // 3. Try to UPDATE the deleted record
+        let mut update_data = HashMap::new();
+        update_data.insert("firma".to_string(), create_string_value("Updated Deleted Record"));
+
+        let update_result = context.client.put_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            record_id,
+            update_data,
+        ).await;
+
+        match update_result {
+            Ok(_) => {
+                // This might be a bug - updating deleted records should probably fail
+                println!("Deleted Record Test: UPDATE on deleted record succeeded (potential bug?)");
+                
+                // Check if the record is still considered deleted
+                let get_result = context.client.get_table_data(
+                    context.profile_name.clone(),
+                    context.table_name.clone(),
+                    record_id,
+                ).await;
+                
+                if get_result.is_err() {
+                    println!("Deleted Record Test: Record still appears deleted after update");
+                } else {
+                    println!("Deleted Record Test: Record appears to be undeleted after update");
+                }
+            }
+            Err(e) => {
+                if let Some(status) = e.downcast_ref::<Status>() {
+                    assert_eq!(status.code(), tonic::Code::NotFound,
+                              "UPDATE on deleted record should return NotFound");
+                    println!("Deleted Record Test: UPDATE correctly rejected on deleted record");
+                }
+            }
+        }
+    }
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_delete_already_deleted_record(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // 1. Create and delete a record
+    let initial_data = context.create_test_form_data();
+    let post_result = context.client.post_table_data(
+        context.profile_name.clone(),
+        context.table_name.clone(),
+        initial_data,
+    ).await;
+
+    if let Ok(post_response) = post_result {
+        let record_id = post_response.inserted_id;
+
+        // First deletion
+        let delete_result1 = context.client.delete_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            record_id,
+        ).await;
+        assert!(delete_result1.is_ok(), "First delete should succeed");
+
+        // Second deletion (idempotent)
+        let delete_result2 = context.client.delete_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            record_id,
+        ).await;
+
+        assert!(delete_result2.is_ok(), "Second delete should succeed (idempotent)");
+        if let Ok(response) = delete_result2 {
+            assert!(response.success, "Delete should report success even for already-deleted record");
+        }
+        println!("Double Delete Test: Both deletions succeeded (idempotent behavior)");
+    }
+}
+
+// ========================================================================
+// VALIDATION AND BOUNDARY TESTS
+// ========================================================================
+
+#[rstest]
+#[tokio::test]
+async fn test_large_data_handling(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // Test with very large string values
+    let large_string = "A".repeat(10000); // 10KB string
+    let very_large_string = "B".repeat(100000); // 100KB string
+
+    let test_cases = vec![
+        ("Large", large_string),
+        ("VeryLarge", very_large_string),
+    ];
+
+    for (case_name, large_value) in test_cases {
+        let mut data = HashMap::new();
+        data.insert("firma".to_string(), create_string_value(&large_value));
+
+        let result = context.client.post_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            data,
+        ).await;
+
+        match result {
+            Ok(response) => {
+                println!("Large Data Test: {} string handled successfully", case_name);
+                
+                // Verify round-trip
+                if let Ok(get_response) = context.client.get_table_data(
+                    context.profile_name.clone(),
+                    context.table_name.clone(),
+                    response.inserted_id,
+                ).await {
+                    if let Some(retrieved_value) = get_response.data.get("firma") {
+                        assert_eq!(retrieved_value.len(), large_value.len(),
+                                  "Large string should survive round-trip for case: {}", case_name);
+                    }
+                }
+            }
+            Err(e) => {
+                println!("Large Data Test: {} failed (may hit size limits): {}", case_name, e);
+            }
+        }
+    }
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_sql_injection_attempts(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // Test potential SQL injection strings
+    let injection_attempts = vec![
+        ("SingleQuote", "'; DROP TABLE users; --"),
+        ("DoubleQuote", "\"; DROP TABLE users; --"),
+        ("Union", "' UNION SELECT * FROM users --"),
+        ("Comment", "/* malicious comment */"),
+        ("Semicolon", "; DELETE FROM users;"),
+    ];
+
+    for (case_name, injection_string) in injection_attempts {
+        let mut data = HashMap::new();
+        data.insert("firma".to_string(), create_string_value(injection_string));
+        data.insert("kz".to_string(), create_string_value("KZ123"));
+
+        let result = context.client.post_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            data,
+        ).await;
+
+        match result {
+            Ok(response) => {
+                println!("SQL Injection Test: {} handled safely (parameterized queries)", case_name);
+                
+                // Verify the malicious string was stored as-is (not executed)
+                if let Ok(get_response) = context.client.get_table_data(
+                    context.profile_name.clone(),
+                    context.table_name.clone(),
+                    response.inserted_id,
+                ).await {
+                    if let Some(retrieved_value) = get_response.data.get("firma") {
+                        assert_eq!(retrieved_value, injection_string,
+                                  "Injection string should be stored literally for case: {}", case_name);
+                    }
+                }
+            }
+            Err(e) => {
+                println!("SQL Injection Test: {} rejected: {}", case_name, e);
+            }
+        }
+    }
+}
+
+#[rstest]
+#[tokio::test]
+async fn test_concurrent_operations_with_same_data(#[future] form_test_context: FormTestContext) {
+    let context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    // Test multiple concurrent operations with identical data
+    let mut handles = Vec::new();
+    let num_tasks = 10;
+
+    for i in 0..num_tasks {
+        let mut context_clone = context.clone();
+        let handle = tokio::spawn(async move {
+            let mut data = HashMap::new();
+            data.insert("firma".to_string(), create_string_value("Concurrent Identical"));
+            data.insert("kz".to_string(), create_string_value(&format!("SAME{:02}", i)));
+            
+            context_clone.client.post_table_data(
+                context_clone.profile_name,
+                context_clone.table_name,
+                data,
+            ).await
+        });
+        handles.push(handle);
+    }
+
+    // Wait for all to complete
+    let mut success_count = 0;
+    let mut inserted_ids = Vec::new();
+
+    for (i, handle) in handles.into_iter().enumerate() {
+        match handle.await {
+            Ok(Ok(response)) => {
+                success_count += 1;
+                inserted_ids.push(response.inserted_id);
+                println!("Concurrent Identical Data: Task {} succeeded with ID {}", i, response.inserted_id);
+            }
+            Ok(Err(e)) => {
+                println!("Concurrent Identical Data: Task {} failed: {}", i, e);
+            }
+            Err(e) => {
+                println!("Concurrent Identical Data: Task {} panicked: {}", i, e);
+            }
+        }
+    }
+
+    assert!(success_count > 0, "At least some concurrent operations should succeed");
+    
+    // Verify all IDs are unique
+    let unique_ids: std::collections::HashSet<_> = inserted_ids.iter().collect();
+    assert_eq!(unique_ids.len(), inserted_ids.len(), "All inserted IDs should be unique");
+    
+    println!("Concurrent Identical Data: {}/{} operations succeeded with unique IDs", 
+             success_count, num_tasks);
+}
+
+// ========================================================================
+// PERFORMANCE AND STRESS TESTS
+// ========================================================================
+
+#[rstest]
+#[tokio::test]
+async fn test_bulk_operations_performance(#[future] form_test_context: FormTestContext) {
+    let mut context = form_test_context.await;
+    skip_if_backend_unavailable!();
+
+    let operation_count = 50;
+    let start_time = std::time::Instant::now();
+    
+    let mut successful_operations = 0;
+    let mut created_ids = Vec::new();
+
+    // Bulk create
+    for i in 0..operation_count {
+        let mut data = HashMap::new();
+        data.insert("firma".to_string(), create_string_value(&format!("Bulk Company {}", i)));
+        data.insert("kz".to_string(), create_string_value(&format!("BLK{:02}", i)));
+
+        if let Ok(response) = context.client.post_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            data,
+        ).await {
+            successful_operations += 1;
+            created_ids.push(response.inserted_id);
+        }
+    }
+
+    let create_duration = start_time.elapsed();
+    println!("Bulk Performance: Created {} records in {:?}", successful_operations, create_duration);
+
+    // Bulk read
+    let read_start = std::time::Instant::now();
+    let mut successful_reads = 0;
+
+    for &record_id in &created_ids {
+        if context.client.get_table_data(
+            context.profile_name.clone(),
+            context.table_name.clone(),
+            record_id,
+        ).await.is_ok() {
+            successful_reads += 1;
+        }
+    }
+
+    let read_duration = read_start.elapsed();
+    println!("Bulk Performance: Read {} records in {:?}", successful_reads, read_duration);
+
+    // Performance assertions
+    assert!(successful_operations > operation_count * 8 / 10, 
+           "At least 80% of operations should succeed");
+    assert!(create_duration.as_secs() < 60, 
+           "Bulk operations should complete in reasonable time");
+
+    println!("Bulk Performance Test: {}/{} creates, {}/{} reads successful", 
+             successful_operations, operation_count, successful_reads, created_ids.len());
+}

client/tests/form/requests/mod.rs

@@ -0,0 +1 @@
+pub mod form_request_tests;

client/tests/mod.rs

@@ -0,0 +1,3 @@
+// tests/mod.rs
+
+pub mod form;

common/Cargo.toml

@@ -5,6 +5,8 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
+prost-types = { workspace = true }
+
 tonic = "0.13.0"
 prost = "0.13.5"
 serde = { version = "1.0.219", features = ["derive"] }

common/proto/adresar.proto

@@ -1,6 +1,6 @@
 // proto/adresar.proto
 syntax = "proto3";
-package multieko2.adresar;
+package komp_ac.adresar;
 
 import "common.proto";
 // import "table_structure.proto";

common/proto/auth.proto

@@ -1,6 +1,6 @@
 // proto/auth.proto
 syntax = "proto3";
-package multieko2.auth;
+package komp_ac.auth;
 
 import "common.proto";
 

common/proto/common.proto

@@ -1,6 +1,6 @@
 // proto/common.proto
 syntax = "proto3";
-package multieko2.common;
+package komp_ac.common;
 
 message Empty {}
 message CountResponse { int64 count = 1; }

common/proto/search.proto

@@ -1,6 +1,6 @@
 // In common/proto/search.proto
 syntax = "proto3";
-package multieko2.search;
+package komp_ac.search;
 
 service Searcher {
     rpc SearchTable(SearchRequest) returns (SearchResponse);

common/proto/table_definition.proto

@@ -1,12 +1,12 @@
 // common/proto/table_definition.proto
 syntax = "proto3";
-package multieko2.table_definition;
+package komp_ac.table_definition;
 
 import "common.proto";
 
 service TableDefinition {
     rpc PostTableDefinition (PostTableDefinitionRequest) returns (TableDefinitionResponse);
-    rpc GetProfileTree (multieko2.common.Empty) returns (ProfileTreeResponse);
+    rpc GetProfileTree (komp_ac.common.Empty) returns (ProfileTreeResponse);
     rpc DeleteTable (DeleteTableRequest) returns (DeleteTableResponse);
 }
 

common/proto/table_script.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package multieko2.table_script;
+package komp_ac.table_script;
 
 service TableScript {
     rpc PostTableScript(PostTableScriptRequest) returns (TableScriptResponse);

common/proto/table_structure.proto

@@ -1,6 +1,6 @@
 // proto/table_structure.proto
 syntax = "proto3";
-package multieko2.table_structure;
+package komp_ac.table_structure;
 
 import "common.proto";
 

common/proto/tables_data.proto

@@ -1,22 +1,23 @@
 // common/proto/tables_data.proto
 syntax = "proto3";
-package multieko2.tables_data;
+package komp_ac.tables_data;
 
 import "common.proto";
+import "google/protobuf/struct.proto";
 
 service TablesData {
   rpc PostTableData (PostTableDataRequest) returns (PostTableDataResponse);
   rpc PutTableData (PutTableDataRequest) returns (PutTableDataResponse);
   rpc DeleteTableData (DeleteTableDataRequest) returns (DeleteTableDataResponse);
   rpc GetTableData(GetTableDataRequest) returns (GetTableDataResponse);
-  rpc GetTableDataCount(GetTableDataCountRequest) returns (multieko2.common.CountResponse);
+  rpc GetTableDataCount(GetTableDataCountRequest) returns (komp_ac.common.CountResponse);
   rpc GetTableDataByPosition(GetTableDataByPositionRequest) returns (GetTableDataResponse);
 }
 
 message PostTableDataRequest {
   string profile_name = 1;
   string table_name = 2;
-  map<string, string> data = 3;
+  map<string, google.protobuf.Value> data = 3;
 }
 
 message PostTableDataResponse {
@@ -29,7 +30,7 @@ message PutTableDataRequest {
   string profile_name = 1;
   string table_name = 2;
   int64 id = 3;
-  map<string, string> data = 4;
+  map<string, google.protobuf.Value> data = 4;
 }
 
 message PutTableDataResponse {

common/proto/uctovnictvo.proto

@@ -1,6 +1,6 @@
 // proto/uctovnictvo.proto
 syntax = "proto3";
-package multieko2.uctovnictvo;
+package komp_ac.uctovnictvo;
 
 import "common.proto";
 

common/src/lib.rs

@@ -3,33 +3,33 @@
 pub mod search;
 
 pub mod proto {
-    pub mod multieko2 {
+    pub mod komp_ac {
         pub mod adresar {
-            include!("proto/multieko2.adresar.rs");
+            include!("proto/komp_ac.adresar.rs");
         }
         pub mod auth {
-            include!("proto/multieko2.auth.rs");
+            include!("proto/komp_ac.auth.rs");
         }
         pub mod common {
-            include!("proto/multieko2.common.rs");
+            include!("proto/komp_ac.common.rs");
         }
         pub mod table_structure {
-            include!("proto/multieko2.table_structure.rs");
+            include!("proto/komp_ac.table_structure.rs");
         }
         pub mod uctovnictvo {
-            include!("proto/multieko2.uctovnictvo.rs");
+            include!("proto/komp_ac.uctovnictvo.rs");
         }
         pub mod table_definition {
-            include!("proto/multieko2.table_definition.rs");
+            include!("proto/komp_ac.table_definition.rs");
         }
         pub mod tables_data {
-            include!("proto/multieko2.tables_data.rs");
+            include!("proto/komp_ac.tables_data.rs");
         }
         pub mod table_script {
-            include!("proto/multieko2.table_script.rs");
+            include!("proto/komp_ac.table_script.rs");
         }
         pub mod search {
-            include!("proto/multieko2.search.rs");
+            include!("proto/komp_ac.search.rs");
         }
         pub const FILE_DESCRIPTOR_SET: &[u8] =
             include_bytes!("proto/descriptor.bin");

common/src/proto/komp_ac.adresar.rs

@@ -0,0 +1,791 @@
+// This file is @generated by prost-build.
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct GetAdresarRequest {
+    #[prost(int64, tag = "1")]
+    pub id: i64,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct DeleteAdresarRequest {
+    #[prost(int64, tag = "1")]
+    pub id: i64,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PostAdresarRequest {
+    #[prost(string, tag = "1")]
+    pub firma: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub kz: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub drc: ::prost::alloc::string::String,
+    #[prost(string, tag = "4")]
+    pub ulica: ::prost::alloc::string::String,
+    #[prost(string, tag = "5")]
+    pub psc: ::prost::alloc::string::String,
+    #[prost(string, tag = "6")]
+    pub mesto: ::prost::alloc::string::String,
+    #[prost(string, tag = "7")]
+    pub stat: ::prost::alloc::string::String,
+    #[prost(string, tag = "8")]
+    pub banka: ::prost::alloc::string::String,
+    #[prost(string, tag = "9")]
+    pub ucet: ::prost::alloc::string::String,
+    #[prost(string, tag = "10")]
+    pub skladm: ::prost::alloc::string::String,
+    #[prost(string, tag = "11")]
+    pub ico: ::prost::alloc::string::String,
+    #[prost(string, tag = "12")]
+    pub kontakt: ::prost::alloc::string::String,
+    #[prost(string, tag = "13")]
+    pub telefon: ::prost::alloc::string::String,
+    #[prost(string, tag = "14")]
+    pub skladu: ::prost::alloc::string::String,
+    #[prost(string, tag = "15")]
+    pub fax: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AdresarResponse {
+    #[prost(int64, tag = "1")]
+    pub id: i64,
+    #[prost(string, tag = "2")]
+    pub firma: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub kz: ::prost::alloc::string::String,
+    #[prost(string, tag = "4")]
+    pub drc: ::prost::alloc::string::String,
+    #[prost(string, tag = "5")]
+    pub ulica: ::prost::alloc::string::String,
+    #[prost(string, tag = "6")]
+    pub psc: ::prost::alloc::string::String,
+    #[prost(string, tag = "7")]
+    pub mesto: ::prost::alloc::string::String,
+    #[prost(string, tag = "8")]
+    pub stat: ::prost::alloc::string::String,
+    #[prost(string, tag = "9")]
+    pub banka: ::prost::alloc::string::String,
+    #[prost(string, tag = "10")]
+    pub ucet: ::prost::alloc::string::String,
+    #[prost(string, tag = "11")]
+    pub skladm: ::prost::alloc::string::String,
+    #[prost(string, tag = "12")]
+    pub ico: ::prost::alloc::string::String,
+    #[prost(string, tag = "13")]
+    pub kontakt: ::prost::alloc::string::String,
+    #[prost(string, tag = "14")]
+    pub telefon: ::prost::alloc::string::String,
+    #[prost(string, tag = "15")]
+    pub skladu: ::prost::alloc::string::String,
+    #[prost(string, tag = "16")]
+    pub fax: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PutAdresarRequest {
+    #[prost(int64, tag = "1")]
+    pub id: i64,
+    #[prost(string, tag = "2")]
+    pub firma: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub kz: ::prost::alloc::string::String,
+    #[prost(string, tag = "4")]
+    pub drc: ::prost::alloc::string::String,
+    #[prost(string, tag = "5")]
+    pub ulica: ::prost::alloc::string::String,
+    #[prost(string, tag = "6")]
+    pub psc: ::prost::alloc::string::String,
+    #[prost(string, tag = "7")]
+    pub mesto: ::prost::alloc::string::String,
+    #[prost(string, tag = "8")]
+    pub stat: ::prost::alloc::string::String,
+    #[prost(string, tag = "9")]
+    pub banka: ::prost::alloc::string::String,
+    #[prost(string, tag = "10")]
+    pub ucet: ::prost::alloc::string::String,
+    #[prost(string, tag = "11")]
+    pub skladm: ::prost::alloc::string::String,
+    #[prost(string, tag = "12")]
+    pub ico: ::prost::alloc::string::String,
+    #[prost(string, tag = "13")]
+    pub kontakt: ::prost::alloc::string::String,
+    #[prost(string, tag = "14")]
+    pub telefon: ::prost::alloc::string::String,
+    #[prost(string, tag = "15")]
+    pub skladu: ::prost::alloc::string::String,
+    #[prost(string, tag = "16")]
+    pub fax: ::prost::alloc::string::String,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct DeleteAdresarResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+}
+/// Generated client implementations.
+pub mod adresar_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    #[derive(Debug, Clone)]
+    pub struct AdresarClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl AdresarClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> AdresarClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::Body>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> AdresarClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            AdresarClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+        pub async fn post_adresar(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PostAdresarRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::AdresarResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/komp_ac.adresar.Adresar/PostAdresar",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("komp_ac.adresar.Adresar", "PostAdresar"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_adresar(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetAdresarRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::AdresarResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/komp_ac.adresar.Adresar/GetAdresar",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("komp_ac.adresar.Adresar", "GetAdresar"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn put_adresar(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PutAdresarRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::AdresarResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/komp_ac.adresar.Adresar/PutAdresar",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("komp_ac.adresar.Adresar", "PutAdresar"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn delete_adresar(
+            &mut self,
+            request: impl tonic::IntoRequest<super::DeleteAdresarRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteAdresarResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/komp_ac.adresar.Adresar/DeleteAdresar",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("komp_ac.adresar.Adresar", "DeleteAdresar"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_adresar_count(
+            &mut self,
+            request: impl tonic::IntoRequest<super::super::common::Empty>,
+        ) -> std::result::Result<
+            tonic::Response<super::super::common::CountResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/komp_ac.adresar.Adresar/GetAdresarCount",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("komp_ac.adresar.Adresar", "GetAdresarCount"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_adresar_by_position(
+            &mut self,
+            request: impl tonic::IntoRequest<super::super::common::PositionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::AdresarResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/komp_ac.adresar.Adresar/GetAdresarByPosition",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("komp_ac.adresar.Adresar", "GetAdresarByPosition"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod adresar_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    /// Generated trait containing gRPC methods that should be implemented for use with AdresarServer.
+    #[async_trait]
+    pub trait Adresar: std::marker::Send + std::marker::Sync + 'static {
+        async fn post_adresar(
+            &self,
+            request: tonic::Request<super::PostAdresarRequest>,
+        ) -> std::result::Result<tonic::Response<super::AdresarResponse>, tonic::Status>;
+        async fn get_adresar(
+            &self,
+            request: tonic::Request<super::GetAdresarRequest>,
+        ) -> std::result::Result<tonic::Response<super::AdresarResponse>, tonic::Status>;
+        async fn put_adresar(
+            &self,
+            request: tonic::Request<super::PutAdresarRequest>,
+        ) -> std::result::Result<tonic::Response<super::AdresarResponse>, tonic::Status>;
+        async fn delete_adresar(
+            &self,
+            request: tonic::Request<super::DeleteAdresarRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteAdresarResponse>,
+            tonic::Status,
+        >;
+        async fn get_adresar_count(
+            &self,
+            request: tonic::Request<super::super::common::Empty>,
+        ) -> std::result::Result<
+            tonic::Response<super::super::common::CountResponse>,
+            tonic::Status,
+        >;
+        async fn get_adresar_by_position(
+            &self,
+            request: tonic::Request<super::super::common::PositionRequest>,
+        ) -> std::result::Result<tonic::Response<super::AdresarResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct AdresarServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> AdresarServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            Self {
+                inner,
+                accept_compression_encodings: Default::default(),
+                send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
+            }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        where
+            F: tonic::service::Interceptor,
+        {
+            InterceptedService::new(Self::new(inner), interceptor)
+        }
+        /// Enable decompressing requests with the given encoding.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.accept_compression_encodings.enable(encoding);
+            self
+        }
+        /// Compress responses with the given encoding, if the client supports it.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.send_compression_encodings.enable(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
+    }
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for AdresarServer<T>
+    where
+        T: Adresar,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::Body>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/komp_ac.adresar.Adresar/PostAdresar" => {
+                    #[allow(non_camel_case_types)]
+                    struct PostAdresarSvc<T: Adresar>(pub Arc<T>);
+                    impl<
+                        T: Adresar,
+                    > tonic::server::UnaryService<super::PostAdresarRequest>
+                    for PostAdresarSvc<T> {
+                        type Response = super::AdresarResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PostAdresarRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Adresar>::post_adresar(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PostAdresarSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/komp_ac.adresar.Adresar/GetAdresar" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetAdresarSvc<T: Adresar>(pub Arc<T>);
+                    impl<
+                        T: Adresar,
+                    > tonic::server::UnaryService<super::GetAdresarRequest>
+                    for GetAdresarSvc<T> {
+                        type Response = super::AdresarResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetAdresarRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Adresar>::get_adresar(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetAdresarSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/komp_ac.adresar.Adresar/PutAdresar" => {
+                    #[allow(non_camel_case_types)]
+                    struct PutAdresarSvc<T: Adresar>(pub Arc<T>);
+                    impl<
+                        T: Adresar,
+                    > tonic::server::UnaryService<super::PutAdresarRequest>
+                    for PutAdresarSvc<T> {
+                        type Response = super::AdresarResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PutAdresarRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Adresar>::put_adresar(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = PutAdresarSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/komp_ac.adresar.Adresar/DeleteAdresar" => {
+                    #[allow(non_camel_case_types)]
+                    struct DeleteAdresarSvc<T: Adresar>(pub Arc<T>);
+                    impl<
+                        T: Adresar,
+                    > tonic::server::UnaryService<super::DeleteAdresarRequest>
+                    for DeleteAdresarSvc<T> {
+                        type Response = super::DeleteAdresarResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::DeleteAdresarRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Adresar>::delete_adresar(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = DeleteAdresarSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/komp_ac.adresar.Adresar/GetAdresarCount" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetAdresarCountSvc<T: Adresar>(pub Arc<T>);
+                    impl<
+                        T: Adresar,
+                    > tonic::server::UnaryService<super::super::common::Empty>
+                    for GetAdresarCountSvc<T> {
+                        type Response = super::super::common::CountResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::super::common::Empty>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Adresar>::get_adresar_count(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetAdresarCountSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/komp_ac.adresar.Adresar/GetAdresarByPosition" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetAdresarByPositionSvc<T: Adresar>(pub Arc<T>);
+                    impl<
+                        T: Adresar,
+                    > tonic::server::UnaryService<super::super::common::PositionRequest>
+                    for GetAdresarByPositionSvc<T> {
+                        type Response = super::AdresarResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<
+                                super::super::common::PositionRequest,
+                            >,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Adresar>::get_adresar_by_position(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = GetAdresarByPositionSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(
+                            tonic::body::Body::default(),
+                        );
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
+            }
+        }
+    }
+    impl<T> Clone for AdresarServer<T> {
+        fn clone(&self) -> Self {
+            let inner = self.inner.clone();
+            Self {
+                inner,
+                accept_compression_encodings: self.accept_compression_encodings,
+                send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
+            }
+        }
+    }
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "komp_ac.adresar.Adresar";
+    impl<T> tonic::server::NamedService for AdresarServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}

common/src/proto/komp_ac.auth.rs

@@ -0,0 +1,418 @@
+// This file is @generated by prost-build.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RegisterRequest {
+    #[prost(string, tag = "1")]
+    pub username: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub email: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub password: ::prost::alloc::string::String,
+    #[prost(string, tag = "4")]
+    pub password_confirmation: ::prost::alloc::string::String,
+    #[prost(string, tag = "5")]
+    pub role: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AuthResponse {
+    /// UUID in string format
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+    /// Registered username
+    #[prost(string, tag = "2")]
+    pub username: ::prost::alloc::string::String,
+    /// Registered email (if provided)
+    #[prost(string, tag = "3")]
+    pub email: ::prost::alloc::string::String,
+    /// Default role: 'accountant'
+    #[prost(string, tag = "4")]
+    pub role: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoginRequest {
+    /// Can be username or email
+    #[prost(string, tag = "1")]
+    pub identifier: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub password: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoginResponse {
+    /// JWT token
+    #[prost(string, tag = "1")]
+    pub access_token: ::prost::alloc::string::String,
+    /// Usually "Bearer"
+    #[prost(string, tag = "2")]
+    pub token_type: ::prost::alloc::string::String,
+    /// Expiration in seconds (86400 for 24 hours)
+    #[prost(int32, tag = "3")]
+    pub expires_in: i32,
+    /// User's UUID in string format
+    #[prost(string, tag = "4")]
+    pub user_id: ::prost::alloc::string::String,
+    /// User's role
+    #[prost(string, tag = "5")]
+    pub role: ::prost::alloc::string::String,
+    #[prost(string, tag = "6")]
+    pub username: ::prost::alloc::string::String,
+}
+/// Generated client implementations.
+pub mod auth_service_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    #[derive(Debug, Clone)]
+    pub struct AuthServiceClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl AuthServiceClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> AuthServiceClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::Body>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> AuthServiceClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            AuthServiceClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+        pub async fn register(
+            &mut self,
+            request: impl tonic::IntoRequest<super::RegisterRequest>,
+        ) -> std::result::Result<tonic::Response<super::AuthResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/komp_ac.auth.AuthService/Register",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("komp_ac.auth.AuthService", "Register"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn login(
+            &mut self,
+            request: impl tonic::IntoRequest<super::LoginRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoginResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/komp_ac.auth.AuthService/Login",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("komp_ac.auth.AuthService", "Login"));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod auth_service_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    /// Generated trait containing gRPC methods that should be implemented for use with AuthServiceServer.
+    #[async_trait]
+    pub trait AuthService: std::marker::Send + std::marker::Sync + 'static {
+        async fn register(
+            &self,
+            request: tonic::Request<super::RegisterRequest>,
+        ) -> std::result::Result<tonic::Response<super::AuthResponse>, tonic::Status>;
+        async fn login(
+            &self,
+            request: tonic::Request<super::LoginRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoginResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct AuthServiceServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> AuthServiceServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            Self {
+                inner,
+                accept_compression_encodings: Default::default(),
+                send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
+            }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        where
+            F: tonic::service::Interceptor,
+        {
+            InterceptedService::new(Self::new(inner), interceptor)
+        }
+        /// Enable decompressing requests with the given encoding.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.accept_compression_encodings.enable(encoding);
+            self
+        }
+        /// Compress responses with the given encoding, if the client supports it.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.send_compression_encodings.enable(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
+    }
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for AuthServiceServer<T>
+    where
+        T: AuthService,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::Body>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/komp_ac.auth.AuthService/Register" => {
+                    #[allow(non_camel_case_types)]
+                    struct RegisterSvc<T: AuthService>(pub Arc<T>);
+                    impl<
+                        T: AuthService,
+                    > tonic::server::UnaryService<super::RegisterRequest>
+                    for RegisterSvc<T> {
+                        type Response = super::AuthResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::RegisterRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as AuthService>::register(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = RegisterSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/komp_ac.auth.AuthService/Login" => {
+                    #[allow(non_camel_case_types)]
+                    struct LoginSvc<T: AuthService>(pub Arc<T>);
+                    impl<T: AuthService> tonic::server::UnaryService<super::LoginRequest>
+                    for LoginSvc<T> {
+                        type Response = super::LoginResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::LoginRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as AuthService>::login(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = LoginSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(
+                            tonic::body::Body::default(),
+                        );
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
+            }
+        }
+    }
+    impl<T> Clone for AuthServiceServer<T> {
+        fn clone(&self) -> Self {
+            let inner = self.inner.clone();
+            Self {
+                inner,
+                accept_compression_encodings: self.accept_compression_encodings,
+                send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
+            }
+        }
+    }
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "komp_ac.auth.AuthService";
+    impl<T> tonic::server::NamedService for AuthServiceServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}

common/src/proto/komp_ac.common.rs

@@ -0,0 +1,13 @@
+// This file is @generated by prost-build.
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct Empty {}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct CountResponse {
+    #[prost(int64, tag = "1")]
+    pub count: i64,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct PositionRequest {
+    #[prost(int64, tag = "1")]
+    pub position: i64,
+}

common/src/proto/komp_ac.search.rs

@@ -0,0 +1,317 @@
+// This file is @generated by prost-build.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SearchRequest {
+    #[prost(string, tag = "1")]
+    pub table_name: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub query: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SearchResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub hits: ::prost::alloc::vec::Vec<search_response::Hit>,
+}
+/// Nested message and enum types in `SearchResponse`.
+pub mod search_response {
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct Hit {
+        /// PostgreSQL row ID
+        #[prost(int64, tag = "1")]
+        pub id: i64,
+        #[prost(float, tag = "2")]
+        pub score: f32,
+        #[prost(string, tag = "3")]
+        pub content_json: ::prost::alloc::string::String,
+    }
+}
+/// Generated client implementations.
+pub mod searcher_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    #[derive(Debug, Clone)]
+    pub struct SearcherClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl SearcherClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> SearcherClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::Body>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> SearcherClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            SearcherClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+        pub async fn search_table(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SearchRequest>,
+        ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/komp_ac.search.Searcher/SearchTable",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("komp_ac.search.Searcher", "SearchTable"));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod searcher_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    /// Generated trait containing gRPC methods that should be implemented for use with SearcherServer.
+    #[async_trait]
+    pub trait Searcher: std::marker::Send + std::marker::Sync + 'static {
+        async fn search_table(
+            &self,
+            request: tonic::Request<super::SearchRequest>,
+        ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct SearcherServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> SearcherServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            Self {
+                inner,
+                accept_compression_encodings: Default::default(),
+                send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
+            }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        where
+            F: tonic::service::Interceptor,
+        {
+            InterceptedService::new(Self::new(inner), interceptor)
+        }
+        /// Enable decompressing requests with the given encoding.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.accept_compression_encodings.enable(encoding);
+            self
+        }
+        /// Compress responses with the given encoding, if the client supports it.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.send_compression_encodings.enable(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
+    }
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for SearcherServer<T>
+    where
+        T: Searcher,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::Body>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/komp_ac.search.Searcher/SearchTable" => {
+                    #[allow(non_camel_case_types)]
+                    struct SearchTableSvc<T: Searcher>(pub Arc<T>);
+                    impl<T: Searcher> tonic::server::UnaryService<super::SearchRequest>
+                    for SearchTableSvc<T> {
+                        type Response = super::SearchResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SearchRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Searcher>::search_table(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SearchTableSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(
+                            tonic::body::Body::default(),
+                        );
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
+            }
+        }
+    }
+    impl<T> Clone for SearcherServer<T> {
+        fn clone(&self) -> Self {
+            let inner = self.inner.clone();
+            Self {
+                inner,
+                accept_compression_encodings: self.accept_compression_encodings,
+                send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
+            }
+        }
+    }
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "komp_ac.search.Searcher";
+    impl<T> tonic::server::NamedService for SearcherServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}