unimportant change

accpeting now null in the post table data as nothing
post doesnt work, but refactored code displays the autocomplete at least, needs fix
2025-06-17 10:27:22 +02:00 · 2025-06-16 22:51:05 +02:00 · 2025-06-16 16:42:25 +02:00 · 2025-06-16 16:10:24 +02:00 · 2025-06-16 14:42:49 +02:00 · 2025-06-16 11:54:54 +02:00
60 changed files with 3925 additions and 1423 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,4 @@
 /target
 .env
+/tantivy_indexes
+server/tantivy_indexes
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -303,6 +303,15 @@ dependencies = [
 "typenum",
 ]

+[[package]]
+name = "bitpacking"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c1d3e2bfd8d06048a179f7b17afc3188effa10385e7b00dc65af6aae732ea92"
+dependencies = [
+ "crunchy",
+]
+
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -322,6 +331,31 @@ dependencies = [
 "cipher",
 ]

+[[package]]
+name = "bon"
+version = "3.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced38439e7a86a4761f7f7d5ded5ff009135939ecb464a24452eaa4c1696af7d"
+dependencies = [
+ "bon-macros",
+ "rustversion",
+]
+
+[[package]]
+name = "bon-macros"
+version = "3.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce61d2d3844c6b8d31b2353d9f66cf5e632b3e9549583fe3cac2f4f6136725e"
+dependencies = [
+ "darling",
+ "ident_case",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 2.0.100",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.17.0"
@@ -361,9 +395,17 @@ version = "1.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e3a13707ac958681c13b39b458c073d0d9bc8a22cb1b2f4c8e55eb72c13f362"
 dependencies = [
+ "jobserver",
+ "libc",
 "shlex",
 ]

+[[package]]
+name = "census"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f4c707c6a209cbe82d10abd08e1ea8995e9ea937d2550646e02798948992be0"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -407,6 +449,7 @@ dependencies = [
 "dotenvy",
 "lazy_static",
 "prost",
+ "prost-types",
 "ratatui",
 "serde",
 "serde_json",
@@ -445,7 +488,9 @@ name = "common"
 version = "0.3.13"
 dependencies = [
 "prost",
+ "prost-types",
 "serde",
+ "tantivy",
 "tonic",
 "tonic-build",
 ]
@@ -541,6 +586,15 @@ version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"

+[[package]]
+name = "crc32fast"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "crossbeam"
 version = "0.8.4"
@@ -622,6 +676,12 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "crunchy"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
+
 [[package]]
 name = "crypto-common"
 version = "0.1.6"
@@ -699,6 +759,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e"
 dependencies = [
 "powerfmt",
+ "serde",
 ]

 [[package]]
@@ -772,6 +833,12 @@ version = "0.15.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"

+[[package]]
+name = "downcast-rs"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea8a8b81cacc08888170eef4d13b775126db426d0b348bee9d18c2c1eaf123cf"
+
 [[package]]
 name = "either"
 version = "1.15.0"
@@ -825,6 +892,12 @@ dependencies = [
 "pin-project-lite",
 ]

+[[package]]
+name = "fastdivide"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afc2bd4d5a73106dd53d10d73d3401c2f32730ba2c0b93ddb888a8983680471"
+
 [[package]]
 name = "fastrand"
 version = "2.3.0"
@@ -884,6 +957,16 @@ dependencies = [
 "percent-encoding",
 ]

+[[package]]
+name = "fs4"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7e180ac76c23b45e767bd7ae9579bc0bb458618c4bc71835926e098e61d15f8"
+dependencies = [
+ "rustix 0.38.44",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "futures-channel"
 version = "0.3.31"
@@ -1142,6 +1225,12 @@ dependencies = [
 "windows-sys 0.59.0",
 ]

+[[package]]
+name = "htmlescape"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9025058dae765dee5070ec375f591e2ba14638c63feff74f13805a72e523163"
+
 [[package]]
 name = "http"
 version = "1.3.1"
@@ -1242,6 +1331,15 @@ dependencies = [
 "tracing",
 ]

+[[package]]
+name = "hyperloglogplus"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "621debdf94dcac33e50475fdd76d34d5ea9c0362a834b9db08c3024696c1fbe3"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "iana-time-zone"
 version = "0.1.63"
@@ -1520,6 +1618,16 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"

+[[package]]
+name = "jobserver"
+version = "0.1.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38f262f097c174adebe41eb73d66ae9c06b2844fb0da69969647bbddd9b0538a"
+dependencies = [
+ "getrandom 0.3.2",
+ "libc",
+]
+
 [[package]]
 name = "js-sys"
 version = "0.3.77"
@@ -1566,6 +1674,12 @@ dependencies = [
 "spin",
 ]

+[[package]]
+name = "levenshtein_automata"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c2cdeb66e45e9f36bfad5bbdb4d2384e70936afbee843c6f6543f0c551ebb25"
+
 [[package]]
 name = "libc"
 version = "0.2.172"
@@ -1651,6 +1765,12 @@ dependencies = [
 "hashbrown 0.15.2",
 ]

+[[package]]
+name = "lz4_flex"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75761162ae2b0e580d7e7c390558127e5f01b4194debd6221fd8c207fc80e3f5"
+
 [[package]]
 name = "matchit"
 version = "0.8.4"
@@ -1667,18 +1787,42 @@ dependencies = [
 "digest",
 ]

+[[package]]
+name = "measure_time"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51c55d61e72fc3ab704396c5fa16f4c184db37978ae4e94ca8959693a235fc0e"
+dependencies = [
+ "log",
+]
+
 [[package]]
 name = "memchr"
 version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"

+[[package]]
+name = "memmap2"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd3f7eed9d3848f8b98834af67102b720745c4ec028fcd0aa0239277e7de374f"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "mime"
 version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"

+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
 [[package]]
 name = "miniz_oxide"
 version = "0.8.8"
@@ -1706,6 +1850,12 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03"

+[[package]]
+name = "murmurhash32"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2195bf6aa996a481483b29d62a7663eed3fe39600c460e323f8ff41e90bdd89b"
+
 [[package]]
 name = "native-tls"
 version = "0.2.14"
@@ -1723,6 +1873,16 @@ dependencies = [
 "tempfile",
 ]

+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
 [[package]]
 name = "nu-ansi-term"
 version = "0.46.0"
@@ -1857,6 +2017,12 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"

+[[package]]
+name = "oneshot"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ce411919553d3f9fa53a0880544cda985a112117a0444d5ff1e870a893d6ea"
+
 [[package]]
 name = "openssl"
 version = "0.10.72"
@@ -1913,6 +2079,15 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"

+[[package]]
+name = "ownedbytes"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fbd56f7631767e61784dc43f8580f403f4475bd4aaa4da003e6295e1bab4a7e"
+dependencies = [
+ "stable_deref_trait",
+]
+
 [[package]]
 name = "parking"
 version = "2.2.1"
@@ -2275,6 +2450,16 @@ dependencies = [
 "getrandom 0.3.2",
 ]

+[[package]]
+name = "rand_distr"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32cb0b9bc82b0a0876c2dd994a7e7a2683d3e7390ca40e6886785ef0c7e3ee31"
+dependencies = [
+ "num-traits",
+ "rand 0.8.5",
+]
+
 [[package]]
 name = "rand_xoshiro"
 version = "0.6.0"
@@ -2305,6 +2490,26 @@ dependencies = [
 "unicode-width 0.2.0",
 ]

+[[package]]
+name = "rayon"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.5.11"
@@ -2444,12 +2649,28 @@ dependencies = [
 "unicode-ident",
 ]

+[[package]]
+name = "rust-stemmers"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e46a2036019fdb888131db7a4c847a1063a7493f971ed94ea82c67eada63ca54"
+dependencies = [
+ "serde",
+ "serde_derive",
+]
+
 [[package]]
 name = "rustc-demangle"
 version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"

+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -2512,6 +2733,23 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"

+[[package]]
+name = "search"
+version = "0.3.13"
+dependencies = [
+ "anyhow",
+ "common",
+ "prost",
+ "serde",
+ "serde_json",
+ "sqlx",
+ "tantivy",
+ "tokio",
+ "tonic",
+ "tonic-reflection",
+ "tracing",
+]
+
 [[package]]
 name = "security-framework"
 version = "2.11.1"
@@ -2598,6 +2836,7 @@ dependencies = [
 name = "server"
 version = "0.3.13"
 dependencies = [
+ "anyhow",
 "bcrypt",
 "chrono",
 "common",
@@ -2606,13 +2845,17 @@ dependencies = [
 "jsonwebtoken",
 "lazy_static",
 "prost",
+ "prost-types",
 "regex",
 "rstest",
+ "rust-stemmers",
+ "search",
 "serde",
 "serde_json",
 "sqlx",
 "steel-core",
 "steel-derive 0.5.0 (git+https://github.com/mattwparas/steel.git?branch=master)",
+ "tantivy",
 "thiserror 2.0.12",
 "time",
 "tokio",
@@ -2722,6 +2965,15 @@ dependencies = [
 "typenum",
 ]

+[[package]]
+name = "sketches-ddsketch"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1e9a774a6c28142ac54bb25d25562e6bcf957493a184f15ad4eebccb23e410a"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "slab"
 version = "0.4.9"
@@ -2771,9 +3023,9 @@ dependencies = [

 [[package]]
 name = "sqlx"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c3a85280daca669cfd3bcb68a337882a8bc57ec882f72c5d13a430613a738e"
+checksum = "1fefb893899429669dcdd979aff487bd78f4064e5e7907e4269081e0ef7d97dc"
 dependencies = [
 "sqlx-core",
 "sqlx-macros",
@@ -2784,9 +3036,9 @@ dependencies = [

 [[package]]
 name = "sqlx-core"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f743f2a3cea30a58cd479013f75550e879009e3a02f616f18ca699335aa248c3"
+checksum = "ee6798b1838b6a0f69c007c133b8df5866302197e404e8b6ee8ed3e3a5e68dc6"
 dependencies = [
 "base64",
 "bytes",
@@ -2822,9 +3074,9 @@ dependencies = [

 [[package]]
 name = "sqlx-macros"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f4200e0fde19834956d4252347c12a083bdcb237d7a1a1446bffd8768417dce"
+checksum = "a2d452988ccaacfbf5e0bdbc348fb91d7c8af5bee192173ac3636b5fb6e6715d"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2835,9 +3087,9 @@ dependencies = [

 [[package]]
 name = "sqlx-macros-core"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "882ceaa29cade31beca7129b6beeb05737f44f82dbe2a9806ecea5a7093d00b7"
+checksum = "19a9c1841124ac5a61741f96e1d9e2ec77424bf323962dd894bdb93f37d5219b"
 dependencies = [
 "dotenvy",
 "either",
@@ -2854,16 +3106,15 @@ dependencies = [
 "sqlx-postgres",
 "sqlx-sqlite",
 "syn 2.0.100",
- "tempfile",
 "tokio",
 "url",
 ]

 [[package]]
 name = "sqlx-mysql"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0afdd3aa7a629683c2d750c2df343025545087081ab5942593a5288855b1b7a7"
+checksum = "aa003f0038df784eb8fecbbac13affe3da23b45194bd57dba231c8f48199c526"
 dependencies = [
 "atoi",
 "base64",
@@ -2906,9 +3157,9 @@ dependencies = [

 [[package]]
 name = "sqlx-postgres"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0bedbe1bbb5e2615ef347a5e9d8cd7680fb63e77d9dafc0f29be15e53f1ebe6"
+checksum = "db58fcd5a53cf07c184b154801ff91347e4c30d17a3562a635ff028ad5deda46"
 dependencies = [
 "atoi",
 "base64",
@@ -2946,9 +3197,9 @@ dependencies = [

 [[package]]
 name = "sqlx-sqlite"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c26083e9a520e8eb87a06b12347679b142dc2ea29e6e409f805644a7a979a5bc"
+checksum = "c2d12fe70b2c1b4401038055f90f151b78208de1f9f89a7dbfd41587a10c3eea"
 dependencies = [
 "atoi",
 "chrono",
@@ -3162,6 +3413,152 @@ dependencies = [
 "syn 2.0.100",
 ]

+[[package]]
+name = "tantivy"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca2374a21157427c5faff2d90930f035b6c22a5d7b0e5b0b7f522e988ef33c06"
+dependencies = [
+ "aho-corasick",
+ "arc-swap",
+ "base64",
+ "bitpacking",
+ "bon",
+ "byteorder",
+ "census",
+ "crc32fast",
+ "crossbeam-channel",
+ "downcast-rs",
+ "fastdivide",
+ "fnv",
+ "fs4",
+ "htmlescape",
+ "hyperloglogplus",
+ "itertools 0.14.0",
+ "levenshtein_automata",
+ "log",
+ "lru",
+ "lz4_flex",
+ "measure_time",
+ "memmap2",
+ "once_cell",
+ "oneshot",
+ "rayon",
+ "regex",
+ "rust-stemmers",
+ "rustc-hash",
+ "serde",
+ "serde_json",
+ "sketches-ddsketch",
+ "smallvec",
+ "tantivy-bitpacker",
+ "tantivy-columnar",
+ "tantivy-common",
+ "tantivy-fst",
+ "tantivy-query-grammar",
+ "tantivy-stacker",
+ "tantivy-tokenizer-api",
+ "tempfile",
+ "thiserror 2.0.12",
+ "time",
+ "uuid",
+ "winapi",
+]
+
+[[package]]
+name = "tantivy-bitpacker"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1adc286a39e089ae9938935cd488d7d34f14502544a36607effd2239ff0e2494"
+dependencies = [
+ "bitpacking",
+]
+
+[[package]]
+name = "tantivy-columnar"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6300428e0c104c4f7db6f95b466a6f5c1b9aece094ec57cdd365337908dc7344"
+dependencies = [
+ "downcast-rs",
+ "fastdivide",
+ "itertools 0.14.0",
+ "serde",
+ "tantivy-bitpacker",
+ "tantivy-common",
+ "tantivy-sstable",
+ "tantivy-stacker",
+]
+
+[[package]]
+name = "tantivy-common"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91b6ea6090ce03dc72c27d0619e77185d26cc3b20775966c346c6d4f7e99d7f"
+dependencies = [
+ "async-trait",
+ "byteorder",
+ "ownedbytes",
+ "serde",
+ "time",
+]
+
+[[package]]
+name = "tantivy-fst"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d60769b80ad7953d8a7b2c70cdfe722bbcdcac6bccc8ac934c40c034d866fc18"
+dependencies = [
+ "byteorder",
+ "regex-syntax",
+ "utf8-ranges",
+]
+
+[[package]]
+name = "tantivy-query-grammar"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e810cdeeebca57fc3f7bfec5f85fdbea9031b2ac9b990eb5ff49b371d52bbe6a"
+dependencies = [
+ "nom",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "tantivy-sstable"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "709f22c08a4c90e1b36711c1c6cad5ae21b20b093e535b69b18783dd2cb99416"
+dependencies = [
+ "futures-util",
+ "itertools 0.14.0",
+ "tantivy-bitpacker",
+ "tantivy-common",
+ "tantivy-fst",
+ "zstd",
+]
+
+[[package]]
+name = "tantivy-stacker"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bcdebb267671311d1e8891fd9d1301803fdb8ad21ba22e0a30d0cab49ba59c1"
+dependencies = [
+ "murmurhash32",
+ "rand_distr",
+ "tantivy-common",
+]
+
+[[package]]
+name = "tantivy-tokenizer-api"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfa942fcee81e213e09715bbce8734ae2180070b97b33839a795ba1de201547d"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "tempfile"
 version = "3.19.1"
@@ -3424,9 +3821,9 @@ dependencies = [

 [[package]]
 name = "tonic-reflection"
-version = "0.13.0"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88fa815be858816dad226a49439ee90b7bcf81ab55bee72fdb217f1e6778c3ca"
+checksum = "f9687bd5bfeafebdded2356950f278bba8226f0b32109537c4253406e09aafe1"
 dependencies = [
 "prost",
 "prost-types",
@@ -3648,6 +4045,12 @@ version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"

+[[package]]
+name = "utf8-ranges"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcfc827f90e53a02eaef5e535ee14266c1d569214c6aa70133a624d8a3164ba"
+
 [[package]]
 name = "utf8_iter"
 version = "1.0.4"
@@ -3850,7 +4253,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]

 [[package]]
@@ -4214,3 +4617,31 @@ dependencies = [
 "quote",
 "syn 2.0.100",
 ]
+
+[[package]]
+name = "zstd"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "7.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.15+zstd.1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb81183ddd97d0c74cedf1d50d85c8d08c1b8b68ee863bdee9e706eedba1a237"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [workspace]
-members = ["client", "server", "common"]
+members = ["client", "server", "common", "search"]
 resolver = "2"

 [workspace.package]
@@ -16,4 +16,28 @@ categories = ["command-line-interface"]

 # [workspace.metadata]
 # TODO:
-# documentation = "https://docs.rs/accounting-client"`
+# documentation = "https://docs.rs/accounting-client"
+
+[workspace.dependencies]
+# Async and gRPC
+tokio = { version = "1.44.2", features = ["full"] }
+tonic = "0.13.0"
+prost = "0.13.5"
+async-trait = "0.1.88"
+prost-types = "0.13.0"
+
+# Data Handling & Serialization
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.140"
+time = "0.3.41"
+
+# Utilities & Error Handling
+anyhow = "1.0.98"
+dotenvy = "0.15.7"
+lazy_static = "1.5.0"
+tracing = "0.1.41"
+
+# Search crate
+tantivy = "0.24.1"
+
+common = { path = "./common" }
--- a/README.md
+++ b/README.md
@@ -18,3 +18,8 @@ Client with tracing:
 ```
 ENABLE_TRACING=1 RUST_LOG=client=debug cargo watch -x 'run --package client -- client'
 ```
+
+Client with debug that cant be traced
+```
+cargo run --package client --features ui-debug -- client
+```
--- a/client/Cargo.toml
+++ b/client/Cargo.toml
@@ -9,6 +9,7 @@ anyhow = "1.0.98"
 async-trait = "0.1.88"
 common = { path = "../common" }

+prost-types = { workspace = true }
 crossterm = "0.28.1"
 dirs = "6.0.0"
 dotenvy = "0.15.7"
@@ -26,3 +27,7 @@ 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"
+
+[features]
+default = []
+ui-debug = []
--- a/client/config.toml
+++ b/client/config.toml
@@ -17,6 +17,7 @@ toggle_buffer_list = ["ctrl+b"]
 next_field = ["Tab"]
 prev_field = ["Shift+Tab"]
 exit_table_scroll = ["esc"]
+open_search = ["ctrl+f"]

 [keybindings.common]
 save = ["ctrl+s"]
@@ -69,10 +70,11 @@ prev_field = ["shift+enter"]
 exit = ["esc", "ctrl+e"]
 delete_char_forward = ["delete"]
 delete_char_backward = ["backspace"]
-move_left = ["left"]
+move_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"]
--- a/client/src/components/common.rs
+++ b/client/src/components/common.rs
@@ -5,6 +5,7 @@ pub mod text_editor;
 pub mod background;
 pub mod dialog;
 pub mod autocomplete;
+pub mod search_palette;
 pub mod find_file_palette;

 pub use command_line::*;
@@ -13,4 +14,5 @@ pub use text_editor::*;
 pub use background::*;
 pub use dialog::*;
 pub use autocomplete::*;
+pub use search_palette::*;
 pub use find_file_palette::*;
--- a/client/src/components/common/autocomplete.rs
+++ b/client/src/components/common/autocomplete.rs
@@ -1,6 +1,8 @@
 // src/components/common/autocomplete.rs

 use crate::config::colors::themes::Theme;
+use crate::state::pages::form::FormState;
+use common::proto::multieko2::search::search_response::Hit;
 use ratatui::{
    layout::Rect,
    style::{Color, Modifier, Style},
@@ -9,7 +11,8 @@ use ratatui::{
 };
 use unicode_width::UnicodeWidthStr;

-/// Renders an opaque dropdown list for autocomplete suggestions.
+/// Renders an opaque dropdown list for simple string-based suggestions.
+/// THIS IS THE RESTORED FUNCTION.
 pub fn render_autocomplete_dropdown(
    f: &mut Frame,
    input_rect: Rect,
@@ -21,39 +24,32 @@ pub fn render_autocomplete_dropdown(
    if suggestions.is_empty() {
        return;
    }
-    // --- Calculate Dropdown Size & Position ---
-    let max_suggestion_width = suggestions.iter().map(|s| s.width()).max().unwrap_or(0) as u16;
+    let max_suggestion_width =
+        suggestions.iter().map(|s| s.width()).max().unwrap_or(0) as u16;
    let horizontal_padding: u16 = 2;
    let dropdown_width = (max_suggestion_width + horizontal_padding).max(10);
    let dropdown_height = (suggestions.len() as u16).min(5);

    let mut dropdown_area = Rect {
-        x: input_rect.x, // Align horizontally with input
-        y: input_rect.y + 1, // Position directly below input
+        x: input_rect.x,
+        y: input_rect.y + 1,
        width: dropdown_width,
        height: dropdown_height,
    };

-    // --- Clamping Logic (prevent rendering off-screen) ---
-    // Clamp vertically (if it goes below the frame)
    if dropdown_area.bottom() > frame_area.height {
-        dropdown_area.y = input_rect.y.saturating_sub(dropdown_height); // Try rendering above
+        dropdown_area.y = input_rect.y.saturating_sub(dropdown_height);
    }
-    // Clamp horizontally (if it goes past the right edge)
    if dropdown_area.right() > frame_area.width {
        dropdown_area.x = frame_area.width.saturating_sub(dropdown_width);
    }
-    // Ensure x is not negative (if clamping pushes it left)
    dropdown_area.x = dropdown_area.x.max(0);
-    // Ensure y is not negative (if clamping pushes it up)
    dropdown_area.y = dropdown_area.y.max(0);
-    // --- End Clamping ---

-    // Render a solid background block first to ensure opacity
-    let background_block = Block::default().style(Style::default().bg(Color::DarkGray));
+    let background_block =
+        Block::default().style(Style::default().bg(Color::DarkGray));
    f.render_widget(background_block, dropdown_area);

-    // Create list items, ensuring each has a defined background
    let items: Vec<ListItem> = suggestions
        .iter()
        .enumerate()
@@ -61,30 +57,97 @@ pub fn render_autocomplete_dropdown(
            let is_selected = selected_index == Some(i);
            let s_width = s.width() as u16;
            let padding_needed = dropdown_width.saturating_sub(s_width);
-            let padded_s = format!("{}{}", s, " ".repeat(padding_needed as usize));
+            let padded_s =
+                format!("{}{}", s, " ".repeat(padding_needed as usize));

            ListItem::new(padded_s).style(if is_selected {
                Style::default()
-                    .fg(theme.bg) // Text color on highlight
-                    .bg(theme.highlight) // Highlight background
+                    .fg(theme.bg)
+                    .bg(theme.highlight)
                    .add_modifier(Modifier::BOLD)
            } else {
-                // Style for non-selected items (matching background block)
-                Style::default()
-                    .fg(theme.fg) // Text color on gray
-                    .bg(Color::DarkGray) // Explicit gray background
+                Style::default().fg(theme.fg).bg(Color::DarkGray)
            })
        })
        .collect();

-    // Create the list widget (without its own block)
    let list = List::new(items);
+    let mut list_state = ListState::default();
+    list_state.select(selected_index);

-    // State for managing selection highlight (still needed for logic)
-    let mut profile_list_state = ListState::default();
-    profile_list_state.select(selected_index);
-
-    // Render the list statefully *over* the background block
-    f.render_stateful_widget(list, dropdown_area, &mut profile_list_state);
+    f.render_stateful_widget(list, dropdown_area, &mut list_state);
 }

+/// Renders an opaque dropdown list for rich `Hit`-based suggestions.
+/// RENAMED from render_rich_autocomplete_dropdown
+pub fn render_hit_autocomplete_dropdown(
+    f: &mut Frame,
+    input_rect: Rect,
+    frame_area: Rect,
+    theme: &Theme,
+    suggestions: &[Hit],
+    selected_index: Option<usize>,
+    form_state: &FormState,
+) {
+    if suggestions.is_empty() {
+        return;
+    }
+
+    let display_names: Vec<String> = suggestions
+        .iter()
+        .map(|hit| form_state.get_display_name_for_hit(hit))
+        .collect();
+
+    let max_suggestion_width =
+        display_names.iter().map(|s| s.width()).max().unwrap_or(0) as u16;
+    let horizontal_padding: u16 = 2;
+    let dropdown_width = (max_suggestion_width + horizontal_padding).max(10);
+    let dropdown_height = (suggestions.len() as u16).min(5);
+
+    let mut dropdown_area = Rect {
+        x: input_rect.x,
+        y: input_rect.y + 1,
+        width: dropdown_width,
+        height: dropdown_height,
+    };
+
+    if dropdown_area.bottom() > frame_area.height {
+        dropdown_area.y = input_rect.y.saturating_sub(dropdown_height);
+    }
+    if dropdown_area.right() > frame_area.width {
+        dropdown_area.x = frame_area.width.saturating_sub(dropdown_width);
+    }
+    dropdown_area.x = dropdown_area.x.max(0);
+    dropdown_area.y = dropdown_area.y.max(0);
+
+    let background_block =
+        Block::default().style(Style::default().bg(Color::DarkGray));
+    f.render_widget(background_block, dropdown_area);
+
+    let items: Vec<ListItem> = display_names
+        .iter()
+        .enumerate()
+        .map(|(i, s)| {
+            let is_selected = selected_index == Some(i);
+            let s_width = s.width() as u16;
+            let padding_needed = dropdown_width.saturating_sub(s_width);
+            let padded_s =
+                format!("{}{}", s, " ".repeat(padding_needed as usize));
+
+            ListItem::new(padded_s).style(if is_selected {
+                Style::default()
+                    .fg(theme.bg)
+                    .bg(theme.highlight)
+                    .add_modifier(Modifier::BOLD)
+            } else {
+                Style::default().fg(theme.fg).bg(Color::DarkGray)
+            })
+        })
+        .collect();
+
+    let list = List::new(items);
+    let mut list_state = ListState::default();
+    list_state.select(selected_index);
+
+    f.render_stateful_widget(list, dropdown_area, &mut list_state);
+}
--- a/client/src/components/common/search_palette.rs
+++ b/client/src/components/common/search_palette.rs
@@ -0,0 +1,121 @@
+// src/components/common/search_palette.rs
+
+use crate::config::colors::themes::Theme;
+use crate::state::app::search::SearchState;
+use ratatui::{
+    layout::{Constraint, Direction, Layout, Rect},
+    style::{Modifier, Style},
+    text::{Line, Span},
+    widgets::{Block, Borders, Clear, List, ListItem, Paragraph},
+    Frame,
+};
+
+/// Renders the search palette dialog over the main UI.
+pub fn render_search_palette(
+    f: &mut Frame,
+    area: Rect,
+    theme: &Theme,
+    state: &SearchState,
+) {
+    // --- Dialog Area Calculation ---
+    let height = (area.height as f32 * 0.7).min(30.0) as u16;
+    let width = (area.width as f32 * 0.6).min(100.0) as u16;
+    let dialog_area = Rect {
+        x: area.x + (area.width - width) / 2,
+        y: area.y + (area.height - height) / 4,
+        width,
+        height,
+    };
+
+    f.render_widget(Clear, dialog_area); // Clear background
+
+    let block = Block::default()
+        .title(format!(" Search in '{}' ", state.table_name))
+        .borders(Borders::ALL)
+        .border_style(Style::default().fg(theme.accent));
+    f.render_widget(block.clone(), dialog_area);
+
+    // --- Inner Layout (Input + Results) ---
+    let inner_chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .margin(1)
+        .constraints([
+            Constraint::Length(3), // For input box
+            Constraint::Min(0),    // For results list
+        ])
+        .split(dialog_area);
+
+    // --- Render Input Box ---
+    let input_block = Block::default()
+        .title("Query")
+        .borders(Borders::ALL)
+        .border_style(Style::default().fg(theme.border));
+    let input_text = Paragraph::new(state.input.as_str())
+        .block(input_block)
+        .style(Style::default().fg(theme.fg));
+    f.render_widget(input_text, inner_chunks[0]);
+    // Set cursor position
+    f.set_cursor(
+        inner_chunks[0].x + state.cursor_position as u16 + 1,
+        inner_chunks[0].y + 1,
+    );
+
+    // --- Render Results List ---
+    if state.is_loading {
+        let loading_p = Paragraph::new("Searching...")
+            .style(Style::default().fg(theme.fg).add_modifier(Modifier::ITALIC));
+        f.render_widget(loading_p, inner_chunks[1]);
+    } else {
+        let list_items: Vec<ListItem> = state
+            .results
+            .iter()
+            .map(|hit| {
+                // Parse the JSON string to make it readable
+                let content_summary = match serde_json::from_str::<
+                    serde_json::Value,
+                >(&hit.content_json)
+                {
+                    Ok(json) => {
+                        if let Some(obj) = json.as_object() {
+                            // Create a summary from the first few non-null string values
+                            obj.values()
+                                .filter_map(|v| v.as_str())
+                                .filter(|s| !s.is_empty())
+                                .take(3)
+                                .collect::<Vec<_>>()
+                                .join(" | ")
+                        } else {
+                            "Non-object JSON".to_string()
+                        }
+                    }
+                    Err(_) => "Invalid JSON content".to_string(),
+                };
+
+                let line = Line::from(vec![
+                    Span::styled(
+                        format!("{:<4.2} ", hit.score),
+                        Style::default().fg(theme.accent),
+                    ),
+                    Span::raw(content_summary),
+                ]);
+                ListItem::new(line)
+            })
+            .collect();
+
+        let results_list = List::new(list_items)
+            .block(Block::default().title("Results"))
+            .highlight_style(
+                Style::default()
+                    .bg(theme.highlight)
+                    .fg(theme.bg)
+                    .add_modifier(Modifier::BOLD),
+            )
+            .highlight_symbol(">> ");
+
+        // We need a mutable ListState to render the selection
+        let mut list_state =
+            ratatui::widgets::ListState::default().with_selected(Some(state.selected_index));
+
+        f.render_stateful_widget(results_list, inner_chunks[1], &mut list_state);
+    }
+}
--- a/client/src/components/common/status_line.rs
+++ b/client/src/components/common/status_line.rs
@@ -1,14 +1,15 @@
-// src/components/common/status_line.rs
-use ratatui::{
-    style::Style,
-    layout::Rect,
-    Frame,
-    text::{Line, Span},
-    widgets::Paragraph,
-};
-use unicode_width::UnicodeWidthStr;
+// client/src/components/common/status_line.rs
 use crate::config::colors::themes::Theme;
+use crate::state::app::state::AppState;
+use ratatui::{
+    layout::Rect,
+    style::Style,
+    text::{Line, Span, Text},
+    widgets::{Paragraph, Wrap}, // Make sure Wrap is imported
+    Frame,
+};
 use std::path::Path;
+use unicode_width::UnicodeWidthStr;

 pub fn render_status_line(
    f: &mut Frame,
@@ -17,11 +18,41 @@ pub fn render_status_line(
    theme: &Theme,
    is_edit_mode: bool,
    current_fps: f64,
+    app_state: &AppState,
 ) {
+    #[cfg(feature = "ui-debug")]
+    {
+        if let Some(debug_state) = &app_state.debug_state {
+            let paragraph = if debug_state.is_error {
+                // --- THIS IS THE CRITICAL LOGIC FOR ERRORS ---
+                // 1. Create a `Text` object, which can contain multiple lines.
+                let error_text = Text::from(debug_state.displayed_message.clone());
+
+                // 2. Create a Paragraph from the Text and TELL IT TO WRAP.
+                Paragraph::new(error_text)
+                    .wrap(Wrap { trim: true }) // This line makes the text break into new rows.
+                    .style(Style::default().bg(theme.highlight).fg(theme.bg))
+            } else {
+                // --- This is for normal, single-line info messages ---
+                Paragraph::new(debug_state.displayed_message.as_str())
+                    .style(Style::default().fg(theme.accent).bg(theme.bg))
+            };
+            f.render_widget(paragraph, area);
+        } else {
+            // Fallback for when debug state is None
+            let paragraph = Paragraph::new("").style(Style::default().bg(theme.bg));
+            f.render_widget(paragraph, area);
+        }
+        return; // Stop here and don't render the normal status line.
+    }
+
+    // --- The normal status line rendering logic (unchanged) ---
    let program_info = format!("multieko2 v{}", env!("CARGO_PKG_VERSION"));
    let mode_text = if is_edit_mode { "[EDIT]" } else { "[READ-ONLY]" };

-    let home_dir = dirs::home_dir().map(|p| p.to_string_lossy().into_owned()).unwrap_or_default();
+    let home_dir = dirs::home_dir()
+        .map(|p| p.to_string_lossy().into_owned())
+        .unwrap_or_default();
    let display_dir = if current_dir.starts_with(&home_dir) {
        current_dir.replacen(&home_dir, "~", 1)
    } else {
@@ -36,35 +67,51 @@ pub fn render_status_line(
    let separator = " | ";
    let separator_width = UnicodeWidthStr::width(separator);

-    let fixed_width_with_fps = mode_width + separator_width + separator_width +
-        program_info_width + separator_width + fps_width;
-    let show_fps = fixed_width_with_fps <= available_width; // Use <= to show if it fits exactly
+    let fixed_width_with_fps = mode_width
+        + separator_width
+        + separator_width
+        + program_info_width
+        + separator_width
+        + fps_width;
+
+    let show_fps = fixed_width_with_fps <= available_width;

    let remaining_width_for_dir = available_width.saturating_sub(
-        mode_width + separator_width + // after mode
-        separator_width + program_info_width + // after program_info
-        if show_fps { separator_width + fps_width } else { 0 } // after fps
+        mode_width
+            + separator_width
+            + separator_width
+            + program_info_width
+            + (if show_fps {
+                separator_width + fps_width
+            } else {
+                0
+            }),
    );

-    // Original directory display logic
-    let dir_display_text_str = if UnicodeWidthStr::width(display_dir.as_str()) <= remaining_width_for_dir {
-        display_dir // display_dir is already a String here
+    let dir_display_text_str = if UnicodeWidthStr::width(display_dir.as_str())
+        <= remaining_width_for_dir
+    {
+        display_dir
    } else {
-        let dir_name = Path::new(current_dir) // Use original current_dir for path logic
+        let dir_name = Path::new(current_dir)
            .file_name()
            .and_then(|n| n.to_str())
-            .unwrap_or(current_dir); // Fallback to current_dir if no filename
+            .unwrap_or(current_dir);
        if UnicodeWidthStr::width(dir_name) <= remaining_width_for_dir {
            dir_name.to_string()
        } else {
-            dir_name.chars().take(remaining_width_for_dir).collect::<String>()
+            dir_name
+                .chars()
+                .take(remaining_width_for_dir)
+                .collect::<String>()
        }
    };

-    // Calculate current content width based on what will be displayed
-    let mut current_content_width = mode_width + separator_width +
-                                    UnicodeWidthStr::width(dir_display_text_str.as_str()) +
-                                    separator_width + program_info_width;
+    let mut current_content_width = mode_width
+        + separator_width
+        + UnicodeWidthStr::width(dir_display_text_str.as_str())
+        + separator_width
+        + program_info_width;
    if show_fps {
        current_content_width += separator_width + fps_width;
    }
@@ -72,27 +119,36 @@ pub fn render_status_line(
    let mut line_spans = vec![
        Span::styled(mode_text, Style::default().fg(theme.accent)),
        Span::styled(separator, Style::default().fg(theme.border)),
-        Span::styled(dir_display_text_str.as_str(), Style::default().fg(theme.fg)),
+        Span::styled(
+            dir_display_text_str.as_str(),
+            Style::default().fg(theme.fg),
+        ),
        Span::styled(separator, Style::default().fg(theme.border)),
-        Span::styled(program_info.as_str(), Style::default().fg(theme.secondary)),
+        Span::styled(
+            program_info.as_str(),
+            Style::default().fg(theme.secondary),
+        ),
    ];

    if show_fps {
-        line_spans.push(Span::styled(separator, Style::default().fg(theme.border)));
-        line_spans.push(Span::styled(fps_text.as_str(), Style::default().fg(theme.secondary)));
+        line_spans
+            .push(Span::styled(separator, Style::default().fg(theme.border)));
+        line_spans.push(Span::styled(
+            fps_text.as_str(),
+            Style::default().fg(theme.secondary),
+        ));
    }

-    // Calculate padding
    let padding_needed = available_width.saturating_sub(current_content_width);
    if padding_needed > 0 {
        line_spans.push(Span::styled(
            " ".repeat(padding_needed),
-            Style::default().bg(theme.bg), // Ensure padding uses background color
+            Style::default().bg(theme.bg),
        ));
    }

-    let paragraph = Paragraph::new(Line::from(line_spans))
-        .style(Style::default().bg(theme.bg));
+    let paragraph =
+        Paragraph::new(Line::from(line_spans)).style(Style::default().bg(theme.bg));

    f.render_widget(paragraph, area);
 }
--- a/client/src/components/form/form.rs
+++ b/client/src/components/form/form.rs
@@ -1,73 +1,73 @@
 // src/components/form/form.rs
+use crate::components::common::autocomplete; // <--- ADD THIS IMPORT
+use crate::components::handlers::canvas::render_canvas;
+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 ratatui::{
-    widgets::{Paragraph, Block, Borders},
-    layout::{Layout, Constraint, Direction, Rect, Margin, Alignment},
+    layout::{Alignment, Constraint, Direction, Layout, Margin, Rect},
    style::Style,
+    widgets::{Block, Borders, Paragraph},
    Frame,
 };
-use crate::config::colors::themes::Theme;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::app::highlight::HighlightState;
-use crate::components::handlers::canvas::render_canvas;

 pub fn render_form(
    f: &mut Frame,
    area: Rect,
-    form_state_param: &impl CanvasState,
+    form_state: &FormState, // <--- CHANGE THIS to the concrete type
    fields: &[&str],
    current_field_idx: &usize,
    inputs: &[&String],
+    table_name: &str,
    theme: &Theme,
    is_edit_mode: bool,
    highlight_state: &HighlightState,
    total_count: u64,
    current_position: u64,
 ) {
-    // Create Adresar card
+    let card_title = format!(" {} ", table_name);
+
    let adresar_card = Block::default()
        .borders(Borders::ALL)
        .border_style(Style::default().fg(theme.border))
-        .title(" Adresar ")
+        .title(card_title)
        .style(Style::default().bg(theme.bg).fg(theme.fg));

    f.render_widget(adresar_card, area);

-    // Define inner area
    let inner_area = area.inner(Margin {
        horizontal: 1,
        vertical: 1,
    });

-    // Create main layout
    let main_layout = Layout::default()
        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(1),
-            Constraint::Min(1),
-        ])
+        .constraints([Constraint::Length(1), Constraint::Min(1)])
        .split(inner_area);

-    // Render count/position
    let count_position_text = if total_count == 0 && current_position == 1 {
        "Total: 0 | New Entry".to_string()
    } else if current_position > total_count && total_count > 0 {
        format!("Total: {} | New Entry ({})", total_count, current_position)
-    } else if total_count == 0 && current_position > 1 { // Should not happen if logic is correct
+    } else if total_count == 0 && current_position > 1 {
        format!("Total: 0 | New Entry ({})", current_position)
-    }
-    else {
-        format!("Total: {} | Position: {}/{}", total_count, current_position, total_count)
+    } else {
+        format!(
+            "Total: {} | Position: {}/{}",
+            total_count, current_position, total_count
+        )
    };
    let count_para = Paragraph::new(count_position_text)
        .style(Style::default().fg(theme.fg))
        .alignment(Alignment::Left);
    f.render_widget(count_para, main_layout[0]);

-    // Delegate input handling to canvas
-    render_canvas(
+    // Get the active field's rect from render_canvas
+    let active_field_rect = render_canvas(
        f,
        main_layout[1],
-        form_state_param,
+        form_state,
        fields,
        current_field_idx,
        inputs,
@@ -75,4 +75,41 @@ pub fn render_form(
        is_edit_mode,
        highlight_state,
    );
+
+    // --- NEW: RENDER AUTOCOMPLETE ---
+    if form_state.autocomplete_active {
+        if let Some(active_rect) = active_field_rect {
+            let selected_index = form_state.get_selected_suggestion_index();
+
+            if let Some(rich_suggestions) = form_state.get_rich_suggestions() {
+                if !rich_suggestions.is_empty() {
+                    // CHANGE THIS to call the renamed function
+                    autocomplete::render_hit_autocomplete_dropdown(
+                        f,
+                        active_rect,
+                        f.area(),
+                        theme,
+                        rich_suggestions,
+                        selected_index,
+                        form_state,
+                    );
+                }
+            }
+            // The fallback to simple suggestions is now correctly handled
+            // because the original render_autocomplete_dropdown exists again.
+            else if let Some(simple_suggestions) = form_state.get_suggestions() {
+                if !simple_suggestions.is_empty() {
+                    autocomplete::render_autocomplete_dropdown(
+                        f,
+                        active_rect,
+                        f.area(),
+                        theme,
+                        simple_suggestions,
+                        selected_index,
+                    );
+                }
+            }
+        }
+    }
 }
+
--- a/client/src/components/handlers/buffer_list.rs
+++ b/client/src/components/handlers/buffer_list.rs
@@ -18,7 +18,7 @@ pub fn render_buffer_list(
    area: Rect,
    theme: &Theme,
    buffer_state: &BufferState,
-    app_state: &AppState,  // Add this parameter
+    app_state: &AppState,
 ) {
    // --- Style Definitions ---
    let active_style = Style::default()
@@ -39,8 +39,7 @@ pub fn render_buffer_list(
    let mut spans = Vec::new();
    let mut current_width = 0;

-    // TODO: Replace with actual table name from server response
-    let current_table_name = Some("2025_customer");
+    let current_table_name = app_state.current_view_table_name.as_deref();

    for (original_index, view) in buffer_state.history.iter().enumerate() {
        // Filter: Only process views matching the active layer
--- a/client/src/components/handlers/canvas.rs
+++ b/client/src/components/handlers/canvas.rs
@@ -1,16 +1,16 @@
 // 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::app::highlight::HighlightState;
 use crate::state::pages::canvas_state::CanvasState;
-use crate::state::app::highlight::HighlightState; // Ensure correct import path
-use std::cmp::{min, max};
+use std::cmp::{max, min};

 pub fn render_canvas(
    f: &mut Frame,
@@ -21,9 +21,8 @@ pub fn render_canvas(
    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) ...
    let columns = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([Constraint::Percentage(30), Constraint::Percentage(70)])
@@ -58,46 +57,47 @@ 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 trait method to get display value
+        let text = form_state.get_display_value_for_field(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) }
+                    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 +111,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 +132,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 +140,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)
                        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 +158,31 @@ 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));
                } else {
-                    // Line outside linewise highlight range
                    line = Line::from(Span::styled(
                        text,
-                        // Use normal styling (active or inactive)
                        if is_active { normal_style_in_highlight } else { normal_style_outside }
                    ));
                }
            }
-        } // End match highlight_state
+        }

        let input_display = Paragraph::new(line).alignment(Alignment::Left);
        f.render_widget(input_display, input_rows[i]);

        if is_active {
            active_field_input_rect = Some(input_rows[i]);
-            let cursor_x = input_rows[i].x + form_state.current_cursor_pos() as u16;
+
+            // --- CORRECTED CURSOR POSITIONING LOGIC ---
+            // Use the new generic trait method to check for an override.
+            let cursor_x = if form_state.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 + form_state.current_cursor_pos() as u16
+            };
            let cursor_y = input_rows[i].y;
            f.set_cursor_position((cursor_x, cursor_y));
        }
@@ -191,4 +190,3 @@ pub fn render_canvas(

    active_field_input_rect
 }
-
--- a/client/src/functions/modes/edit/auth_e.rs
+++ b/client/src/functions/modes/edit/auth_e.rs
@@ -4,6 +4,7 @@ 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 std::any::Any;
@@ -13,6 +14,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 +29,7 @@ pub async fn execute_common_action<S: CanvasState + Any>(
                match action {
                    "save" => {
                        let outcome = save(
+                            app_state,
                            form_state,
                            grpc_client,
                        )
--- a/client/src/functions/modes/edit/form_e.rs
+++ b/client/src/functions/modes/edit/form_e.rs
@@ -3,6 +3,7 @@
 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;
@@ -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,10 +28,11 @@ pub async fn execute_common_action<S: CanvasState + Any>(
                match action {
                    "save" => {
                        let save_result = save(
+                            app_state,
                            form_state,
                            grpc_client,
                        ).await;
-                        
+
                        match save_result {
                            Ok(save_outcome) => {
                                let message = match save_outcome {
@@ -47,7 +50,7 @@ pub async fn execute_common_action<S: CanvasState + Any>(
                            form_state,
                            grpc_client,
                        ).await;
-                        
+
                        match revert_result {
                            Ok(message) => Ok(EventOutcome::Ok(message)),
                            Err(e) => Err(e),
--- a/client/src/lib.rs
+++ b/client/src/lib.rs
@@ -7,6 +7,7 @@ pub mod components;
 pub mod modes;
 pub mod functions;
 pub mod services;
+pub mod utils;

 pub use ui::run_ui;

--- a/client/src/main.rs
+++ b/client/src/main.rs
@@ -1,5 +1,7 @@
 // client/src/main.rs
 use client::run_ui;
+#[cfg(feature = "ui-debug")]
+use client::utils::debug_logger::UiDebugWriter;
 use dotenvy::dotenv;
 use anyhow::Result;
 use tracing_subscriber;
@@ -7,8 +9,22 @@ use std::env;

 #[tokio::main]
 async fn main() -> Result<()> {
-    if env::var("ENABLE_TRACING").is_ok() {
-        tracing_subscriber::fmt::init();
+    #[cfg(feature = "ui-debug")]
+    {
+        // If ui-debug is on, set up our custom writer.
+        let writer = UiDebugWriter::new();
+        tracing_subscriber::fmt()
+            .with_level(false) // Don't show INFO, ERROR, etc.
+            .with_target(false) // Don't show the module path.
+            .without_time() // This is the correct and simpler method.
+            .with_writer(move || writer.clone())
+            .init();
+    }
+    #[cfg(not(feature = "ui-debug"))]
+    {
+        if env::var("ENABLE_TRACING").is_ok() {
+            tracing_subscriber::fmt::init();
+        }
    }

    dotenv().ok();
--- a/client/src/modes/canvas/common_mode.rs
+++ b/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?;
--- a/client/src/modes/canvas/edit.rs
+++ b/client/src/modes/canvas/edit.rs
@@ -1,20 +1,22 @@
 // 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,
+};
+use crate::modes::handlers::event::EventHandler;
 use crate::services::grpc_client::GrpcClient;
+use crate::state::app::state::AppState;
+use crate::state::pages::admin::AdminState;
 use crate::state::pages::{
    auth::{LoginState, RegisterState},
    canvas_state::CanvasState,
+    form::FormState,
 };
-use crate::state::pages::form::FormState; // <<< ADD THIS LINE
-// AddLogicState is already imported
-// AddTableState is already imported
-use crate::state::pages::admin::AdminState;
-use crate::modes::handlers::event::EventOutcome;
-use crate::functions::modes::edit::{add_logic_e, auth_e, form_e, add_table_e};
-use crate::state::app::state::AppState;
 use anyhow::Result;
-use crossterm::event::KeyEvent; // Removed KeyCode, KeyModifiers as they were unused
-use tracing::debug;
+use common::proto::multieko2::search::search_response::Hit;
+use crossterm::event::{KeyCode, KeyEvent};
+use tokio::sync::mpsc;
+use tracing::{debug, info};

 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum EditEventOutcome {
@@ -22,231 +24,313 @@ pub enum EditEventOutcome {
    ExitEditMode,
 }

+/// Helper function to spawn a non-blocking search task for autocomplete.
+async fn trigger_form_autocomplete_search(
+    form_state: &mut FormState,
+    grpc_client: &mut GrpcClient,
+    sender: mpsc::UnboundedSender<Vec<Hit>>,
+) {
+    if let Some(field_def) = form_state.fields.get(form_state.current_field) {
+        if field_def.is_link {
+            if let Some(target_table) = &field_def.link_target_table {
+                // 1. Update state for immediate UI feedback
+                form_state.autocomplete_loading = true;
+                form_state.autocomplete_active = true;
+                form_state.autocomplete_suggestions.clear();
+                form_state.selected_suggestion_index = None;
+
+                // 2. Clone everything needed for the background task
+                let query = form_state.get_current_input().to_string();
+                let table_to_search = target_table.clone();
+                let mut grpc_client_clone = grpc_client.clone();
+
+                info!(
+                    "[Autocomplete] Spawning search in '{}' for query: '{}'",
+                    table_to_search, query
+                );
+
+                // 3. Spawn the non-blocking task
+                tokio::spawn(async move {
+                    match grpc_client_clone
+                        .search_table(table_to_search, query)
+                        .await
+                    {
+                        Ok(response) => {
+                            // Send results back through the channel
+                            let _ = sender.send(response.hits);
+                        }
+                        Err(e) => {
+                            tracing::error!(
+                                "[Autocomplete] Search failed: {:?}",
+                                e
+                            );
+                            // Send an empty vec on error so the UI can stop loading
+                            let _ = sender.send(vec![]);
+                        }
+                    }
+                });
+            }
+        }
+    }
+}
+
+
+#[allow(clippy::too_many_arguments)]
 pub async fn handle_edit_event(
    key: KeyEvent,
    config: &Config,
-    form_state: &mut FormState, // Now FormState is in scope
+    form_state: &mut FormState,
    login_state: &mut LoginState,
    register_state: &mut RegisterState,
    admin_state: &mut AdminState,
-    ideal_cursor_column: &mut usize,
    current_position: &mut u64,
    total_count: u64,
-    grpc_client: &mut GrpcClient,
+    event_handler: &mut EventHandler,
    app_state: &AppState,
 ) -> Result<EditEventOutcome> {
-    // --- Global command mode check ---
-    if let Some("enter_command_mode") = config.get_action_for_key_in_mode(
-        &config.keybindings.global, // Assuming command mode can be entered globally
-        key.code,
-        key.modifiers,
-    ) {
-        // This check might be redundant if EventHandler already prevents entering Edit mode
-        // when command_mode is true. However, it's a safeguard.
-        return Ok(EditEventOutcome::Message(
-            "Cannot enter command mode from edit mode here.".to_string(),
-        ));
-    }
-
-    // --- Common actions (save, revert) ---
-    if let Some(action) = config.get_action_for_key_in_mode(
-        &config.keybindings.common,
-        key.code,
-        key.modifiers,
-    ).as_deref() {
-        if matches!(action, "save" | "revert") {
-            let message_string: String = if app_state.ui.show_login {
-                auth_e::execute_common_action(action, login_state, grpc_client, current_position, total_count).await?
-            } else if app_state.ui.show_register {
-                auth_e::execute_common_action(action, register_state, grpc_client, current_position, total_count).await?
-            } else if app_state.ui.show_add_table {
-                // TODO: Implement common actions for AddTable if needed
-                format!("Action '{}' not implemented for Add Table in edit mode.", action)
-            } else if app_state.ui.show_add_logic {
-                // TODO: Implement common actions for AddLogic if needed
-                format!("Action '{}' not implemented for Add Logic in edit mode.", action)
-            } else { // Assuming Form view
-                let outcome = form_e::execute_common_action(action, form_state, grpc_client).await?;
-                match outcome {
-                    EventOutcome::Ok(msg) | EventOutcome::DataSaved(_, msg) => msg,
-                    _ => format!("Unexpected outcome from common action: {:?}", outcome),
+    // --- AUTOCOMPLETE-SPECIFIC KEY HANDLING ---
+    if app_state.ui.show_form && form_state.autocomplete_active {
+        if let Some(action) =
+            config.get_edit_action_for_key(key.code, key.modifiers)
+        {
+            match action {
+                "suggestion_down" => {
+                    if !form_state.autocomplete_suggestions.is_empty() {
+                        let current =
+                            form_state.selected_suggestion_index.unwrap_or(0);
+                        let next = (current + 1)
+                            % form_state.autocomplete_suggestions.len();
+                        form_state.selected_suggestion_index = Some(next);
+                    }
+                    return Ok(EditEventOutcome::Message(String::new()));
                }
-            };
-            return Ok(EditEventOutcome::Message(message_string));
+                "suggestion_up" => {
+                    if !form_state.autocomplete_suggestions.is_empty() {
+                        let current =
+                            form_state.selected_suggestion_index.unwrap_or(0);
+                        let prev = if current == 0 {
+                            form_state.autocomplete_suggestions.len() - 1
+                        } else {
+                            current - 1
+                        };
+                        form_state.selected_suggestion_index = Some(prev);
+                    }
+                    return Ok(EditEventOutcome::Message(String::new()));
+                }
+                "exit" => {
+                    form_state.deactivate_autocomplete();
+                    return Ok(EditEventOutcome::Message(
+                        "Autocomplete cancelled".to_string(),
+                    ));
+                }
+                "enter_decider" => {
+                    if let Some(selected_idx) =
+                        form_state.selected_suggestion_index
+                    {
+                        if let Some(selection) = form_state
+                            .autocomplete_suggestions
+                            .get(selected_idx)
+                            .cloned()
+                        {
+                            // --- THIS IS THE CORE LOGIC CHANGE ---
+
+                            // 1. Get the friendly display name for the UI
+                            let display_name =
+                                form_state.get_display_name_for_hit(&selection);
+
+                            // 2. Store the REAL ID in the form's values
+                            let current_input =
+                                form_state.get_current_input_mut();
+                            *current_input = selection.id.to_string();
+
+                            // 3. Set the persistent display override in the map
+                            form_state.link_display_map.insert(
+                                form_state.current_field,
+                                display_name,
+                            );
+
+                            // 4. Finalize state
+                            form_state.deactivate_autocomplete();
+                            form_state.set_has_unsaved_changes(true);
+                            return Ok(EditEventOutcome::Message(
+                                "Selection made".to_string(),
+                            ));
+                        }
+                    }
+                    form_state.deactivate_autocomplete();
+                    // Fall through to default 'enter' behavior
+                }
+                _ => {} // Let other keys fall through to the live search logic
+            }
        }
    }

-    // --- Edit-specific actions ---
-    if let Some(action_str) = config.get_edit_action_for_key(key.code, key.modifiers).as_deref() {
-        // --- Handle "enter_decider" (Enter key) ---
-        if action_str == "enter_decider" {
-            let effective_action = if app_state.ui.show_register
-                && register_state.in_suggestion_mode
-                && register_state.current_field() == 4 { // Role field
-                "select_suggestion"
-            } else if app_state.ui.show_add_logic
-                && admin_state.add_logic_state.in_target_column_suggestion_mode
-                && admin_state.add_logic_state.current_field() == 1 { // Target Column field
-                "select_suggestion"
-            } else {
-                "next_field" // Default action for Enter
-            };
+    // --- LIVE AUTOCOMPLETE TRIGGER LOGIC ---
+    let mut trigger_search = false;

-            let msg = if app_state.ui.show_login {
-                auth_e::execute_edit_action(effective_action, key, login_state, ideal_cursor_column).await?
-            } else if app_state.ui.show_add_table {
-                add_table_e::execute_edit_action(effective_action, key, &mut admin_state.add_table_state, ideal_cursor_column).await?
-            } else if app_state.ui.show_add_logic {
-                add_logic_e::execute_edit_action(effective_action, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?
-            } else if app_state.ui.show_register {
-                auth_e::execute_edit_action(effective_action, key, register_state, ideal_cursor_column).await?
-            } else { // Form view
-                form_e::execute_edit_action(effective_action, key, form_state, ideal_cursor_column).await?
-            };
+    if app_state.ui.show_form {
+        // Manual trigger
+        if let Some("trigger_autocomplete") =
+            config.get_edit_action_for_key(key.code, key.modifiers)
+        {
+            if !form_state.autocomplete_active {
+                trigger_search = true;
+            }
+        }
+        // Live search trigger while typing
+        else if form_state.autocomplete_active {
+            if let KeyCode::Char(_) | KeyCode::Backspace = key.code {
+                let action = if let KeyCode::Backspace = key.code {
+                    "delete_char_backward"
+                } else {
+                    "insert_char"
+                };
+                // FIX: Pass &mut event_handler.ideal_cursor_column
+                form_e::execute_edit_action(
+                    action,
+                    key,
+                    form_state,
+                    &mut event_handler.ideal_cursor_column,
+                )
+                .await?;
+                trigger_search = true;
+            }
+        }
+    }
+
+    if trigger_search {
+        trigger_form_autocomplete_search(
+            form_state,
+            &mut event_handler.grpc_client,
+            event_handler.autocomplete_result_sender.clone(),
+        )
+        .await;
+        return Ok(EditEventOutcome::Message("Searching...".to_string()));
+    }
+
+    // --- GENERAL EDIT MODE EVENT HANDLING (IF NOT AUTOCOMPLETE) ---
+
+    if let Some(action_str) =
+        config.get_edit_action_for_key(key.code, key.modifiers)
+    {
+        // Handle Enter key (next field)
+        if action_str == "enter_decider" {
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            let msg = form_e::execute_edit_action(
+                "next_field",
+                key,
+                form_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?;
            return Ok(EditEventOutcome::Message(msg));
        }

-        // --- Handle "exit" (Escape key) ---
+        // Handle exiting edit mode
        if action_str == "exit" {
-            if app_state.ui.show_register && register_state.in_suggestion_mode {
-                let msg = auth_e::execute_edit_action("exit_suggestion_mode", key, register_state, ideal_cursor_column).await?;
-                return Ok(EditEventOutcome::Message(msg));
-            } else if app_state.ui.show_add_logic && admin_state.add_logic_state.in_target_column_suggestion_mode {
-                admin_state.add_logic_state.in_target_column_suggestion_mode = false;
-                admin_state.add_logic_state.show_target_column_suggestions = false;
-                admin_state.add_logic_state.selected_target_column_suggestion_index = None;
-                return Ok(EditEventOutcome::Message("Exited column suggestions".to_string()));
-            } else {
-                return Ok(EditEventOutcome::ExitEditMode);
-            }
+            return Ok(EditEventOutcome::ExitEditMode);
        }

-        // --- Autocomplete for AddLogicState Target Column ---
-        if app_state.ui.show_add_logic && admin_state.add_logic_state.current_field() == 1 { // Target Column field
-            if action_str == "suggestion_down" { // "Tab" is mapped to suggestion_down
-                if !admin_state.add_logic_state.in_target_column_suggestion_mode {
-                    // Attempt to open suggestions
-                    if let Some(profile_name) = admin_state.add_logic_state.profile_name.clone().into() {
-                        if let Some(table_name) = admin_state.add_logic_state.selected_table_name.clone() {
-                            debug!("Fetching table structure for autocomplete: Profile='{}', Table='{}'", profile_name, table_name);
-                            match grpc_client.get_table_structure(profile_name, table_name).await {
-                                Ok(ts_response) => {
-                                    admin_state.add_logic_state.table_columns_for_suggestions =
-                                        ts_response.columns.into_iter().map(|c| c.name).collect();
-                                    admin_state.add_logic_state.update_target_column_suggestions();
-                                    if !admin_state.add_logic_state.target_column_suggestions.is_empty() {
-                                        admin_state.add_logic_state.in_target_column_suggestion_mode = true;
-                                        // update_target_column_suggestions handles initial selection
-                                        return Ok(EditEventOutcome::Message("Column suggestions shown".to_string()));
-                                    } else {
-                                        return Ok(EditEventOutcome::Message("No column suggestions for current input".to_string()));
-                                    }
-                                }
-                                Err(e) => {
-                                    debug!("Error fetching table structure: {}", e);
-                                    admin_state.add_logic_state.table_columns_for_suggestions.clear(); // Clear old data on error
-                                    admin_state.add_logic_state.update_target_column_suggestions();
-                                    return Ok(EditEventOutcome::Message(format!("Error fetching columns: {}", e)));
-                                }
-                            }
-                        } else {
-                             return Ok(EditEventOutcome::Message("No table selected for column suggestions".to_string()));
-                        }
-                    } else { // Should not happen if AddLogic is properly initialized
-                        return Ok(EditEventOutcome::Message("Profile name missing for column suggestions".to_string()));
-                    }
-                } else { // Already in suggestion mode, navigate down
-                    let msg = add_logic_e::execute_edit_action(action_str, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?;
-                    return Ok(EditEventOutcome::Message(msg));
-                }
-            } else if admin_state.add_logic_state.in_target_column_suggestion_mode && action_str == "suggestion_up" {
-                 let msg = add_logic_e::execute_edit_action(action_str, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?;
-                return Ok(EditEventOutcome::Message(msg));
-            }
-        }
-
-        // --- Autocomplete for RegisterState Role Field ---
-        if app_state.ui.show_register && register_state.current_field() == 4 { // Role field
-            if !register_state.in_suggestion_mode && action_str == "suggestion_down" { // Tab
-                register_state.update_role_suggestions();
-                if !register_state.role_suggestions.is_empty() {
-                    register_state.in_suggestion_mode = true;
-                    // update_role_suggestions should handle initial selection
-                    return Ok(EditEventOutcome::Message("Role suggestions shown".to_string()));
-                } else {
-                    // If Tab doesn't open suggestions, it might fall through to "next_field"
-                    // or you might want specific behavior. For now, let it fall through.
-                }
-            }
-            if register_state.in_suggestion_mode && matches!(action_str, "suggestion_down" | "suggestion_up") {
-                let msg = auth_e::execute_edit_action(action_str, key, register_state, ideal_cursor_column).await?;
-                return Ok(EditEventOutcome::Message(msg));
-            }
-        }
-
-        // --- Dispatch other edit actions ---
+        // Handle all other edit actions
        let msg = if app_state.ui.show_login {
-            auth_e::execute_edit_action(action_str, key, login_state, ideal_cursor_column).await?
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            auth_e::execute_edit_action(
+                action_str,
+                key,
+                login_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
        } else if app_state.ui.show_add_table {
-            add_table_e::execute_edit_action(action_str, key, &mut admin_state.add_table_state, ideal_cursor_column).await?
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            add_table_e::execute_edit_action(
+                action_str,
+                key,
+                &mut admin_state.add_table_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
        } else if app_state.ui.show_add_logic {
-            // If not a suggestion action handled above for AddLogic
-             if !(admin_state.add_logic_state.in_target_column_suggestion_mode && matches!(action_str, "suggestion_down" | "suggestion_up")) {
-                add_logic_e::execute_edit_action(action_str, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?
-            } else { String::new() /* Already handled */ }
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            add_logic_e::execute_edit_action(
+                action_str,
+                key,
+                &mut admin_state.add_logic_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
        } else if app_state.ui.show_register {
-            if !(register_state.in_suggestion_mode && matches!(action_str, "suggestion_down" | "suggestion_up")) {
-                auth_e::execute_edit_action(action_str, key, register_state, ideal_cursor_column).await?
-            } else { String::new() /* Already handled */ }
-        } else { // Form view
-            form_e::execute_edit_action(action_str, key, form_state, ideal_cursor_column).await?
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            auth_e::execute_edit_action(
+                action_str,
+                key,
+                register_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
+        } else {
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            form_e::execute_edit_action(
+                action_str,
+                key,
+                form_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
        };
        return Ok(EditEventOutcome::Message(msg));
    }

-    // --- Character insertion ---
-    // If character insertion happens while in suggestion mode, exit suggestion mode first.
-    let mut exited_suggestion_mode_for_typing = false;
-    if app_state.ui.show_register && register_state.in_suggestion_mode {
-        register_state.in_suggestion_mode = false;
-        register_state.show_role_suggestions = false;
-        register_state.selected_suggestion_index = None;
-        exited_suggestion_mode_for_typing = true;
-    }
-    if app_state.ui.show_add_logic && admin_state.add_logic_state.in_target_column_suggestion_mode {
-        admin_state.add_logic_state.in_target_column_suggestion_mode = false;
-        admin_state.add_logic_state.show_target_column_suggestions = false;
-        admin_state.add_logic_state.selected_target_column_suggestion_index = None;
-        exited_suggestion_mode_for_typing = true;
+    // --- 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",
+                key,
+                login_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
+        } else if app_state.ui.show_add_table {
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            add_table_e::execute_edit_action(
+                "insert_char",
+                key,
+                &mut admin_state.add_table_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
+        } else if app_state.ui.show_add_logic {
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            add_logic_e::execute_edit_action(
+                "insert_char",
+                key,
+                &mut admin_state.add_logic_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
+        } else if app_state.ui.show_register {
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            auth_e::execute_edit_action(
+                "insert_char",
+                key,
+                register_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
+        } else {
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            form_e::execute_edit_action(
+                "insert_char",
+                key,
+                form_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
+        };
+        return Ok(EditEventOutcome::Message(msg));
    }

-    let mut char_insert_msg = if app_state.ui.show_login {
-        auth_e::execute_edit_action("insert_char", key, login_state, ideal_cursor_column).await?
-    } else if app_state.ui.show_add_table {
-        add_table_e::execute_edit_action("insert_char", key, &mut admin_state.add_table_state, ideal_cursor_column).await?
-    } else if app_state.ui.show_add_logic {
-        add_logic_e::execute_edit_action("insert_char", key, &mut admin_state.add_logic_state, ideal_cursor_column).await?
-    } else if app_state.ui.show_register {
-        auth_e::execute_edit_action("insert_char", key, register_state, ideal_cursor_column).await?
-    } else { // Form view
-        form_e::execute_edit_action("insert_char", key, form_state, ideal_cursor_column).await?
-    };
-
-    // After character insertion, update suggestions if applicable
-    if app_state.ui.show_register && register_state.current_field() == 4 {
-        register_state.update_role_suggestions();
-        // If we just exited suggestion mode by typing, don't immediately show them again unless Tab is pressed.
-        // However, update_role_suggestions will set show_role_suggestions if matches are found.
-        // This is fine, as the render logic checks in_suggestion_mode.
-    }
-    if app_state.ui.show_add_logic && admin_state.add_logic_state.current_field() == 1 {
-        admin_state.add_logic_state.update_target_column_suggestions();
-    }
-
-    if exited_suggestion_mode_for_typing && char_insert_msg.is_empty() {
-        char_insert_msg = "Suggestions hidden".to_string();
-    }
-
-
-    Ok(EditEventOutcome::Message(char_insert_msg))
+    Ok(EditEventOutcome::Message(String::new())) // No action taken
 }
--- a/client/src/modes/canvas/read_only.rs
+++ b/client/src/modes/canvas/read_only.rs
@@ -23,8 +23,6 @@ pub async fn handle_read_only_event(
    add_table_state: &mut AddTableState,
    add_logic_state: &mut AddLogicState,
    key_sequence_tracker: &mut KeySequenceTracker,
-    current_position: &mut u64,
-    total_count: u64,
    grpc_client: &mut GrpcClient,
    command_message: &mut String,
    edit_mode_cooldown: &mut bool,
@@ -74,12 +72,10 @@ pub async fn handle_read_only_event(
                    action,
                    form_state,
                    grpc_client,
-                    current_position,
-                    total_count,
                    ideal_cursor_column,
                )
                .await?
-            } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) { // Handle login context actions
+            } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
                crate::tui::functions::login::handle_action(action).await?
            } else if app_state.ui.show_add_table {
                add_table_ro::execute_action(
@@ -143,12 +139,10 @@ pub async fn handle_read_only_event(
                        action,
                        form_state,
                        grpc_client,
-                        current_position,
-                        total_count,
                        ideal_cursor_column,
                    )
                    .await?
-                } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) { // Handle login context actions
+                } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) {
                    crate::tui::functions::login::handle_action(action).await?
                } else if app_state.ui.show_add_table {
                    add_table_ro::execute_action(
@@ -177,7 +171,7 @@ pub async fn handle_read_only_event(
                        key_sequence_tracker,
                        command_message,
                    ).await?
-                } else if app_state.ui.show_login { // Handle login general actions
+                } else if app_state.ui.show_login {
                    auth_ro::execute_action(
                        action,
                        app_state,
@@ -211,8 +205,6 @@ pub async fn handle_read_only_event(
                    action,
                    form_state,
                    grpc_client,
-                    current_position,
-                    total_count,
                    ideal_cursor_column,
                )
                .await?
@@ -245,7 +237,7 @@ pub async fn handle_read_only_event(
                    key_sequence_tracker,
                    command_message,
                ).await?
-            } else if app_state.ui.show_login { // Handle login general actions
+            } else if app_state.ui.show_login {
                auth_ro::execute_action(
                    action,
                    app_state,
--- a/client/src/modes/common/command_mode.rs
+++ b/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?;
--- a/client/src/modes/general/command_navigation.rs
+++ b/client/src/modes/general/command_navigation.rs
@@ -82,6 +82,8 @@ impl TableDependencyGraph {
    }
 }

+
+// ... (NavigationState struct and its new(), activate_*, deactivate(), add_char(), remove_char(), move_*, autocomplete_selected(), get_display_input() methods are unchanged) ...
 pub struct NavigationState {
    pub active: bool,
    pub input: String,
@@ -114,7 +116,7 @@ impl NavigationState {
        self.input.clear();
        self.current_path.clear();
        self.graph = None;
-        self.update_filtered_options(); // Initial filter with empty input
+        self.update_filtered_options();
    }

    pub fn activate_table_tree(&mut self, graph: TableDependencyGraph) {
@@ -123,7 +125,7 @@ impl NavigationState {
        self.graph = Some(graph);
        self.input.clear();
        self.current_path.clear();
-        self.update_options_for_path(); // Initial options are root tables
+        self.update_options_for_path();
    }

    pub fn deactivate(&mut self) {
@@ -145,7 +147,6 @@ impl NavigationState {
            NavigationType::TableTree => {
                if c == '/' {
                    if !self.input.is_empty() {
-                        // Append current input to path
                        if self.current_path.is_empty() {
                            self.current_path = self.input.clone();
                        } else {
@@ -155,10 +156,9 @@ impl NavigationState {
                        self.input.clear();
                        self.update_options_for_path();
                    }
-                    // If input is empty and char is '/', do nothing or define behavior
                } else {
                    self.input.push(c);
-                    self.update_filtered_options(); // Filter current level options based on input
+                    self.update_filtered_options();
                }
            }
        }
@@ -172,24 +172,15 @@ impl NavigationState {
            }
            NavigationType::TableTree => {
                if self.input.is_empty() {
-                    // If input is empty, try to go up in path
                    if !self.current_path.is_empty() {
-                        if let Some(last_slash_idx) =
-                            self.current_path.rfind('/')
-                        {
-                            // Set input to the segment being removed from path
-                            self.input = self.current_path
-                                [last_slash_idx + 1..]
-                                .to_string();
-                            self.current_path =
-                                self.current_path[..last_slash_idx].to_string();
+                        if let Some(last_slash_idx) = self.current_path.rfind('/') {
+                            self.input = self.current_path[last_slash_idx + 1..].to_string();
+                            self.current_path = self.current_path[..last_slash_idx].to_string();
                        } else {
-                            // Path was a single segment
                            self.input = self.current_path.clone();
                            self.current_path.clear();
                        }
                        self.update_options_for_path();
-                        // After path change, current input might match some options, so filter
                        self.update_filtered_options();
                    }
                } else {
@@ -218,9 +209,7 @@ impl NavigationState {
            return;
        }
        self.selected_index = match self.selected_index {
-            Some(current) if current >= self.filtered_options.len() - 1 => {
-                Some(0)
-            }
+            Some(current) if current >= self.filtered_options.len() - 1 => Some(0),
            Some(current) => Some(current + 1),
            None => Some(0),
        };
@@ -234,18 +223,11 @@ impl NavigationState {

    pub fn autocomplete_selected(&mut self) {
        if let Some(selected_option_str) = self.get_selected_option_str() {
-            // The current `self.input` is the text being typed for the current segment/filter.
-            // We replace it with the full string of the selected option.
            self.input = selected_option_str.to_string();
-
-            // After updating the input, we need to re-filter the options.
-            // This will typically result in the filtered_options containing only the
-            // autocompleted item (or items that start with it, if any).
            self.update_filtered_options();
        }
    }

-    // Returns the string to display in the input line of the palette
    pub fn get_display_input(&self) -> String {
        match self.navigation_type {
            NavigationType::FindFile => self.input.clone(),
@@ -259,11 +241,12 @@ impl NavigationState {
        }
    }

-    // Gets the full path of the currently selected item for TableTree, or input for FindFile
+    // --- START FIX ---
    pub fn get_selected_value(&self) -> Option<String> {
        match self.navigation_type {
            NavigationType::FindFile => {
-                if self.input.is_empty() { None } else { Some(self.input.clone()) }
+                // Return the highlighted option, not the raw input buffer.
+                self.get_selected_option_str().map(|s| s.to_string())
            }
            NavigationType::TableTree => {
                self.get_selected_option_str().map(|selected_name| {
@@ -276,26 +259,23 @@ impl NavigationState {
            }
        }
    }
+    // --- END FIX ---

-    // Update self.all_options based on current_path (for TableTree)
    fn update_options_for_path(&mut self) {
        if let NavigationType::TableTree = self.navigation_type {
            if let Some(graph) = &self.graph {
-                self.all_options =
-                    graph.get_dependent_children(&self.current_path);
+                self.all_options = graph.get_dependent_children(&self.current_path);
            } else {
                self.all_options.clear();
            }
        }
-        // For FindFile, all_options is set once at activation.
        self.update_filtered_options();
    }

-    // Update self.filtered_options based on self.all_options and self.input
    fn update_filtered_options(&mut self) {
        let filter_text = match self.navigation_type {
            NavigationType::FindFile => &self.input,
-            NavigationType::TableTree => &self.input, // For TableTree, input is the current segment being typed
+            NavigationType::TableTree => &self.input,
        }
        .to_lowercase();

@@ -319,11 +299,12 @@ impl NavigationState {
        if self.filtered_options.is_empty() {
            self.selected_index = None;
        } else {
-            self.selected_index = Some(0); // Default to selecting the first item
+            self.selected_index = Some(0);
        }
    }
 }

+
 pub async fn handle_command_navigation_event(
    navigation_state: &mut NavigationState,
    key: KeyEvent,
@@ -338,51 +319,15 @@ pub async fn handle_command_navigation_event(
            navigation_state.deactivate();
            Ok(EventOutcome::Ok("Navigation cancelled".to_string()))
        }
-        KeyCode::Enter => {
-            if let Some(selected_value) = navigation_state.get_selected_value() {
-                let message = match navigation_state.navigation_type {
-                    NavigationType::FindFile => format!("Selected file: {}", selected_value),
-                    NavigationType::TableTree => format!("Selected table: {}", selected_value),
-                };
-                navigation_state.deactivate();
-                Ok(EventOutcome::Ok(message))
-            } else {
-                // Enhanced Enter behavior for TableTree: if input is a valid partial path, try to navigate
-                if navigation_state.navigation_type == NavigationType::TableTree && !navigation_state.input.is_empty() {
-                    // Check if current input is a prefix of any option or a full option name
-                    if let Some(selected_opt_str) = navigation_state.get_selected_option_str() {
-                        if navigation_state.input == selected_opt_str {
-                            // Input exactly matches the selected option, try to navigate
-                            let input_before_slash = navigation_state.input.clone();
-                            navigation_state.add_char('/');
-                            
-                            if navigation_state.input.is_empty() {
-                                return Ok(EventOutcome::Ok(format!("Navigated to: {}/", input_before_slash)));
-                            } else {
-                                return Ok(EventOutcome::Ok(format!("Selected leaf: {}", input_before_slash)));
-                            }
-                        }
-                    }
-                }
-                Ok(EventOutcome::Ok("No valid selection to confirm or navigate".to_string()))
-            }
-        }
        KeyCode::Tab => {
            if let Some(selected_opt_str) = navigation_state.get_selected_option_str() {
-                // Scenario 1: Input already exactly matches the selected option
                if navigation_state.input == selected_opt_str {
-                    // Only attempt to navigate deeper for TableTree mode
                    if navigation_state.navigation_type == NavigationType::TableTree {
                        let path_before_nav = navigation_state.current_path.clone();
                        let input_before_nav = navigation_state.input.clone();
-
                        navigation_state.add_char('/');
-
-                        if navigation_state.input.is_empty() &&
-                           (navigation_state.current_path != path_before_nav || !navigation_state.all_options.is_empty()) {
-                            // Navigation successful
-                        } else {
-                            // Revert if navigation didn't happen
+                        if !(navigation_state.input.is_empty() &&
+                           (navigation_state.current_path != path_before_nav || !navigation_state.all_options.is_empty())) {
                            if !navigation_state.input.is_empty() && navigation_state.input != input_before_nav {
                                navigation_state.input = input_before_nav;
                                if navigation_state.current_path != path_before_nav {
@@ -393,20 +338,11 @@ pub async fn handle_command_navigation_event(
                        }
                    }
                } else {
-                    // Scenario 2: Input is a partial match - autocomplete
                    navigation_state.autocomplete_selected();
                }
            }
            Ok(EventOutcome::Ok(String::new()))
        }
-        KeyCode::Up => {
-            navigation_state.move_up();
-            Ok(EventOutcome::Ok(String::new()))
-        }
-        KeyCode::Down => {
-            navigation_state.move_down();
-            Ok(EventOutcome::Ok(String::new()))
-        }
        KeyCode::Backspace => {
            navigation_state.remove_char();
            Ok(EventOutcome::Ok(String::new()))
@@ -428,12 +364,24 @@ pub async fn handle_command_navigation_event(
                    }
                    "select" => {
                        if let Some(selected_value) = navigation_state.get_selected_value() {
-                            let message = match navigation_state.navigation_type {
-                                NavigationType::FindFile => format!("Selected file: {}", selected_value),
-                                NavigationType::TableTree => format!("Selected table: {}", selected_value),
+                            let outcome = match navigation_state.navigation_type {
+                                // --- START FIX ---
+                                NavigationType::FindFile => {
+                                    // The purpose of this palette is to select a table.
+                                    // Emit a TableSelected event instead of a generic Ok message.
+                                    EventOutcome::TableSelected {
+                                        path: selected_value,
+                                    }
+                                }
+                                // --- END FIX ---
+                                NavigationType::TableTree => {
+                                    EventOutcome::TableSelected {
+                                        path: selected_value,
+                                    }
+                                }
                            };
                            navigation_state.deactivate();
-                            Ok(EventOutcome::Ok(message))
+                            Ok(outcome)
                        } else {
                            Ok(EventOutcome::Ok("No selection".to_string()))
                        }
--- a/client/src/modes/handlers/event.rs
+++ b/client/src/modes/handlers/event.rs
@@ -7,7 +7,7 @@ use crate::functions::modes::navigation::add_logic_nav::SaveLogicResultSender;
 use crate::functions::modes::navigation::add_table_nav::SaveTableResultSender;
 use crate::functions::modes::navigation::{add_table_nav, admin_nav};
 use crate::modes::general::command_navigation::{
-    handle_command_navigation_event, NavigationState, TableDependencyGraph,
+    handle_command_navigation_event, NavigationState,
 };
 use crate::modes::{
    canvas::{common_mode, edit, read_only},
@@ -21,6 +21,7 @@ use crate::state::{
    app::{
        buffer::{AppView, BufferState},
        highlight::HighlightState,
+        search::SearchState, // Correctly imported
        state::AppState,
    },
    pages::{
@@ -41,10 +42,12 @@ 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 crossterm::cursor::SetCursorStyle;
-use crossterm::event::KeyCode;
-use crossterm::event::{Event, KeyEvent};
+use crossterm::event::{Event, KeyCode, KeyEvent};
 use tokio::sync::mpsc;
+use tokio::sync::mpsc::unbounded_channel;
+use tracing::{error, info};

 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum EventOutcome {
@@ -52,6 +55,7 @@ pub enum EventOutcome {
    Exit(String),
    DataSaved(SaveOutcome, String),
    ButtonSelected { context: UiContext, index: usize },
+    TableSelected { path: String },
 }

 impl EventOutcome {
@@ -73,11 +77,17 @@ pub struct EventHandler {
    pub ideal_cursor_column: usize,
    pub key_sequence_tracker: KeySequenceTracker,
    pub auth_client: AuthClient,
+    pub grpc_client: GrpcClient,
    pub login_result_sender: mpsc::Sender<LoginResult>,
    pub register_result_sender: mpsc::Sender<RegisterResult>,
    pub save_table_result_sender: SaveTableResultSender,
    pub save_logic_result_sender: SaveLogicResultSender,
    pub navigation_state: NavigationState,
+    pub search_result_sender: mpsc::UnboundedSender<Vec<Hit>>,
+    pub search_result_receiver: mpsc::UnboundedReceiver<Vec<Hit>>,
+    // --- ADDED FOR LIVE AUTOCOMPLETE ---
+    pub autocomplete_result_sender: mpsc::UnboundedSender<Vec<Hit>>,
+    pub autocomplete_result_receiver: mpsc::UnboundedReceiver<Vec<Hit>>,
 }

 impl EventHandler {
@@ -86,7 +96,10 @@ impl EventHandler {
        register_result_sender: mpsc::Sender<RegisterResult>,
        save_table_result_sender: SaveTableResultSender,
        save_logic_result_sender: SaveLogicResultSender,
+        grpc_client: GrpcClient,
    ) -> Result<Self> {
+        let (search_tx, search_rx) = unbounded_channel();
+        let (autocomplete_tx, autocomplete_rx) = unbounded_channel(); // ADDED
        Ok(EventHandler {
            command_mode: false,
            command_input: String::new(),
@@ -97,11 +110,17 @@ impl EventHandler {
            ideal_cursor_column: 0,
            key_sequence_tracker: KeySequenceTracker::new(400),
            auth_client: AuthClient::new().await?,
+            grpc_client,
            login_result_sender,
            register_result_sender,
            save_table_result_sender,
            save_logic_result_sender,
            navigation_state: NavigationState::new(),
+            search_result_sender: search_tx,
+            search_result_receiver: search_rx,
+            // --- ADDED ---
+            autocomplete_result_sender: autocomplete_tx,
+            autocomplete_result_receiver: autocomplete_rx,
        })
    }

@@ -113,13 +132,122 @@ impl EventHandler {
        self.navigation_state.activate_find_file(options);
    }

+    // This function handles state changes.
+    async fn handle_search_palette_event(
+        &mut self,
+        key_event: KeyEvent,
+        form_state: &mut FormState,
+        app_state: &mut AppState,
+    ) -> Result<EventOutcome> {
+        let mut should_close = false;
+        let mut outcome_message = String::new();
+        let mut trigger_search = false;
+
+        if let Some(search_state) = app_state.search_state.as_mut() {
+            match key_event.code {
+                KeyCode::Esc => {
+                    should_close = true;
+                    outcome_message = "Search cancelled".to_string();
+                }
+                KeyCode::Enter => {
+                    if let Some(selected_hit) =
+                        search_state.results.get(search_state.selected_index)
+                    {
+                        if let Ok(data) = serde_json::from_str::<
+                            std::collections::HashMap<String, String>,
+                        >(&selected_hit.content_json)
+                        {
+                            let detached_pos = form_state.total_count + 2;
+                            form_state
+                                .update_from_response(&data, detached_pos);
+                        }
+                        should_close = true;
+                        outcome_message =
+                            format!("Loaded record ID {}", selected_hit.id);
+                    }
+                }
+                KeyCode::Up => search_state.previous_result(),
+                KeyCode::Down => search_state.next_result(),
+                KeyCode::Char(c) => {
+                    search_state
+                        .input
+                        .insert(search_state.cursor_position, c);
+                    search_state.cursor_position += 1;
+                    trigger_search = true;
+                }
+                KeyCode::Backspace => {
+                    if search_state.cursor_position > 0 {
+                        search_state.cursor_position -= 1;
+                        search_state.input.remove(search_state.cursor_position);
+                        trigger_search = true;
+                    }
+                }
+                KeyCode::Left => {
+                    search_state.cursor_position =
+                        search_state.cursor_position.saturating_sub(1);
+                }
+                KeyCode::Right => {
+                    if search_state.cursor_position < search_state.input.len()
+                    {
+                        search_state.cursor_position += 1;
+                    }
+                }
+                _ => {}
+            }
+
+            // --- START CORRECTED LOGIC ---
+            if trigger_search {
+                search_state.is_loading = true;
+                search_state.results.clear();
+                search_state.selected_index = 0;
+
+                let query = search_state.input.clone();
+                let table_name = search_state.table_name.clone();
+                let sender = self.search_result_sender.clone();
+                let mut grpc_client = self.grpc_client.clone();
+
+                info!(
+                    "--- 1. Spawning search task for query: '{}' ---",
+                    query
+                );
+                // We now move the grpc_client into the task, just like with login.
+                tokio::spawn(async move {
+                    info!("--- 2. Background task started. ---");
+                    match grpc_client.search_table(table_name, query).await {
+                        Ok(response) => {
+                            info!(
+                                "--- 3a. gRPC call successful. Found {} hits. ---",
+                                response.hits.len()
+                            );
+                            let _ = sender.send(response.hits);
+                        }
+                        Err(e) => {
+                            // THE FIX: Use the debug formatter `{:?}` to print the full error chain.
+                            error!("--- 3b. gRPC call failed: {:?} ---", e);
+                            let _ = sender.send(vec![]);
+                        }
+                    }
+                });
+            }
+        }
+
+        // The borrow on `app_state.search_state` ends here.
+        // Now we can safely modify the Option itself.
+        if should_close {
+            app_state.search_state = None;
+            app_state.ui.show_search_palette = false;
+            app_state.ui.focus_outside_canvas = false;
+        }
+
+        Ok(EventOutcome::Ok(outcome_message))
+    }
+
    #[allow(clippy::too_many_arguments)]
    pub async fn handle_event(
        &mut self,
        event: Event,
        config: &Config,
        terminal: &mut TerminalCore,
-        grpc_client: &mut GrpcClient,
        command_handler: &mut CommandHandler,
        form_state: &mut FormState,
        auth_state: &mut AuthState,
@@ -130,18 +258,36 @@ impl EventHandler {
        buffer_state: &mut BufferState,
        app_state: &mut AppState,
    ) -> Result<EventOutcome> {
-        let mut current_mode = ModeManager::derive_mode(app_state, self, admin_state);
+        if app_state.ui.show_search_palette {
+            if let Event::Key(key_event) = event {
+                // The call no longer passes grpc_client
+                return self
+                    .handle_search_palette_event(
+                        key_event,
+                        form_state,
+                        app_state,
+                    )
+                    .await;
+            }
+            return Ok(EventOutcome::Ok(String::new()));
+        }
+
+        let mut current_mode =
+            ModeManager::derive_mode(app_state, self, admin_state);

-        // Handle active command navigation first
        if current_mode == AppMode::General && self.navigation_state.active {
            if let Event::Key(key_event) = event {
-                let outcome =
-                    handle_command_navigation_event(&mut self.navigation_state, key_event, config)
-                        .await?;
+                let outcome = handle_command_navigation_event(
+                    &mut self.navigation_state,
+                    key_event,
+                    config,
+                )
+                .await?;

                if !self.navigation_state.active {
                    self.command_message = outcome.get_message_if_ok();
-                    current_mode = ModeManager::derive_mode(app_state, self, admin_state);
+                    current_mode =
+                        ModeManager::derive_mode(app_state, self, admin_state);
                }
                app_state.update_mode(current_mode);
                return Ok(outcome);
@@ -190,7 +336,6 @@ impl EventHandler {
                    return dialog_result;
                }
            } else if let Event::Resize(_, _) = event {
-                // Handle resize if needed
            }
            return Ok(EventOutcome::Ok(String::new()));
        }
@@ -199,7 +344,12 @@ impl EventHandler {
            let key_code = key_event.code;
            let modifiers = key_event.modifiers;

-            if UiStateHandler::toggle_sidebar(&mut app_state.ui, config, key_code, modifiers) {
+            if UiStateHandler::toggle_sidebar(
+                &mut app_state.ui,
+                config,
+                key_code,
+                modifiers,
+            ) {
                let message = format!(
                    "Sidebar {}",
                    if app_state.ui.show_sidebar {
@@ -210,7 +360,12 @@ impl EventHandler {
                );
                return Ok(EventOutcome::Ok(message));
            }
-            if UiStateHandler::toggle_buffer_list(&mut app_state.ui, config, key_code, modifiers) {
+            if UiStateHandler::toggle_buffer_list(
+                &mut app_state.ui,
+                config,
+                key_code,
+                modifiers,
+            ) {
                let message = format!(
                    "Buffer {}",
                    if app_state.ui.show_buffer_list {
@@ -231,7 +386,9 @@ impl EventHandler {
                    match action {
                        "next_buffer" => {
                            if buffer::switch_buffer(buffer_state, true) {
-                                return Ok(EventOutcome::Ok("Switched to next buffer".to_string()));
+                                return Ok(EventOutcome::Ok(
+                                    "Switched to next buffer".to_string(),
+                                ));
                            }
                        }
                        "previous_buffer" => {
@@ -242,19 +399,44 @@ impl EventHandler {
                            }
                        }
                        "close_buffer" => {
-                            let current_table_name = Some("2025_customer");
-                            let message =
-                                buffer_state.close_buffer_with_intro_fallback(current_table_name);
+                            let current_table_name =
+                                app_state.current_view_table_name.as_deref();
+                            let message = buffer_state
+                                .close_buffer_with_intro_fallback(
+                                    current_table_name,
+                                );
                            return Ok(EventOutcome::Ok(message));
                        }
                        _ => {}
                    }
                }
+
+                if let Some(action) =
+                    config.get_general_action(key_code, modifiers)
+                {
+                    if action == "open_search" {
+                        if app_state.ui.show_form {
+                            if let Some(table_name) =
+                                app_state.current_view_table_name.clone()
+                            {
+                                app_state.ui.show_search_palette = true;
+                                app_state.search_state =
+                                    Some(SearchState::new(table_name));
+                                app_state.ui.focus_outside_canvas = true;
+                                return Ok(EventOutcome::Ok(
+                                    "Search palette opened".to_string(),
+                                ));
+                            }
+                        }
+                    }
+                }
            }

            match current_mode {
                AppMode::General => {
-                    if app_state.ui.show_admin && auth_state.role.as_deref() == Some("admin") {
+                    if app_state.ui.show_admin
+                        && auth_state.role.as_deref() == Some("admin")
+                    {
                        if admin_nav::handle_admin_navigation(
                            key_event,
                            config,
@@ -263,14 +445,15 @@ impl EventHandler {
                            buffer_state,
                            &mut self.command_message,
                        ) {
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
+                            return Ok(EventOutcome::Ok(
+                                self.command_message.clone(),
+                            ));
                        }
                    }

                    if app_state.ui.show_add_logic {
-                        let client_clone = grpc_client.clone();
+                        let client_clone = self.grpc_client.clone();
                        let sender_clone = self.save_logic_result_sender.clone();
-
                        if add_logic_nav::handle_add_logic_navigation(
                            key_event,
                            config,
@@ -282,14 +465,15 @@ impl EventHandler {
                            sender_clone,
                            &mut self.command_message,
                        ) {
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
+                            return Ok(EventOutcome::Ok(
+                                self.command_message.clone(),
+                            ));
                        }
                    }

                    if app_state.ui.show_add_table {
-                        let client_clone = grpc_client.clone();
+                        let client_clone = self.grpc_client.clone();
                        let sender_clone = self.save_table_result_sender.clone();
-
                        if add_table_nav::handle_add_table_navigation(
                            key_event,
                            config,
@@ -299,7 +483,9 @@ impl EventHandler {
                            sender_clone,
                            &mut self.command_message,
                        ) {
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
+                            return Ok(EventOutcome::Ok(
+                                self.command_message.clone(),
+                            ));
                        }
                    }

@@ -323,11 +509,20 @@ impl EventHandler {
                        Ok(EventOutcome::ButtonSelected { context, index }) => {
                            let message = match context {
                                UiContext::Intro => {
-                                    intro::handle_intro_selection(app_state, buffer_state, index);
-                                    if app_state.ui.show_admin {
-                                        if !app_state.profile_tree.profiles.is_empty() {
-                                            admin_state.profile_list_state.select(Some(0));
-                                        }
+                                    intro::handle_intro_selection(
+                                        app_state,
+                                        buffer_state,
+                                        index,
+                                    );
+                                    if app_state.ui.show_admin
+                                        && !app_state
+                                            .profile_tree
+                                            .profiles
+                                            .is_empty()
+                                    {
+                                        admin_state
+                                            .profile_list_state
+                                            .select(Some(0));
                                    }
                                    format!("Intro Option {} selected", index)
                                }
@@ -338,10 +533,12 @@ impl EventHandler {
                                        self.auth_client.clone(),
                                        self.login_result_sender.clone(),
                                    ),
-                                    1 => {
-                                        login::back_to_main(login_state, app_state, buffer_state)
-                                            .await
-                                    }
+                                    1 => login::back_to_main(
+                                        login_state,
+                                        app_state,
+                                        buffer_state,
+                                    )
+                                    .await,
                                    _ => "Invalid Login Option".to_string(),
                                },
                                UiContext::Register => match index {
@@ -351,23 +548,23 @@ impl EventHandler {
                                        self.auth_client.clone(),
                                        self.register_result_sender.clone(),
                                    ),
-                                    1 => {
-                                        register::back_to_login(
-                                            register_state,
-                                            app_state,
-                                            buffer_state,
-                                        )
-                                        .await
-                                    }
+                                    1 => register::back_to_login(
+                                        register_state,
+                                        app_state,
+                                        buffer_state,
+                                    )
+                                    .await,
                                    _ => "Invalid Login Option".to_string(),
                                },
                                UiContext::Admin => {
-                                    admin::handle_admin_selection(app_state, admin_state);
+                                    admin::handle_admin_selection(
+                                        app_state,
+                                        admin_state,
+                                    );
                                    format!("Admin Option {} selected", index)
                                }
-                                UiContext::Dialog => {
-                                    "Internal error: Unexpected dialog state".to_string()
-                                }
+                                UiContext::Dialog => "Internal error: Unexpected dialog state"
+                                    .to_string(),
                            };
                            return Ok(EventOutcome::Ok(message));
                        }
@@ -376,74 +573,27 @@ 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,
-                        };
+                    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 };
                        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 = 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() };
                        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)
-                    {
+                    } 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 = 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() };
                        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);
@@ -459,26 +609,26 @@ impl EventHandler {
                        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) {
+                    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,
                                    auth_state,
                                    login_state,
                                    register_state,
-                                    grpc_client,
+                                    &mut self.grpc_client,
                                    &mut self.auth_client,
                                    terminal,
                                    app_state,
@@ -489,88 +639,75 @@ impl EventHandler {
                        }
                    }

-                    // Extracting values to avoid borrow conflicts
-                    let mut current_position = form_state.current_position;
-                    let total_count = form_state.total_count;
-
-                    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 current_position,
-                        total_count,
-                        grpc_client,
-                        &mut self.command_message,
-                        &mut self.edit_mode_cooldown,
-                        &mut self.ideal_cursor_column,
-                    )
-                    .await?;
+                    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, // <-- FIX 1
+                            &mut self.command_message,
+                            &mut self.edit_mode_cooldown,
+                            &mut self.ideal_cursor_column,
+                        )
+                        .await?;
                    return Ok(EventOutcome::Ok(message));
                }

                AppMode::Highlight => {
-                    if config.get_highlight_action_for_key(key_code, modifiers)
-                        == Some("exit_highlight_mode")
-                    {
+                    if config.get_highlight_action_for_key(key_code, modifiers) == Some("exit_highlight_mode") {
                        self.highlight_state = HighlightState::Off;
                        self.command_message = "Exited highlight mode".to_string();
                        terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
                        return Ok(EventOutcome::Ok(self.command_message.clone()));
-                    } else if config.get_highlight_action_for_key(key_code, modifiers)
-                        == Some("enter_highlight_mode_linewise")
-                    {
+                    } else if config.get_highlight_action_for_key(key_code, modifiers) == Some("enter_highlight_mode_linewise") {
                        if let HighlightState::Characterwise { anchor } = self.highlight_state {
-                            self.highlight_state = HighlightState::Linewise {
-                                anchor_line: anchor.0,
-                            };
+                            self.highlight_state = HighlightState::Linewise { anchor_line: anchor.0 };
                            self.command_message = "-- LINE HIGHLIGHT --".to_string();
                            return Ok(EventOutcome::Ok(self.command_message.clone()));
                        }
                        return Ok(EventOutcome::Ok("".to_string()));
                    }

-                    // Extracting values to avoid borrow conflicts
-                    let mut current_position = form_state.current_position;
-                    let total_count = form_state.total_count;
-
-                    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 current_position,
-                        total_count,
-                        grpc_client,
-                        &mut self.command_message,
-                        &mut self.edit_mode_cooldown,
-                        &mut self.ideal_cursor_column,
-                    )
-                    .await?;
+                    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, // <-- FIX 2
+                            &mut self.command_message,
+                            &mut self.edit_mode_cooldown,
+                            &mut self.ideal_cursor_column,
+                        )
+                        .await?;
                    return Ok(EventOutcome::Ok(message));
                }

                AppMode::Edit => {
-                    if let Some(action) = config.get_common_action(key_code, modifiers) {
+                    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,
                                    auth_state,
                                    login_state,
                                    register_state,
-                                    grpc_client,
+                                    &mut self.grpc_client,
                                    &mut self.auth_client,
                                    terminal,
                                    app_state,
@@ -581,10 +718,9 @@ impl EventHandler {
                        }
                    }

-                    // Extracting values to avoid borrow conflicts
                    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,
@@ -592,10 +728,9 @@ impl EventHandler {
                        login_state,
                        register_state,
                        admin_state,
-                        &mut self.ideal_cursor_column,
                        &mut current_position,
                        total_count,
-                        grpc_client,
+                        self,
                        app_state,
                    )
                    .await;
@@ -604,56 +739,29 @@ 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()
-                            };
+                            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() };
                            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()
-                            };
-                            if !current_input.is_empty()
-                                && current_cursor_pos >= current_input.len()
-                            {
+                            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() };
+                            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
-                                };
+                                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);
                                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());
@@ -667,15 +775,14 @@ impl EventHandler {
                        self.command_message.clear();
                        self.command_mode = false;
                        self.key_sequence_tracker.reset();
-                        return Ok(EventOutcome::Ok("Exited command mode".to_string()));
+                        return Ok(EventOutcome::Ok(
+                            "Exited command mode".to_string(),
+                        ));
                    }

                    if config.is_command_execute(key_code, modifiers) {
-
-                        // Extracting values to avoid borrow conflicts
                        let mut current_position = form_state.current_position;
                        let total_count = form_state.total_count;
-
                        let outcome = command_mode::handle_command_event(
                            key_event,
                            config,
@@ -685,20 +792,21 @@ impl EventHandler {
                            form_state,
                            &mut self.command_input,
                            &mut self.command_message,
-                            grpc_client,
+                            &mut self.grpc_client, // <-- FIX 5
                            command_handler,
                            terminal,
                            &mut current_position,
                            total_count,
                        )
                        .await?;
-
-                        // Update form_state with potentially changed position
                        form_state.current_position = current_position;
-                        
                        self.command_mode = false;
                        self.key_sequence_tracker.reset();
-                        let new_mode = ModeManager::derive_mode(app_state, self, admin_state);
+                        let new_mode = ModeManager::derive_mode(
+                            app_state,
+                            self,
+                            admin_state,
+                        );
                        app_state.update_mode(new_mode);
                        return Ok(outcome);
                    }
@@ -711,41 +819,60 @@ impl EventHandler {

                    if let KeyCode::Char(c) = key_code {
                        if c == 'f' {
-                            // Assuming 'f' is part of the sequence, e.g. ":f" or " f"
                            self.key_sequence_tracker.add_key(key_code);
-                            let sequence = self.key_sequence_tracker.get_sequence();
+                            let sequence =
+                                self.key_sequence_tracker.get_sequence();

-                            if config.matches_key_sequence_generalized(&sequence)
-                                == Some("find_file_palette_toggle")
+                            if config.matches_key_sequence_generalized(
+                                &sequence,
+                            ) == Some("find_file_palette_toggle")
                            {
-                                if app_state.ui.show_form || app_state.ui.show_intro {
-                                    // Build table graph from profile data
-                                    let graph = TableDependencyGraph::from_profile_tree(
-                                        &app_state.profile_tree,
-                                    );
+                                if app_state.ui.show_form
+                                    || app_state.ui.show_intro
+                                {
+                                    let mut all_table_paths: Vec<String> =
+                                        app_state
+                                            .profile_tree
+                                            .profiles
+                                            .iter()
+                                            .flat_map(|profile| {
+                                                profile.tables.iter().map(
+                                                    move |table| {
+                                                        format!(
+                                                            "{}/{}",
+                                                            profile.name,
+                                                            table.name
+                                                        )
+                                                    },
+                                                )
+                                            })
+                                            .collect();
+                                    all_table_paths.sort();

-                                    // Activate navigation with graph
-                                    self.navigation_state.activate_table_tree(graph);
+                                    self.navigation_state
+                                        .activate_find_file(all_table_paths);

-                                    self.command_mode = false; // Exit command mode
+                                    self.command_mode = false;
                                    self.command_input.clear();
-                                    // Message is set by render_find_file_palette's prompt_prefix
-                                    self.command_message.clear(); // Clear old command message
+                                    self.command_message.clear();
                                    self.key_sequence_tracker.reset();
-                                    // ModeManager will derive AppMode::General due to navigation_state.active
-                                    // app_state.update_mode(AppMode::General); // This will be handled by ModeManager
                                    return Ok(EventOutcome::Ok(
-                                        "Table tree palette activated".to_string(),
+                                        "Table selection palette activated"
+                                            .to_string(),
                                    ));
                                } else {
                                    self.key_sequence_tracker.reset();
                                    self.command_input.push('f');
-                                    if sequence.len() > 1 && sequence[0] == KeyCode::Char('f') {
+                                    if sequence.len() > 1
+                                        && sequence[0] == KeyCode::Char('f')
+                                    {
                                        self.command_input.push('f');
                                    }
-                                    self.command_message =
-                                        "Find File not available in this view.".to_string();
-                                    return Ok(EventOutcome::Ok(self.command_message.clone()));
+                                    self.command_message = "Find File not available in this view."
+                                        .to_string();
+                                    return Ok(EventOutcome::Ok(
+                                        self.command_message.clone(),
+                                    ));
                                }
                            }

@@ -754,7 +881,9 @@ impl EventHandler {
                            }
                        }

-                        if c != 'f' && !self.key_sequence_tracker.current_sequence.is_empty() {
+                        if c != 'f'
+                            && !self.key_sequence_tracker.current_sequence.is_empty()
+                        {
                            self.key_sequence_tracker.reset();
                        }

--- a/client/src/modes/highlight/highlight.rs
+++ b/client/src/modes/highlight/highlight.rs
@@ -44,8 +44,6 @@ pub async fn handle_highlight_event(
        &mut admin_state.add_table_state,
        &mut admin_state.add_logic_state,
        key_sequence_tracker,
-        current_position,
-        total_count,
        grpc_client,
        command_message, // Pass the message buffer
        edit_mode_cooldown,
--- a/client/src/services/grpc_client.rs
+++ b/client/src/services/grpc_client.rs
@@ -1,7 +1,6 @@
 // src/services/grpc_client.rs

-use tonic::transport::Channel;
-use common::proto::multieko2::common::{CountResponse, Empty};
+use common::proto::multieko2::common::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::{
@@ -20,44 +19,44 @@ use common::proto::multieko2::tables_data::{
    PostTableDataRequest, PostTableDataResponse, PutTableDataRequest,
    PutTableDataResponse,
 };
-use anyhow::{Context, Result}; // Added Context
-use std::collections::HashMap; // NEW
+use common::proto::multieko2::search::{
+    searcher_client::SearcherClient, SearchRequest, SearchResponse,
+};
+use anyhow::{Context, Result};
+use std::collections::HashMap;
+use tonic::transport::Channel;
+use prost_types::Value;

 #[derive(Clone)]
 pub struct GrpcClient {
    table_structure_client: TableStructureServiceClient<Channel>,
    table_definition_client: TableDefinitionClient<Channel>,
    table_script_client: TableScriptClient<Channel>,
-    tables_data_client: TablesDataClient<Channel>, // NEW
+    tables_data_client: TablesDataClient<Channel>,
+    search_client: SearcherClient<Channel>,
 }

 impl GrpcClient {
    pub async fn new() -> Result<Self> {
-        let table_structure_client = TableStructureServiceClient::connect(
-            "http://[::1]:50051",
-        )
-        .await
-        .context("Failed to connect to TableStructureService")?;
-        let table_definition_client = TableDefinitionClient::connect(
-            "http://[::1]:50051",
-        )
-        .await
-        .context("Failed to connect to TableDefinitionService")?;
-        let table_script_client =
-            TableScriptClient::connect("http://[::1]:50051")
-                .await
-                .context("Failed to connect to TableScriptService")?;
-        let tables_data_client =
-            TablesDataClient::connect("http://[::1]:50051")
-                .await
-                .context("Failed to connect to TablesDataService")?; // NEW
+        let channel = Channel::from_static("http://[::1]:50051")
+            .connect()
+            .await
+            .context("Failed to create gRPC channel")?;
+
+        let table_structure_client =
+            TableStructureServiceClient::new(channel.clone());
+        let table_definition_client =
+            TableDefinitionClient::new(channel.clone());
+        let table_script_client = TableScriptClient::new(channel.clone());
+        let tables_data_client = TablesDataClient::new(channel.clone());
+        let search_client = SearcherClient::new(channel.clone());

        Ok(Self {
-            // adresar_client, // REMOVE
            table_structure_client,
            table_definition_client,
            table_script_client,
-            tables_data_client, // NEW
+            tables_data_client,
+            search_client,
        })
    }

@@ -136,7 +135,7 @@ impl GrpcClient {
        Ok(response.into_inner().count as u64)
    }

-    pub async fn get_table_data_by_position(
+pub async fn get_table_data_by_position(
        &mut self,
        profile_name: String,
        table_name: String,
@@ -160,12 +159,14 @@ impl GrpcClient {
        &mut self,
        profile_name: String,
        table_name: String,
-        data: HashMap<String, String>,
+        // CHANGE THIS: Accept the pre-converted data
+        data: HashMap<String, Value>,
    ) -> Result<PostTableDataResponse> {
+        // The conversion logic is now gone from here.
        let grpc_request = PostTableDataRequest {
            profile_name,
            table_name,
-            data,
+            data, // This is now the correct type
        };
        let request = tonic::Request::new(grpc_request);
        let response = self
@@ -181,13 +182,15 @@ impl GrpcClient {
        profile_name: String,
        table_name: String,
        id: i64,
-        data: HashMap<String, String>,
+        // CHANGE THIS: Accept the pre-converted data
+        data: HashMap<String, Value>,
    ) -> Result<PutTableDataResponse> {
+        // The conversion logic is now gone from here.
        let grpc_request = PutTableDataRequest {
            profile_name,
            table_name,
            id,
-            data,
+            data, // This is now the correct type
        };
        let request = tonic::Request::new(grpc_request);
        let response = self
@@ -197,4 +200,17 @@ impl GrpcClient {
            .context("gRPC PutTableData call failed")?;
        Ok(response.into_inner())
    }
+
+    pub async fn search_table(
+        &mut self,
+        table_name: String,
+        query: String,
+    ) -> Result<SearchResponse> {
+        let request = tonic::Request::new(SearchRequest { table_name, query });
+        let response = self
+            .search_client
+            .search_table(request)
+            .await?;
+        Ok(response.into_inner())
+    }
 }
--- a/client/src/services/ui_service.rs
+++ b/client/src/services/ui_service.rs
@@ -1,15 +1,100 @@
 // 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 anyhow::{Context, Result};
+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::{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,
@@ -82,7 +167,7 @@ impl UiService {
                    .into_iter()
                    .map(|col| col.name)
                    .collect();
-                Ok(column_names)
+                Ok(filter_user_columns(column_names))
            }
            Err(e) => {
                tracing::warn!("Failed to fetch columns for {}.{}: {}", profile_name, table_name, e);
@@ -90,12 +175,11 @@ impl UiService {
            }
        }
    }
-    
-    // MODIFIED: To set initial view table in AppState and return initial column names
+
+    // REFACTOR THIS FUNCTION
    pub async fn initialize_app_state_and_form(
        grpc_client: &mut GrpcClient,
        app_state: &mut AppState,
-        // Returns (initial_profile, initial_table, initial_columns)
    ) -> Result<(String, String, Vec<String>)> {
        let profile_tree = grpc_client
            .get_profile_tree()
@@ -103,8 +187,6 @@ impl UiService {
            .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)
-        // For now, let's hardcode a default for simplicity, but this should be more dynamic
        let initial_profile_name = app_state
            .profile_tree
            .profiles
@@ -117,34 +199,28 @@ impl UiService {
            .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
+            .unwrap_or_else(|| "2025_company_data1".to_string());

        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
-            ))?;
+        // NOW, just call our new central function. This avoids code duplication.
+        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();
+        // The field names for the UI are derived from the new form_state
+        let field_names = form_state.fields.iter().map(|f| f.display_name.clone()).collect();

-        Ok((initial_profile_name, initial_table_name, column_names))
+        Ok((initial_profile_name, initial_table_name, field_names))
    }

-    // NEW: Fetches and sets count for the current table in FormState
    pub async fn fetch_and_set_table_count(
        grpc_client: &mut GrpcClient,
        form_state: &mut FormState,
@@ -161,35 +237,26 @@ impl UiService {
            ))?;
        form_state.total_count = total_count;

-        // Set initial position: if table has items, point to first, else point to new entry
        if total_count > 0 {
-            form_state.current_position = 1;
+            form_state.current_position = total_count;
        } else {
-            form_state.current_position = 1; // For a new entry in an empty table
+            form_state.current_position = 1;
        }
        Ok(())
    }

-    // MODIFIED: Generic table data loading
    pub async fn load_table_data_by_position(
        grpc_client: &mut GrpcClient,
-        form_state: &mut FormState, // Takes &mut FormState to update it
-                                    // position is now read from form_state.current_position
+        form_state: &mut FormState,
    ) -> Result<String> {
-        // Ensure current_position is valid before fetching
        if form_state.current_position == 0 || (form_state.total_count > 0 && form_state.current_position > form_state.total_count) {
-             // This indicates a "new entry" state, no data to load from server.
-             // The caller should handle this by calling form_state.reset_to_empty()
-             // or ensuring this function isn't called for a new entry position.
-             // For now, let's assume reset_to_empty was called if needed.
-            form_state.reset_to_empty(); // Ensure fields are clear for new entry
+            form_state.reset_to_empty();
            return Ok(format!(
                "New entry mode for table {}.{}",
                form_state.profile_name, form_state.table_name
            ));
        }
        if form_state.total_count == 0 && form_state.current_position == 1 {
-            // Table is empty, this is the position for a new entry
            form_state.reset_to_empty();
            return Ok(format!(
                "New entry mode for empty table {}.{}",
@@ -197,7 +264,6 @@ impl UiService {
            ));
        }

-
        match grpc_client
            .get_table_data_by_position(
                form_state.profile_name.clone(),
@@ -207,8 +273,8 @@ impl UiService {
            .await
        {
            Ok(response) => {
-                form_state.update_from_response(&response.data);
-                // ID, values, current_field, current_cursor_pos, has_unsaved_changes are set by update_from_response
+                // FIX: Pass the current position as the second argument
+                form_state.update_from_response(&response.data, form_state.current_position);
                Ok(format!(
                    "Loaded entry {}/{} for table {}.{}",
                    form_state.current_position,
@@ -218,9 +284,6 @@ impl UiService {
                ))
            }
            Err(e) => {
-                // If loading fails (e.g., record deleted, network error), what should happen?
-                // Maybe reset to a new entry state or show an error and keep current data.
-                // For now, log error and return error message.
                tracing::error!(
                    "Error loading entry {} for table {}.{}: {}",
                    form_state.current_position,
@@ -228,8 +291,6 @@ impl UiService {
                    form_state.table_name,
                    e
                );
-                // Potentially clear form or revert to a safe state
-                // form_state.reset_to_empty();
                Err(anyhow::anyhow!(
                    "Error loading entry {}: {}",
                    form_state.current_position,
@@ -239,27 +300,20 @@ impl UiService {
        }
    }

-    // MODIFIED: To work with FormState's count and position
    pub async fn handle_save_outcome(
        save_outcome: SaveOutcome,
-        _grpc_client: &mut GrpcClient, // May not be needed if count is fetched separately
-        _app_state: &mut AppState,     // May not be needed directly
+        _grpc_client: &mut GrpcClient,
+        _app_state: &mut AppState,
        form_state: &mut FormState,
    ) -> Result<()> {
        match save_outcome {
            SaveOutcome::CreatedNew(new_id) => {
-                // form_state.total_count and form_state.current_position should have been updated
-                // by the `save` function itself.
-                // Ensure form_state.id is set.
                form_state.id = new_id;
-                // Potentially, re-fetch count to be absolutely sure, but save should be authoritative.
-                // UiService::fetch_and_set_table_count(grpc_client, form_state).await?;
            }
            SaveOutcome::UpdatedExisting | SaveOutcome::NoChange => {
-                // No changes to total_count or current_position needed from here.
+                // No action needed
            }
        }
        Ok(())
    }
 }
-
--- a/client/src/state/app.rs
+++ b/client/src/state/app.rs
@@ -2,4 +2,5 @@

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

-use std::env;
-use common::proto::multieko2::table_definition::ProfileTreeResponse;
-use crate::modes::handlers::mode_manager::AppMode;
-use crate::ui::handlers::context::DialogPurpose;
 use anyhow::Result;
+use common::proto::multieko2::table_definition::ProfileTreeResponse;
+// NEW: Import the types we need for the cache
+use common::proto::multieko2::table_structure::TableStructureResponse;
+use crate::modes::handlers::mode_manager::AppMode;
+use crate::state::app::search::SearchState;
+use crate::ui::handlers::context::DialogPurpose;
+use std::collections::HashMap;
+use std::env;
+use std::sync::Arc;
+#[cfg(feature = "ui-debug")]
+use std::time::Instant;

+// --- DialogState and UiState are unchanged ---
 pub struct DialogState {
    pub dialog_show: bool,
    pub dialog_title: String,
@@ -26,10 +34,19 @@ pub struct UiState {
    pub show_form: bool,
    pub show_login: bool,
    pub show_register: bool,
+    pub show_search_palette: bool,
    pub focus_outside_canvas: bool,
    pub dialog: DialogState,
 }

+#[cfg(feature = "ui-debug")]
+#[derive(Debug, Clone)]
+pub struct DebugState {
+    pub displayed_message: String,
+    pub is_error: bool,
+    pub display_start_time: Instant,
+}
+
 pub struct AppState {
    // Core editor state
    pub current_dir: String,
@@ -39,18 +56,24 @@ pub struct AppState {
    pub current_view_profile_name: Option<String>,
    pub current_view_table_name: Option<String>,

+    // NEW: The "Rulebook" cache. We use Arc for efficient sharing.
+    pub schema_cache: HashMap<String, Arc<TableStructureResponse>>,
+
    pub focused_button_index: usize,
    pub pending_table_structure_fetch: Option<(String, String)>,

+    pub search_state: Option<SearchState>,
+
    // UI preferences
    pub ui: UiState,
+
+    #[cfg(feature = "ui-debug")]
+    pub debug_state: Option<DebugState>,
 }

 impl AppState {
    pub fn new() -> Result<Self> {
-        let current_dir = env::current_dir()?
-            .to_string_lossy()
-            .to_string();
+        let current_dir = env::current_dir()?.to_string_lossy().to_string();
        Ok(AppState {
            current_dir,
            profile_tree: ProfileTreeResponse::default(),
@@ -58,24 +81,28 @@ impl AppState {
            current_view_profile_name: None,
            current_view_table_name: None,
            current_mode: AppMode::General,
+            schema_cache: HashMap::new(), // NEW: Initialize the cache
            focused_button_index: 0,
            pending_table_structure_fetch: None,
+            search_state: None,
            ui: UiState::default(),
+
+            #[cfg(feature = "ui-debug")]
+            debug_state: None,
        })
    }

+    // --- ALL YOUR EXISTING METHODS ARE UNTOUCHED ---
+
    pub fn update_mode(&mut self, mode: AppMode) {
        self.current_mode = mode;
    }
-    
+
    pub fn set_current_view_table(&mut self, profile_name: String, table_name: String) {
        self.current_view_profile_name = Some(profile_name);
        self.current_view_table_name = Some(table_name);
    }

-    // Add dialog helper methods
-    /// Shows a dialog with the given title, message, and buttons.
-    /// The first button (index 0) is active by default.
    pub fn show_dialog(
        &mut self,
        title: &str,
@@ -93,19 +120,17 @@ impl AppState {
        self.ui.focus_outside_canvas = true;
    }

-    /// Shows a dialog specifically for loading states.
    pub fn show_loading_dialog(&mut self, title: &str, message: &str) {
        self.ui.dialog.dialog_title = title.to_string();
        self.ui.dialog.dialog_message = message.to_string();
-        self.ui.dialog.dialog_buttons.clear(); // No buttons during loading
+        self.ui.dialog.dialog_buttons.clear();
        self.ui.dialog.dialog_active_button_index = 0;
-        self.ui.dialog.purpose = None; // Purpose is set when loading finishes
+        self.ui.dialog.purpose = None;
        self.ui.dialog.is_loading = true;
        self.ui.dialog.dialog_show = true;
-        self.ui.focus_outside_canvas = true; // Keep focus management consistent
+        self.ui.focus_outside_canvas = true;
    }

-    /// Updates the content of an existing dialog, typically after loading.
    pub fn update_dialog_content(
        &mut self,
        message: &str,
@@ -115,16 +140,12 @@ impl AppState {
        if self.ui.dialog.dialog_show {
            self.ui.dialog.dialog_message = message.to_string();
            self.ui.dialog.dialog_buttons = buttons;
-            self.ui.dialog.dialog_active_button_index = 0; // Reset focus
+            self.ui.dialog.dialog_active_button_index = 0;
            self.ui.dialog.purpose = Some(purpose);
-            self.ui.dialog.is_loading = false; // Loading finished
-                                               // Keep dialog_show = true
-                                               // Keep focus_outside_canvas = true
+            self.ui.dialog.is_loading = false;
        }
    }

-
-    /// Hides the dialog and clears its content.
    pub fn hide_dialog(&mut self) {
        self.ui.dialog.dialog_show = false;
        self.ui.dialog.dialog_title.clear();
@@ -133,32 +154,30 @@ impl AppState {
        self.ui.dialog.dialog_active_button_index = 0;
        self.ui.dialog.purpose = None;
        self.ui.focus_outside_canvas = false;
+        self.ui.dialog.is_loading = false;
    }

-    /// Sets the active button index, wrapping around if necessary.
    pub fn next_dialog_button(&mut self) {
        if !self.ui.dialog.dialog_buttons.is_empty() {
            let next_index = (self.ui.dialog.dialog_active_button_index + 1)
                % self.ui.dialog.dialog_buttons.len();
-            self.ui.dialog.dialog_active_button_index = next_index; // Use new name
+            self.ui.dialog.dialog_active_button_index = next_index;
        }
    }

-    /// Sets the active button index, wrapping around if necessary.
    pub fn previous_dialog_button(&mut self) {
        if !self.ui.dialog.dialog_buttons.is_empty() {
            let len = self.ui.dialog.dialog_buttons.len();
            let prev_index =
                (self.ui.dialog.dialog_active_button_index + len - 1) % len;
-            self.ui.dialog.dialog_active_button_index = prev_index; // Use new name
+            self.ui.dialog.dialog_active_button_index = prev_index;
        }
    }

-    /// Gets the label of the currently active button, if any.
    pub fn get_active_dialog_button_label(&self) -> Option<&str> {
        self.ui.dialog
-            .dialog_buttons // Use new name
-            .get(self.ui.dialog.dialog_active_button_index) // Use new name
+            .dialog_buttons
+            .get(self.ui.dialog.dialog_active_button_index)
            .map(|s| s.as_str())
    }
 }
@@ -175,13 +194,13 @@ impl Default for UiState {
            show_login: false,
            show_register: false,
            show_buffer_list: true,
+            show_search_palette: false, // ADDED
            focus_outside_canvas: false,
            dialog: DialogState::default(),
        }
    }
 }

-// Update the Default implementation for DialogState itself
 impl Default for DialogState {
    fn default() -> Self {
        Self {
--- a/client/src/state/pages/canvas_state.rs
+++ b/client/src/state/pages/canvas_state.rs
@@ -1,7 +1,9 @@
-// src/state/canvas_state.rs
+// src/state/pages/canvas_state.rs

+use common::proto::multieko2::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;
@@ -9,12 +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
+    }
 }
--- a/client/src/state/pages/form.rs
+++ b/client/src/state/pages/form.rs
@@ -1,46 +1,109 @@
 // src/state/pages/form.rs

-use std::collections::HashMap; // NEW
 use crate::config::colors::themes::Theme;
-use ratatui::layout::Rect;
-use ratatui::Frame;
 use crate::state::app::highlight::HighlightState;
 use crate::state::pages::canvas_state::CanvasState;
+use common::proto::multieko2::search::search_response::Hit;
+use ratatui::layout::Rect;
+use ratatui::Frame;
+use std::collections::HashMap;

+fn json_value_to_string(value: &serde_json::Value) -> String {
+    match value {
+        serde_json::Value::String(s) => s.clone(),
+        serde_json::Value::Number(n) => n.to_string(),
+        serde_json::Value::Bool(b) => b.to_string(),
+        _ => String::new(),
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct FieldDefinition {
+    pub display_name: String,
+    pub data_key: String,
+    pub is_link: bool,
+    pub link_target_table: Option<String>,
+}
+
+#[derive(Clone)]
 pub struct FormState {
    pub id: i64,
-    // NEW fields for dynamic table context
    pub profile_name: String,
    pub table_name: String,
    pub total_count: u64,
-    pub current_position: u64, // 1-based index, 0 or total_count + 1 for new entry
-
-    pub fields: Vec<String>, // Already dynamic, which is good
+    pub current_position: u64,
+    pub fields: Vec<FieldDefinition>,
    pub values: Vec<String>,
    pub current_field: usize,
    pub has_unsaved_changes: bool,
    pub current_cursor_pos: usize,
+    pub autocomplete_active: bool,
+    pub autocomplete_suggestions: Vec<Hit>,
+    pub selected_suggestion_index: Option<usize>,
+    pub autocomplete_loading: bool,
+    pub link_display_map: HashMap<usize, String>,
 }

 impl FormState {
-    // MODIFIED constructor
    pub fn new(
        profile_name: String,
        table_name: String,
-        fields: Vec<String>,
+        fields: Vec<FieldDefinition>,
    ) -> Self {
        let values = vec![String::new(); fields.len()];
        FormState {
-            id: 0, // Default to 0, indicating a new or unloaded record
+            id: 0,
            profile_name,
            table_name,
-            total_count: 0,    // Will be fetched after initialization
-            current_position: 0, // Will be set after count is fetched (e.g., 1 or total_count + 1)
+            total_count: 0,
+            current_position: 1,
            fields,
            values,
            current_field: 0,
            has_unsaved_changes: false,
            current_cursor_pos: 0,
+            autocomplete_active: false,
+            autocomplete_suggestions: Vec::new(),
+            selected_suggestion_index: None,
+            autocomplete_loading: false,
+            link_display_map: HashMap::new(),
+        }
+    }
+
+    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)
        }
    }

@@ -51,42 +114,40 @@ impl FormState {
        theme: &Theme,
        is_edit_mode: bool,
        highlight_state: &HighlightState,
-        // total_count and current_position are now part of self
    ) {
        let fields_str_slice: Vec<&str> =
-            self.fields.iter().map(|s| s.as_str()).collect();
+            self.fields().iter().map(|s| *s).collect();
        let values_str_slice: Vec<&String> = self.values.iter().collect();

        crate::components::form::form::render_form(
            f,
            area,
-            self, // Pass self as CanvasState
+            self,
            &fields_str_slice,
            &self.current_field,
            &values_str_slice,
+            &self.table_name,
            theme,
            is_edit_mode,
            highlight_state,
-            self.total_count,    // MODIFIED: Use self.total_count
-            self.current_position, // MODIFIED: Use self.current_position
+            self.total_count,
+            self.current_position,
        );
    }

-    // MODIFIED: Reset now also considers table context for counts
    pub fn reset_to_empty(&mut self) {
        self.id = 0;
        self.values.iter_mut().for_each(|v| v.clear());
        self.current_field = 0;
        self.current_cursor_pos = 0;
        self.has_unsaved_changes = false;
-        // current_position should be set to total_count + 1 for a new entry
-        // This might be better handled by the logic that calls reset_to_empty
-        // For now, let's ensure it's consistent with a "new" state.
        if self.total_count > 0 {
            self.current_position = self.total_count + 1;
        } else {
-            self.current_position = 1; // If table is empty, new record is at position 1
+            self.current_position = 1;
        }
+        self.deactivate_autocomplete();
+        self.link_display_map.clear();
    }

    pub fn get_current_input(&self) -> &str {
@@ -97,48 +158,62 @@ 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")
    }

-    // MODIFIED: Update from a generic HashMap response
    pub fn update_from_response(
        &mut self,
        response_data: &HashMap<String, String>,
+        new_position: u64,
    ) {
-        self.values = self.fields
+        self.values = self
+            .fields
            .iter()
-            .map(|field_name| {
-                response_data.get(field_name).cloned().unwrap_or_default()
+            .map(|field_def| {
+                response_data
+                    .get(&field_def.data_key)
+                    .cloned()
+                    .unwrap_or_default()
            })
            .collect();

-        if let Some(id_str) = response_data.get("id") {
-            match id_str.parse::<i64>() {
-                Ok(parsed_id) => self.id = parsed_id,
-                Err(e) => {
-                    tracing::error!(
-                        "Failed to parse 'id' field '{}' for table {}.{}: {}",
-                        id_str,
-                        self.profile_name,
-                        self.table_name,
-                        e
-                    );
-                    self.id = 0; // Default to 0 if parsing fails
-                }
+        let id_str_opt = response_data
+            .iter()
+            .find(|(k, _)| k.eq_ignore_ascii_case("id"))
+            .map(|(_, v)| v);
+
+        if let Some(id_str) = id_str_opt {
+            if let Ok(parsed_id) = id_str.parse::<i64>() {
+                self.id = parsed_id;
+            } else {
+                tracing::error!(
+                    "Failed to parse 'id' field '{}' for table {}.{}",
+                    id_str,
+                    self.profile_name,
+                    self.table_name
+                );
+                self.id = 0;
            }
        } else {
-            // If no ID is present, it might be a new record structure or an error
-            // For now, assume it means the record doesn't have an ID from the server yet
            self.id = 0;
        }
+
+        self.current_position = new_position;
        self.has_unsaved_changes = false;
-        // current_field and current_cursor_pos might need resetting or adjusting
-        // depending on the desired behavior after loading data.
-        // For now, let's reset current_field to 0.
        self.current_field = 0;
        self.current_cursor_pos = 0;
+        self.deactivate_autocomplete();
+        self.link_display_map.clear();
+    }
+
+    pub fn deactivate_autocomplete(&mut self) {
+        self.autocomplete_active = false;
+        self.autocomplete_suggestions.clear();
+        self.selected_suggestion_index = None;
+        self.autocomplete_loading = false;
    }
 }

@@ -146,52 +221,69 @@ impl CanvasState for FormState {
    fn current_field(&self) -> usize {
        self.current_field
    }
-
    fn current_cursor_pos(&self) -> usize {
        self.current_cursor_pos
    }
-
    fn has_unsaved_changes(&self) -> bool {
        self.has_unsaved_changes
    }
-
    fn inputs(&self) -> Vec<&String> {
        self.values.iter().collect()
    }
-
    fn get_current_input(&self) -> &str {
-        // Re-use the struct's own method
        FormState::get_current_input(self)
    }
-
    fn get_current_input_mut(&mut self) -> &mut String {
-        // Re-use the struct's own method
        FormState::get_current_input_mut(self)
    }
-
    fn fields(&self) -> Vec<&str> {
-        self.fields.iter().map(|s| s.as_str()).collect()
+        self.fields
+            .iter()
+            .map(|f| f.display_name.as_str())
+            .collect()
    }
-
    fn set_current_field(&mut self, index: usize) {
        if index < self.fields.len() {
            self.current_field = index;
        }
+        self.deactivate_autocomplete();
    }
-
    fn set_current_cursor_pos(&mut self, pos: usize) {
        self.current_cursor_pos = pos;
    }
-
    fn set_has_unsaved_changes(&mut self, changed: bool) {
        self.has_unsaved_changes = changed;
    }
-
    fn get_suggestions(&self) -> Option<&[String]> {
        None
    }
-
+    fn get_rich_suggestions(&self) -> Option<&[Hit]> {
+        if self.autocomplete_active {
+            Some(&self.autocomplete_suggestions)
+        } else {
+            None
+        }
+    }
    fn get_selected_suggestion_index(&self) -> Option<usize> {
-        None
+        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("")
+    }
+
+    // --- IMPLEMENT THE NEW TRAIT METHOD ---
+    fn has_display_override(&self, index: usize) -> bool {
+        self.link_display_map.contains_key(&index)
    }
 }
--- a/client/src/tui/functions/common/form.rs
+++ b/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,44 +24,64 @@ pub async fn save(
        return Ok(SaveOutcome::NoChange);
    }

+    // --- NEW: VALIDATION & CONVERSION STEP ---
+    let cache_key =
+        format!("{}.{}", form_state.profile_name, form_state.table_name);
+    let schema = match app_state.schema_cache.get(&cache_key) {
+        Some(s) => s,
+        None => {
+            return Err(anyhow!(
+                "Schema for table '{}' not found in cache. Cannot save.",
+                form_state.table_name
+            ));
+        }
+    };
+
    let data_map: HashMap<String, String> = form_state
        .fields
        .iter()
        .zip(form_state.values.iter())
-        .map(|(field, value)| (field.clone(), value.clone()))
+        .map(|(field_def, value)| (field_def.data_key.clone(), value.clone()))
        .collect();

+    // Use our new translator. It returns a user-friendly error on failure.
+    let converted_data =
+        match data_converter::convert_and_validate_data(&data_map, schema) {
+            Ok(data) => data,
+            Err(user_error) => return Err(anyhow!(user_error)),
+        };
+    // --- END OF NEW STEP ---
+
    let outcome: SaveOutcome;
-
-    let is_new_entry = form_state.id == 0 || (form_state.total_count > 0 && form_state.current_position > form_state.total_count) || (form_state.total_count == 0 && form_state.current_position == 1) ;
-
+    let is_new_entry = form_state.id == 0
+        || (form_state.total_count > 0
+            && form_state.current_position > form_state.total_count)
+        || (form_state.total_count == 0 && form_state.current_position == 1);

    if is_new_entry {
        let response = grpc_client
            .post_table_data(
                form_state.profile_name.clone(),
                form_state.table_name.clone(),
-                data_map,
+                converted_data, // Use the validated & converted data
            )
            .await
            .context("Failed to post new table data")?;

        if response.success {
            form_state.id = response.inserted_id;
-            // After creating a new entry, total_count increases, and current_position becomes this new total_count
            form_state.total_count += 1;
            form_state.current_position = form_state.total_count;
            outcome = SaveOutcome::CreatedNew(response.inserted_id);
        } else {
-            return Err(anyhow::anyhow!(
+            return Err(anyhow!(
                "Server failed to insert data: {}",
                response.message
            ));
        }
    } else {
-        // This assumes form_state.id is valid for an existing record
        if form_state.id == 0 {
-            return Err(anyhow::anyhow!(
+            return Err(anyhow!(
                "Cannot update record: ID is 0, but not classified as new entry."
            ));
        }
@@ -67,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")?;
@@ -75,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
            ));
@@ -126,6 +149,8 @@ pub async fn revert(
            form_state.table_name
        ))?;

-    form_state.update_from_response(&response.data);
+    // FIX: Pass the current position as the second argument
+    form_state.update_from_response(&response.data, form_state.current_position);
    Ok("Changes discarded, reloaded last saved version".to_string())
 }
+
--- a/client/src/tui/functions/form.rs
+++ b/client/src/tui/functions/form.rs
@@ -1,19 +1,15 @@
 // 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 crate::state::pages::canvas_state::CanvasState;
-use crate::services::ui_service::UiService;
 use anyhow::{anyhow, Result};

 pub async fn handle_action(
    action: &str,
    form_state: &mut FormState,
-    grpc_client: &mut GrpcClient,
-    current_position: &mut u64,
-    total_count: u64,
+    _grpc_client: &mut GrpcClient,
    ideal_cursor_column: &mut usize,
 ) -> Result<String> {
-    // Check for unsaved changes in both cases
    if form_state.has_unsaved_changes() {
        return Ok(
            "Unsaved changes. Save (Ctrl+S) or Revert (Ctrl+R) before navigating."
@@ -21,56 +17,29 @@ pub async fn handle_action(
        );
    }

+    let total_count = form_state.total_count;
+
    match action {
        "previous_entry" => {
-            let new_position = form_state.current_position.saturating_sub(1);
-            if new_position >= 1 {
-                form_state.current_position = new_position;
-                *current_position = new_position;
-                
-                if new_position <= form_state.total_count {
-                    let load_message = UiService::load_table_data_by_position(grpc_client, form_state).await?;
-                    
-                    let current_input = form_state.get_current_input();
-                    let max_cursor_pos = if !current_input.is_empty() {
-                        current_input.len() - 1
-                    } else { 0 };
-                    form_state.current_cursor_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                    
-                    Ok(load_message)
-                } else {
-                    Ok(format!("Moved to position {}", new_position))
-                }
-            } else {
-                Ok("Already at first position".into())
+            // Only decrement if the current position is greater than the first record.
+            // This prevents wrapping from 1 to total_count.
+            // It also correctly handles moving from "New Entry" (total_count + 1) to the last record.
+            if form_state.current_position > 1 {
+                form_state.current_position -= 1;
+                *ideal_cursor_column = 0;
            }
        }
        "next_entry" => {
-            if form_state.current_position <= form_state.total_count {
+            // Only increment if the current position is not yet at the "New Entry" stage.
+            // The "New Entry" position is total_count + 1.
+            // This allows moving from the last record to "New Entry", but stops there.
+            if form_state.current_position <= total_count {
                form_state.current_position += 1;
-                *current_position = form_state.current_position;
-                
-                if form_state.current_position <= form_state.total_count {
-                    let load_message = UiService::load_table_data_by_position(grpc_client, form_state).await?;
-                    
-                    let current_input = form_state.get_current_input();
-                    let max_cursor_pos = if !current_input.is_empty() {
-                        current_input.len() - 1
-                    } else { 0 };
-                    form_state.current_cursor_pos = (*ideal_cursor_column).min(max_cursor_pos);
-                    
-                    Ok(load_message)
-                } else {
-                    form_state.reset_to_empty();
-                    form_state.current_field = 0;
-                    form_state.current_cursor_pos = 0;
-                    *ideal_cursor_column = 0;
-                    Ok("New form entry mode".into())
-                }
-            } else {
-                Ok("Already at last entry".into())
+                *ideal_cursor_column = 0;
            }
        }
-        _ => Err(anyhow!("Unknown form action: {}", action))
+        _ => return Err(anyhow!("Unknown form action: {}", action)),
    }
+
+    Ok(String::new())
 }
--- a/client/src/ui/handlers/render.rs
+++ b/client/src/ui/handlers/render.rs
@@ -1,34 +1,36 @@
-// client/src/ui/handlers/render.rs
+// src/ui/handlers/render.rs

 use crate::components::{
+    admin::add_logic::render_add_logic,
+    admin::render_add_table,
+    auth::{login::render_login, register::render_register},
+    common::dialog::render_dialog,
+    common::find_file_palette,
+    common::search_palette::render_search_palette,
+    form::form::render_form,
+    handlers::sidebar::{self, calculate_sidebar_layout},
+    intro::intro::render_intro,
    render_background,
    render_buffer_list,
    render_command_line,
    render_status_line,
-    intro::intro::render_intro,
-    handlers::sidebar::{self, calculate_sidebar_layout},
-    form::form::render_form,
-    admin::render_add_table,
-    admin::add_logic::render_add_logic,
-    auth::{login::render_login, register::render_register},
-    common::find_file_palette,
 };
 use crate::config::colors::themes::Theme;
+use crate::modes::general::command_navigation::NavigationState;
+use crate::state::pages::canvas_state::CanvasState;
+use crate::state::app::buffer::BufferState;
+use crate::state::app::highlight::HighlightState;
+use crate::state::app::state::AppState;
+use crate::state::pages::admin::AdminState;
+use crate::state::pages::auth::AuthState;
+use crate::state::pages::auth::LoginState;
+use crate::state::pages::auth::RegisterState;
+use crate::state::pages::form::FormState;
+use crate::state::pages::intro::IntroState;
 use ratatui::{
    layout::{Constraint, Direction, Layout},
    Frame,
 };
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::pages::form::FormState;
-use crate::state::pages::auth::AuthState;
-use crate::state::pages::auth::LoginState;
-use crate::state::pages::auth::RegisterState;
-use crate::state::pages::intro::IntroState;
-use crate::state::app::buffer::BufferState;
-use crate::state::app::state::AppState;
-use crate::state::pages::admin::AdminState;
-use crate::state::app::highlight::HighlightState;
-use crate::modes::general::command_navigation::NavigationState;

 #[allow(clippy::too_many_arguments)]
 pub fn render_ui(
@@ -53,16 +55,28 @@ pub fn render_ui(
 ) {
    render_background(f, f.area(), theme);

+    // --- START DYNAMIC LAYOUT LOGIC ---
+    let mut status_line_height = 1;
+    #[cfg(feature = "ui-debug")]
+    {
+        if let Some(debug_state) = &app_state.debug_state {
+            if debug_state.is_error {
+                status_line_height = 4;
+            }
+        }
+    }
+    // --- END DYNAMIC LAYOUT LOGIC ---
+
    const PALETTE_OPTIONS_HEIGHT_FOR_LAYOUT: u16 = 15;

-    let mut bottom_area_constraints: Vec<Constraint> = vec![Constraint::Length(1)];

+    let mut bottom_area_constraints: Vec<Constraint> = vec![Constraint::Length(status_line_height)];
    let command_palette_area_height = if navigation_state.active {
        1 + PALETTE_OPTIONS_HEIGHT_FOR_LAYOUT
    } else if event_handler_command_mode_active {
        1
    } else {
-        0 // Neither is active
+        0
    };

    if command_palette_area_height > 0 {
@@ -75,7 +89,6 @@ pub fn render_ui(
    }
    main_layout_constraints.extend(bottom_area_constraints);

-
    let root_chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints(main_layout_constraints)
@@ -106,63 +119,94 @@ pub fn render_ui(
        None
    };

-
    if app_state.ui.show_intro {
        render_intro(f, intro_state, main_content_area, theme);
    } else if app_state.ui.show_register {
        render_register(
-            f, main_content_area, theme, register_state, app_state,
+            f,
+            main_content_area,
+            theme,
+            register_state,
+            app_state,
            register_state.current_field() < 4,
            highlight_state,
        );
    } else if app_state.ui.show_add_table {
        render_add_table(
-            f, main_content_area, theme, app_state, &mut admin_state.add_table_state,
+            f,
+            main_content_area,
+            theme,
+            app_state,
+            &mut admin_state.add_table_state,
            is_event_handler_edit_mode,
            highlight_state,
        );
    } else if app_state.ui.show_add_logic {
        render_add_logic(
-            f, main_content_area, theme, app_state, &mut admin_state.add_logic_state,
-            is_event_handler_edit_mode, highlight_state,
+            f,
+            main_content_area,
+            theme,
+            app_state,
+            &mut admin_state.add_logic_state,
+            is_event_handler_edit_mode,
+            highlight_state,
        );
    } else if app_state.ui.show_login {
        render_login(
-            f, main_content_area, theme, login_state, app_state,
+            f,
+            main_content_area,
+            theme,
+            login_state,
+            app_state,
            login_state.current_field() < 2,
            highlight_state,
        );
    } else if app_state.ui.show_admin {
        crate::components::admin::admin_panel::render_admin_panel(
-            f, app_state, auth_state, admin_state, main_content_area, theme,
-            &app_state.profile_tree, &app_state.selected_profile,
+            f,
+            app_state,
+            auth_state,
+            admin_state,
+            main_content_area,
+            theme,
+            &app_state.profile_tree,
+            &app_state.selected_profile,
        );
    } else if app_state.ui.show_form {
-        let (sidebar_area, form_actual_area) = calculate_sidebar_layout(
-            app_state.ui.show_sidebar, main_content_area
-        );
+        let (sidebar_area, form_actual_area) =
+            calculate_sidebar_layout(app_state.ui.show_sidebar, main_content_area);
        if let Some(sidebar_rect) = sidebar_area {
            sidebar::render_sidebar(
-                f, sidebar_rect, theme, &app_state.profile_tree, &app_state.selected_profile
+                f,
+                sidebar_rect,
+                theme,
+                &app_state.profile_tree,
+                &app_state.selected_profile,
            );
        }
        let available_width = form_actual_area.width;
        let form_render_area = if available_width >= 80 {
-            Layout::default().direction(Direction::Horizontal)
+            Layout::default()
+                .direction(Direction::Horizontal)
                .constraints([Constraint::Min(0), Constraint::Length(80), Constraint::Min(0)])
                .split(form_actual_area)[1]
        } else {
-            Layout::default().direction(Direction::Horizontal)
-                .constraints([Constraint::Min(0), Constraint::Length(available_width), Constraint::Min(0)])
+            Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([
+                    Constraint::Min(0),
+                    Constraint::Length(available_width),
+                    Constraint::Min(0),
+                ])
                .split(form_actual_area)[1]
        };
-        let fields_vec: Vec<&str> = form_state.fields.iter().map(AsRef::as_ref).collect();
-        let values_vec: Vec<&String> = form_state.values.iter().collect();
-        render_form(
-            f, form_render_area, form_state, &fields_vec, &form_state.current_field,
-            &values_vec, theme, is_event_handler_edit_mode, highlight_state,
-            form_state.total_count,
-            form_state.current_position,
+        
+        form_state.render(
+            f,
+            form_render_area,
+            theme,
+            is_event_handler_edit_mode,
+            highlight_state,
        );
    }

@@ -170,25 +214,51 @@ pub fn render_ui(
        render_buffer_list(f, area, theme, buffer_state, app_state);
    }

-    render_status_line(f, status_line_area, current_dir, theme, is_event_handler_edit_mode, current_fps);
+    render_status_line(
+        f,
+        status_line_area,
+        current_dir,
+        theme,
+        is_event_handler_edit_mode,
+        current_fps,
+        app_state,
+    );

-    if let Some(palette_or_command_area) = command_render_area { // Use the calculated area
+    if let Some(palette_or_command_area) = command_render_area {
        if navigation_state.active {
            find_file_palette::render_find_file_palette(
                f,
-                palette_or_command_area, // Use the correct area
+                palette_or_command_area,
                theme,
-                navigation_state, // Pass the navigation_state directly
+                navigation_state,
            );
        } else if event_handler_command_mode_active {
            render_command_line(
                f,
-                palette_or_command_area, // Use the correct area
+                palette_or_command_area,
                event_handler_command_input,
-                true, // Assuming it's always active when this branch is hit
+                true,
                theme,
                event_handler_command_message,
            );
        }
    }
+
+    // This block now correctly handles drawing popups over any view.
+    if app_state.ui.show_search_palette {
+        if let Some(search_state) = &app_state.search_state {
+            render_search_palette(f, f.area(), theme, search_state);
+        }
+    } else if app_state.ui.dialog.dialog_show {
+        render_dialog(
+            f,
+            f.area(),
+            theme,
+            &app_state.ui.dialog.dialog_title,
+            &app_state.ui.dialog.dialog_message,
+            &app_state.ui.dialog.dialog_buttons,
+            app_state.ui.dialog.dialog_active_button_index,
+            app_state.ui.dialog.is_loading,
+        );
+    }
 }
--- a/client/src/ui/handlers/ui.rs
+++ b/client/src/ui/handlers/ui.rs
@@ -9,7 +9,7 @@ use crate::modes::common::commands::CommandHandler;
 use crate::modes::handlers::event::{EventHandler, EventOutcome};
 use crate::modes::handlers::mode_manager::{AppMode, ModeManager};
 use crate::state::pages::canvas_state::CanvasState;
-use crate::state::pages::form::FormState;
+use crate::state::pages::form::{FormState, FieldDefinition}; // Import FieldDefinition
 use crate::state::pages::auth::AuthState;
 use crate::state::pages::auth::LoginState;
 use crate::state::pages::auth::RegisterState;
@@ -26,12 +26,17 @@ use crate::tui::functions::common::register::RegisterResult;
 use crate::ui::handlers::context::DialogPurpose;
 use crate::tui::functions::common::login;
 use crate::tui::functions::common::register;
-use std::time::Instant;
+use crate::utils::columns::filter_user_columns;
 use anyhow::{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};
+#[cfg(feature = "ui-debug")]
+use crate::state::app::state::DebugState;
+#[cfg(feature = "ui-debug")]
+use crate::utils::debug_logger::pop_next_debug_message;

 pub async fn run_ui() -> Result<()> {
    let config = Config::load().context("Failed to load configuration")?;
@@ -50,6 +55,7 @@ pub async fn run_ui() -> Result<()> {
        register_result_sender.clone(),
        save_table_result_sender.clone(),
        save_logic_result_sender.clone(),
+        grpc_client.clone(),
    )
    .await
    .context("Failed to create event handler")?;
@@ -81,16 +87,25 @@ pub async fn run_ui() -> Result<()> {
        }
    }

-    // Initialize AppState and FormState with table data
-    let (initial_profile, initial_table, initial_columns) =
+    let (initial_profile, initial_table, initial_columns_from_service) =
        UiService::initialize_app_state_and_form(&mut grpc_client, &mut app_state)
            .await
            .context("Failed to initialize app state and form")?;

+    let initial_field_defs: Vec<FieldDefinition> = filter_user_columns(initial_columns_from_service)
+        .into_iter()
+        .map(|col_name| FieldDefinition {
+            display_name: col_name.clone(),
+            data_key: col_name,
+            is_link: false,
+            link_target_table: None,
+        })
+        .collect();
+
    let mut form_state = FormState::new(
        initial_profile.clone(),
        initial_table.clone(),
-        initial_columns,
+        initial_field_defs,
    );

    UiService::fetch_and_set_table_count(&mut grpc_client, &mut form_state)
@@ -100,7 +115,6 @@ pub async fn run_ui() -> Result<()> {
            initial_profile, initial_table
        ))?;

-    // Load initial data for the form
    if form_state.total_count > 0 {
        if let Err(e) = UiService::load_table_data_by_position(&mut grpc_client, &mut form_state).await {
            event_handler.command_message = format!("Error loading initial data: {}", e);
@@ -120,214 +134,63 @@ pub async fn run_ui() -> Result<()> {
    let mut needs_redraw = true;
    let mut prev_view_profile_name = app_state.current_view_profile_name.clone();
    let mut prev_view_table_name = app_state.current_view_table_name.clone();
+    let mut table_just_switched = false;

    loop {
-        if let Some(active_view) = buffer_state.get_active_view() {
-            app_state.ui.show_intro = false;
-            app_state.ui.show_login = false;
-            app_state.ui.show_register = false;
-            app_state.ui.show_admin = false;
-            app_state.ui.show_add_table = false;
-            app_state.ui.show_add_logic = false;
-            app_state.ui.show_form = false;
-            match active_view {
-                AppView::Intro => app_state.ui.show_intro = true,
-                AppView::Login => app_state.ui.show_login = true,
-                AppView::Register => app_state.ui.show_register = true,
-                AppView::Admin => {
-                    info!("Active view is Admin, refreshing profile tree...");
-                    match grpc_client.get_profile_tree().await {
-                        Ok(refreshed_tree) => {
-                            app_state.profile_tree = refreshed_tree;
-                        }
-                        Err(e) => {
-                            error!("Failed to refresh profile tree for Admin panel: {}", e);
-                            event_handler.command_message = format!("Error refreshing admin data: {}", e);
-                        }
-                    }
-                    app_state.ui.show_admin = true;
-                    let profile_names = app_state.profile_tree.profiles.iter()
-                        .map(|p| p.name.clone())
-                        .collect();
-                    admin_state.set_profiles(profile_names);
-
-                    if admin_state.current_focus == AdminFocus::default() ||
-                       !matches!(admin_state.current_focus,
-                                AdminFocus::InsideProfilesList |
-                                AdminFocus::Tables | AdminFocus::InsideTablesList |
-                                AdminFocus::Button1 | AdminFocus::Button2 | AdminFocus::Button3) {
-                         admin_state.current_focus = AdminFocus::ProfilesPane;
-                    }
-                    if admin_state.profile_list_state.selected().is_none() && !app_state.profile_tree.profiles.is_empty() {
-                        admin_state.profile_list_state.select(Some(0));
-                    }
-                }
-                AppView::AddTable => app_state.ui.show_add_table = true,
-                AppView::AddLogic => app_state.ui.show_add_logic = true,
-                AppView::Form => app_state.ui.show_form = true,
-                AppView::Scratch => {}
-            }
-        }
-
-        // Handle table change for FormView
-        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();
-
-            if prev_view_profile_name != current_view_profile || prev_view_table_name != current_view_table {
-                if let (Some(prof_name), Some(tbl_name)) = (current_view_profile.as_ref(), current_view_table.as_ref()) {
-                    app_state.show_loading_dialog("Loading Table", &format!("Fetching data for {}.{}...", prof_name, tbl_name));
-                    needs_redraw = true;
-
-                    match grpc_client.get_table_structure(prof_name.clone(), tbl_name.clone()).await {
-                        Ok(structure_response) => {
-                            let new_columns: Vec<String> = structure_response.columns.iter().map(|c| c.name.clone()).collect();
-                            form_state = FormState::new(prof_name.clone(), tbl_name.clone(), new_columns);
-
-                            if let Err(e) = UiService::fetch_and_set_table_count(&mut grpc_client, &mut form_state).await {
-                                app_state.update_dialog_content(&format!("Error fetching count: {}", e), vec!["OK".to_string()], DialogPurpose::LoginFailed);
-                            } else {
-                                if form_state.total_count > 0 {
-                                    if let Err(e) = UiService::load_table_data_by_position(&mut grpc_client, &mut form_state).await {
-                                         app_state.update_dialog_content(&format!("Error loading data: {}", e), vec!["OK".to_string()], DialogPurpose::LoginFailed);
-                                    } else {
-                                        app_state.hide_dialog();
-                                    }
-                                } else {
-                                    form_state.reset_to_empty();
-                                    app_state.hide_dialog();
-                                }
-                            }
-                        }
-                        Err(e) => {
-                            app_state.update_dialog_content(&format!("Error fetching table structure: {}", e), vec!["OK".to_string()], DialogPurpose::LoginFailed);
-                            app_state.current_view_profile_name = prev_view_profile_name.clone();
-                            app_state.current_view_table_name = prev_view_table_name.clone();
-                        }
-                    }
-                }
-                prev_view_profile_name = current_view_profile;
-                prev_view_table_name = current_view_table;
-                needs_redraw = true;
-            }
-        }
-
-        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 &&
-                   admin_state.add_logic_state.selected_table_name.as_deref() == Some(table_name.as_str()) {
-                    info!("Fetching table structure for {}.{}", profile_name, table_name);
-                    let fetch_message = UiService::initialize_add_logic_table_data(
-                        &mut grpc_client,
-                        &mut admin_state.add_logic_state,
-                        &app_state.profile_tree,
-                    ).await.unwrap_or_else(|e| {
-                        error!("Error initializing add_logic_table_data: {}", e);
-                        format!("Error fetching table structure: {}", e)
-                    });
-
-                    if !fetch_message.contains("Error") && !fetch_message.contains("Warning") {
-                        info!("{}", fetch_message);
-                    } else {
-                        event_handler.command_message = fetch_message;
-                    }
-                    needs_redraw = true;
-                } else {
-                    error!(
-                        "Mismatch in pending_table_structure_fetch: app_state wants {}.{}, but add_logic_state is for {}.{:?}",
-                        profile_name, table_name,
-                        admin_state.add_logic_state.profile_name,
-                        admin_state.add_logic_state.selected_table_name
-                    );
-                }
-            } else {
-                warn!(
-                    "Pending table structure fetch for {}.{} but AddLogic view is not active. Fetch ignored.",
-                    profile_name, table_name
-                );
-            }
-        }
-
-        if needs_redraw {
-            terminal.draw(|f| {
-                render_ui(
-                    f,
-                    &mut form_state,
-                    &mut auth_state,
-                    &login_state,
-                    &register_state,
-                    &intro_state,
-                    &mut admin_state,
-                    &buffer_state,
-                    &theme,
-                    event_handler.is_edit_mode,
-                    &event_handler.highlight_state,
-                    &event_handler.command_input,
-                    event_handler.command_mode,
-                    &event_handler.command_message,
-                    &event_handler.navigation_state,
-                    &app_state.current_dir,
-                    current_fps,
-                    &app_state,
-                );
-            }).context("Terminal draw call failed")?;
-            needs_redraw = false;
-        }
-
-        if let Some(table_name) = admin_state.add_logic_state.script_editor_awaiting_column_autocomplete.clone() {
-            if app_state.ui.show_add_logic {
-                let profile_name = admin_state.add_logic_state.profile_name.clone();
-
-                info!("Fetching columns for table selection: {}.{}", profile_name, table_name);
-                match UiService::fetch_columns_for_table(&mut grpc_client, &profile_name, &table_name).await {
-                    Ok(columns) => {
-                        admin_state.add_logic_state.set_columns_for_table_autocomplete(columns.clone());
-                        info!("Loaded {} columns for table '{}'", columns.len(), table_name);
-                        event_handler.command_message = format!("Columns for '{}' loaded. Select a column.", table_name);
-                    }
-                    Err(e) => {
-                        error!("Failed to fetch columns for {}.{}: {}", profile_name, table_name, e);
-                        admin_state.add_logic_state.script_editor_awaiting_column_autocomplete = None;
-                        admin_state.add_logic_state.deactivate_script_editor_autocomplete();
-                        event_handler.command_message = format!("Error loading columns for '{}': {}", table_name, e);
-                    }
-                }
-                needs_redraw = true;
-            }
-        }
-
-        let current_mode = ModeManager::derive_mode(&app_state, &event_handler, &admin_state);
-        match current_mode {
-            AppMode::Edit => { terminal.show_cursor()?; }
-            AppMode::Highlight => { terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?; terminal.show_cursor()?; }
-            AppMode::ReadOnly => {
-                if !app_state.ui.focus_outside_canvas { terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?; }
-                else { terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?; }
-                terminal.show_cursor().context("Failed to show cursor in ReadOnly mode")?;
-            }
-            AppMode::General => {
-                if app_state.ui.focus_outside_canvas { terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?; terminal.show_cursor()?; }
-                else { terminal.hide_cursor()?; }
-            }
-            AppMode::Command => { terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?; terminal.show_cursor().context("Failed to show cursor in Command mode")?; }
-        }
-
        let position_before_event = form_state.current_position;
+        let mut event_processed = false;

-        if app_state.ui.dialog.is_loading {
+        // --- CHANNEL RECEIVERS ---
+
+        // For main search palette
+        match event_handler.search_result_receiver.try_recv() {
+            Ok(hits) => {
+                info!("--- 4. Main loop received message from channel. ---");
+                if let Some(search_state) = app_state.search_state.as_mut() {
+                    search_state.results = hits;
+                    search_state.is_loading = false;
+                }
+                needs_redraw = true;
+            }
+            Err(mpsc::error::TryRecvError::Empty) => {
+            }
+            Err(mpsc::error::TryRecvError::Disconnected) => {
+                error!("Search result channel disconnected!");
+            }
+        }
+
+        // --- ADDED: For live form autocomplete ---
+        match event_handler.autocomplete_result_receiver.try_recv() {
+            Ok(hits) => {
+                if form_state.autocomplete_active {
+                    form_state.autocomplete_suggestions = hits;
+                    form_state.autocomplete_loading = false;
+                    if !form_state.autocomplete_suggestions.is_empty() {
+                        form_state.selected_suggestion_index = Some(0);
+                    } else {
+                        form_state.selected_suggestion_index = None;
+                    }
+                    event_handler.command_message = format!("Found {} suggestions.", form_state.autocomplete_suggestions.len());
+                }
+                needs_redraw = true;
+            }
+            Err(mpsc::error::TryRecvError::Empty) => {}
+            Err(mpsc::error::TryRecvError::Disconnected) => {
+                error!("Autocomplete result channel disconnected!");
+            }
+        }
+
+
+        if app_state.ui.show_search_palette {
            needs_redraw = true;
        }
-
-        let mut event_outcome_result = Ok(EventOutcome::Ok(String::new()));
-        let mut event_processed = false;
        if crossterm_event::poll(std::time::Duration::from_millis(1))? {
            let event = event_reader.read_event().context("Failed to read terminal event")?;
            event_processed = true;
-            event_outcome_result = event_handler.handle_event(
+            let event_outcome_result = event_handler.handle_event(
                event,
                &config,
                &mut terminal,
-                &mut grpc_client,
                &mut command_handler,
                &mut form_state,
                &mut auth_state,
@@ -338,10 +201,53 @@ pub async fn run_ui() -> Result<()> {
                &mut buffer_state,
                &mut app_state,
            ).await;
-        }

-        if event_processed {
-            needs_redraw = true;
+            let mut should_exit = false;
+            match event_outcome_result {
+                Ok(outcome) => match outcome {
+                    EventOutcome::Ok(message) => {
+                        if !message.is_empty() {
+                            event_handler.command_message = message;
+                        }
+                    }
+                    EventOutcome::Exit(message) => {
+                        event_handler.command_message = message;
+                        should_exit = true;
+                    }
+                    EventOutcome::DataSaved(save_outcome, message) => {
+                        event_handler.command_message = message;
+                        if let Err(e) = UiService::handle_save_outcome(
+                            save_outcome,
+                            &mut grpc_client,
+                            &mut app_state,
+                            &mut form_state,
+                        ).await {
+                            event_handler.command_message =
+                                format!("Error handling save outcome: {}", e);
+                        }
+                    }
+                    EventOutcome::ButtonSelected { .. } => {}
+                    EventOutcome::TableSelected { path } => {
+                        let parts: Vec<&str> = path.split('/').collect();
+                        if parts.len() == 2 {
+                            let profile_name = parts[0].to_string();
+                            let table_name = parts[1].to_string();
+
+                            app_state.set_current_view_table(profile_name, table_name);
+                            buffer_state.update_history(AppView::Form);
+                            event_handler.command_message = format!("Loading table: {}", path);
+                        } else {
+                            event_handler.command_message = format!("Invalid table path: {}", path);
+                        }
+                    }
+                },
+                Err(e) => {
+                    event_handler.command_message = format!("Error: {}", e);
+                }
+            }
+            if should_exit {
+                return Ok(());
+            }
        }

        match login_result_receiver.try_recv() {
@@ -393,62 +299,216 @@ pub async fn run_ui() -> Result<()> {
            }
        }

-        let mut should_exit = false;
-        match event_outcome_result {
-            Ok(outcome) => match outcome {
-                EventOutcome::Ok(_message) => {}
-                EventOutcome::Exit(message) => {
-                    event_handler.command_message = message;
-                    should_exit = true;
-                }
-                EventOutcome::DataSaved(save_outcome, message) => {
-                    event_handler.command_message = message;
-                    if let Err(e) = UiService::handle_save_outcome(
-                        save_outcome,
-                        &mut grpc_client,
-                        &mut app_state,
-                        &mut form_state,
-                    )
-                    .await
-                    {
-                        event_handler.command_message =
-                            format!("Error handling save outcome: {}", e);
+        if let Some(active_view) = buffer_state.get_active_view() {
+            app_state.ui.show_intro = false;
+            app_state.ui.show_login = false;
+            app_state.ui.show_register = false;
+            app_state.ui.show_admin = false;
+            app_state.ui.show_add_table = false;
+            app_state.ui.show_add_logic = false;
+            app_state.ui.show_form = false;
+            match active_view {
+                AppView::Intro => app_state.ui.show_intro = true,
+                AppView::Login => app_state.ui.show_login = true,
+                AppView::Register => app_state.ui.show_register = true,
+                AppView::Admin => {
+                    info!("Active view is Admin, refreshing profile tree...");
+                    match grpc_client.get_profile_tree().await {
+                        Ok(refreshed_tree) => {
+                            app_state.profile_tree = refreshed_tree;
+                        }
+                        Err(e) => {
+                            error!("Failed to refresh profile tree for Admin panel: {}", e);
+                            event_handler.command_message = format!("Error refreshing admin data: {}", e);
+                        }
+                    }
+                    app_state.ui.show_admin = true;
+                    let profile_names = app_state.profile_tree.profiles.iter()
+                        .map(|p| p.name.clone())
+                        .collect();
+                    admin_state.set_profiles(profile_names);
+
+                    if admin_state.current_focus == AdminFocus::default() ||
+                    !matches!(admin_state.current_focus,
+                                AdminFocus::InsideProfilesList |
+                                AdminFocus::Tables | AdminFocus::InsideTablesList |
+                                AdminFocus::Button1 | AdminFocus::Button2 | AdminFocus::Button3) {
+                        admin_state.current_focus = AdminFocus::ProfilesPane;
+                    }
+                    if admin_state.profile_list_state.selected().is_none() && !app_state.profile_tree.profiles.is_empty() {
+                        admin_state.profile_list_state.select(Some(0));
                    }
                }
-                EventOutcome::ButtonSelected { context: _, index: _ } => {}
-            },
-            Err(e) => {
-                event_handler.command_message = format!("Error: {}", e);
+                AppView::AddTable => app_state.ui.show_add_table = true,
+                AppView::AddLogic => app_state.ui.show_add_logic = true,
+                AppView::Form => app_state.ui.show_form = true,
+                AppView::Scratch => {}
+            }
+        }
+
+        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();
+
+            // This condition correctly detects a table switch.
+            if prev_view_profile_name != current_view_profile
+                || prev_view_table_name != current_view_table
+            {
+                if let (Some(prof_name), Some(tbl_name)) =
+                    (current_view_profile.as_ref(), current_view_table.as_ref())
+                {
+                    // --- START OF REFACTORED LOGIC ---
+                    app_state.show_loading_dialog(
+                        "Loading Table",
+                        &format!("Fetching data for {}.{}...", prof_name, tbl_name),
+                    );
+                    needs_redraw = true;
+
+                    // 1. Call our new, central function. It handles fetching AND caching.
+                    match UiService::load_table_view(
+                        &mut grpc_client,
+                        &mut app_state,
+                        prof_name,
+                        tbl_name,
+                    )
+                    .await
+                    {
+                        Ok(mut new_form_state) => {
+                            // 2. The function succeeded, we have a new FormState.
+                            //    Now, fetch its data.
+                            if let Err(e) = UiService::fetch_and_set_table_count(
+                                &mut grpc_client,
+                                &mut new_form_state,
+                            )
+                            .await
+                            {
+                                // Handle count fetching error
+                                app_state.update_dialog_content(
+                                    &format!("Error fetching count: {}", e),
+                                    vec!["OK".to_string()],
+                                    DialogPurpose::LoginFailed, // Or a more appropriate purpose
+                                );
+                            } else if new_form_state.total_count > 0 {
+                                // If there are records, load the first/last one
+                                if let Err(e) = UiService::load_table_data_by_position(
+                                    &mut grpc_client,
+                                    &mut new_form_state,
+                                )
+                                .await
+                                {
+                                    // Handle data loading error
+                                    app_state.update_dialog_content(
+                                        &format!("Error loading data: {}", e),
+                                        vec!["OK".to_string()],
+                                        DialogPurpose::LoginFailed, // Or a more appropriate purpose
+                                    );
+                                } else {
+                                    // Success! Hide the loading dialog.
+                                    app_state.hide_dialog();
+                                }
+                            } else {
+                                // No records, so just reset to an empty form.
+                                new_form_state.reset_to_empty();
+                                app_state.hide_dialog();
+                            }
+
+                            // 3. CRITICAL: Replace the old form_state with the new one.
+                            form_state = new_form_state;
+
+                            // 4. Update our tracking variables.
+                            prev_view_profile_name = current_view_profile;
+                            prev_view_table_name = current_view_table;
+                            table_just_switched = true;
+                        }
+                        Err(e) => {
+                            // This handles errors from load_table_view (e.g., schema fetch failed)
+                            app_state.update_dialog_content(
+                                &format!("Error loading table: {}", e),
+                                vec!["OK".to_string()],
+                                DialogPurpose::LoginFailed, // Or a more appropriate purpose
+                            );
+                            // Revert the view change in app_state to avoid a loop
+                            app_state.current_view_profile_name =
+                                prev_view_profile_name.clone();
+                            app_state.current_view_table_name =
+                                prev_view_table_name.clone();
+                        }
+                    }
+                    // --- END OF REFACTORED LOGIC ---
+                }
+                needs_redraw = true;
+            }
+        }
+
+        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 &&
+                admin_state.add_logic_state.selected_table_name.as_deref() == Some(table_name.as_str()) {
+                    info!("Fetching table structure for {}.{}", profile_name, table_name);
+                    let fetch_message = UiService::initialize_add_logic_table_data(
+                        &mut grpc_client,
+                        &mut admin_state.add_logic_state,
+                        &app_state.profile_tree,
+                    ).await.unwrap_or_else(|e| {
+                        error!("Error initializing add_logic_table_data: {}", e);
+                        format!("Error fetching table structure: {}", e)
+                    });
+
+                    if !fetch_message.contains("Error") && !fetch_message.contains("Warning") {
+                        info!("{}", fetch_message);
+                    } else {
+                        event_handler.command_message = fetch_message;
+                    }
+                    needs_redraw = true;
+                } else {
+                    error!(
+                        "Mismatch in pending_table_structure_fetch: app_state wants {}.{}, but add_logic_state is for {}.{:?}",
+                        profile_name, table_name,
+                        admin_state.add_logic_state.profile_name,
+                        admin_state.add_logic_state.selected_table_name
+                    );
+                }
+            } else {
+                warn!(
+                    "Pending table structure fetch for {}.{} but AddLogic view is not active. Fetch ignored.",
+                    profile_name, table_name
+                );
+            }
+        }
+
+        if let Some(table_name) = admin_state.add_logic_state.script_editor_awaiting_column_autocomplete.clone() {
+            if app_state.ui.show_add_logic {
+                let profile_name = admin_state.add_logic_state.profile_name.clone();
+
+                info!("Fetching columns for table selection: {}.{}", profile_name, table_name);
+                match UiService::fetch_columns_for_table(&mut grpc_client, &profile_name, &table_name).await {
+                    Ok(columns) => {
+                        admin_state.add_logic_state.set_columns_for_table_autocomplete(columns.clone());
+                        info!("Loaded {} columns for table '{}'", columns.len(), table_name);
+                        event_handler.command_message = format!("Columns for '{}' loaded. Select a column.", table_name);
+                    }
+                    Err(e) => {
+                        error!("Failed to fetch columns for {}.{}: {}", profile_name, table_name, e);
+                        admin_state.add_logic_state.script_editor_awaiting_column_autocomplete = None;
+                        admin_state.add_logic_state.deactivate_script_editor_autocomplete();
+                        event_handler.command_message = format!("Error loading columns for '{}': {}", table_name, e);
+                    }
+                }
+                needs_redraw = true;
            }
        }

-// --- MODIFIED: Position Change Handling (operates on form_state) ---
        let position_changed = form_state.current_position != position_before_event;
        let mut position_logic_needs_redraw = false;

-        if app_state.ui.show_form { // Only if the form is active
+        if app_state.ui.show_form && !table_just_switched {
            if position_changed && !event_handler.is_edit_mode {
-                // This part is okay: update cursor for the current field BEFORE loading new data
-                let current_input_before_load = form_state.get_current_input();
-                let max_cursor_pos_before_load = if !current_input_before_load.is_empty() { current_input_before_load.chars().count() } else { 0 };
-                form_state.current_cursor_pos = event_handler.ideal_cursor_column.min(max_cursor_pos_before_load);
                position_logic_needs_redraw = true;

-                // Validate new form_state.current_position
-                if form_state.total_count > 0 && form_state.current_position > form_state.total_count + 1 {
-                    form_state.current_position = form_state.total_count + 1; // Cap at new entry
-                } else if form_state.total_count == 0 && form_state.current_position > 1 {
-                    form_state.current_position = 1; // Cap at new entry for empty table
-                }
-                if form_state.current_position == 0 && form_state.total_count > 0 {
-                     form_state.current_position = 1; // Don't allow 0 if there are records
-                }
-
-
-                // Load data for the new position OR reset for new entry
-                if (form_state.total_count > 0 && form_state.current_position <= form_state.total_count && form_state.current_position > 0)
-                {
-                    // It's an existing record position
+                if form_state.current_position > form_state.total_count {
+                    form_state.reset_to_empty();
+                    event_handler.command_message = format!("New entry for {}.{}", form_state.profile_name, form_state.table_name);
+                } else {
                    match UiService::load_table_data_by_position(&mut grpc_client, &mut form_state).await {
                        Ok(load_message) => {
                            if event_handler.command_message.is_empty() || !load_message.starts_with("Error") {
@@ -457,34 +517,20 @@ pub async fn run_ui() -> Result<()> {
                        }
                        Err(e) => {
                            event_handler.command_message = format!("Error loading data: {}", e);
-                            // Consider what to do with form_state here - maybe revert position or clear form
                        }
                    }
-                } else {
-                    // Position indicates a new entry (or table is empty and position is 1)
-                    form_state.reset_to_empty(); // This sets id=0, clears values, and sets current_position correctly
-                    event_handler.command_message = format!("New entry for {}.{}", form_state.profile_name, form_state.table_name);
                }

-                // NOW, after data is loaded or form is reset, get the current input string and its length
                let current_input_after_load_str = form_state.get_current_input();
                let current_input_len_after_load = current_input_after_load_str.chars().count();
-
-                let max_cursor_pos_for_readonly_after_load = if current_input_len_after_load > 0 {
+                let max_cursor_pos = if current_input_len_after_load > 0 {
                    current_input_len_after_load.saturating_sub(1)
                } else {
                    0
                };
+                form_state.current_cursor_pos = event_handler.ideal_cursor_column.min(max_cursor_pos);

-                if event_handler.is_edit_mode {
-                    form_state.current_cursor_pos = event_handler.ideal_cursor_column.min(current_input_len_after_load);
-                } else {
-                    form_state.current_cursor_pos = event_handler.ideal_cursor_column.min(max_cursor_pos_for_readonly_after_load);
-                    // The check for empty string is implicitly handled by max_cursor_pos_for_readonly_after_load being 0
-                }
-
-            } else if !position_changed && !event_handler.is_edit_mode && app_state.ui.show_form {
-                // Update cursor if not editing and position didn't change (e.g. arrow keys within field)
+            } else if !position_changed && !event_handler.is_edit_mode {
                let current_input_str = form_state.get_current_input();
                let current_input_len = current_input_str.chars().count();
                let max_cursor_pos = if current_input_len > 0 {
@@ -512,8 +558,68 @@ pub async fn run_ui() -> Result<()> {
            needs_redraw = true;
        }

-        if should_exit {
-            return Ok(());
+        if app_state.ui.dialog.is_loading {
+            needs_redraw = true;
+        }
+
+        #[cfg(feature = "ui-debug")]
+        {
+            let can_display_next = match &app_state.debug_state {
+                Some(current) => current.display_start_time.elapsed() >= Duration::from_secs(2),
+                None => true,
+            };
+
+            if can_display_next {
+                if let Some((new_message, is_error)) = pop_next_debug_message() {
+                    app_state.debug_state = Some(DebugState {
+                        displayed_message: new_message,
+                        is_error,
+                        display_start_time: Instant::now(),
+                    });
+                }
+            }
+        }
+
+        if event_processed || needs_redraw || position_changed {
+            let current_mode = ModeManager::derive_mode(&app_state, &event_handler, &admin_state);
+            match current_mode {
+                AppMode::Edit => { terminal.show_cursor()?; }
+                AppMode::Highlight => { terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?; terminal.show_cursor()?; }
+                AppMode::ReadOnly => {
+                    if !app_state.ui.focus_outside_canvas { terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?; }
+                    else { terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?; }
+                    terminal.show_cursor().context("Failed to show cursor in ReadOnly mode")?;
+                }
+                AppMode::General => {
+                    if app_state.ui.focus_outside_canvas { terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?; terminal.show_cursor()?; }
+                    else { terminal.hide_cursor()?; }
+                }
+                AppMode::Command => { terminal.set_cursor_style(SetCursorStyle::SteadyUnderScore)?; terminal.show_cursor().context("Failed to show cursor in Command mode")?; }
+            }
+
+            terminal.draw(|f| {
+                render_ui(
+                    f,
+                    &mut form_state,
+                    &mut auth_state,
+                    &login_state,
+                    &register_state,
+                    &intro_state,
+                    &mut admin_state,
+                    &buffer_state,
+                    &theme,
+                    event_handler.is_edit_mode,
+                    &event_handler.highlight_state,
+                    &event_handler.command_input,
+                    event_handler.command_mode,
+                    &event_handler.command_message,
+                    &event_handler.navigation_state,
+                    &app_state.current_dir,
+                    current_fps,
+                    &app_state,
+                );
+            }).context("Terminal draw call failed")?;
+            needs_redraw = false;
        }

        let now = Instant::now();
@@ -522,5 +628,7 @@ pub async fn run_ui() -> Result<()> {
        if frame_duration.as_secs_f64() > 1e-6 {
            current_fps = 1.0 / frame_duration.as_secs_f64();
        }
+
+        table_just_switched = false;
    }
 }
--- a/client/src/utils/columns.rs
+++ b/client/src/utils/columns.rs
@@ -0,0 +1,14 @@
+// src/utils/columns.rs
+pub fn is_system_column(column_name: &str) -> bool {
+    match column_name {
+        "id" | "deleted" | "created_at" => true,
+        name if name.ends_with("_id") => true,
+        _ => false,
+    }
+}
+
+pub fn filter_user_columns(all_columns: Vec<String>) -> Vec<String> {
+    all_columns.into_iter()
+        .filter(|col| !is_system_column(col))
+        .collect()
+}
--- a/client/src/utils/data_converter.rs
+++ b/client/src/utils/data_converter.rs
@@ -0,0 +1,50 @@
+// src/utils/data_converter.rs
+
+use common::proto::multieko2::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()
+}
--- a/client/src/utils/debug_logger.rs
+++ b/client/src/utils/debug_logger.rs
@@ -0,0 +1,46 @@
+// client/src/utils/debug_logger.rs
+use lazy_static::lazy_static;
+use std::collections::VecDeque; // <-- FIX: Import VecDeque
+use std::io;
+use std::sync::{Arc, Mutex}; // <-- FIX: Import Mutex
+
+lazy_static! {
+    static ref UI_DEBUG_BUFFER: Arc<Mutex<VecDeque<(String, bool)>>> =
+        Arc::new(Mutex::new(VecDeque::from([(String::from("Logger initialized..."), false)])));
+}
+
+#[derive(Clone)]
+pub struct UiDebugWriter;
+
+impl Default for UiDebugWriter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl UiDebugWriter {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl io::Write for UiDebugWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let mut buffer = UI_DEBUG_BUFFER.lock().unwrap();
+        let message = String::from_utf8_lossy(buf);
+        let trimmed_message = message.trim().to_string();
+        let is_error = trimmed_message.starts_with("ERROR");
+        // Add the new message to the back of the queue
+        buffer.push_back((trimmed_message, is_error));
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+// A public function to pop the next message from the front of the queue.
+pub fn pop_next_debug_message() -> Option<(String, bool)> {
+    UI_DEBUG_BUFFER.lock().unwrap().pop_front()
+}
--- a/client/src/utils/mod.rs
+++ b/client/src/utils/mod.rs
@@ -0,0 +1,9 @@
+// src/utils/mod.rs
+
+pub mod columns;
+pub mod debug_logger;
+pub mod data_converter;
+
+pub use columns::*;
+pub use debug_logger::*;
+pub use data_converter::*;
--- a/common/Cargo.toml
+++ b/common/Cargo.toml
@@ -5,9 +5,14 @@ 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"] }

+# Search
+tantivy = { workspace = true }
+
 [build-dependencies]
 tonic-build = "0.13.0"
--- a/common/build.rs
+++ b/common/build.rs
@@ -14,6 +14,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                "proto/table_definition.proto",
                "proto/tables_data.proto",
                "proto/table_script.proto",
+                "proto/search.proto",
            ],
            &["proto"],
        )?;
--- a/common/proto/search.proto
+++ b/common/proto/search.proto
@@ -0,0 +1,20 @@
+// In common/proto/search.proto
+syntax = "proto3";
+package multieko2.search;
+
+service Searcher {
+    rpc SearchTable(SearchRequest) returns (SearchResponse);
+}
+
+message SearchRequest {
+    string table_name = 1;
+    string query = 2;
+}
+message SearchResponse {
+    message Hit {
+        int64 id = 1; // PostgreSQL row ID
+        float score = 2;
+        string content_json = 3;
+    }
+    repeated Hit hits = 1;
+}
--- a/common/proto/tables_data.proto
+++ b/common/proto/tables_data.proto
@@ -3,6 +3,7 @@ syntax = "proto3";
 package multieko2.tables_data;

 import "common.proto";
+import "google/protobuf/struct.proto";

 service TablesData {
  rpc PostTableData (PostTableDataRequest) returns (PostTableDataResponse);
@@ -16,7 +17,7 @@ service TablesData {
 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 {
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -1,4 +1,7 @@
 // common/src/lib.rs
+
+pub mod search;
+
 pub mod proto {
    pub mod multieko2 {
        pub mod adresar {
@@ -25,6 +28,9 @@ pub mod proto {
        pub mod table_script {
            include!("proto/multieko2.table_script.rs");
        }
+        pub mod search {
+            include!("proto/multieko2.search.rs");
+        }
        pub const FILE_DESCRIPTOR_SET: &[u8] =
            include_bytes!("proto/descriptor.bin");
    }
--- a/common/src/proto/descriptor.bin
+++ b/common/src/proto/descriptor.bin
--- a/common/src/proto/multieko2.search.rs
+++ b/common/src/proto/multieko2.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(
+                "/multieko2.search.Searcher/SearchTable",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("multieko2.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() {
+                "/multieko2.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 = "multieko2.search.Searcher";
+    impl<T> tonic::server::NamedService for SearcherServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}
--- a/common/src/proto/multieko2.tables_data.rs
+++ b/common/src/proto/multieko2.tables_data.rs
@@ -5,10 +5,10 @@ pub struct PostTableDataRequest {
    pub profile_name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub table_name: ::prost::alloc::string::String,
-    #[prost(map = "string, string", tag = "3")]
+    #[prost(map = "string, message", tag = "3")]
    pub data: ::std::collections::HashMap<
        ::prost::alloc::string::String,
-        ::prost::alloc::string::String,
+        ::prost_types::Value,
    >,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -28,10 +28,10 @@ pub struct PutTableDataRequest {
    pub table_name: ::prost::alloc::string::String,
    #[prost(int64, tag = "3")]
    pub id: i64,
-    #[prost(map = "string, string", tag = "4")]
+    #[prost(map = "string, message", tag = "4")]
    pub data: ::std::collections::HashMap<
        ::prost::alloc::string::String,
-        ::prost::alloc::string::String,
+        ::prost_types::Value,
    >,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
--- a/common/src/search.rs
+++ b/common/src/search.rs
@@ -0,0 +1,78 @@
+// common/src/search.rs
+
+use tantivy::schema::*;
+use tantivy::tokenizer::*;
+use tantivy::Index;
+
+/// Creates a hybrid Slovak search schema with optimized prefix fields.
+pub fn create_search_schema() -> Schema {
+    let mut schema_builder = Schema::builder();
+
+    schema_builder.add_u64_field("pg_id", INDEXED | STORED);
+
+    // FIELD 1: For prefixes (1-4 chars).
+    let short_prefix_indexing = TextFieldIndexing::default()
+        .set_tokenizer("slovak_prefix_edge")
+        .set_index_option(IndexRecordOption::WithFreqsAndPositions);
+    let short_prefix_options = TextOptions::default()
+        .set_indexing_options(short_prefix_indexing)
+        .set_stored();
+    schema_builder.add_text_field("prefix_edge", short_prefix_options);
+
+    // FIELD 2: For the full word.
+    let full_word_indexing = TextFieldIndexing::default()
+        .set_tokenizer("slovak_prefix_full")
+        .set_index_option(IndexRecordOption::WithFreqsAndPositions);
+    let full_word_options = TextOptions::default()
+        .set_indexing_options(full_word_indexing)
+        .set_stored();
+    schema_builder.add_text_field("prefix_full", full_word_options);
+
+    // NGRAM FIELD: For substring matching.
+    let ngram_field_indexing = TextFieldIndexing::default()
+        .set_tokenizer("slovak_ngram")
+        .set_index_option(IndexRecordOption::WithFreqsAndPositions);
+    let ngram_options = TextOptions::default()
+        .set_indexing_options(ngram_field_indexing)
+        .set_stored();
+    schema_builder.add_text_field("text_ngram", ngram_options);
+
+    schema_builder.build()
+}
+
+/// Registers all necessary Slovak tokenizers with the index.
+///
+/// This must be called by ANY process that opens the index
+/// to ensure the tokenizers are loaded into memory.
+pub fn register_slovak_tokenizers(index: &Index) -> tantivy::Result<()> {
+    let tokenizer_manager = index.tokenizers();
+
+    // TOKENIZER for `prefix_edge`: Edge N-gram (1-4 chars)
+    let edge_tokenizer =
+        TextAnalyzer::builder(NgramTokenizer::new(1, 4, true)?)
+            .filter(RemoveLongFilter::limit(40))
+            .filter(LowerCaser)
+            .filter(AsciiFoldingFilter)
+            .build();
+    tokenizer_manager.register("slovak_prefix_edge", edge_tokenizer);
+
+    // TOKENIZER for `prefix_full`: Simple word tokenizer
+    let full_tokenizer =
+        TextAnalyzer::builder(SimpleTokenizer::default())
+            .filter(RemoveLongFilter::limit(40))
+            .filter(LowerCaser)
+            .filter(AsciiFoldingFilter)
+            .build();
+    tokenizer_manager.register("slovak_prefix_full", full_tokenizer);
+
+    // NGRAM TOKENIZER: For substring matching.
+    let ngram_tokenizer =
+        TextAnalyzer::builder(NgramTokenizer::new(3, 3, false)?)
+            .filter(RemoveLongFilter::limit(40))
+            .filter(LowerCaser)
+            .filter(AsciiFoldingFilter)
+            .build();
+    tokenizer_manager.register("slovak_ngram", ngram_tokenizer);
+
+    Ok(())
+}
--- a/search/Cargo.toml
+++ b/search/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "search"
+version.workspace = true
+edition.workspace = true
+license = "AGPL-3.0-or-later"
+
+[dependencies]
+anyhow = { workspace = true }
+prost = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+tokio = { workspace = true }
+tonic = { workspace = true }
+tracing = { workspace = true }
+tantivy = { workspace = true }
+
+common = { path = "../common" }
+tonic-reflection = "0.13.1"
+sqlx = { version = "0.8.6", features = ["postgres"] }
--- a/search/src/lib.rs
+++ b/search/src/lib.rs
@@ -0,0 +1,302 @@
+// src/lib.rs
+
+use std::collections::HashMap;
+use std::path::Path;
+use tantivy::collector::TopDocs;
+use tantivy::query::{
+    BooleanQuery, BoostQuery, FuzzyTermQuery, Occur, Query, QueryParser,
+    TermQuery,
+};
+use tantivy::schema::{IndexRecordOption, Value};
+use tantivy::{Index, TantivyDocument, Term};
+use tonic::{Request, Response, Status};
+
+use common::proto::multieko2::search::{
+    search_response::Hit, SearchRequest, SearchResponse,
+};
+pub use common::proto::multieko2::search::searcher_server::SearcherServer;
+use common::proto::multieko2::search::searcher_server::Searcher;
+use common::search::register_slovak_tokenizers;
+use sqlx::{PgPool, Row};
+use tracing::info;
+
+// We need to hold the database pool in our service struct.
+pub struct SearcherService {
+    pub pool: PgPool,
+}
+
+// normalize_slovak_text function remains unchanged...
+fn normalize_slovak_text(text: &str) -> String {
+    // ... function content is unchanged ...
+    text.chars()
+        .map(|c| match c {
+            'á' | 'à' | 'â' | 'ä' | 'ă' | 'ā' => 'a',
+            'Á' | 'À' | 'Â' | 'Ä' | 'Ă' | 'Ā' => 'A',
+            'é' | 'è' | 'ê' | 'ë' | 'ě' | 'ē' => 'e',
+            'É' | 'È' | 'Ê' | 'Ë' | 'Ě' | 'Ē' => 'E',
+            'í' | 'ì' | 'î' | 'ï' | 'ī' => 'i',
+            'Í' | 'Ì' | 'Î' | 'Ï' | 'Ī' => 'I',
+            'ó' | 'ò' | 'ô' | 'ö' | 'ō' | 'ő' => 'o',
+            'Ó' | 'Ò' | 'Ô' | 'Ö' | 'Ō' | 'Ő' => 'O',
+            'ú' | 'ù' | 'û' | 'ü' | 'ū' | 'ű' => 'u',
+            'Ú' | 'Ù' | 'Û' | 'Ü' | 'Ū' | 'Ű' => 'U',
+            'ý' | 'ỳ' | 'ŷ' | 'ÿ' => 'y',
+            'Ý' | 'Ỳ' | 'Ŷ' | 'Ÿ' => 'Y',
+            'č' => 'c',
+            'Č' => 'C',
+            'ď' => 'd',
+            'Ď' => 'D',
+            'ľ' => 'l',
+            'Ľ' => 'L',
+            'ň' => 'n',
+            'Ň' => 'N',
+            'ř' => 'r',
+            'Ř' => 'R',
+            'š' => 's',
+            'Š' => 'S',
+            'ť' => 't',
+            'Ť' => 'T',
+            'ž' => 'z',
+            'Ž' => 'Z',
+            _ => c,
+        })
+        .collect()
+}
+
+#[tonic::async_trait]
+impl Searcher for SearcherService {
+    async fn search_table(
+        &self,
+        request: Request<SearchRequest>,
+    ) -> Result<Response<SearchResponse>, Status> {
+        let req = request.into_inner();
+        let table_name = req.table_name;
+        let query_str = req.query;
+
+        // --- MODIFIED LOGIC ---
+        // If the query is empty, fetch the 5 most recent records.
+        if query_str.trim().is_empty() {
+            info!(
+                "Empty query for table '{}'. Fetching default results.",
+                table_name
+            );
+            let qualified_table = format!("gen.\"{}\"", table_name);
+            let sql = format!(
+                "SELECT id, to_jsonb(t) AS data FROM {} t ORDER BY id DESC LIMIT 5",
+                qualified_table
+            );
+
+            let rows = sqlx::query(&sql)
+                .fetch_all(&self.pool)
+                .await
+                .map_err(|e| {
+                    Status::internal(format!(
+                        "DB query for default results failed: {}",
+                        e
+                    ))
+                })?;
+
+            let hits: Vec<Hit> = rows
+                .into_iter()
+                .map(|row| {
+                    let id: i64 = row.try_get("id").unwrap_or_default();
+                    let json_data: serde_json::Value =
+                        row.try_get("data").unwrap_or_default();
+                    Hit {
+                        id,
+                        // Score is 0.0 as this is not a relevance-ranked search
+                        score: 0.0,
+                        content_json: json_data.to_string(),
+                    }
+                })
+                .collect();
+
+            info!("--- SERVER: Successfully processed empty query. Returning {} default hits. ---", hits.len());
+            return Ok(Response::new(SearchResponse { hits }));
+        }
+        // --- END OF MODIFIED LOGIC ---
+
+        let index_path = Path::new("./tantivy_indexes").join(&table_name);
+        if !index_path.exists() {
+            return Err(Status::not_found(format!(
+                "No search index found for table '{}'",
+                table_name
+            )));
+        }
+
+        let index = Index::open_in_dir(&index_path)
+            .map_err(|e| Status::internal(format!("Failed to open index: {}", e)))?;
+
+        register_slovak_tokenizers(&index).map_err(|e| {
+            Status::internal(format!("Failed to register Slovak tokenizers: {}", e))
+        })?;
+
+        let reader = index.reader().map_err(|e| {
+            Status::internal(format!("Failed to create index reader: {}", e))
+        })?;
+        let searcher = reader.searcher();
+        let schema = index.schema();
+
+        let pg_id_field = schema.get_field("pg_id").map_err(|_| {
+            Status::internal("Schema is missing the 'pg_id' field.")
+        })?;
+
+        // --- Query Building Logic (no changes here) ---
+        let prefix_edge_field = schema.get_field("prefix_edge").unwrap();
+        let prefix_full_field = schema.get_field("prefix_full").unwrap();
+        let text_ngram_field = schema.get_field("text_ngram").unwrap();
+        let normalized_query = normalize_slovak_text(&query_str);
+        let words: Vec<&str> = normalized_query.split_whitespace().collect();
+        if words.is_empty() {
+            return Ok(Response::new(SearchResponse { hits: vec![] }));
+        }
+        let mut query_layers: Vec<(Occur, Box<dyn Query>)> = Vec::new();
+        // ... all your query building layers remain exactly the same ...
+        // ===============================
+        // LAYER 1: PREFIX MATCHING (HIGHEST PRIORITY, Boost: 4.0)
+        // ===============================
+        {
+            let mut must_clauses: Vec<(Occur, Box<dyn Query>)> = Vec::new();
+            for word in &words {
+                let edge_term =
+                    Term::from_field_text(prefix_edge_field, word);
+                let full_term =
+                    Term::from_field_text(prefix_full_field, word);
+
+                let per_word_query = BooleanQuery::new(vec![
+                    (
+                        Occur::Should,
+                        Box::new(TermQuery::new(
+                            edge_term,
+                            IndexRecordOption::Basic,
+                        )),
+                    ),
+                    (
+                        Occur::Should,
+                        Box::new(TermQuery::new(
+                            full_term,
+                            IndexRecordOption::Basic,
+                        )),
+                    ),
+                ]);
+                must_clauses.push((Occur::Must, Box::new(per_word_query) as Box<dyn Query>));
+            }
+
+            if !must_clauses.is_empty() {
+                let prefix_query = BooleanQuery::new(must_clauses);
+                let boosted_query =
+                    BoostQuery::new(Box::new(prefix_query), 4.0);
+                query_layers.push((Occur::Should, Box::new(boosted_query)));
+            }
+        }
+
+        // ===============================
+        // LAYER 2: FUZZY MATCHING (HIGH PRIORITY, Boost: 3.0)
+        // ===============================
+        {
+            let last_word = words.last().unwrap();
+            let fuzzy_term =
+                Term::from_field_text(prefix_full_field, last_word);
+            let fuzzy_query = FuzzyTermQuery::new(fuzzy_term, 2, true);
+            let boosted_query = BoostQuery::new(Box::new(fuzzy_query), 3.0);
+            query_layers.push((Occur::Should, Box::new(boosted_query)));
+        }
+
+        // ===============================
+        // LAYER 3: PHRASE MATCHING WITH SLOP (MEDIUM PRIORITY, Boost: 2.0)
+        // ===============================
+        if words.len() > 1 {
+            let slop_parser =
+                QueryParser::for_index(&index, vec![prefix_full_field]);
+            let slop_query_str = format!("\"{}\"~3", normalized_query);
+            if let Ok(slop_query) = slop_parser.parse_query(&slop_query_str) {
+                let boosted_query = BoostQuery::new(slop_query, 2.0);
+                query_layers.push((Occur::Should, Box::new(boosted_query)));
+            }
+        }
+
+        // ===============================
+        // LAYER 4: NGRAM SUBSTRING MATCHING (LOWEST PRIORITY, Boost: 1.0)
+        // ===============================
+        {
+            let ngram_parser =
+                QueryParser::for_index(&index, vec![text_ngram_field]);
+            if let Ok(ngram_query) =
+                ngram_parser.parse_query(&normalized_query)
+            {
+                let boosted_query = BoostQuery::new(ngram_query, 1.0);
+                query_layers.push((Occur::Should, Box::new(boosted_query)));
+            }
+        }
+        let master_query = BooleanQuery::new(query_layers);
+        // --- End of Query Building Logic ---
+
+        let top_docs = searcher
+            .search(&master_query, &TopDocs::with_limit(100))
+            .map_err(|e| Status::internal(format!("Search failed: {}", e)))?;
+
+        if top_docs.is_empty() {
+            return Ok(Response::new(SearchResponse { hits: vec![] }));
+        }
+
+        // --- NEW LOGIC: Fetch from DB and combine results ---
+
+        // Step 1: Extract (score, pg_id) from Tantivy results.
+        let mut scored_ids: Vec<(f32, u64)> = Vec::new();
+        for (score, doc_address) in top_docs {
+            let doc: TantivyDocument = searcher.doc(doc_address).map_err(|e| {
+                Status::internal(format!("Failed to retrieve document: {}", e))
+            })?;
+            if let Some(pg_id_value) = doc.get_first(pg_id_field) {
+                if let Some(pg_id) = pg_id_value.as_u64() {
+                    scored_ids.push((score, pg_id));
+                }
+            }
+        }
+
+        // Step 2: Fetch all corresponding rows from Postgres in a single query.
+        let pg_ids: Vec<i64> =
+            scored_ids.iter().map(|(_, id)| *id as i64).collect();
+        let qualified_table = format!("gen.\"{}\"", table_name);
+        let query_str = format!(
+            "SELECT id, to_jsonb(t) AS data FROM {} t WHERE id = ANY($1)",
+            qualified_table
+        );
+
+        let rows = sqlx::query(&query_str)
+            .bind(&pg_ids)
+            .fetch_all(&self.pool)
+            .await
+            .map_err(|e| {
+                Status::internal(format!("Database query failed: {}", e))
+            })?;
+
+        // Step 3: Map the database results by ID for quick lookup.
+        let mut content_map: HashMap<i64, String> = HashMap::new();
+        for row in rows {
+            let id: i64 = row.try_get("id").unwrap_or(0);
+            let json_data: serde_json::Value =
+                row.try_get("data").unwrap_or(serde_json::Value::Null);
+            content_map.insert(id, json_data.to_string());
+        }
+
+        // Step 4: Build the final response, combining Tantivy scores with PG content.
+        let hits: Vec<Hit> = scored_ids
+            .into_iter()
+            .filter_map(|(score, pg_id)| {
+                content_map
+                    .get(&(pg_id as i64))
+                    .map(|content_json| Hit {
+                        id: pg_id as i64,
+                        score,
+                        content_json: content_json.clone(),
+                    })
+            })
+            .collect();
+
+        info!("--- SERVER: Successfully processed search. Returning {} hits. ---", hits.len());
+
+        let response = SearchResponse { hits };
+        Ok(Response::new(response))
+    }
+}
--- a/server/Cargo.toml
+++ b/server/Cargo.toml
@@ -6,7 +6,11 @@ license = "AGPL-3.0-or-later"

 [dependencies]
 common = { path = "../common" }
+search = { path = "../search" }

+anyhow = { workspace = true }
+tantivy = { workspace = true }
+prost-types = { workspace = true }
 chrono = { version = "0.4.40", features = ["serde"] }
 dotenvy = "0.15.7"
 prost = "0.13.5"
@@ -28,6 +32,7 @@ bcrypt = "0.17.0"
 validator = { version = "0.20.0", features = ["derive"] }
 uuid = { version = "1.16.0", features = ["serde", "v4"] }
 jsonwebtoken = "9.3.1"
+rust-stemmers = "1.2.0"

 [lib]
 name = "server"
--- a/server/src/indexer.rs
+++ b/server/src/indexer.rs
@@ -0,0 +1,139 @@
+// server/src/indexer.rs
+
+use sqlx::{PgPool, Row};
+use tantivy::schema::Term;
+use tantivy::{doc, IndexWriter};
+use tokio::sync::mpsc::Receiver;
+use tracing::{error, info, warn};
+use tantivy::schema::Schema;
+use crate::search_schema;
+
+const INDEX_DIR: &str = "./tantivy_indexes";
+
+/// Defines the commands that can be sent to the indexer task.
+#[derive(Debug)]
+pub enum IndexCommand {
+    /// Add a new document or update an existing one.
+    AddOrUpdate(IndexCommandData),
+    /// Remove a document from the index.
+    Delete(IndexCommandData),
+}
+
+#[derive(Debug)]
+pub struct IndexCommandData {
+    pub table_name: String,
+    pub row_id: i64,
+}
+
+/// The main loop for the background indexer task.
+pub async fn indexer_task(pool: PgPool, mut receiver: Receiver<IndexCommand>) {
+    info!("Background indexer task started.");
+    while let Some(command) = receiver.recv().await {
+        info!("Indexer received command: {:?}", command);
+        let result = match command {
+            IndexCommand::AddOrUpdate(data) => {
+                handle_add_or_update(&pool, data).await
+            }
+            IndexCommand::Delete(data) => handle_delete(&pool, data).await,
+        };
+
+        if let Err(e) = result {
+            error!("Failed to process index command: {}", e);
+        }
+    }
+    warn!("Indexer channel closed. Task is shutting down.");
+}
+
+/// Handles adding or updating a document in a Tantivy index.
+async fn handle_add_or_update(
+    pool: &PgPool,
+    data: IndexCommandData,
+) -> anyhow::Result<()> {
+    let qualified_table = format!("gen.\"{}\"", data.table_name);
+    let query_str = format!(
+        "SELECT to_jsonb(t) AS data FROM {} t WHERE id = $1",
+        qualified_table
+    );
+    let row = sqlx::query(&query_str)
+        .bind(data.row_id)
+        .fetch_one(pool)
+        .await?;
+    let json_data: serde_json::Value = row.try_get("data")?;
+    let slovak_text = extract_text_content(&json_data);
+
+    let (mut writer, schema) = get_index_writer(&data.table_name)?;
+    let pg_id_field = schema.get_field("pg_id").unwrap();
+    let prefix_edge_field = schema.get_field("prefix_edge").unwrap();
+    let prefix_full_field = schema.get_field("prefix_full").unwrap();
+    let text_ngram_field = schema.get_field("text_ngram").unwrap();
+
+    let id_term = Term::from_field_u64(pg_id_field, data.row_id as u64);
+    writer.delete_term(id_term);
+
+    writer.add_document(doc!(
+        pg_id_field => data.row_id as u64,
+        prefix_edge_field => slovak_text.clone(),
+        prefix_full_field => slovak_text.clone(),
+        text_ngram_field => slovak_text
+    ))?;
+
+    writer.commit()?;
+    info!(
+        "Successfully indexed document id:{} for table:{}",
+        data.row_id, data.table_name
+    );
+    Ok(())
+}
+
+/// Handles deleting a document from a Tantivy index.
+async fn handle_delete(
+    _pool: &PgPool,
+    data: IndexCommandData,
+) -> anyhow::Result<()> {
+    let (mut writer, schema) = get_index_writer(&data.table_name)?;
+    let pg_id_field = schema.get_field("pg_id").unwrap();
+
+    let id_term = Term::from_field_u64(pg_id_field, data.row_id as u64);
+    writer.delete_term(id_term);
+    writer.commit()?;
+
+    info!(
+        "Successfully deleted document id:{} from table:{}",
+        data.row_id, data.table_name
+    );
+
+    Ok(())
+}
+
+/// Helper to get or create an index and return its writer and schema.
+fn get_index_writer(
+    table_name: &str,
+) -> anyhow::Result<(IndexWriter, Schema)> {
+    let index = search_schema::get_or_create_index(table_name)?;
+    let schema = index.schema();
+    let writer = index.writer(100_000_000)?; // 100MB heap
+    Ok((writer, schema))
+}
+
+/// Extract all text content from a JSON object for indexing
+fn extract_text_content(json_data: &serde_json::Value) -> String {
+    let mut full_text = String::new();
+
+    if let Some(obj) = json_data.as_object() {
+        for value in obj.values() {
+            match value {
+                serde_json::Value::String(s) => {
+                    full_text.push_str(s);
+                    full_text.push(' ');
+                }
+                serde_json::Value::Number(n) => {
+                    full_text.push_str(&n.to_string());
+                    full_text.push(' ');
+                }
+                _ => {}
+            }
+        }
+    }
+
+    full_text.trim().to_string()
+}
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -1,6 +1,8 @@
 // src/lib.rs
 pub mod db;
 pub mod auth;
+pub mod indexer;
+pub mod search_schema;
 pub mod server;
 pub mod adresar;
 pub mod uctovnictvo;
--- a/server/src/search_schema.rs
+++ b/server/src/search_schema.rs
@@ -0,0 +1,26 @@
+// server/src/search_schema.rs
+
+use std::path::Path;
+use tantivy::Index;
+
+// Re-export the functions from the common crate.
+// This makes them available as `crate::search_schema::create_search_schema`, etc.
+pub use common::search::{create_search_schema, register_slovak_tokenizers};
+
+/// Gets an existing index or creates a new one.
+/// This function now uses the shared logic from the `common` crate.
+pub fn get_or_create_index(table_name: &str) -> tantivy::Result<Index> {
+    let index_path = Path::new("./tantivy_indexes").join(table_name);
+    std::fs::create_dir_all(&index_path)?;
+
+    let index = if index_path.join("meta.json").exists() {
+        Index::open_in_dir(&index_path)?
+    } else {
+        let schema = create_search_schema();
+        Index::create_in_dir(&index_path, schema)?
+    };
+
+    // This now calls the single, authoritative function from `common`.
+    register_slovak_tokenizers(&index)?;
+    Ok(index)
+}
--- a/server/src/server/run.rs
+++ b/server/src/server/run.rs
@@ -1,7 +1,9 @@
-// src/server/run.rs
 use tonic::transport::Server;
 use tonic_reflection::server::Builder as ReflectionBuilder;

+use tokio::sync::mpsc;
+use crate::indexer::{indexer_task, IndexCommand};
+
 use common::proto::multieko2::FILE_DESCRIPTOR_SET;
 use crate::server::services::{
    AdresarService,
@@ -21,23 +23,38 @@ use common::proto::multieko2::{
    table_script::table_script_server::TableScriptServer,
    auth::auth_service_server::AuthServiceServer
 };
+use search::{SearcherService, SearcherServer};

 pub async fn run_server(db_pool: sqlx::PgPool) -> Result<(), Box<dyn std::error::Error>> {
    // Initialize JWT for authentication
    crate::auth::logic::jwt::init_jwt()?;
-    
+
    let addr = "[::1]:50051".parse()?;
+    println!("Unified Server listening on {}", addr);
+
+    // 1. Create the MPSC channel for indexer commands
+    let (indexer_tx, indexer_rx) = mpsc::channel::<IndexCommand>(100); // Buffer of 100 messages
+
+    // 2. Spawn the background indexer task
+    let indexer_pool = db_pool.clone();
+    tokio::spawn(indexer_task(indexer_pool, indexer_rx));

    let reflection_service = ReflectionBuilder::configure()
        .register_encoded_file_descriptor_set(FILE_DESCRIPTOR_SET)
        .build_v1()?;

-    // Initialize services
+    // Initialize services, passing the indexer sender to the relevant ones
    let table_definition_service = TableDefinitionService { db_pool: db_pool.clone() };
-    let tables_data_service = TablesDataService { db_pool: db_pool.clone() };
+    let tables_data_service = TablesDataService {
+        db_pool: db_pool.clone(),
+        indexer_tx: indexer_tx.clone(), // Pass the sender
+    };
    let table_script_service = TableScriptService { db_pool: db_pool.clone() };
    let auth_service = AuthServiceImpl { db_pool: db_pool.clone() };

+    // MODIFIED: Instantiate SearcherService with the database pool
+    let search_service = SearcherService { pool: db_pool.clone() };
+
    Server::builder()
        .add_service(AdresarServer::new(AdresarService { db_pool: db_pool.clone() }))
        .add_service(UctovnictvoServer::new(UctovnictvoService { db_pool: db_pool.clone() }))
@@ -46,6 +63,7 @@ pub async fn run_server(db_pool: sqlx::PgPool) -> Result<(), Box<dyn std::error:
        .add_service(TablesDataServer::new(tables_data_service))
        .add_service(TableScriptServer::new(table_script_service))
        .add_service(AuthServiceServer::new(auth_service))
+        .add_service(SearcherServer::new(search_service)) // This now works correctly
        .add_service(reflection_service)
        .serve(addr)
        .await?;
--- a/server/src/server/services/tables_data_service.rs
+++ b/server/src/server/services/tables_data_service.rs
@@ -1,5 +1,10 @@
 // src/server/services/tables_data_service.rs
+
 use tonic::{Request, Response, Status};
+// Add these imports
+use tokio::sync::mpsc;
+use crate::indexer::IndexCommand;
+
 use common::proto::multieko2::tables_data::tables_data_server::TablesData;
 use common::proto::multieko2::common::CountResponse;
 use common::proto::multieko2::tables_data::{
@@ -15,6 +20,8 @@ use sqlx::PgPool;
 #[derive(Debug)]
 pub struct TablesDataService {
    pub db_pool: PgPool,
+    // MODIFIED: Add the sender field
+    pub indexer_tx: mpsc::Sender<IndexCommand>,
 }

 #[tonic::async_trait]
@@ -24,25 +31,34 @@ impl TablesData for TablesDataService {
        request: Request<PostTableDataRequest>,
    ) -> Result<Response<PostTableDataResponse>, Status> {
        let request = request.into_inner();
-        let response = post_table_data(&self.db_pool, request).await?;
+        // MODIFIED: Pass the indexer_tx to the handler
+        let response = post_table_data(
+            &self.db_pool,
+            request,
+            &self.indexer_tx,
+        )
+        .await?;
        Ok(Response::new(response))
    }

-    // Add the new method implementation
+    // You will later apply the same pattern to put_table_data...
    async fn put_table_data(
        &self,
        request: Request<PutTableDataRequest>,
    ) -> Result<Response<PutTableDataResponse>, Status> {
        let request = request.into_inner();
+        // TODO: Update put_table_data handler to accept and use indexer_tx
        let response = put_table_data(&self.db_pool, request).await?;
        Ok(Response::new(response))
    }

+    // ...and delete_table_data
    async fn delete_table_data(
        &self,
        request: Request<DeleteTableDataRequest>,
    ) -> Result<Response<DeleteTableDataResponse>, Status> {
        let request = request.into_inner();
+        // TODO: Update delete_table_data handler to accept and use indexer_tx
        let response = delete_table_data(&self.db_pool, request).await?;
        Ok(Response::new(response))
    }
--- a/server/src/table_definition/handlers/post_table_definition.rs
+++ b/server/src/table_definition/handlers/post_table_definition.rs
@@ -45,6 +45,13 @@ fn map_field_type(field_type: &str) -> Result<&str, Status> {
        .ok_or_else(|| Status::invalid_argument(format!("Invalid field type: {}", field_type)))
 }

+fn is_invalid_table_name(table_name: &str) -> bool {
+    table_name.ends_with("_id") ||
+    table_name == "id" ||
+    table_name == "deleted" ||
+    table_name == "created_at"
+}
+
 pub async fn post_table_definition(
    db_pool: &PgPool,
    request: PostTableDefinitionRequest,
@@ -55,6 +62,13 @@ pub async fn post_table_definition(
        .trim_matches('_')
        .to_lowercase();

+    // New validation check
+    if is_invalid_table_name(&user_part_cleaned) {
+        return Err(Status::invalid_argument(
+            "Table name cannot be 'id', 'deleted', 'created_at' or end with '_id'"
+        ));
+    }
+
    if !user_part_cleaned.is_empty() && !is_valid_identifier(&user_part_cleaned) {
        return Err(Status::invalid_argument("Invalid table name"));
    } else if user_part_cleaned.is_empty() {
@@ -142,8 +156,8 @@ async fn execute_table_definition(
           RETURNING id"#,
        profile.id,
        &table_name,
-        json!(request.columns.iter().map(|c| c.name.clone()).collect::<Vec<_>>()),
-        json!(request.indexes.iter().map(|i| i.clone()).collect::<Vec<_>>())
+        json!(columns),
+        json!(indexes)
    )
    .fetch_one(&mut **tx)
    .await
--- a/server/src/tables_data/handlers/get_table_data.rs
+++ b/server/src/tables_data/handlers/get_table_data.rs
@@ -1,9 +1,10 @@
 // src/tables_data/handlers/get_table_data.rs
+
 use tonic::Status;
 use sqlx::{PgPool, Row};
 use std::collections::HashMap;
 use common::proto::multieko2::tables_data::{GetTableDataRequest, GetTableDataResponse};
-use crate::shared::schema_qualifier::qualify_table_name_for_data; // Import schema qualifier
+use crate::shared::schema_qualifier::qualify_table_name_for_data;

 pub async fn get_table_data(
    db_pool: &PgPool,
@@ -48,28 +49,44 @@ pub async fn get_table_data(
            return Err(Status::internal("Invalid column format"));
        }
        let name = parts[0].trim_matches('"').to_string();
-        let sql_type = parts[1].to_string();
-        user_columns.push((name, sql_type));
+        user_columns.push(name);
    }

-    // Prepare all columns (system + user-defined)
-    let system_columns = vec![
-        ("id".to_string(), "BIGINT".to_string()),
-        ("deleted".to_string(), "BOOLEAN".to_string()),
-        ("firma".to_string(), "TEXT".to_string()),
-    ];
-    let all_columns: Vec<(String, String)> = system_columns
-        .into_iter()
-        .chain(user_columns.into_iter())
-        .collect();
+    // --- START OF FIX ---

-    // Build SELECT clause with COALESCE and type casting
-    let columns_clause = all_columns
+    // 1. Get all foreign key columns for this table
+    let fk_columns_query = sqlx::query!(
+        r#"SELECT ltd.table_name
+        FROM table_definition_links tdl
+        JOIN table_definitions ltd ON tdl.linked_table_id = ltd.id
+        WHERE tdl.source_table_id = $1"#,
+        table_def.id
+    )
+    .fetch_all(db_pool)
+    .await
+    .map_err(|e| Status::internal(format!("Foreign key lookup error: {}", e)))?;
+
+    // 2. Build the list of foreign key column names
+    let mut foreign_key_columns = Vec::new();
+    for fk in fk_columns_query {
+        let base_name = fk.table_name.split_once('_').map_or(fk.table_name.as_str(), |(_, rest)| rest);
+        foreign_key_columns.push(format!("{}_id", base_name));
+    }
+
+    // 3. Prepare a complete list of all columns to select
+    let mut all_column_names = vec!["id".to_string(), "deleted".to_string()];
+    all_column_names.extend(user_columns);
+    all_column_names.extend(foreign_key_columns);
+
+    // 4. Build the SELECT clause with all columns
+    let columns_clause = all_column_names
        .iter()
-        .map(|(name, _)| format!("COALESCE(\"{0}\"::TEXT, '') AS \"{0}\"", name))
+        .map(|name| format!("COALESCE(\"{0}\"::TEXT, '') AS \"{0}\"", name))
        .collect::<Vec<_>>()
        .join(", ");

+    // --- END OF FIX ---
+
    // Qualify table name with schema
    let qualified_table = qualify_table_name_for_data(&table_name)?;

@@ -88,7 +105,6 @@ pub async fn get_table_data(
        Ok(row) => row,
        Err(sqlx::Error::RowNotFound) => return Err(Status::not_found("Record not found")),
        Err(e) => {
-            // Handle "relation does not exist" error specifically
            if let Some(db_err) = e.as_database_error() {
                if db_err.code() == Some(std::borrow::Cow::Borrowed("42P01")) {
                    return Err(Status::internal(format!(
@@ -101,9 +117,9 @@ pub async fn get_table_data(
        }
    };

-    // Build response data
+    // Build response data from the complete list of columns
    let mut data = HashMap::new();
-    for (column_name, _) in &all_columns {
+    for column_name in &all_column_names {
        let value: String = row
            .try_get(column_name.as_str())
            .map_err(|e| Status::internal(format!("Failed to get column {}: {}", column_name, e)))?;
--- a/server/src/tables_data/handlers/post_table_data.rs
+++ b/server/src/tables_data/handlers/post_table_data.rs
@@ -1,4 +1,5 @@
 // src/tables_data/handlers/post_table_data.rs
+
 use tonic::Status;
 use sqlx::{PgPool, Arguments};
 use sqlx::postgres::PgArguments;
@@ -6,33 +7,23 @@ use chrono::{DateTime, Utc};
 use common::proto::multieko2::tables_data::{PostTableDataRequest, PostTableDataResponse};
 use std::collections::HashMap;
 use std::sync::Arc;
-use crate::shared::schema_qualifier::qualify_table_name_for_data; // Import schema qualifier
+use crate::shared::schema_qualifier::qualify_table_name_for_data;
+use prost_types::value::Kind; // NEW: Import the Kind enum

 use crate::steel::server::execution::{self, Value};
 use crate::steel::server::functions::SteelContext;

+use crate::indexer::{IndexCommand, IndexCommandData};
+use tokio::sync::mpsc;
+use tracing::error;
+
 pub async fn post_table_data(
    db_pool: &PgPool,
    request: PostTableDataRequest,
+    indexer_tx: &mpsc::Sender<IndexCommand>,
 ) -> Result<PostTableDataResponse, Status> {
    let profile_name = request.profile_name;
    let table_name = request.table_name;
-    let mut data = HashMap::new();
-
-    // Process and validate all data values
-    for (key, value) in request.data {
-        let trimmed = value.trim().to_string();
-
-        // Handle specially - it cannot be empty
-        if trimmed.is_empty() {
-            return Err(Status::invalid_argument("Firma cannot be empty"));
-        }
-
-        // Add trimmed non-empty values to data map
-        if !trimmed.is_empty() {
-            data.insert(key, trimmed);
-        }
-    }

    // Lookup profile
    let profile = sqlx::query!(
@@ -88,7 +79,7 @@ pub async fn post_table_data(
    // Build system columns with foreign keys
    let mut system_columns = vec!["deleted".to_string()];
    for fk in fk_columns {
-        let base_name = fk.table_name.split('_').last().unwrap_or(&fk.table_name);
+        let base_name = fk.table_name.split_once('_').map_or(fk.table_name.as_str(), |(_, rest)| rest);
        system_columns.push(format!("{}_id", base_name));
    }

@@ -97,13 +88,32 @@ pub async fn post_table_data(

    // Validate all data columns
    let user_columns: Vec<&String> = columns.iter().map(|(name, _)| name).collect();
-    for key in data.keys() {
+    for key in request.data.keys() {
        if !system_columns_set.contains(key.as_str()) &&
           !user_columns.contains(&&key.to_string()) {
            return Err(Status::invalid_argument(format!("Invalid column: {}", key)));
        }
    }

+    // ========================================================================
+    // FIX #1: SCRIPT VALIDATION LOOP
+    // This loop now correctly handles JSON `null` (which becomes `None`).
+    // ========================================================================
+    let mut string_data_for_scripts = HashMap::new();
+    for (key, proto_value) in &request.data {
+        let str_val = match &proto_value.kind {
+            Some(Kind::StringValue(s)) => s.clone(),
+            Some(Kind::NumberValue(n)) => n.to_string(),
+            Some(Kind::BoolValue(b)) => b.to_string(),
+            // This now correctly skips both protobuf `NULL` and JSON `null`.
+            Some(Kind::NullValue(_)) | None => continue,
+            Some(Kind::StructValue(_)) | Some(Kind::ListValue(_)) => {
+                return Err(Status::invalid_argument(format!("Unsupported type for script validation in column '{}'", key)));
+            }
+        };
+        string_data_for_scripts.insert(key.clone(), str_val);
+    }
+
    // Validate Steel scripts
    let scripts = sqlx::query!(
        "SELECT target_column, script FROM table_scripts WHERE table_definitions_id = $1",
@@ -116,21 +126,18 @@ pub async fn post_table_data(
    for script_record in scripts {
        let target_column = script_record.target_column;

-        // Ensure target column exists in submitted data
-        let user_value = data.get(&target_column)
+        let user_value = string_data_for_scripts.get(&target_column)
            .ok_or_else(|| Status::invalid_argument(
                format!("Script target column '{}' is required", target_column)
            ))?;

-        // Create execution context
        let context = SteelContext {
-            current_table: table_name.clone(), // Keep base name for scripts
+            current_table: table_name.clone(),
            profile_id,
-            row_data: data.clone(),
+            row_data: string_data_for_scripts.clone(),
            db_pool: Arc::new(db_pool.clone()),
        };

-        // Execute validation script
        let script_result = execution::execute_script(
            script_record.script,
            "STRINGS",
@@ -141,7 +148,6 @@ pub async fn post_table_data(
            format!("Script execution failed for '{}': {}", target_column, e)
        ))?;

-        // Validate script output
        let Value::Strings(mut script_output) = script_result else {
            return Err(Status::internal("Script must return string values"));
        };
@@ -163,11 +169,16 @@ pub async fn post_table_data(
    let mut placeholders = Vec::new();
    let mut param_idx = 1;

-    for (col, value) in data {
+    // ========================================================================
+    // FIX #2: DATABASE INSERTION LOOP
+    // This loop now correctly handles JSON `null` (which becomes `None`)
+    // without crashing and correctly inserts a SQL NULL.
+    // ========================================================================
+    for (col, proto_value) in request.data {
        let sql_type = if system_columns_set.contains(col.as_str()) {
            match col.as_str() {
                "deleted" => "BOOLEAN",
-                _ if col.ends_with("_id") => "BIGINT", // Handle foreign keys
+                _ if col.ends_with("_id") => "BIGINT",
                _ => return Err(Status::invalid_argument("Invalid system column")),
            }
        } else {
@@ -177,36 +188,65 @@ pub async fn post_table_data(
                .ok_or_else(|| Status::invalid_argument(format!("Column not found: {}", col)))?
        };

+        // Check for `None` (from JSON null) or `Some(NullValue)` first.
+        let kind = match &proto_value.kind {
+            None | Some(Kind::NullValue(_)) => {
+                // It's a null value. Add the correct SQL NULL type and continue.
+                match sql_type {
+                    "BOOLEAN" => params.add(None::<bool>),
+                    "TEXT" | "VARCHAR(15)" | "VARCHAR(255)" => params.add(None::<String>),
+                    "TIMESTAMPTZ" => params.add(None::<DateTime<Utc>>),
+                    "BIGINT" => params.add(None::<i64>),
+                    _ => return Err(Status::invalid_argument(format!("Unsupported type for null value: {}", sql_type))),
+                }.map_err(|e| Status::internal(format!("Failed to add null parameter for {}: {}", col, e)))?;
+
+                columns_list.push(format!("\"{}\"", col));
+                placeholders.push(format!("${}", param_idx));
+                param_idx += 1;
+                continue; // Skip to the next column in the loop
+            }
+            // If it's not null, just pass the inner `Kind` through.
+            Some(k) => k,
+        };
+
+        // From here, we know `kind` is not a null type.
        match sql_type {
            "TEXT" | "VARCHAR(15)" | "VARCHAR(255)" => {
-                if let Some(max_len) = sql_type.strip_prefix("VARCHAR(")
-                    .and_then(|s| s.strip_suffix(')'))
-                    .and_then(|s| s.parse::<usize>().ok())
-                {
-                    if value.len() > max_len {
-                        return Err(Status::internal(format!("Value too long for {}", col)));
+                if let Kind::StringValue(value) = kind {
+                    if let Some(max_len) = sql_type.strip_prefix("VARCHAR(").and_then(|s| s.strip_suffix(')')).and_then(|s| s.parse::<usize>().ok()) {
+                        if value.len() > max_len {
+                            return Err(Status::internal(format!("Value too long for {}", col)));
+                        }
                    }
+                    params.add(value).map_err(|e| Status::invalid_argument(format!("Failed to add text parameter for {}: {}", col, e)))?;
+                } else {
+                    return Err(Status::invalid_argument(format!("Expected string for column '{}'", col)));
                }
-                params.add(value)
-                    .map_err(|e| Status::invalid_argument(format!("Failed to add text parameter for {}: {}", col, e)))?;
            },
            "BOOLEAN" => {
-                let val = value.parse::<bool>()
-                    .map_err(|_| Status::invalid_argument(format!("Invalid boolean for {}", col)))?;
-                params.add(val)
-                    .map_err(|e| Status::invalid_argument(format!("Failed to add boolean parameter for {}: {}", col, e)))?;
+                if let Kind::BoolValue(val) = kind {
+                    params.add(val).map_err(|e| Status::invalid_argument(format!("Failed to add boolean parameter for {}: {}", col, e)))?;
+                } else {
+                    return Err(Status::invalid_argument(format!("Expected boolean for column '{}'", col)));
+                }
            },
            "TIMESTAMPTZ" => {
-                let dt = DateTime::parse_from_rfc3339(&value)
-                    .map_err(|_| Status::invalid_argument(format!("Invalid timestamp for {}", col)))?;
-                params.add(dt.with_timezone(&Utc))
-                    .map_err(|e| Status::invalid_argument(format!("Failed to add timestamp parameter for {}: {}", col, e)))?;
+                if let Kind::StringValue(value) = kind {
+                    let dt = DateTime::parse_from_rfc3339(value).map_err(|_| Status::invalid_argument(format!("Invalid timestamp for {}", col)))?;
+                    params.add(dt.with_timezone(&Utc)).map_err(|e| Status::invalid_argument(format!("Failed to add timestamp parameter for {}: {}", col, e)))?;
+                } else {
+                    return Err(Status::invalid_argument(format!("Expected ISO 8601 string for column '{}'", col)));
+                }
            },
            "BIGINT" => {
-                let val = value.parse::<i64>()
-                    .map_err(|_| Status::invalid_argument(format!("Invalid integer for {}", col)))?;
-                params.add(val)
-                    .map_err(|e| Status::invalid_argument(format!("Failed to add integer parameter for {}: {}", col, e)))?;
+                if let Kind::NumberValue(val) = kind {
+                    if val.fract() != 0.0 {
+                        return Err(Status::invalid_argument(format!("Expected integer for column '{}', but got a float", col)));
+                    }
+                    params.add(*val as i64).map_err(|e| Status::invalid_argument(format!("Failed to add integer parameter for {}: {}", col, e)))?;
+                } else {
+                    return Err(Status::invalid_argument(format!("Expected number for column '{}'", col)));
+                }
            },
            _ => return Err(Status::invalid_argument(format!("Unsupported type {}", sql_type))),
        }
@@ -230,7 +270,6 @@ pub async fn post_table_data(
        placeholders.join(", ")
    );

-    // Execute query with enhanced error handling
    let result = sqlx::query_scalar_with::<_, i64, _>(&sql, params)
        .fetch_one(db_pool)
        .await;
@@ -238,7 +277,6 @@ pub async fn post_table_data(
    let inserted_id = match result {
        Ok(id) => id,
        Err(e) => {
-            // Handle "relation does not exist" error specifically
            if let Some(db_err) = e.as_database_error() {
                if db_err.code() == Some(std::borrow::Cow::Borrowed("42P01")) {
                    return Err(Status::internal(format!(
@@ -251,6 +289,18 @@ pub async fn post_table_data(
        }
    };

+    let command = IndexCommand::AddOrUpdate(IndexCommandData {
+        table_name: table_name.clone(),
+        row_id: inserted_id,
+    });
+
+    if let Err(e) = indexer_tx.send(command).await {
+        error!(
+            "CRITICAL: DB insert for table '{}' (id: {}) succeeded but failed to queue for indexing: {}. Search index is now inconsistent.",
+            table_name, inserted_id, e
+        );
+    }
+
    Ok(PostTableDataResponse {
        success: true,
        message: "Data inserted successfully".into(),
--- a/server/src/tables_data/handlers/put_table_data.rs
+++ b/server/src/tables_data/handlers/put_table_data.rs
@@ -4,8 +4,8 @@ use sqlx::{PgPool, Arguments, Postgres};
 use sqlx::postgres::PgArguments;
 use chrono::{DateTime, Utc};
 use common::proto::multieko2::tables_data::{PutTableDataRequest, PutTableDataResponse};
-use std::collections::HashMap;
-use crate::shared::schema_qualifier::qualify_table_name_for_data; // Import schema qualifier
+use crate::shared::schema_qualifier::qualify_table_name_for_data;
+use prost_types::value::Kind;

 pub async fn put_table_data(
    db_pool: &PgPool,
@@ -15,23 +15,9 @@ pub async fn put_table_data(
    let table_name = request.table_name;
    let record_id = request.id;

-    // Preprocess and validate data
-    let mut processed_data = HashMap::new();
-    let mut null_fields = Vec::new();
-
-    for (key, value) in request.data {
-        let trimmed = value.trim().to_string();
-
-        if key == "firma" && trimmed.is_empty() {
-            return Err(Status::invalid_argument("Firma cannot be empty"));
-        }
-
-        // Store fields that should be set to NULL
-        if key != "firma" && trimmed.is_empty() {
-            null_fields.push(key);
-        } else {
-            processed_data.insert(key, trimmed);
-        }
+    // If no data is provided to update, it's an invalid request.
+    if request.data.is_empty() {
+        return Err(Status::invalid_argument("No fields provided to update."));
    }

    // Lookup profile
@@ -73,13 +59,29 @@ pub async fn put_table_data(
        columns.push((name, sql_type));
    }

-    // Validate system columns
-    let system_columns = ["firma", "deleted"];
+    // Get all foreign key columns for this table (needed for validation)
+    let fk_columns = sqlx::query!(
+        r#"SELECT ltd.table_name
+        FROM table_definition_links tdl
+        JOIN table_definitions ltd ON tdl.linked_table_id = ltd.id
+        WHERE tdl.source_table_id = $1"#,
+        table_def.id
+    )
+    .fetch_all(db_pool)
+    .await
+    .map_err(|e| Status::internal(format!("Foreign key lookup error: {}", e)))?;
+
+    let mut system_columns = vec!["deleted".to_string()];
+    for fk in fk_columns {
+        let base_name = fk.table_name.split_once('_').map_or(fk.table_name.as_str(), |(_, rest)| rest);
+        system_columns.push(format!("{}_id", base_name));
+    }
+    let system_columns_set: std::collections::HashSet<_> = system_columns.iter().map(|s| s.as_str()).collect();
    let user_columns: Vec<&String> = columns.iter().map(|(name, _)| name).collect();

    // Validate input columns
-    for key in processed_data.keys() {
-        if !system_columns.contains(&key.as_str()) && !user_columns.contains(&key) {
+    for key in request.data.keys() {
+        if !system_columns_set.contains(key.as_str()) && !user_columns.contains(&key) {
            return Err(Status::invalid_argument(format!("Invalid column: {}", key)));
        }
    }
@@ -89,45 +91,65 @@ pub async fn put_table_data(
    let mut set_clauses = Vec::new();
    let mut param_idx = 1;

-    // Add data parameters for non-empty fields
-    for (col, value) in &processed_data {
-        let sql_type = if system_columns.contains(&col.as_str()) {
+    for (col, proto_value) in request.data {
+        let sql_type = if system_columns_set.contains(col.as_str()) {
            match col.as_str() {
-                "firma" => "TEXT",
                "deleted" => "BOOLEAN",
+                _ if col.ends_with("_id") => "BIGINT",
                _ => return Err(Status::invalid_argument("Invalid system column")),
            }
        } else {
            columns.iter()
-                .find(|(name, _)| name == col)
+                .find(|(name, _)| name == &col)
                .map(|(_, sql_type)| sql_type.as_str())
                .ok_or_else(|| Status::invalid_argument(format!("Column not found: {}", col)))?
        };

+        // A provided value cannot be null or empty in a PUT request.
+        // To clear a field, it should be set to an empty string "" for text,
+        // or a specific value for other types if needed (though typically not done).
+        // For now, we reject nulls.
+        let kind = proto_value.kind.ok_or_else(|| {
+            Status::invalid_argument(format!("Value for column '{}' cannot be empty in a PUT request. To clear a text field, send an empty string.", col))
+        })?;
+
        match sql_type {
            "TEXT" | "VARCHAR(15)" | "VARCHAR(255)" => {
-                if let Some(max_len) = sql_type.strip_prefix("VARCHAR(")
-                    .and_then(|s| s.strip_suffix(')'))
-                    .and_then(|s| s.parse::<usize>().ok())
-                {
-                    if value.len() > max_len {
-                        return Err(Status::internal(format!("Value too long for {}", col)));
-                    }
+                if let Kind::StringValue(value) = kind {
+                    params.add(value)
+                        .map_err(|e| Status::internal(format!("Failed to add text parameter for {}: {}", col, e)))?;
+                } else {
+                    return Err(Status::invalid_argument(format!("Expected string for column '{}'", col)));
                }
-                params.add(value)
-                    .map_err(|e| Status::internal(format!("Failed to add text parameter for {}: {}", col, e)))?;
            },
            "BOOLEAN" => {
-                let val = value.parse::<bool>()
-                    .map_err(|_| Status::invalid_argument(format!("Invalid boolean for {}", col)))?;
-                params.add(val)
-                    .map_err(|e| Status::internal(format!("Failed to add boolean parameter for {}极 {}", col, e)))?;
+                if let Kind::BoolValue(val) = kind {
+                    params.add(val)
+                        .map_err(|e| Status::internal(format!("Failed to add boolean parameter for {}: {}", col, e)))?;
+                } else {
+                    return Err(Status::invalid_argument(format!("Expected boolean for column '{}'", col)));
+                }
            },
            "TIMESTAMPTZ" => {
-                let dt = DateTime::parse_from_rfc3339(value)
-                    .map_err(|_| Status::invalid_argument(format!("Invalid timestamp for {}", col)))?;
-                params.add(dt.with_timezone(&Utc))
-                    .map_err(|e| Status::internal(format!("Failed to add timestamp parameter for {}: {}", col, e)))?;
+                if let Kind::StringValue(value) = kind {
+                    let dt = DateTime::parse_from_rfc3339(&value)
+                        .map_err(|_| Status::invalid_argument(format!("Invalid timestamp for {}", col)))?;
+                    params.add(dt.with_timezone(&Utc))
+                        .map_err(|e| Status::internal(format!("Failed to add timestamp parameter for {}: {}", col, e)))?;
+                } else {
+                    return Err(Status::invalid_argument(format!("Expected ISO 8601 string for column '{}'", col)));
+                }
+            },
+            "BIGINT" => {
+                if let Kind::NumberValue(val) = kind {
+                    if val.fract() != 0.0 {
+                        return Err(Status::invalid_argument(format!("Expected integer for column '{}', but got a float", col)));
+                    }
+                    params.add(val as i64)
+                        .map_err(|e| Status::internal(format!("Failed to add integer parameter for {}: {}", col, e)))?;
+                } else {
+                    return Err(Status::invalid_argument(format!("Expected number for column '{}'", col)));
+                }
            },
            _ => return Err(Status::invalid_argument(format!("Unsupported type {}", sql_type))),
        }
@@ -136,27 +158,10 @@ pub async fn put_table_data(
        param_idx += 1;
    }

-    // Add NULL clauses for empty fields
-    for field in null_fields {
-        // Make sure the field is valid
-        if !system_columns.contains(&field.as_str()) && !user_columns.contains(&&field) {
-            return Err(Status::invalid_argument(format!("Invalid column to set NULL: {}", field)));
-        }
-        set_clauses.push(format!("\"{}\" = NULL", field));
-    }
-
-    // Ensure we have at least one field to update
-    if set_clauses.is_empty() {
-        return Err(Status::invalid_argument("No valid fields to update"));
-    }
-
-    // Add ID parameter at the end
    params.add(record_id)
        .map_err(|e| Status::internal(format!("Failed to add record_id parameter: {}", e)))?;

-    // Qualify table name with schema
    let qualified_table = qualify_table_name_for_data(&table_name)?;
-
    let set_clause = set_clauses.join(", ");
    let sql = format!(
        "UPDATE {} SET {} WHERE id = ${} AND deleted = FALSE RETURNING id",
@@ -177,7 +182,6 @@ pub async fn put_table_data(
        }),
        Ok(None) => Err(Status::not_found("Record not found or already deleted")),
        Err(e) => {
-            // Handle "relation does not exist" error specifically
            if let Some(db_err) = e.as_database_error() {
                if db_err.code() == Some(std::borrow::Cow::Borrowed("42P01")) {
                    return Err(Status::internal(format!(
Author	SHA1	Message	Date
filipriec	3dfa922b9e	unimportant change	2025-06-17 10:27:22 +02:00
filipriec	248d54a30f	accpeting now null in the post table data as nothing	2025-06-16 22:51:05 +02:00
filipriec	b30fef4ccd	post doesnt work, but refactored code displays the autocomplete at least, needs fix	2025-06-16 16:42:25 +02:00
filipriec	a9c4527318	complete redesign oh how client is displaying data	2025-06-16 16:10:24 +02:00
filipriec	c31f08d5b8	fixing post with links	2025-06-16 14:42:49 +02:00
filipriec	9e0fa9ddb1	autocomplete now autocompleting data not just id	2025-06-16 11:54:54 +02:00
filipriec	8fcd28832d	better answer parsing	2025-06-16 11:14:04 +02:00
filipriec	cccf029464	autocomplete is now perfectc	2025-06-16 10:52:28 +02:00
filipriec	512e7fb9e7	suggestions in the dropdown menu now works amazingly well	2025-06-15 23:11:27 +02:00
filipriec	0e69df8282	empty search is now allowed	2025-06-15 18:36:01 +02:00
filipriec	eb5532c200	finally works as i wanted it to	2025-06-15 14:23:19 +02:00
filipriec	49ed1dfe33	trash	2025-06-15 13:52:43 +02:00
filipriec	62d1c3f7f5	suggestion works, but not exactly, needs more stuff	2025-06-15 13:35:45 +02:00
filipriec	b49dce3334	dropdown is being triggered	2025-06-15 12:15:25 +02:00
filipriec	8ace9bc4d1	links are now in the get method of the backend	2025-06-14 18:09:30 +02:00
filipriec	ce490007ed	fixing server responses, now push data links fixed	2025-06-14 17:39:59 +02:00
filipriec	eb96c64e26	links to the other tables	2025-06-14 12:47:59 +02:00
filipriec	2ac96a8486	working perfectly well with the search and debug in the status line when enabled	2025-06-13 20:46:33 +02:00
filipriec	b8e6cc22af	way better debugging in the status line now	2025-06-13 16:57:58 +02:00
filipriec	634a01f618	service search changed	2025-06-13 16:53:39 +02:00
filipriec	6abea062ba	ui debug in status line	2025-06-13 15:26:45 +02:00
filipriec	f50887a326	outputting to the status line	2025-06-13 13:38:40 +02:00
filipriec	3c0af05a3c	the search tui is not working yet	2025-06-11 22:08:23 +02:00
filipriec	c9131d4457	working but not properly displaying search results	2025-06-11 16:46:55 +02:00
filipriec	2af79a3ef2	search added, but unable to trigger it yet	2025-06-11 16:24:42 +02:00
filipriec	afd9228efa	json in the otput of the tantivy	2025-06-11 14:07:22 +02:00
filipriec	495d77fda5	4 ngram tokenizer, not doing anything elsekeeping this as is	2025-06-10 23:56:31 +02:00
filipriec	679bb3b6ab	search in common module, now fixing layer mixing issue	2025-06-10 13:47:18 +02:00
filipriec	350c522d19	better search but still has some flaws. It at least works, even tho its not perfect. Needs more testing, but im pretty happy with it rn, keeping it this way	2025-06-10 00:22:31 +02:00
filipriec	4760f42589	slovak language tokenized search	2025-06-09 16:36:18 +02:00
filipriec	50d15e321f	automatic indexing is working perfectly well	2025-06-08 23:26:13 +02:00
filipriec	a3e7fd8f0a	forgotten changes to the lib that are needed for a single port of two crates working separately	2025-06-08 22:40:46 +02:00
filipriec	645172747a	we are now running search server at the same port as the whole backend service	2025-06-08 21:53:48 +02:00
filipriec	7c4ac1eebc	search via tantivy on different grpc port works perfectly well now	2025-06-08 21:28:10 +02:00
filipriec	4b4301ad49	fixed now it all compiled successfuly	2025-06-08 20:14:44 +02:00
filipriec	b60e03eb70	search crate compiled, lets get to fixing all the other errors	2025-06-08 20:10:57 +02:00
filipriec	2c7bda3ff1	search crate created	2025-06-08 16:25:56 +02:00
filipriec	eeaaa3635b	crucial dialog reloading bug fixed for good(hardest bug had a single line of code fix)	2025-06-08 10:53:46 +02:00
filipriec	e61cbb3956	features ui debug is now working perfectly well, it debugs the rerender flags	2025-06-08 09:26:56 +02:00
filipriec	f9841f2ef3	centralizing logic in the formstate	2025-06-08 00:00:37 +02:00
filipriec	dc232b2523	form is now working as expected	2025-06-07 15:25:35 +02:00
filipriec	b086b3e236	hardcoded firma is being removed part2	2025-06-07 15:12:00 +02:00
filipriec	387e1a0fe0	displaying data properly, fixing hardcoded backend to firma part one	2025-06-07 14:05:35 +02:00
filipriec	08e01d41f2	now properly not displaying in the frontend form fields that should be hidden from the user	2025-06-07 09:37:12 +02:00
filipriec	f5edf52571	working find palette now properly well	2025-06-07 09:16:43 +02:00
filipriec	02c62213c3	making select from the find file to work, not yet working, needs more redesign in how select is working	2025-06-06 23:44:29 +02:00
filipriec	d0722fbbbe	working well now, creation of the columns	2025-06-06 20:18:51 +02:00
filipriec	4ec569342d	hidden from the user now in the form	2025-06-03 18:47:14 +02:00
filipriec	9540d9ccb9	table definitions are now forbidden for user to allocated rust autoallocated table columns	2025-06-03 18:46:57 +02:00