working perfectly well with the search and debug in the status line when enabled

way better debugging in the status line now
service search changed
2025-06-13 20:46:33 +02:00 · 2025-06-13 16:57:58 +02:00 · 2025-06-13 16:53:39 +02:00 · 2025-06-13 15:26:45 +02:00 · 2025-06-13 13:38:40 +02:00 · 2025-06-11 22:08:23 +02:00
69 changed files with 4151 additions and 1266 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 /target
 .env
+/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"
@@ -446,6 +488,7 @@ version = "0.3.13"
 dependencies = [
 "prost",
 "serde",
+ "tantivy",
 "tonic",
 "tonic-build",
 ]
@@ -541,6 +584,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 +674,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 +757,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e"
 dependencies = [
 "powerfmt",
+ "serde",
 ]

 [[package]]
@@ -772,6 +831,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 +890,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 +955,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 +1223,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 +1329,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 +1616,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 +1672,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 +1763,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 +1785,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 +1848,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 +1871,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 +2015,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 +2077,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 +2448,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 +2488,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 +2647,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 +2731,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 +2834,7 @@ dependencies = [
 name = "server"
 version = "0.3.13"
 dependencies = [
+ "anyhow",
 "bcrypt",
 "chrono",
 "common",
@@ -2608,11 +2845,14 @@ dependencies = [
 "prost",
 "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 +2962,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 +3020,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 +3033,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 +3071,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 +3084,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 +3103,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 +3154,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 +3194,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 +3410,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 +3818,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 +4042,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 +4250,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 +4614,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,27 @@ 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"
+
+# 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
@@ -26,3 +26,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"]
@@ -83,6 +84,7 @@ quit = ["q"]
 force_quit = ["q!"]
 save_and_quit = ["wq"]
 revert = ["r"]
+find_file_palette_toggle = ["ff"]

 [editor]
 keybinding_mode = "vim"  # Options: "default", "vim", "emacs"
--- a/client/src/components/common.rs
+++ b/client/src/components/common.rs
@@ -5,6 +5,8 @@ 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::*;
 pub use status_line::*;
@@ -12,3 +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/command_line.rs
+++ b/client/src/components/common/command_line.rs
@@ -1,4 +1,5 @@
-// src/client/components/command_line.rs
+// src/components/common/command_line.rs
+
 use ratatui::{
    widgets::{Block, Paragraph},
    style::Style,
@@ -6,30 +7,63 @@ use ratatui::{
    Frame,
 };
 use crate::config::colors::themes::Theme;
+use unicode_width::UnicodeWidthStr; // Import for width calculation

-pub fn render_command_line(f: &mut Frame, area: Rect, input: &str, active: bool, theme: &Theme, message: &str) {
-    let prompt = if active {
-        ":"
+pub fn render_command_line(
+    f: &mut Frame,
+    area: Rect,
+    input: &str,    // This is event_handler.command_input
+    active: bool,   // This is event_handler.command_mode
+    theme: &Theme,
+    message: &str,  // This is event_handler.command_message
+) {
+    // Original logic for determining display_text
+    let display_text = if !active {
+        // If not in normal command mode, but there's a message (e.g. from Find File palette closing)
+        // Or if command mode is off and message is empty (render minimally)
+        if message.is_empty() {
+            "".to_string() // Render an empty string, background will cover
        } else {
-        ""
-    };
-
-    // Combine the prompt, input, and message
-    let display_text = if message.is_empty() {
+            message.to_string()
+        }
+    } else { // active is true (normal command mode)
+        let prompt = ":";
+        if message.is_empty() || message == ":" {
            format!("{}{}", prompt, input)
        } else {
+            if input.is_empty() { // If command was just executed, input is cleared, show message
+                message.to_string()
+            } else { // Show input and message
                format!("{}{} | {}", prompt, input, message)
+            }
+        }
    };

-    let style = if active {
+    let content_width = UnicodeWidthStr::width(display_text.as_str());
+    let available_width = area.width as usize;
+    let padding_needed = available_width.saturating_sub(content_width);
+
+    let display_text_padded = if padding_needed > 0 {
+        format!("{}{}", display_text, " ".repeat(padding_needed))
+    } else {
+        // If text is too long, ratatui's Paragraph will handle truncation.
+        // We could also truncate here if specific behavior is needed:
+        // display_text.chars().take(available_width).collect::<String>()
+        display_text
+    };
+
+    // Determine style based on active state, but apply to the whole paragraph
+    let text_style = if active {
        Style::default().fg(theme.accent)
    } else {
+        // If not active, but there's a message, use default foreground.
+        // If message is also empty, this style won't matter much for empty text.
        Style::default().fg(theme.fg)
    };

-    let paragraph = Paragraph::new(display_text)
-        .block(Block::default().style(Style::default().bg(theme.bg)))
-        .style(style);
+    let paragraph = Paragraph::new(display_text_padded)
+        .block(Block::default().style(Style::default().bg(theme.bg))) // Block ensures bg for whole area
+        .style(text_style); // Style for the text itself

    f.render_widget(paragraph, area);
 }
--- a/client/src/components/common/find_file_palette.rs
+++ b/client/src/components/common/find_file_palette.rs
@@ -0,0 +1,142 @@
+// src/components/common/find_file_palette.rs
+
+use crate::config::colors::themes::Theme;
+use crate::modes::general::command_navigation::NavigationState; // Corrected path
+use ratatui::{
+    layout::{Constraint, Direction, Layout, Rect},
+    style::Style,
+    widgets::{Block, List, ListItem, Paragraph},
+    Frame,
+};
+use unicode_width::UnicodeWidthStr;
+
+const PALETTE_MAX_VISIBLE_OPTIONS: usize = 15;
+const PADDING_CHAR: &str = " ";
+
+pub fn render_find_file_palette(
+    f: &mut Frame,
+    area: Rect,
+    theme: &Theme,
+    navigation_state: &NavigationState,
+) {
+    let palette_display_input = navigation_state.get_display_input(); // Use the new method
+
+    let num_total_filtered = navigation_state.filtered_options.len();
+    let current_selected_list_idx = navigation_state.selected_index;
+
+    let mut display_start_offset = 0;
+    if num_total_filtered > PALETTE_MAX_VISIBLE_OPTIONS {
+        if let Some(sel_idx) = current_selected_list_idx {
+            if sel_idx >= display_start_offset + PALETTE_MAX_VISIBLE_OPTIONS {
+                display_start_offset = sel_idx - PALETTE_MAX_VISIBLE_OPTIONS + 1;
+            } else if sel_idx < display_start_offset {
+                display_start_offset = sel_idx;
+            }
+            display_start_offset = display_start_offset
+                .min(num_total_filtered.saturating_sub(PALETTE_MAX_VISIBLE_OPTIONS));
+        }
+    }
+    display_start_offset = display_start_offset.max(0);
+
+    let display_end_offset = (display_start_offset + PALETTE_MAX_VISIBLE_OPTIONS)
+        .min(num_total_filtered);
+
+    // navigation_state.filtered_options is Vec<(usize, String)>
+    // We only need the String part for display.
+    let visible_options_slice: Vec<&String> = if num_total_filtered > 0 {
+        navigation_state.filtered_options
+            [display_start_offset..display_end_offset]
+            .iter()
+            .map(|(_, opt_str)| opt_str)
+            .collect()
+    } else {
+        Vec::new()
+    };
+
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([
+            Constraint::Length(1), // For palette input line
+            Constraint::Min(0), // For options list, take remaining space
+        ])
+        .split(area);
+    
+    // Ensure list_area height does not exceed PALETTE_MAX_VISIBLE_OPTIONS
+    let list_area_height = std::cmp::min(chunks[1].height, PALETTE_MAX_VISIBLE_OPTIONS as u16);
+    let final_list_area = Rect::new(chunks[1].x, chunks[1].y, chunks[1].width, list_area_height);
+
+
+    let input_area = chunks[0];
+    // let list_area = chunks[1]; // Use final_list_area
+
+    let prompt_prefix = match navigation_state.navigation_type {
+        crate::modes::general::command_navigation::NavigationType::FindFile => "Find File: ",
+        crate::modes::general::command_navigation::NavigationType::TableTree => "Table Path: ",
+    };
+    let base_prompt_text = format!("{}{}", prompt_prefix, palette_display_input);
+    let prompt_text_width = UnicodeWidthStr::width(base_prompt_text.as_str());
+    let input_area_width = input_area.width as usize;
+    let input_padding_needed =
+        input_area_width.saturating_sub(prompt_text_width);
+
+    let padded_prompt_text = if input_padding_needed > 0 {
+        format!(
+            "{}{}",
+            base_prompt_text,
+            PADDING_CHAR.repeat(input_padding_needed)
+        )
+    } else {
+        base_prompt_text
+    };
+
+    let input_paragraph = Paragraph::new(padded_prompt_text)
+        .style(Style::default().fg(theme.accent).bg(theme.bg));
+    f.render_widget(input_paragraph, input_area);
+
+    let mut display_list_items: Vec<ListItem> =
+        Vec::with_capacity(PALETTE_MAX_VISIBLE_OPTIONS);
+
+    for (idx_in_visible_slice, opt_str) in
+        visible_options_slice.iter().enumerate()
+    {
+        // The selected_index in navigation_state is relative to the full filtered_options list.
+        // We need to check if the current item (from the visible slice) corresponds to the selected_index.
+        let original_filtered_idx = display_start_offset + idx_in_visible_slice;
+        let is_selected =
+            current_selected_list_idx == Some(original_filtered_idx);
+
+        let style = if is_selected {
+            Style::default().fg(theme.bg).bg(theme.accent)
+        } else {
+            Style::default().fg(theme.fg).bg(theme.bg)
+        };
+
+        let opt_width = opt_str.width() as u16;
+        let list_item_width = final_list_area.width;
+        let padding_amount = list_item_width.saturating_sub(opt_width);
+        let padded_opt_str = format!(
+            "{}{}",
+            opt_str,
+            PADDING_CHAR.repeat(padding_amount as usize)
+        );
+        display_list_items.push(ListItem::new(padded_opt_str).style(style));
+    }
+
+    // Fill remaining lines in the list area to maintain fixed height appearance
+    let num_rendered_options = display_list_items.len();
+    if num_rendered_options < PALETTE_MAX_VISIBLE_OPTIONS && (final_list_area.height as usize) > num_rendered_options {
+        for _ in num_rendered_options..(final_list_area.height as usize) {
+            let empty_padded_str =
+                PADDING_CHAR.repeat(final_list_area.width as usize);
+            display_list_items.push(
+                ListItem::new(empty_padded_str)
+                    .style(Style::default().fg(theme.bg).bg(theme.bg)),
+            );
+        }
+    }
+
+
+    let options_list_widget = List::new(display_list_items)
+        .block(Block::default().style(Style::default().bg(theme.bg)));
+    f.render_widget(options_list_widget, final_list_area);
+}
--- 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,13 +1,15 @@
-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,
@@ -16,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 {
@@ -35,16 +67,30 @@ pub fn render_status_line(
    let separator = " | ";
    let separator_width = UnicodeWidthStr::width(separator);

-    let fixed_width_with_fps = mode_width + separator_width + separator_width + 
-        program_info_width + separator_width + fps_width;
-    let show_fps = fixed_width_with_fps < available_width;
+    let fixed_width_with_fps = mode_width
+        + separator_width
+        + separator_width
+        + program_info_width
+        + separator_width
+        + fps_width;
+
+    let show_fps = fixed_width_with_fps <= available_width;

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

-    let dir_display_text = if UnicodeWidthStr::width(display_dir.as_str()) <= remaining_width_for_dir {
+    let dir_display_text_str = if UnicodeWidthStr::width(display_dir.as_str())
+        <= remaining_width_for_dir
+    {
        display_dir
    } else {
        let dir_name = Path::new(current_dir)
@@ -54,25 +100,55 @@ pub fn render_status_line(
        if UnicodeWidthStr::width(dir_name) <= remaining_width_for_dir {
            dir_name.to_string()
        } else {
-            dir_name.chars().take(remaining_width_for_dir).collect()
+            dir_name
+                .chars()
+                .take(remaining_width_for_dir)
+                .collect::<String>()
        }
    };

-    let mut spans = vec![
+    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;
+    }
+
+    let mut line_spans = vec![
        Span::styled(mode_text, Style::default().fg(theme.accent)),
-        Span::styled(" | ", Style::default().fg(theme.border)),
-        Span::styled(dir_display_text, Style::default().fg(theme.fg)),
-        Span::styled(" | ", Style::default().fg(theme.border)),
-        Span::styled(program_info, Style::default().fg(theme.secondary)),
+        Span::styled(separator, Style::default().fg(theme.border)),
+        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),
+        ),
    ];

    if show_fps {
-        spans.push(Span::styled(" | ", Style::default().fg(theme.border)));
-        spans.push(Span::styled(fps_text, 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),
+        ));
    }

-    let paragraph = Paragraph::new(Line::from(spans))
-        .style(Style::default().bg(theme.bg));
+    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),
+        ));
+    }
+
+    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
@@ -13,32 +13,33 @@ use crate::components::handlers::canvas::render_canvas;
 pub fn render_form(
    f: &mut Frame,
    area: Rect,
-    form_state: &impl CanvasState,
+    form_state_param: &impl CanvasState,
    fields: &[&str],
-    current_field: &usize,
+    current_field_idx: &usize,
    inputs: &[&String],
+    table_name: &str, // This parameter receives the correct table name
    theme: &Theme,
    is_edit_mode: bool,
    highlight_state: &HighlightState,
    total_count: u64,
    current_position: u64,
 ) {
-    // Create Adresar card
+    // Use the dynamic `table_name` parameter for the title instead of a hardcoded string.
+    let card_title = format!(" {} ", table_name);
+
    let adresar_card = Block::default()
        .borders(Borders::ALL)
        .border_style(Style::default().fg(theme.border))
-        .title(" Adresar ")
+        .title(card_title) // Use the dynamic 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([
@@ -47,20 +48,27 @@ pub fn render_form(
        ])
        .split(inner_area);

-    // Render count/position
-    let count_position_text = format!("Total: {} | Position: {}", total_count, current_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 {
+        format!("Total: 0 | New Entry ({})", current_position)
+    }
+    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(
        f,
        main_layout[1],
-        form_state,
+        form_state_param,
        fields,
-        current_field,
+        current_field_idx,
        inputs,
        theme,
        is_edit_mode,
--- 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/functions/modes/edit/auth_e.rs
+++ b/client/src/functions/modes/edit/auth_e.rs
@@ -29,8 +29,6 @@ pub async fn execute_common_action<S: CanvasState + Any>(
                        let outcome = save(
                            form_state,
                            grpc_client,
-                            current_position,
-                            total_count,
                        )
                        .await?;
                        let message = format!("Save successful: {:?}", outcome); // Simple message for now
@@ -40,8 +38,6 @@ pub async fn execute_common_action<S: CanvasState + Any>(
                        revert(
                            form_state,
                            grpc_client,
-                            current_position,
-                            total_count,
                        )
                        .await
                    }
--- a/client/src/functions/modes/edit/form_e.rs
+++ b/client/src/functions/modes/edit/form_e.rs
@@ -14,8 +14,6 @@ pub async fn execute_common_action<S: CanvasState + Any>(
    action: &str,
    state: &mut S,
    grpc_client: &mut GrpcClient,
-    current_position: &mut u64,
-    total_count: u64,
 ) -> Result<EventOutcome> {
    match action {
        "save" | "revert" => {
@@ -30,8 +28,6 @@ pub async fn execute_common_action<S: CanvasState + Any>(
                        let save_result = save(
                            form_state,
                            grpc_client,
-                            current_position,
-                            total_count,
                        ).await;
                        
                        match save_result {
@@ -50,8 +46,6 @@ pub async fn execute_common_action<S: CanvasState + Any>(
                        let revert_result = revert(
                            form_state,
                            grpc_client,
-                            current_position,
-                            total_count,
                        ).await;
                        
                        match revert_result {
--- 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,9 +9,23 @@ use std::env;

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

    dotenv().ok();
    run_ui().await
--- a/client/src/modes/canvas/common_mode.rs
+++ b/client/src/modes/canvas/common_mode.rs
@@ -24,8 +24,6 @@ pub async fn handle_core_action(
    auth_client: &mut AuthClient,
    terminal: &mut TerminalCore,
    app_state: &mut AppState,
-    current_position: &mut u64,
-    total_count: u64,
 ) -> Result<EventOutcome> {
    match action {
        "save" => {
@@ -36,8 +34,6 @@ pub async fn handle_core_action(
                let save_outcome = form_save(
                    form_state,
                    grpc_client,
-                    current_position,
-                    total_count,
                ).await.context("Register save action failed")?;
                let message = match save_outcome {
                    SaveOutcome::NoChange => "No changes to save.".to_string(),
@@ -58,8 +54,6 @@ pub async fn handle_core_action(
                let save_outcome = form_save(
                    form_state,
                    grpc_client,
-                    current_position,
-                    total_count,
                ).await?;
                match save_outcome {
                    SaveOutcome::NoChange => "No changes to save.".to_string(),
@@ -81,8 +75,6 @@ pub async fn handle_core_action(
                let message = form_revert(
                    form_state,
                    grpc_client,
-                    current_position,
-                    total_count,
                ).await.context("Form revert x action failed")?;
                Ok(EventOutcome::Ok(message))
            }
--- a/client/src/modes/canvas/edit.rs
+++ b/client/src/modes/canvas/edit.rs
@@ -66,7 +66,7 @@ pub async fn handle_edit_event(
                // 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, current_position, total_count).await?;
+                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),
--- 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
@@ -119,8 +119,6 @@ async fn process_command(
            let outcome = save(
                form_state,
                grpc_client,
-                current_position,
-                total_count,
            ).await?;
            let message = match outcome {
                SaveOutcome::CreatedNew(_) => "New entry created".to_string(),
@@ -134,8 +132,6 @@ async fn process_command(
            let message = revert(
                form_state,
                grpc_client,
-                current_position,
-                total_count,
            ).await?;
            command_input.clear();
            Ok(EventOutcome::Ok(message))
--- a/client/src/modes/general.rs
+++ b/client/src/modes/general.rs
@@ -1,3 +1,4 @@
 // src/client/modes/general.rs
 pub mod navigation;
 pub mod dialog;
+pub mod command_navigation;
--- a/client/src/modes/general/command_navigation.rs
+++ b/client/src/modes/general/command_navigation.rs
@@ -0,0 +1,396 @@
+// src/modes/general/command_navigation.rs
+use crate::config::binds::config::Config;
+use crate::modes::handlers::event::EventOutcome;
+use anyhow::Result;
+use common::proto::multieko2::table_definition::ProfileTreeResponse;
+use crossterm::event::{KeyCode, KeyEvent};
+use std::collections::{HashMap, HashSet};
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum NavigationType {
+    FindFile,
+    TableTree,
+}
+
+#[derive(Debug, Clone)]
+pub struct TableDependencyGraph {
+    all_tables: HashSet<String>,
+    dependents_map: HashMap<String, Vec<String>>,
+    root_tables: Vec<String>,
+}
+
+impl TableDependencyGraph {
+    pub fn from_profile_tree(profile_tree: &ProfileTreeResponse) -> Self {
+        let mut dependents_map: HashMap<String, Vec<String>> = HashMap::new();
+        let mut all_tables_set: HashSet<String> = HashSet::new();
+        let mut table_dependencies: HashMap<String, Vec<String>> = HashMap::new();
+
+        for profile in &profile_tree.profiles {
+            for table in &profile.tables {
+                all_tables_set.insert(table.name.clone());
+                table_dependencies.insert(table.name.clone(), table.depends_on.clone());
+
+                for dependency_name in &table.depends_on {
+                    dependents_map
+                        .entry(dependency_name.clone())
+                        .or_default()
+                        .push(table.name.clone());
+                }
+            }
+        }
+
+        let root_tables: Vec<String> = all_tables_set
+            .iter()
+            .filter(|name| {
+                table_dependencies
+                    .get(*name)
+                    .map_or(true, |deps| deps.is_empty())
+            })
+            .cloned()
+            .collect();
+
+        let mut sorted_root_tables = root_tables;
+        sorted_root_tables.sort();
+
+        for dependents_list in dependents_map.values_mut() {
+            dependents_list.sort();
+        }
+
+        Self {
+            all_tables: all_tables_set,
+            dependents_map,
+            root_tables: sorted_root_tables,
+        }
+    }
+
+    pub fn get_dependent_children(&self, path: &str) -> Vec<String> {
+        if path.is_empty() {
+            return self.root_tables.clone();
+        }
+
+        let path_segments: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();
+        if let Some(last_segment_name) = path_segments.last() {
+            if self.all_tables.contains(*last_segment_name) {
+                return self
+                    .dependents_map
+                    .get(*last_segment_name)
+                    .cloned()
+                    .unwrap_or_default();
+            }
+        }
+        Vec::new()
+    }
+}
+
+
+// ... (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,
+    pub selected_index: Option<usize>,
+    pub filtered_options: Vec<(usize, String)>,
+    pub navigation_type: NavigationType,
+    pub current_path: String,
+    pub graph: Option<TableDependencyGraph>,
+    pub all_options: Vec<String>,
+}
+
+impl NavigationState {
+    pub fn new() -> Self {
+        Self {
+            active: false,
+            input: String::new(),
+            selected_index: None,
+            filtered_options: Vec::new(),
+            navigation_type: NavigationType::FindFile,
+            current_path: String::new(),
+            graph: None,
+            all_options: Vec::new(),
+        }
+    }
+
+    pub fn activate_find_file(&mut self, options: Vec<String>) {
+        self.active = true;
+        self.navigation_type = NavigationType::FindFile;
+        self.all_options = options;
+        self.input.clear();
+        self.current_path.clear();
+        self.graph = None;
+        self.update_filtered_options();
+    }
+
+    pub fn activate_table_tree(&mut self, graph: TableDependencyGraph) {
+        self.active = true;
+        self.navigation_type = NavigationType::TableTree;
+        self.graph = Some(graph);
+        self.input.clear();
+        self.current_path.clear();
+        self.update_options_for_path();
+    }
+
+    pub fn deactivate(&mut self) {
+        self.active = false;
+        self.input.clear();
+        self.all_options.clear();
+        self.filtered_options.clear();
+        self.selected_index = None;
+        self.current_path.clear();
+        self.graph = None;
+    }
+
+    pub fn add_char(&mut self, c: char) {
+        match self.navigation_type {
+            NavigationType::FindFile => {
+                self.input.push(c);
+                self.update_filtered_options();
+            }
+            NavigationType::TableTree => {
+                if c == '/' {
+                    if !self.input.is_empty() {
+                        if self.current_path.is_empty() {
+                            self.current_path = self.input.clone();
+                        } else {
+                            self.current_path.push('/');
+                            self.current_path.push_str(&self.input);
+                        }
+                        self.input.clear();
+                        self.update_options_for_path();
+                    }
+                } else {
+                    self.input.push(c);
+                    self.update_filtered_options();
+                }
+            }
+        }
+    }
+
+    pub fn remove_char(&mut self) {
+        match self.navigation_type {
+            NavigationType::FindFile => {
+                self.input.pop();
+                self.update_filtered_options();
+            }
+            NavigationType::TableTree => {
+                if self.input.is_empty() {
+                    if !self.current_path.is_empty() {
+                        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 {
+                            self.input = self.current_path.clone();
+                            self.current_path.clear();
+                        }
+                        self.update_options_for_path();
+                        self.update_filtered_options();
+                    }
+                } else {
+                    self.input.pop();
+                    self.update_filtered_options();
+                }
+            }
+        }
+    }
+
+    pub fn move_up(&mut self) {
+        if self.filtered_options.is_empty() {
+            self.selected_index = None;
+            return;
+        }
+        self.selected_index = match self.selected_index {
+            Some(0) => Some(self.filtered_options.len() - 1),
+            Some(current) => Some(current - 1),
+            None => Some(self.filtered_options.len() - 1),
+        };
+    }
+
+    pub fn move_down(&mut self) {
+        if self.filtered_options.is_empty() {
+            self.selected_index = None;
+            return;
+        }
+        self.selected_index = match self.selected_index {
+            Some(current) if current >= self.filtered_options.len() - 1 => Some(0),
+            Some(current) => Some(current + 1),
+            None => Some(0),
+        };
+    }
+
+    pub fn get_selected_option_str(&self) -> Option<&str> {
+        self.selected_index
+            .and_then(|idx| self.filtered_options.get(idx))
+            .map(|(_, option_str)| option_str.as_str())
+    }
+
+    pub fn autocomplete_selected(&mut self) {
+        if let Some(selected_option_str) = self.get_selected_option_str() {
+            self.input = selected_option_str.to_string();
+            self.update_filtered_options();
+        }
+    }
+
+    pub fn get_display_input(&self) -> String {
+        match self.navigation_type {
+            NavigationType::FindFile => self.input.clone(),
+            NavigationType::TableTree => {
+                if self.current_path.is_empty() {
+                    self.input.clone()
+                } else {
+                    format!("{}/{}", self.current_path, self.input)
+                }
+            }
+        }
+    }
+
+    // --- START FIX ---
+    pub fn get_selected_value(&self) -> Option<String> {
+        match self.navigation_type {
+            NavigationType::FindFile => {
+                // 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| {
+                    if self.current_path.is_empty() {
+                        selected_name.to_string()
+                    } else {
+                        format!("{}/{}", self.current_path, selected_name)
+                    }
+                })
+            }
+        }
+    }
+    // --- END FIX ---
+
+    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);
+            } else {
+                self.all_options.clear();
+            }
+        }
+        self.update_filtered_options();
+    }
+
+    fn update_filtered_options(&mut self) {
+        let filter_text = match self.navigation_type {
+            NavigationType::FindFile => &self.input,
+            NavigationType::TableTree => &self.input,
+        }
+        .to_lowercase();
+
+        if filter_text.is_empty() {
+            self.filtered_options = self
+                .all_options
+                .iter()
+                .enumerate()
+                .map(|(i, opt)| (i, opt.clone()))
+                .collect();
+        } else {
+            self.filtered_options = self
+                .all_options
+                .iter()
+                .enumerate()
+                .filter(|(_, opt)| opt.to_lowercase().contains(&filter_text))
+                .map(|(i, opt)| (i, opt.clone()))
+                .collect();
+        }
+
+        if self.filtered_options.is_empty() {
+            self.selected_index = None;
+        } else {
+            self.selected_index = Some(0);
+        }
+    }
+}
+
+
+pub async fn handle_command_navigation_event(
+    navigation_state: &mut NavigationState,
+    key: KeyEvent,
+    config: &Config,
+) -> Result<EventOutcome> {
+    if !navigation_state.active {
+        return Ok(EventOutcome::Ok(String::new()));
+    }
+
+    match key.code {
+        KeyCode::Esc => {
+            navigation_state.deactivate();
+            Ok(EventOutcome::Ok("Navigation cancelled".to_string()))
+        }
+        KeyCode::Tab => {
+            if let Some(selected_opt_str) = navigation_state.get_selected_option_str() {
+                if navigation_state.input == selected_opt_str {
+                    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())) {
+                            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 {
+                                    navigation_state.current_path = path_before_nav;
+                                }
+                                navigation_state.update_options_for_path();
+                            }
+                        }
+                    }
+                } else {
+                    navigation_state.autocomplete_selected();
+                }
+            }
+            Ok(EventOutcome::Ok(String::new()))
+        }
+        KeyCode::Backspace => {
+            navigation_state.remove_char();
+            Ok(EventOutcome::Ok(String::new()))
+        }
+        KeyCode::Char(c) => {
+            navigation_state.add_char(c);
+            Ok(EventOutcome::Ok(String::new()))
+        }
+        _ => {
+            if let Some(action) = config.get_general_action(key.code, key.modifiers) {
+                match action {
+                    "move_up" => {
+                        navigation_state.move_up();
+                        Ok(EventOutcome::Ok(String::new()))
+                    }
+                    "move_down" => {
+                        navigation_state.move_down();
+                        Ok(EventOutcome::Ok(String::new()))
+                    }
+                    "select" => {
+                        if let Some(selected_value) = navigation_state.get_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(outcome)
+                        } else {
+                            Ok(EventOutcome::Ok("No selection".to_string()))
+                        }
+                    }
+                    _ => Ok(EventOutcome::Ok(String::new())),
+                }
+            } else {
+                Ok(EventOutcome::Ok(String::new()))
+            }
+        }
+    }
+}
--- a/client/src/modes/general/navigation.rs
+++ b/client/src/modes/general/navigation.rs
@@ -11,6 +11,7 @@ use crate::state::pages::admin::AdminState;
 use crate::state::pages::canvas_state::CanvasState;
 use crate::ui::handlers::context::UiContext;
 use crate::modes::handlers::event::EventOutcome;
+use crate::modes::general::command_navigation::{handle_command_navigation_event, NavigationState};
 use anyhow::Result;

 pub async fn handle_navigation_event(
@@ -25,7 +26,13 @@ pub async fn handle_navigation_event(
    command_mode: &mut bool,
    command_input: &mut String,
    command_message: &mut String,
+    navigation_state: &mut NavigationState,
 ) -> Result<EventOutcome> {
+    // Handle command navigation first if active
+    if navigation_state.active {
+        return handle_command_navigation_event(navigation_state, key, config).await;
+    }
+
    if let Some(action) = config.get_general_action(key.code, key.modifiers) {
        match action {
            "move_up" => {
--- a/client/src/modes/handlers/event.rs
+++ b/client/src/modes/handlers/event.rs
@@ -1,48 +1,53 @@
 // src/modes/handlers/event.rs
-use crossterm::event::Event;
-use crossterm::cursor::SetCursorStyle;
-use crate::services::grpc_client::GrpcClient;
-use crate::services::auth::AuthClient;
 use crate::config::binds::config::Config;
-use crate::ui::handlers::rat_state::UiStateHandler;
-use crate::ui::handlers::context::UiContext;
+use crate::config::binds::key_sequences::KeySequenceTracker;
 use crate::functions::common::buffer;
-use anyhow::Result;
-use crate::tui::{
-    terminal::core::TerminalCore,
-    functions::{
-        common::{form::SaveOutcome, login, register},
-    },
-    {intro, admin},
+use crate::functions::modes::navigation::add_logic_nav;
+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,
 };
+use crate::modes::{
+    canvas::{common_mode, edit, read_only},
+    common::{command_mode, commands::CommandHandler},
+    general::{dialog, navigation},
+    handlers::mode_manager::{AppMode, ModeManager},
+};
+use crate::services::auth::AuthClient;
+use crate::services::grpc_client::GrpcClient;
 use crate::state::{
    app::{
-        highlight::HighlightState,
-        state::AppState,
        buffer::{AppView, BufferState},
+        highlight::HighlightState,
+        search::SearchState, // Correctly imported
+        state::AppState,
    },
    pages::{
-        auth::{AuthState, LoginState, RegisterState},
        admin::AdminState,
+        auth::{AuthState, LoginState, RegisterState},
        canvas_state::CanvasState,
        form::FormState,
        intro::IntroState,
    },
 };
-use crate::modes::{
-    common::{command_mode, commands::CommandHandler},
-    handlers::mode_manager::{ModeManager, AppMode},
-    canvas::{edit, read_only, common_mode},
-    general::{navigation, dialog},
-};
-use crate::functions::modes::navigation::{admin_nav, add_table_nav};
-use crate::config::binds::key_sequences::KeySequenceTracker;
-use tokio::sync::mpsc;
 use crate::tui::functions::common::login::LoginResult;
 use crate::tui::functions::common::register::RegisterResult;
-use crate::functions::modes::navigation::add_table_nav::SaveTableResultSender;
-use crate::functions::modes::navigation::add_logic_nav::SaveLogicResultSender;
-use crate::functions::modes::navigation::add_logic_nav;
+use crate::tui::{
+    functions::common::{form::SaveOutcome, login, register},
+    terminal::core::TerminalCore,
+    {admin, intro},
+};
+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::{Event, KeyCode, KeyEvent};
+use tokio::sync::mpsc;
+use tokio::sync::mpsc::unbounded_channel;
+use tracing::{info, error};

 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum EventOutcome {
@@ -50,6 +55,16 @@ pub enum EventOutcome {
    Exit(String),
    DataSaved(SaveOutcome, String),
    ButtonSelected { context: UiContext, index: usize },
+    TableSelected { path: String },
+}
+
+impl EventOutcome {
+    pub fn get_message_if_ok(&self) -> String {
+        match self {
+            EventOutcome::Ok(msg) => msg.clone(),
+            _ => String::new(),
+        }
+    }
 }

 pub struct EventHandler {
@@ -62,10 +77,14 @@ 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>>,
 }

 impl EventHandler {
@@ -74,7 +93,9 @@ 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();
        Ok(EventHandler {
            command_mode: false,
            command_input: String::new(),
@@ -83,21 +104,126 @@ impl EventHandler {
            highlight_state: HighlightState::Off,
            edit_mode_cooldown: false,
            ideal_cursor_column: 0,
-            key_sequence_tracker: KeySequenceTracker::new(800),
+            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,
        })
    }

+    pub fn is_navigation_active(&self) -> bool {
+        self.navigation_state.active
+    }
+
+    pub fn activate_find_file(&mut self, options: Vec<String>) {
+        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,
@@ -107,10 +233,34 @@ impl EventHandler {
        admin_state: &mut AdminState,
        buffer_state: &mut BufferState,
        app_state: &mut AppState,
-        total_count: u64,
-        current_position: &mut u64,
    ) -> Result<EventOutcome> {
-        let 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);
+
+        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?;
+
+                if !self.navigation_state.active {
+                    self.command_message = outcome.get_message_if_ok();
+                    current_mode = ModeManager::derive_mode(app_state, self, admin_state);
+                }
+                app_state.update_mode(current_mode);
+                return Ok(outcome);
+            }
+            app_state.update_mode(current_mode);
+            return Ok(EventOutcome::Ok(String::new()));
+        }
+
        app_state.update_mode(current_mode);

        let current_view = {
@@ -121,48 +271,39 @@ impl EventHandler {
            else if ui.show_admin { AppView::Admin }
            else if ui.show_add_logic { AppView::AddLogic }
            else if ui.show_add_table { AppView::AddTable }
-            else if ui.show_form { AppView::Form }  // Remove the dynamic name part
+            else if ui.show_form { AppView::Form }
            else { AppView::Scratch }
        };
        buffer_state.update_history(current_view);

        if app_state.ui.dialog.dialog_show {
+            if let Event::Key(key_event) = event {
                if let Some(dialog_result) = dialog::handle_dialog_event(
-                &event,
-                config,
-                app_state,
-                login_state,
-                register_state,
-                buffer_state,
-                admin_state,
+                    &Event::Key(key_event), config, app_state, login_state,
+                    register_state, buffer_state, admin_state,
                ).await {
                    return dialog_result;
                }
+            } else if let Event::Resize(_, _) = event {
+            }
            return Ok(EventOutcome::Ok(String::new()));
        }

-        if let Event::Key(key) = event {
-            let key_code = key.code;
-            let modifiers = key.modifiers;
+        if let Event::Key(key_event) = event {
+            let key_code = key_event.code;
+            let modifiers = key_event.modifiers;

            if UiStateHandler::toggle_sidebar(&mut app_state.ui, config, key_code, modifiers) {
-                let message = format!("Sidebar {}",
-                    if app_state.ui.show_sidebar { "shown" } else { "hidden" }
-                );
+                let message = format!("Sidebar {}", if app_state.ui.show_sidebar { "shown" } else { "hidden" });
                return Ok(EventOutcome::Ok(message));
            }
            if UiStateHandler::toggle_buffer_list(&mut app_state.ui, config, key_code, modifiers) {
-                let message = format!("Buffer {}",
-                    if app_state.ui.show_buffer_list { "shown" } else { "hidden" }
-                );
+                let message = format!("Buffer {}", if app_state.ui.show_buffer_list { "shown" } else { "hidden" });
                return Ok(EventOutcome::Ok(message));
            }

-
            if !matches!(current_mode, AppMode::Edit | AppMode::Command) {
-                if let Some(action) = config.get_action_for_key_in_mode(
-                    &config.keybindings.global, key_code, modifiers
-                ) {
+                if let Some(action) = config.get_action_for_key_in_mode(&config.keybindings.global, key_code, modifiers) {
                    match action {
                        "next_buffer" => {
                            if buffer::switch_buffer(buffer_state, true) {
@@ -174,187 +315,121 @@ impl EventHandler {
                                return Ok(EventOutcome::Ok("Switched to previous buffer".to_string()));
                            }
                        }
-                        //"close_buffer" => {
-                         //   let message = buffer_state.close_buffer_with_intro_fallback();
-                          //  return Ok(EventOutcome::Ok(message));
-                        //}
                        "close_buffer" => {
-                            // TODO: Replace with actual table name from server response
-                            let current_table_name = Some("2025_customer"); // Your hardcoded 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 => {
-                    // Prioritize Admin Panel navigation if it's visible
-                    if app_state.ui.show_admin
-                        && auth_state.role.as_deref() == Some("admin") {
-                        if admin_nav::handle_admin_navigation(
-                            key,
-                            config,
-                            app_state,
-                            admin_state,
-                            buffer_state,
-                            &mut self.command_message,
-                        ) {
+                    if app_state.ui.show_admin && auth_state.role.as_deref() == Some("admin") {
+                        if admin_nav::handle_admin_navigation(key_event, config, app_state, admin_state, buffer_state, &mut self.command_message) {
                            return Ok(EventOutcome::Ok(self.command_message.clone()));
                        }
                    }
-                    // --- Add Logic Page Navigation ---
+
                    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,
-                            config,
-                            app_state,
-                            &mut admin_state.add_logic_state,
-                            &mut self.is_edit_mode,
-                            buffer_state,
-                            client_clone,
-                            sender_clone,
-                            &mut self.command_message,
+                            key_event, config, app_state, &mut admin_state.add_logic_state,
+                            &mut self.is_edit_mode, buffer_state, client_clone, sender_clone, &mut self.command_message,
                        ) {
                            return Ok(EventOutcome::Ok(self.command_message.clone()));
                        }
                    }

-                    // --- Add Table Page Navigation ---
                    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,
-                            config,
-                            app_state,
-                            &mut admin_state.add_table_state,
-                            client_clone,
-                            sender_clone,
-                            &mut self.command_message,
-
+                            key_event, config, app_state, &mut admin_state.add_table_state,
+                            client_clone, sender_clone, &mut self.command_message,
                        ) {
                            return Ok(EventOutcome::Ok(self.command_message.clone()));
                        }
                    }

                    let nav_outcome = navigation::handle_navigation_event(
-                        key,
-                        config,
-                        form_state,
-                        app_state,
-                        login_state,
-                        register_state,
-                        intro_state,
-                        admin_state,
-                        &mut self.command_mode,
-                        &mut self.command_input,
-                        &mut self.command_message,
+                        key_event, config, form_state, app_state, login_state, register_state,
+                        intro_state, admin_state, &mut self.command_mode, &mut self.command_input,
+                        &mut self.command_message, &mut self.navigation_state,
                    ).await;
+
                    match nav_outcome {
                        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() {
+                                    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)
                                }
-                                UiContext::Login => {
-                                    let login_action_message = match index {
-                                        0 => {
-                                            login::initiate_login(login_state, app_state, self.auth_client.clone(), self.login_result_sender.clone())
-                                        },
+                                UiContext::Login => match index {
+                                    0 => login::initiate_login(login_state, app_state, self.auth_client.clone(), self.login_result_sender.clone()),
                                    1 => login::back_to_main(login_state, app_state, buffer_state).await,
                                    _ => "Invalid Login Option".to_string(),
-                                    };
-                                    login_action_message
-                                }
-                                UiContext::Register => {
-                                    let register_action_message = match index {
-                                        0 => {
-                                            register::initiate_registration(register_state, app_state, self.auth_client.clone(), self.register_result_sender.clone())
                                },
+                                UiContext::Register => match index {
+                                    0 => register::initiate_registration(register_state, app_state, self.auth_client.clone(), self.register_result_sender.clone()),
                                    1 => register::back_to_login(register_state, app_state, buffer_state).await,
                                    _ => "Invalid Login Option".to_string(),
-                                    };
-                                    register_action_message
-                                }
+                                },
                                UiContext::Admin => {
                                    admin::handle_admin_selection(app_state, admin_state);
                                    format!("Admin Option {} selected", index)
                                }
-                                UiContext::Dialog => {
-                                    "Internal error: Unexpected dialog state".to_string()
-                                }
-                            }; // Semicolon added here
+                                UiContext::Dialog => "Internal error: Unexpected dialog state".to_string(),
+                            };
                            return Ok(EventOutcome::Ok(message));
                        }
                        other => return other,
                    }
-                },
+                }

                AppMode::ReadOnly => {
-                    // Check for Linewise highlight first
-                    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() };
+                    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()));
-                    }
-                    // Check for Character-wise highlight
-                    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()));
-                    }
-                    // Check for entering edit mode (before cursor)
-                    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()));
-                    }
-                    // Check for entering edit mode (after cursor)
-                    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{
+                            if app_state.ui.show_login || app_state.ui.show_register {
                                login_state.set_current_cursor_pos(current_cursor_pos + 1);
                                self.ideal_cursor_column = login_state.current_cursor_pos();
                            } else {
@@ -368,42 +443,28 @@ 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()));
-                    }
-                    // Check for entering command mode
-                    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()));
                    }

-                    // Check for common actions (save, quit, etc.) only if no mode change happened
                    if let Some(action) = config.get_common_action(key_code, modifiers) {
                        match action {
                            "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.auth_client,
-                                    terminal,
-                                    app_state,
-                                    current_position,
-                                    total_count,
+                                    action, form_state, auth_state, login_state, register_state,
+                                    &mut self.grpc_client, &mut self.auth_client, terminal, app_state,
                                ).await;
-                            },
+                            }
                            _ => {}
                        }
                    }

-                    // If no mode change or specific common action handled, delegate to read_only handler
                    let (_should_exit, message) = read_only::handle_read_only_event(
                        app_state,
-                        key,
+                        key_event,
                        config,
                        form_state,
                        login_state,
@@ -411,29 +472,22 @@ impl EventHandler {
                        &mut admin_state.add_table_state,
                        &mut admin_state.add_logic_state,
                        &mut self.key_sequence_tracker,
-                        current_position,
-                        total_count,
-                        grpc_client,
+                        &mut self.grpc_client, // <-- FIX 1
                        &mut self.command_message,
                        &mut self.edit_mode_cooldown,
                        &mut self.ideal_cursor_column,
-                    ).await?;
-                    // Note: handle_read_only_event should ignore mode entry keys internally now
+                    )
+                    .await?;
                    return Ok(EventOutcome::Ok(message));
-                }, // End AppMode::ReadOnly
+                }

                AppMode::Highlight => {
-                     // --- Handle Highlight Mode Specific Keys ---
-                     // 1. Check for Exit first
                    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()));
-                     }
-                     // 2. Check for Switch to Linewise
-                     else if config.get_highlight_action_for_key(key_code, modifiers) == Some("enter_highlight_mode_linewise") {
-                         // Only switch if currently characterwise
+                    } 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.command_message = "-- LINE HIGHLIGHT --".to_string();
@@ -443,14 +497,16 @@ impl EventHandler {
                    }

                    let (_should_exit, message) = read_only::handle_read_only_event(
-                        app_state, key, config, form_state, login_state,
+                        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,
-                        current_position, 
-                        total_count, 
-                        grpc_client,
+                        &mut self.grpc_client, // <-- FIX 2
                        &mut self.command_message,
                        &mut self.edit_mode_cooldown,
                        &mut self.ideal_cursor_column,
@@ -460,73 +516,35 @@ impl EventHandler {
                }

                AppMode::Edit => {
-                    // First, check for common actions (save, revert, etc.) that apply in Edit mode
-                    // These might take precedence or have different behavior than the edit handler
                    if let Some(action) = config.get_common_action(key_code, modifiers) {
-                        // Handle common actions like save, revert, force_quit, save_and_quit
-                        // Ensure these actions return EventOutcome directly if they might exit the app
                        match action {
                            "save" | "force_quit" | "save_and_quit" | "revert" => {
-                                // This call likely returns EventOutcome, handle it directly
                                return common_mode::handle_core_action(
-                                    action,
-                                    form_state,
-                                    auth_state,
-                                    login_state,
-                                    register_state,
-                                    grpc_client,
-                                    &mut self.auth_client,
-                                    terminal,
-                                    app_state,
-                                    current_position,
-                                    total_count,
+                                    action, form_state, auth_state, login_state, register_state,
+                                    &mut self.grpc_client, &mut self.auth_client, terminal, app_state, // <-- FIX 3
                                ).await;
-                            },
-                            // Handle other common actions if necessary
+                            }
                            _ => {}
                        }
-                        // If a common action was handled but didn't return/exit,
-                        // we might want to stop further processing for this key event.
-                        // Depending on the action, you might return Ok(EventOutcome::Ok(...)) here.
-                        // For now, assume common actions either exit or don't prevent further processing.
                    }

-                    // If no common action took precedence, delegate to the edit-specific handler
+                    let mut current_position = form_state.current_position;
+                    let total_count = form_state.total_count;
                    let edit_result = edit::handle_edit_event(
-                        key,
-                        config,
-                        form_state,
-                        login_state,
-                        register_state,
-                        admin_state,
-                        &mut self.ideal_cursor_column,
-                        current_position,
-                        total_count,
-                        grpc_client,
-                        app_state,
+                        key_event, config, form_state, login_state, register_state, admin_state,
+                        &mut self.ideal_cursor_column, &mut current_position, total_count,
+                        &mut self.grpc_client, app_state, // <-- FIX 4
                    ).await;

                    match edit_result {
                        Ok(edit::EditEventOutcome::ExitEditMode) => {
-                            // The edit handler signaled to exit the mode
                            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)?;
-                            // Adjust cursor position if needed
-                            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() };
+                            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 };
@@ -536,48 +554,108 @@ impl EventHandler {
                            return Ok(EventOutcome::Ok(self.command_message.clone()));
                        }
                        Ok(edit::EditEventOutcome::Message(msg)) => {
-                            // Stay in edit mode, update message if not empty
-                            if !msg.is_empty() {
-                                self.command_message = msg;
-                            }
-                            self.key_sequence_tracker.reset(); // Reset sequence tracker on successful edit action
+                            if !msg.is_empty() { self.command_message = msg; }
+                            self.key_sequence_tracker.reset();
                            return Ok(EventOutcome::Ok(self.command_message.clone()));
                        }
-                        Err(e) => {
-                            // Handle error from the edit handler
-                            return Err(e.into());
+                        Err(e) => { return Err(e.into()); }
                    }
                }
-                }, // End AppMode::Edit

                AppMode::Command => {
-                    let outcome = command_mode::handle_command_event(
-                        key,
-                        config,
-                        app_state,
-                        login_state,
-                        register_state,
-                        form_state,
-                        &mut self.command_input,
-                        &mut self.command_message,
-                        grpc_client,
-                        command_handler,
-                        terminal,
-                        current_position,
-                        total_count,
-                    ).await?;
-
-                    if let EventOutcome::Ok(msg) = &outcome {
-                        if msg == "Exited command mode" {
+                    if config.is_exit_command_mode(key_code, modifiers) {
+                        self.command_input.clear();
+                        self.command_message.clear();
                        self.command_mode = false;
+                        self.key_sequence_tracker.reset();
+                        return Ok(EventOutcome::Ok("Exited command mode".to_string()));
                    }
-                    }
+
+                    if config.is_command_execute(key_code, modifiers) {
+                        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, app_state, login_state, register_state, form_state,
+                            &mut self.command_input, &mut self.command_message, &mut self.grpc_client, // <-- FIX 5
+                            command_handler, terminal, &mut current_position, total_count,
+                        ).await?;
+                        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);
+                        app_state.update_mode(new_mode);
                        return Ok(outcome);
                    }
+
+                    if key_code == KeyCode::Backspace {
+                        self.command_input.pop();
+                        self.key_sequence_tracker.reset();
+                        return Ok(EventOutcome::Ok(String::new()));
                    }
+
+                    if let KeyCode::Char(c) = key_code {
+                        if c == 'f' {
+                            self.key_sequence_tracker.add_key(key_code);
+                            let sequence = self.key_sequence_tracker.get_sequence();
+
+                            if config.matches_key_sequence_generalized(&sequence) == Some("find_file_palette_toggle") {
+                                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();
+
+                                    self.navigation_state.activate_find_file(all_table_paths);
+
+                                    self.command_mode = false;
+                                    self.command_input.clear();
+                                    self.command_message.clear();
+                                    self.key_sequence_tracker.reset();
+                                    return Ok(EventOutcome::Ok("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') {
+                                        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()));
+                                }
+                            }
+
+                            if config.is_key_sequence_prefix(&sequence) {
+                                return Ok(EventOutcome::Ok(String::new()));
+                            }
+                        }
+
+                        if c != 'f' && !self.key_sequence_tracker.current_sequence.is_empty() {
+                            self.key_sequence_tracker.reset();
+                        }
+
+                        self.command_input.push(c);
+                        return Ok(EventOutcome::Ok(String::new()));
+                    }
+
+                    self.key_sequence_tracker.reset();
+                    return Ok(EventOutcome::Ok(String::new()));
+                }
+            }
+        } else if let Event::Resize(_, _) = event {
+            return Ok(EventOutcome::Ok("Resized".to_string()));
        }

        self.edit_mode_cooldown = false;
        Ok(EventOutcome::Ok(self.command_message.clone()))
    }
+
+    fn is_processed_command(&self, command: &str) -> bool {
+        matches!(command, "w" | "q" | "q!" | "wq" | "r")
+    }
 }
--- a/client/src/modes/handlers/mode_manager.rs
+++ b/client/src/modes/handlers/mode_manager.rs
@@ -23,6 +23,10 @@ impl ModeManager {
        event_handler: &EventHandler,
        admin_state: &AdminState,
    ) -> AppMode {
+        if event_handler.navigation_state.active {
+            return AppMode::General;
+        }
+
        if event_handler.command_mode {
            return AppMode::Command;
        }
@@ -78,12 +82,12 @@ impl ModeManager {
    }

    // Mode transition rules
-    pub fn can_enter_command_mode(current_mode: AppMode) -> bool {
-        !matches!(current_mode, AppMode::Edit)  // Can't enter from Edit mode
+pub fn can_enter_command_mode(current_mode: AppMode) -> bool {
+        !matches!(current_mode, AppMode::Edit)
    }

    pub fn can_enter_edit_mode(current_mode: AppMode) -> bool {
-        matches!(current_mode, AppMode::ReadOnly)  // Only from ReadOnly
+        matches!(current_mode, AppMode::ReadOnly)
    }

    pub fn can_enter_read_only_mode(current_mode: AppMode) -> bool {
--- 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,101 +1,212 @@
 // src/services/grpc_client.rs

 use tonic::transport::Channel;
-use common::proto::multieko2::adresar::adresar_client::AdresarClient;
-use common::proto::multieko2::adresar::{AdresarResponse, PostAdresarRequest, PutAdresarRequest};
-use common::proto::multieko2::common::{CountResponse, PositionRequest, Empty};
+use common::proto::multieko2::common::{CountResponse, Empty};
 use common::proto::multieko2::table_structure::table_structure_service_client::TableStructureServiceClient;
-// Import the new request type for table structure
-use common::proto::multieko2::table_structure::{TableStructureResponse, GetTableStructureRequest};
+use common::proto::multieko2::table_structure::{GetTableStructureRequest, TableStructureResponse};
 use common::proto::multieko2::table_definition::{
    table_definition_client::TableDefinitionClient,
-    ProfileTreeResponse, PostTableDefinitionRequest, TableDefinitionResponse,
+    PostTableDefinitionRequest, ProfileTreeResponse, TableDefinitionResponse,
 };
 use common::proto::multieko2::table_script::{
    table_script_client::TableScriptClient,
    PostTableScriptRequest, TableScriptResponse,
 };
-use anyhow::Result;
+use common::proto::multieko2::tables_data::{
+    tables_data_client::TablesDataClient,
+    GetTableDataByPositionRequest,
+    GetTableDataResponse,
+    GetTableDataCountRequest,
+    PostTableDataRequest, PostTableDataResponse, PutTableDataRequest,
+    PutTableDataResponse,
+};
+use common::proto::multieko2::search::{
+    searcher_client::SearcherClient, SearchRequest, SearchResponse,
+};
+use anyhow::{Context, Result}; // Added Context
+use std::collections::HashMap; // NEW

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

 impl GrpcClient {
    pub async fn new() -> Result<Self> {
-        let adresar_client = AdresarClient::connect("http://[::1]:50051").await?;
-        let table_structure_client = TableStructureServiceClient::connect("http://[::1]:50051").await?;
-        let table_definition_client = TableDefinitionClient::connect("http://[::1]:50051").await?;
-        let table_script_client = TableScriptClient::connect("http://[::1]:50051").await?;
+        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());
+        // NEW: Instantiate the search client
+        let search_client = SearcherClient::new(channel.clone());

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

-    pub async fn get_adresar_count(&mut self) -> Result<u64> {
-        let request = tonic::Request::new(Empty::default());
-        let response: CountResponse = self.adresar_client.get_adresar_count(request).await?.into_inner();
-        Ok(response.count as u64)
-    }
-
-    pub async fn get_adresar_by_position(&mut self, position: u64) -> Result<AdresarResponse> {
-        let request = tonic::Request::new(PositionRequest { position: position as i64 });
-        let response: AdresarResponse = self.adresar_client.get_adresar_by_position(request).await?.into_inner();
-        Ok(response)
-    }
-
-    pub async fn post_adresar(&mut self, request: PostAdresarRequest) -> Result<tonic::Response<AdresarResponse>> {
-        let request = tonic::Request::new(request);
-        let response = self.adresar_client.post_adresar(request).await?;
-        Ok(response)
-    }
-
-    pub async fn put_adresar(&mut self, request: PutAdresarRequest) -> Result<tonic::Response<AdresarResponse>> {
-        let request = tonic::Request::new(request);
-        let response = self.adresar_client.put_adresar(request).await?;
-        Ok(response)
-    }
-
-    // Updated get_table_structure method
    pub async fn get_table_structure(
        &mut self,
        profile_name: String,
        table_name: String,
    ) -> Result<TableStructureResponse> {
-        // Create the new request type
        let grpc_request = GetTableStructureRequest {
            profile_name,
            table_name,
        };
        let request = tonic::Request::new(grpc_request);
-        // Call the new gRPC method
-        let response = self.table_structure_client.get_table_structure(request).await?;
+        let response = self
+            .table_structure_client
+            .get_table_structure(request)
+            .await
+            .context("gRPC GetTableStructure call failed")?;
        Ok(response.into_inner())
    }

-    pub async fn get_profile_tree(&mut self) -> Result<ProfileTreeResponse> {
+    pub async fn get_profile_tree(
+        &mut self,
+    ) -> Result<ProfileTreeResponse> {
        let request = tonic::Request::new(Empty::default());
-        let response = self.table_definition_client.get_profile_tree(request).await?;
+        let response = self
+            .table_definition_client
+            .get_profile_tree(request)
+            .await
+            .context("gRPC GetProfileTree call failed")?;
        Ok(response.into_inner())
    }

-    pub async fn post_table_definition(&mut self, request: PostTableDefinitionRequest) -> Result<TableDefinitionResponse> {
+    pub async fn post_table_definition(
+        &mut self,
+        request: PostTableDefinitionRequest,
+    ) -> Result<TableDefinitionResponse> {
        let tonic_request = tonic::Request::new(request);
-        let response = self.table_definition_client.post_table_definition(tonic_request).await?;
+        let response = self
+            .table_definition_client
+            .post_table_definition(tonic_request)
+            .await
+            .context("gRPC PostTableDefinition call failed")?;
        Ok(response.into_inner())
    }

-    pub async fn post_table_script(&mut self, request: PostTableScriptRequest) -> Result<TableScriptResponse> {
+    pub async fn post_table_script(
+        &mut self,
+        request: PostTableScriptRequest,
+    ) -> Result<TableScriptResponse> {
        let tonic_request = tonic::Request::new(request);
-        let response = self.table_script_client.post_table_script(tonic_request).await?;
+        let response = self
+            .table_script_client
+            .post_table_script(tonic_request)
+            .await
+            .context("gRPC PostTableScript call failed")?;
+        Ok(response.into_inner())
+    }
+
+    // NEW Methods for TablesData service
+    pub async fn get_table_data_count(
+        &mut self,
+        profile_name: String,
+        table_name: String,
+    ) -> Result<u64> {
+        let grpc_request = GetTableDataCountRequest {
+            profile_name,
+            table_name,
+        };
+        let request = tonic::Request::new(grpc_request);
+        let response = self
+            .tables_data_client
+            .get_table_data_count(request)
+            .await
+            .context("gRPC GetTableDataCount call failed")?;
+        Ok(response.into_inner().count as u64)
+    }
+
+    pub async fn get_table_data_by_position(
+        &mut self,
+        profile_name: String,
+        table_name: String,
+        position: i32,
+    ) -> Result<GetTableDataResponse> {
+        let grpc_request = GetTableDataByPositionRequest {
+            profile_name,
+            table_name,
+            position,
+        };
+        let request = tonic::Request::new(grpc_request);
+        let response = self
+            .tables_data_client
+            .get_table_data_by_position(request)
+            .await
+            .context("gRPC GetTableDataByPosition call failed")?;
+        Ok(response.into_inner())
+    }
+
+    pub async fn post_table_data(
+        &mut self,
+        profile_name: String,
+        table_name: String,
+        data: HashMap<String, String>,
+    ) -> Result<PostTableDataResponse> {
+        let grpc_request = PostTableDataRequest {
+            profile_name,
+            table_name,
+            data,
+        };
+        let request = tonic::Request::new(grpc_request);
+        let response = self
+            .tables_data_client
+            .post_table_data(request)
+            .await
+            .context("gRPC PostTableData call failed")?;
+        Ok(response.into_inner())
+    }
+
+    pub async fn put_table_data(
+        &mut self,
+        profile_name: String,
+        table_name: String,
+        id: i64,
+        data: HashMap<String, String>,
+    ) -> Result<PutTableDataResponse> {
+        let grpc_request = PutTableDataRequest {
+            profile_name,
+            table_name,
+            id,
+            data,
+        };
+        let request = tonic::Request::new(grpc_request);
+        let response = self
+            .tables_data_client
+            .put_table_data(request)
+            .await
+            .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
@@ -5,6 +5,7 @@ use crate::state::pages::form::FormState;
 use crate::tui::functions::common::form::SaveOutcome;
 use crate::state::pages::add_logic::AddLogicState;
 use crate::state::app::state::AppState;
+use crate::utils::columns::filter_user_columns;
 use anyhow::{Context, Result};

 pub struct UiService;
@@ -82,7 +83,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);
@@ -91,112 +92,151 @@ impl UiService {
        }
    }

-    pub async fn initialize_app_state(
+    pub async fn initialize_app_state_and_form(
        grpc_client: &mut GrpcClient,
        app_state: &mut AppState,
-    ) -> Result<Vec<String>> {
-        // Fetch profile tree
-        let profile_tree = grpc_client.get_profile_tree().await.context("Failed to get profile tree")?;
+    ) -> Result<(String, String, Vec<String>)> {
+        let profile_tree = grpc_client
+            .get_profile_tree()
+            .await
+            .context("Failed to get profile tree")?;
        app_state.profile_tree = profile_tree;

-        // TODO for general tables and not hardcoded
-        let default_profile_name = "default".to_string();
-        let default_table_name = "2025_customer".to_string();
+        // Determine initial table to load (e.g., first table of first profile, or a default)
+        let initial_profile_name = app_state
+            .profile_tree
+            .profiles
+            .first()
+            .map(|p| p.name.clone())
+            .unwrap_or_else(|| "default".to_string());
+
+        let initial_table_name = app_state
+            .profile_tree
+            .profiles
+            .first()
+            .and_then(|p| p.tables.first().map(|t| t.name.clone()))
+            .unwrap_or_else(|| "2025_company_data1".to_string()); // Fallback if no tables
+
+        app_state.set_current_view_table(
+            initial_profile_name.clone(),
+            initial_table_name.clone(),
+        );

-        // Fetch table structure for the default table
        let table_structure = grpc_client
-            .get_table_structure(default_profile_name, default_table_name)
+            .get_table_structure(
+                initial_profile_name.clone(),
+                initial_table_name.clone(),
+            )
            .await
-            .context("Failed to get initial table structure")?;
+            .context(format!(
+                "Failed to get initial table structure for {}.{}",
+                initial_profile_name, initial_table_name
+            ))?;

-        // Extract the column names from the response
        let column_names: Vec<String> = table_structure
            .columns
            .iter()
            .map(|col| col.name.clone())
            .collect();

-        Ok(column_names)
+        let filtered_columns = filter_user_columns(column_names);
+
+        Ok((initial_profile_name, initial_table_name, filtered_columns))
    }

-    pub async fn initialize_adresar_count(
+    pub async fn fetch_and_set_table_count(
+        grpc_client: &mut GrpcClient,
+        form_state: &mut FormState,
+    ) -> Result<()> {
+        let total_count = grpc_client
+            .get_table_data_count(
+                form_state.profile_name.clone(),
+                form_state.table_name.clone(),
+            )
+            .await
+            .context(format!(
+                "Failed to get count for table {}.{}",
+                form_state.profile_name, form_state.table_name
+            ))?;
+        form_state.total_count = total_count;
+
+        if total_count > 0 {
+            form_state.current_position = total_count;
+        } else {
+            form_state.current_position = 1;
+        }
+        Ok(())
+    }
+
+    pub async fn load_table_data_by_position(
        grpc_client: &mut GrpcClient,
-        app_state: &mut AppState,
-    ) -> Result<()> {
-        let total_count = grpc_client.get_adresar_count().await.context("Failed to get adresar count")?;
-        app_state.update_total_count(total_count);
-        app_state.update_current_position(total_count.saturating_add(1)); // Start in new entry mode
-        Ok(())
-    }
-
-    pub async fn update_adresar_count(
-        grpc_client: &mut GrpcClient,
-        app_state: &mut AppState,
-    ) -> Result<()> {
-        let total_count = grpc_client.get_adresar_count().await.context("Failed to get adresar by position")?;
-        app_state.update_total_count(total_count);
-        Ok(())
-    }
-
-    pub async fn load_adresar_by_position(
-        grpc_client: &mut GrpcClient,
-        _app_state: &mut AppState,
        form_state: &mut FormState,
-        position: u64,
    ) -> Result<String> {
-        match grpc_client.get_adresar_by_position(position).await {
+        if form_state.current_position == 0 || (form_state.total_count > 0 && form_state.current_position > form_state.total_count) {
+            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 {
+            form_state.reset_to_empty();
+            return Ok(format!(
+                "New entry mode for empty table {}.{}",
+                form_state.profile_name, form_state.table_name
+            ));
+        }
+
+        match grpc_client
+            .get_table_data_by_position(
+                form_state.profile_name.clone(),
+                form_state.table_name.clone(),
+                form_state.current_position as i32,
+            )
+            .await
+        {
            Ok(response) => {
-                // Set the ID properly
-                form_state.id = response.id;
-
-                // Update form values dynamically
-                form_state.values = vec![
-                    response.firma,
-                    response.kz,
-                    response.drc,
-                    response.ulica,
-                    response.psc,
-                    response.mesto,
-                    response.stat,
-                    response.banka,
-                    response.ucet,
-                    response.skladm,
-                    response.ico,
-                    response.kontakt,
-                    response.telefon,
-                    response.skladu,
-                    response.fax,
-                ];
-
-                form_state.has_unsaved_changes = false;
-                Ok(format!("Loaded entry {}", position))
+                // 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,
+                    form_state.total_count,
+                    form_state.profile_name,
+                    form_state.table_name
+                ))
            }
            Err(e) => {
-                Ok(format!("Error loading entry: {}", e))
+                tracing::error!(
+                    "Error loading entry {} for table {}.{}: {}",
+                    form_state.current_position,
+                    form_state.profile_name,
+                    form_state.table_name,
+                    e
+                );
+                Err(anyhow::anyhow!(
+                    "Error loading entry {}: {}",
+                    form_state.current_position,
+                    e
+                ))
            }
        }
    }

-    /// Handles the consequences of a save operation, like updating counts.
    pub async fn handle_save_outcome(
        save_outcome: SaveOutcome,
-        grpc_client: &mut GrpcClient,
-        app_state: &mut AppState,
+        _grpc_client: &mut GrpcClient,
+        _app_state: &mut AppState,
        form_state: &mut FormState,
    ) -> Result<()> {
        match save_outcome {
            SaveOutcome::CreatedNew(new_id) => {
-                // A new record was created, update the count!
-                UiService::update_adresar_count(grpc_client, app_state).await?;
-                // Navigate to the new record (now that count is updated)
-                app_state.update_current_position(app_state.total_count);
-                form_state.id = new_id; // Ensure ID is set (might be redundant if save already did it)
+                form_state.id = new_id;
            }
            SaveOutcome::UpdatedExisting | SaveOutcome::NoChange => {
-                // No count update needed for these outcomes
+                // 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,15 @@
-// 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 crate::state::app::search::SearchState; // ADDED
 use anyhow::Result;
+#[cfg(feature = "ui-debug")]
+use std::time::Instant;

+// --- YOUR EXISTING DIALOGSTATE IS UNTOUCHED ---
 pub struct DialogState {
    pub dialog_show: bool,
    pub dialog_title: String,
@@ -26,23 +30,39 @@ pub struct UiState {
    pub show_form: bool,
    pub show_login: bool,
    pub show_register: bool,
+    pub show_search_palette: bool, // ADDED
    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,
-    pub total_count: u64,
-    pub current_position: u64,
    pub profile_tree: ProfileTreeResponse,
    pub selected_profile: Option<String>,
    pub current_mode: AppMode,
+    pub current_view_profile_name: Option<String>,
+    pub current_view_table_name: Option<String>,
+
    pub focused_button_index: usize,
    pub pending_table_structure_fetch: Option<(String, String)>,

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

 impl AppState {
@@ -52,33 +72,32 @@ impl AppState {
            .to_string();
        Ok(AppState {
            current_dir,
-            total_count: 0,
-            current_position: 0,
            profile_tree: ProfileTreeResponse::default(),
            selected_profile: None,
+            current_view_profile_name: None,
+            current_view_table_name: None,
            current_mode: AppMode::General,
            focused_button_index: 0,
            pending_table_structure_fetch: None,
+            search_state: None, // ADDED
            ui: UiState::default(),
+
+            #[cfg(feature = "ui-debug")]
+            debug_state: None,
        })
    }

-    // Existing methods remain unchanged
-    pub fn update_total_count(&mut self, total_count: u64) {
-        self.total_count = total_count;
-    }
-
-    pub fn update_current_position(&mut self, current_position: u64) {
-        self.current_position = current_position;
-    }
+    // --- ALL YOUR EXISTING METHODS ARE UNTOUCHED ---

    pub fn update_mode(&mut self, mode: AppMode) {
        self.current_mode = mode;
    }

-    // 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 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);
+    }
+
    pub fn show_dialog(
        &mut self,
        title: &str,
@@ -96,19 +115,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,
@@ -118,16 +135,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();
@@ -136,32 +149,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())
    }
 }
@@ -178,13 +189,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,6 +1,5 @@
 // src/state/canvas_state.rs

-
 pub trait CanvasState {
    fn current_field(&self) -> usize;
    fn current_cursor_pos(&self) -> usize;
--- a/client/src/state/pages/form.rs
+++ b/client/src/state/pages/form.rs
@@ -1,4 +1,6 @@
 // src/state/pages/form.rs
+
+use std::collections::HashMap;
 use crate::config::colors::themes::Theme;
 use ratatui::layout::Rect;
 use ratatui::Frame;
@@ -7,6 +9,10 @@ use crate::state::pages::canvas_state::CanvasState;

 pub struct FormState {
    pub id: i64,
+    pub profile_name: String,
+    pub table_name: String,
+    pub total_count: u64,
+    pub current_position: u64,
    pub fields: Vec<String>,
    pub values: Vec<String>,
    pub current_field: usize,
@@ -15,11 +21,18 @@ pub struct FormState {
 }

 impl FormState {
-    /// Create a new FormState with dynamic fields.
-    pub fn new(fields: Vec<String>) -> Self {
-        let values = vec![String::new(); fields.len()]; // Initialize values for each field
+    pub fn new(
+        profile_name: String,
+        table_name: String,
+        fields: Vec<String>,
+    ) -> Self {
+        let values = vec![String::new(); fields.len()];
        FormState {
            id: 0,
+            profile_name,
+            table_name,
+            total_count: 0,
+            current_position: 1,
            fields,
            values,
            current_field: 0,
@@ -28,6 +41,7 @@ impl FormState {
        }
    }

+    // This signature is now correct and only deals with form-related state.
    pub fn render(
        &self,
        f: &mut Frame,
@@ -35,31 +49,39 @@ impl FormState {
        theme: &Theme,
        is_edit_mode: bool,
        highlight_state: &HighlightState,
-        total_count: u64,
-        current_position: u64,
    ) {
-        let fields: Vec<&str> = self.fields.iter().map(|s| s.as_str()).collect();
-        let values: Vec<&String> = self.values.iter().collect();
+        let fields_str_slice: Vec<&str> =
+            self.fields.iter().map(|s| s.as_str()).collect();
+        let values_str_slice: Vec<&String> = self.values.iter().collect();

        crate::components::form::form::render_form(
            f,
            area,
            self,
-            &fields,
+            &fields_str_slice,
            &self.current_field,
-            &values,
+            &values_str_slice,
+            &self.table_name,
            theme,
            is_edit_mode,
            highlight_state,
-            total_count,
-            current_position,
+            self.total_count,
+            self.current_position,
        );
    }

+    // ... other methods are unchanged ...
    pub fn reset_to_empty(&mut self) {
-        self.id = 0; // Reset ID to 0 for new entries
-        self.values.iter_mut().for_each(|v| v.clear()); // Clear all values
+        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;
+        if self.total_count > 0 {
+            self.current_position = self.total_count + 1;
+        } else {
+            self.current_position = 1;
+        }
    }

    pub fn get_current_input(&self) -> &str {
@@ -75,15 +97,39 @@ impl FormState {
            .expect("Invalid current_field index")
    }

-    pub fn update_from_response(&mut self, response: common::proto::multieko2::adresar::AdresarResponse) {
-        self.id = response.id;
-        self.values = vec![
-            response.firma, response.kz, response.drc,
-            response.ulica, response.psc, response.mesto,
-            response.stat, response.banka, response.ucet,
-            response.skladm, response.ico, response.kontakt,
-            response.telefon, response.skladu, response.fax,
-        ];
+    pub fn update_from_response(
+        &mut self,
+        response_data: &HashMap<String, String>,
+        new_position: u64,
+    ) {
+        self.values = self.fields.iter().map(|field_from_schema| {
+            response_data
+                .iter()
+                .find(|(key_from_data, _)| key_from_data.eq_ignore_ascii_case(field_from_schema))
+                .map(|(_, value)| value.clone())
+                .unwrap_or_default()
+        }).collect();
+
+        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 {
+            self.id = 0;
+        }
+
+        self.current_position = new_position;
+        self.has_unsaved_changes = false;
+        self.current_field = 0;
+        self.current_cursor_pos = 0;
    }
 }

@@ -105,31 +151,24 @@ impl CanvasState for FormState {
    }

    fn get_current_input(&self) -> &str {
-        self.values
-            .get(self.current_field)
-            .map(|s| s.as_str())
-            .unwrap_or("")
+        FormState::get_current_input(self)
    }

    fn get_current_input_mut(&mut self) -> &mut String {
-        self.values
-            .get_mut(self.current_field)
-            .expect("Invalid current_field index")
+        FormState::get_current_input_mut(self)
    }

    fn fields(&self) -> Vec<&str> {
        self.fields.iter().map(|s| s.as_str()).collect()
    }

-    // --- Implement the setter methods ---
    fn set_current_field(&mut self, index: usize) {
-        if index < self.fields.len() { // Basic bounds check
+        if index < self.fields.len() {
            self.current_field = index;
        }
    }

    fn set_current_cursor_pos(&mut self, pos: usize) {
-        // Optional: Add validation based on current input length if needed
        self.current_cursor_pos = pos;
    }

@@ -137,12 +176,11 @@ impl CanvasState for FormState {
        self.has_unsaved_changes = changed;
    }

-    // --- Autocomplete Support (Not Used for FormState) ---
    fn get_suggestions(&self) -> Option<&[String]> {
-        None // FormState doesn't provide suggestions
+        None
    }

    fn get_selected_suggestion_index(&self) -> Option<usize> {
-        None // FormState doesn't have selected suggestions
+        None
    }
 }
--- a/client/src/tui/functions/common/form.rs
+++ b/client/src/tui/functions/common/form.rs
@@ -2,114 +2,130 @@

 use crate::services::grpc_client::GrpcClient;
 use crate::state::pages::form::FormState;
-use common::proto::multieko2::adresar::{PostAdresarRequest, PutAdresarRequest};
-use anyhow::Result;
+use anyhow::{Context, Result}; // Added Context
+use std::collections::HashMap; // NEW

 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum SaveOutcome {
-    NoChange,         // Nothing needed saving
-    UpdatedExisting,  // An existing record was updated
-    CreatedNew(i64),  // A new record was created (include its new ID)
+    NoChange,
+    UpdatedExisting,
+    CreatedNew(i64), // Keep the ID
 }

-/// Shared logic for saving the current form state
+// MODIFIED save function
 pub async fn save(
    form_state: &mut FormState,
    grpc_client: &mut GrpcClient,
-    current_position: &mut u64,
-    total_count: u64,
-) -> Result<SaveOutcome> { // <-- Return SaveOutcome
+) -> Result<SaveOutcome> {
    if !form_state.has_unsaved_changes {
-        return Ok(SaveOutcome::NoChange); // Early exit if no changes
+        return Ok(SaveOutcome::NoChange);
    }
-    let is_new = *current_position == total_count + 1;

-    let outcome = if is_new {
-        let post_request = PostAdresarRequest {
-            firma: form_state.values[0].clone(),
-            kz: form_state.values[1].clone(),
-            drc: form_state.values[2].clone(),
-            ulica: form_state.values[3].clone(),
-            psc: form_state.values[4].clone(),
-            mesto: form_state.values[5].clone(),
-            stat: form_state.values[6].clone(),
-            banka: form_state.values[7].clone(),
-            ucet: form_state.values[8].clone(),
-            skladm: form_state.values[9].clone(),
-            ico: form_state.values[10].clone(),
-            kontakt: form_state.values[11].clone(),
-            telefon: form_state.values[12].clone(),
-            skladu: form_state.values[13].clone(),
-            fax: form_state.values[14].clone(),
-        };
-        let response = grpc_client.post_adresar(post_request).await?;
-        let new_id = response.into_inner().id;
-        form_state.id = new_id;
-        SaveOutcome::CreatedNew(new_id) // <-- Return CreatedNew with ID
+    let data_map: HashMap<String, String> = form_state.fields.iter()
+        .zip(form_state.values.iter())
+        .map(|(field, value)| (field.clone(), value.clone()))
+        .collect();
+
+    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) ;
+
+
+    if is_new_entry {
+        let response = grpc_client
+            .post_table_data(
+                form_state.profile_name.clone(),
+                form_state.table_name.clone(),
+                data_map,
+            )
+            .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 {
-        let put_request = PutAdresarRequest {
-            id: form_state.id,
-            firma: form_state.values[0].clone(),
-            kz: form_state.values[1].clone(),
-            drc: form_state.values[2].clone(),
-            ulica: form_state.values[3].clone(),
-            psc: form_state.values[4].clone(),
-            mesto: form_state.values[5].clone(),
-            stat: form_state.values[6].clone(),
-            banka: form_state.values[7].clone(),
-            ucet: form_state.values[8].clone(),
-            skladm: form_state.values[9].clone(),
-            ico: form_state.values[10].clone(),
-            kontakt: form_state.values[11].clone(),
-            telefon: form_state.values[12].clone(),
-            skladu: form_state.values[13].clone(),
-            fax: form_state.values[14].clone(),
-        };
-        let _ = grpc_client.put_adresar(put_request).await?;
-        SaveOutcome::UpdatedExisting
-    };
+            return Err(anyhow::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!(
+                "Cannot update record: ID is 0, but not classified as new entry."
+            ));
+        }
+        let response = grpc_client
+            .put_table_data(
+                form_state.profile_name.clone(),
+                form_state.table_name.clone(),
+                form_state.id,
+                data_map,
+            )
+            .await
+            .context("Failed to put (update) table data")?;
+
+        if response.success {
+            outcome = SaveOutcome::UpdatedExisting;
+        } else {
+            return Err(anyhow::anyhow!(
+                "Server failed to update data: {}",
+                response.message
+            ));
+        }
+    }

    form_state.has_unsaved_changes = false;
    Ok(outcome)
 }

-/// Discard changes since last save
 pub async fn revert(
-    form_state: &mut FormState,
+    form_state: &mut FormState, // Takes &mut FormState to update it
    grpc_client: &mut GrpcClient,
-    current_position: &mut u64,
-    total_count: u64,
 ) -> Result<String> {
-    let is_new = *current_position == total_count + 1;
-
-    if is_new {
-        // Clear all fields for new entries
-        form_state.values.iter_mut().for_each(|v| *v = String::new());
-        form_state.has_unsaved_changes = false;
+    if 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 old_total_count = form_state.total_count; // Preserve for correct new position
+        form_state.reset_to_empty(); // reset_to_empty will clear values and set id=0
+        form_state.total_count = old_total_count; // Restore total_count
+        if form_state.total_count > 0 { // Correctly set current_position for new
+             form_state.current_position = form_state.total_count + 1;
+        } else {
+             form_state.current_position = 1;
+        }
        return Ok("New entry cleared".to_string());
    }

-    let data = grpc_client.get_adresar_by_position(*current_position).await?;
+    if form_state.current_position == 0 || form_state.current_position > form_state.total_count {
+        if form_state.total_count > 0 {
+            form_state.current_position = 1;
+        } else {
+            // No records to revert to, effectively a new entry state.
+            form_state.reset_to_empty();
+            return Ok("No saved data to revert to; form cleared.".to_string());
+        }
+    }

-    // Update form fields with saved values
-    form_state.values = vec![
-        data.firma,
-        data.kz,
-        data.drc,
-        data.ulica,
-        data.psc,
-        data.mesto,
-        data.stat,
-        data.banka,
-        data.ucet,
-        data.skladm,
-        data.ico,
-        data.kontakt,
-        data.telefon,
-        data.skladu,
-        data.fax,
-    ];
+    let response = grpc_client
+        .get_table_data_by_position(
+            form_state.profile_name.clone(),
+            form_state.table_name.clone(),
+            form_state.current_position as i32,
+        )
+        .await
+        .context(format!(
+            "Failed to get table data by position {} for table {}.{}",
+            form_state.current_position,
+            form_state.profile_name,
+            form_state.table_name
+        ))?;

-    form_state.has_unsaved_changes = false;
+    // 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 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> {
-            // TODO store unsaved changes without deleting form state values
-    // First 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,71 +17,29 @@ pub async fn handle_action(
        );
    }

+    let total_count = form_state.total_count;
+
    match action {
        "previous_entry" => {
-            let new_position = current_position.saturating_sub(1);
-            if new_position >= 1 {
-                *current_position = new_position;
-                let response = grpc_client.get_adresar_by_position(*current_position).await?;
-
-                // Direct field assignments
-                form_state.id = response.id;
-                form_state.values = vec![
-                    response.firma, response.kz, response.drc,
-                    response.ulica, response.psc, response.mesto,
-                    response.stat, response.banka, response.ucet,
-                    response.skladm, response.ico, response.kontakt,
-                    response.telefon, response.skladu, response.fax,
-                ];
-
-                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 = std::cmp::min(*ideal_cursor_column, max_cursor_pos);
-                form_state.has_unsaved_changes = false;
-
-                Ok(format!("Loaded form entry {}", *current_position))
-            } else {
-                Ok("Already at first form entry".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 *current_position <= total_count {
-                *current_position += 1;
-                if *current_position <= total_count {
-                    let response = grpc_client.get_adresar_by_position(*current_position).await?;
-
-                    // Direct field assignments
-                    form_state.id = response.id;
-                    form_state.values = vec![
-                        response.firma, response.kz, response.drc,
-                        response.ulica, response.psc, response.mesto,
-                        response.stat, response.banka, response.ucet,
-                        response.skladm, response.ico, response.kontakt,
-                        response.telefon, response.skladu, response.fax,
-                    ];
-
-                    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 = std::cmp::min(*ideal_cursor_column, max_cursor_pos);
-                    form_state.has_unsaved_changes = false;
-
-                    Ok(format!("Loaded form entry {}", *current_position))
-                } else {
-                    form_state.reset_to_empty();
-                    form_state.current_field = 0;
-                    form_state.current_cursor_pos = 0;
+            // 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;
                *ideal_cursor_column = 0;
-                    Ok("New form entry mode".into())
-                }
-            } else {
-                Ok("Already at last entry".into())
            }
        }
-        _ => Err(anyhow!("Unknown form action: {}", action))
+        _ => return Err(anyhow!("Unknown form action: {}", action)),
+    }

-    }
+    Ok(String::new())
 }
--- a/client/src/ui/handlers/context.rs
+++ b/client/src/ui/handlers/context.rs
@@ -21,4 +21,3 @@ pub enum DialogPurpose {
    // TODO in the future:
    // ConfirmQuit,
 }
-
--- a/client/src/ui/handlers/rat_state.rs
+++ b/client/src/ui/handlers/rat_state.rs
@@ -1,4 +1,4 @@
-// src/ui/handlers/rat_state.rs
+// client/src/ui/handlers/rat_state.rs
 use crossterm::event::{KeyCode, KeyModifiers};
 use crate::config::binds::config::Config;
 use crate::state::app::state::UiState;
--- a/client/src/ui/handlers/render.rs
+++ b/client/src/ui/handlers/render.rs
@@ -1,30 +1,38 @@
 // 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},
 };
 use crate::config::colors::themes::Theme;
-use ratatui::layout::{Constraint, Direction, Layout};
-use ratatui::Frame;
-use crate::state::pages::form::FormState;
+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 crate::state::app::buffer::BufferState;
-use crate::state::app::state::AppState;
-use crate::state::pages::admin::AdminState;
-use crate::state::app::highlight::HighlightState;
+use ratatui::{
+    layout::{Constraint, Direction, Layout},
+    Frame,
+};

+#[allow(clippy::too_many_arguments)]
 pub fn render_ui(
    f: &mut Frame,
    form_state: &mut FormState,
@@ -35,56 +43,81 @@ pub fn render_ui(
    admin_state: &mut AdminState,
    buffer_state: &BufferState,
    theme: &Theme,
-    is_edit_mode: bool,
+    is_event_handler_edit_mode: bool,
    highlight_state: &HighlightState,
-    total_count: u64,
-    current_position: u64,
+    event_handler_command_input: &str,
+    event_handler_command_mode_active: bool,
+    event_handler_command_message: &str,
+    navigation_state: &NavigationState,
    current_dir: &str,
-    command_input: &str,
-    command_mode: bool,
-    command_message: &str,
    current_fps: f64,
    app_state: &AppState,
 ) {
    render_background(f, f.area(), theme);

-    // Adjust layout based on whether buffer list is shown
-    let constraints = if app_state.ui.show_buffer_list {
-        vec![
-            Constraint::Length(1),   // Buffer list
-            Constraint::Min(1),      // Main content
-            Constraint::Length(1),   // Status line
-            Constraint::Length(1),   // Command line
-        ]
+    // --- 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(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 {
-        vec![
-            Constraint::Min(1),      // Main content
-            Constraint::Length(1),   // Status line (no buffer list)
-            Constraint::Length(1),   // Command line
-        ]
+        0
    };

-    let root = Layout::default()
+    if command_palette_area_height > 0 {
+        bottom_area_constraints.push(Constraint::Length(command_palette_area_height));
+    }
+
+    let mut main_layout_constraints = vec![Constraint::Min(1)];
+    if app_state.ui.show_buffer_list {
+        main_layout_constraints.insert(0, Constraint::Length(1));
+    }
+    main_layout_constraints.extend(bottom_area_constraints);
+
+    let root_chunks = Layout::default()
        .direction(Direction::Vertical)
-        .constraints(constraints)
+        .constraints(main_layout_constraints)
        .split(f.area());

-    let mut buffer_list_area = None;
-    let main_content_area;
-    let status_line_area;
-    let command_line_area;
-
-    // Assign areas based on layout
-    if app_state.ui.show_buffer_list {
-        buffer_list_area = Some(root[0]);
-        main_content_area = root[1];
-        status_line_area = root[2];
-        command_line_area = root[3];
+    let mut chunk_idx = 0;
+    let buffer_list_area = if app_state.ui.show_buffer_list {
+        let area = Some(root_chunks[chunk_idx]);
+        chunk_idx += 1;
+        area
    } else {
-        main_content_area = root[0];
-        status_line_area = root[1];
-        command_line_area = root[2];
+        None
+    };
+
+    let main_content_area = root_chunks[chunk_idx];
+    chunk_idx += 1;
+
+    let status_line_area = root_chunks[chunk_idx];
+    chunk_idx += 1;
+
+    let command_render_area = if command_palette_area_height > 0 {
+        if root_chunks.len() > chunk_idx {
+            Some(root_chunks[chunk_idx])
+        } else {
+            None
        }
+    } else {
+        None
+    };

    if app_state.ui.show_intro {
        render_intro(f, intro_state, main_content_area, theme);
@@ -95,7 +128,7 @@ pub fn render_ui(
            theme,
            register_state,
            app_state,
-            register_state.current_field < 4,
+            register_state.current_field() < 4,
            highlight_state,
        );
    } else if app_state.ui.show_add_table {
@@ -105,7 +138,7 @@ pub fn render_ui(
            theme,
            app_state,
            &mut admin_state.add_table_state,
-            login_state.current_field < 3,
+            is_event_handler_edit_mode,
            highlight_state,
        );
    } else if app_state.ui.show_add_logic {
@@ -115,7 +148,7 @@ pub fn render_ui(
            theme,
            app_state,
            &mut admin_state.add_logic_state,
-            is_edit_mode, // Pass the general edit mode status
+            is_event_handler_edit_mode,
            highlight_state,
        );
    } else if app_state.ui.show_login {
@@ -125,7 +158,7 @@ pub fn render_ui(
            theme,
            login_state,
            app_state,
-            login_state.current_field < 2,
+            login_state.current_field() < 2,
            highlight_state,
        );
    } else if app_state.ui.show_admin {
@@ -140,70 +173,92 @@ pub fn render_ui(
            &app_state.selected_profile,
        );
    } else if app_state.ui.show_form {
-        let (sidebar_area, form_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
+                &app_state.selected_profile,
            );
        }
-
-        // This change makes the form stay stationary when toggling sidebar
-        let available_width = form_area.width;
-        let form_constraint = if available_width >= 80 {
-            // Use main_content_area for centering when enough space
+        let available_width = form_actual_area.width;
+        let form_render_area = if available_width >= 80 {
            Layout::default()
                .direction(Direction::Horizontal)
-                .constraints([
-                    Constraint::Min(0),
-                    Constraint::Length(80),
-                    Constraint::Min(0),
-                ])
-                .split(main_content_area)[1]
+                .constraints([Constraint::Min(0), Constraint::Length(80), Constraint::Min(0)])
+                .split(form_actual_area)[1]
        } else {
-            // Use form_area (post sidebar) when limited space
            Layout::default()
                .direction(Direction::Horizontal)
                .constraints([
                    Constraint::Min(0),
-                    Constraint::Length(80.min(available_width)),
+                    Constraint::Length(available_width),
                    Constraint::Min(0),
                ])
-                .split(form_area)[1]
+                .split(form_actual_area)[1]
        };
        
-        // Convert fields to &[&str] and values to &[&String]
-        let fields: Vec<&str> = form_state.fields.iter().map(|s| s.as_str()).collect();
-        let values: Vec<&String> = form_state.values.iter().collect();
-
-        render_form(
+        form_state.render(
            f,
-            form_constraint,
-            form_state,
-            &fields,
-            &form_state.current_field,
-            &values,
+            form_render_area,
            theme,
-            is_edit_mode,
+            is_event_handler_edit_mode,
            highlight_state,
-            total_count,
-            current_position,
        );
    }

-    // Render buffer list if enabled and area is available
    if let Some(area) = buffer_list_area {
-        if app_state.ui.show_buffer_list {
        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,
+        app_state,
+    );
+
+    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,
+                theme,
+                navigation_state,
+            );
+        } else if event_handler_command_mode_active {
+            render_command_line(
+                f,
+                palette_or_command_area,
+                event_handler_command_input,
+                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,
+        );
    }
-    render_status_line(f, status_line_area, current_dir, theme, is_edit_mode, current_fps);
-    render_command_line(f, command_line_area, command_input, command_mode, theme, command_message);
 }
--- a/client/src/ui/handlers/ui.rs
+++ b/client/src/ui/handlers/ui.rs
@@ -23,42 +23,42 @@ use crate::tui::terminal::{EventReader, TerminalCore};
 use crate::ui::handlers::render::render_ui;
 use crate::tui::functions::common::login::LoginResult;
 use crate::tui::functions::common::register::RegisterResult;
-// Removed: use crate::tui::functions::common::add_table::handle_save_table_action;
-// Removed: use crate::functions::modes::navigation::add_table_nav::SaveTableResultSender;
-use crate::ui::handlers::context::DialogPurpose; // UiContext removed if not used directly
+use crate::ui::handlers::context::DialogPurpose;
 use crate::tui::functions::common::login;
 use crate::tui::functions::common::register;
-use std::time::Instant;
-use anyhow::{Context, Result};
+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}; // Added warn
+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")?;
    let theme = Theme::from_str(&config.colors.theme);
    let mut terminal = TerminalCore::new().context("Failed to initialize terminal")?;
-    let mut grpc_client = GrpcClient::new().await?;
+    let mut grpc_client = GrpcClient::new().await.context("Failed to create GrpcClient")?;
    let mut command_handler = CommandHandler::new();

-    // --- Channel for Login Results ---
-    let (login_result_sender, mut login_result_receiver) =
-        mpsc::channel::<LoginResult>(1);
-    let (register_result_sender, mut register_result_receiver) =
-        mpsc::channel::<RegisterResult>(1);
-    let (save_table_result_sender, mut save_table_result_receiver) =
-        mpsc::channel::<Result<String>>(1);
-    let (save_logic_result_sender, _save_logic_result_receiver) = // Prefixed and removed mut
-        mpsc::channel::<Result<String>>(1);
+    let (login_result_sender, mut login_result_receiver) = mpsc::channel::<LoginResult>(1);
+    let (register_result_sender, mut register_result_receiver) = mpsc::channel::<RegisterResult>(1);
+    let (save_table_result_sender, mut save_table_result_receiver) = mpsc::channel::<Result<String>>(1);
+    let (save_logic_result_sender, _save_logic_result_receiver) = mpsc::channel::<Result<String>>(1);

    let mut event_handler = EventHandler::new(
        login_result_sender.clone(),
        register_result_sender.clone(),
        save_table_result_sender.clone(),
        save_logic_result_sender.clone(),
-    ).await.context("Failed to create event handler")?;
+        grpc_client.clone(),
+    )
+    .await
+    .context("Failed to create event handler")?;
    let event_reader = EventReader::new();

    let mut auth_state = AuthState::default();
@@ -69,7 +69,6 @@ pub async fn run_ui() -> Result<()> {
    let mut buffer_state = BufferState::default();
    let mut app_state = AppState::new().context("Failed to create initial app state")?;

-    // --- DATA: Load auth data from file at startup ---
    let mut auto_logged_in = false;
    match load_auth_data() {
        Ok(Some(stored_data)) => {
@@ -87,15 +86,34 @@ pub async fn run_ui() -> Result<()> {
            error!("Failed to load auth data: {}", e);
        }
    }
-    // --- END DATA ---

-    let column_names =
-        UiService::initialize_app_state(&mut grpc_client, &mut app_state)
-            .await.context("Failed to initialize app state from UI service")?;
-    let mut form_state = FormState::new(column_names);
+    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")?;

-    UiService::initialize_adresar_count(&mut grpc_client, &mut app_state).await?;
+    let filtered_columns = filter_user_columns(initial_columns_from_service);
+
+    let mut form_state = FormState::new(
+        initial_profile.clone(),
+        initial_table.clone(),
+        filtered_columns,
+    );
+
+    UiService::fetch_and_set_table_count(&mut grpc_client, &mut form_state)
+        .await
+        .context(format!(
+            "Failed to fetch initial count for table {}.{}",
+            initial_profile, initial_table
+        ))?;
+
+    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);
+        }
+    } else {
        form_state.reset_to_empty();
+    }

    if auto_logged_in {
        buffer_state.history = vec![AppView::Form];
@@ -106,9 +124,147 @@ pub async fn run_ui() -> Result<()> {
    let mut last_frame_time = Instant::now();
    let mut current_fps = 0.0;
    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 {
-        // --- Synchronize UI View from Active Buffer ---
+        let position_before_event = form_state.current_position;
+        let mut event_processed = false;
+
+        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!");
+            }
+        }
+        if app_state.ui.show_search_palette {
+            needs_redraw = true;
+        }
+        if crossterm_event::poll(std::time::Duration::from_millis(1))? {
+            let event = event_reader.read_event().context("Failed to read terminal event")?;
+            event_processed = true;
+            let event_outcome_result = event_handler.handle_event(
+                event,
+                &config,
+                &mut terminal,
+                &mut command_handler,
+                &mut form_state,
+                &mut auth_state,
+                &mut login_state,
+                &mut register_state,
+                &mut intro_state,
+                &mut admin_state,
+                &mut buffer_state,
+                &mut app_state,
+            ).await;
+
+            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() {
+            Ok(result) => {
+                if login::handle_login_result(result, &mut app_state, &mut auth_state, &mut login_state) {
+                    needs_redraw = true;
+                }
+            }
+            Err(mpsc::error::TryRecvError::Empty) => {}
+            Err(mpsc::error::TryRecvError::Disconnected) => {
+                error!("Login result channel disconnected unexpectedly.");
+            }
+        }
+
+        match register_result_receiver.try_recv() {
+            Ok(result) => {
+                if register::handle_registration_result(result, &mut app_state, &mut register_state) {
+                    needs_redraw = true;
+                }
+            }
+            Err(mpsc::error::TryRecvError::Empty) => {}
+            Err(mpsc::error::TryRecvError::Disconnected) => {
+                error!("Register result channel disconnected unexpectedly.");
+            }
+        }
+
+        match save_table_result_receiver.try_recv() {
+            Ok(result) => {
+                app_state.hide_dialog();
+                match result {
+                    Ok(ref success_message) => {
+                        app_state.show_dialog(
+                            "Save Successful",
+                            success_message,
+                            vec!["OK".to_string()],
+                            DialogPurpose::SaveTableSuccess,
+                        );
+                        admin_state.add_table_state.has_unsaved_changes = false;
+                    }
+                    Err(e) => {
+                        event_handler.command_message = format!("Save failed: {}", e);
+                    }
+                }
+                needs_redraw = true;
+            }
+            Err(mpsc::error::TryRecvError::Empty) => {}
+            Err(mpsc::error::TryRecvError::Disconnected) => {
+                error!("Save table result channel disconnected unexpectedly.");
+            }
+        }
+
        if let Some(active_view) = buffer_state.get_active_view() {
            app_state.ui.show_intro = false;
            app_state.ui.show_login = false;
@@ -155,20 +311,102 @@ pub async fn run_ui() -> Result<()> {
                AppView::Scratch => {}
            }
        }
-        // --- End Synchronization ---

-        // --- Handle Pending Table Structure Fetches ---
+        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();
+
+                            let filtered_columns = filter_user_columns(new_columns);
+                            form_state = FormState::new(
+                                prof_name.clone(),
+                                tbl_name.clone(),
+                                filtered_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();
+                            }
+
+                            prev_view_profile_name = current_view_profile;
+                            prev_view_table_name = current_view_table;
+                            table_just_switched = true;
+                        }
+                        Err(e) => {
+                            app_state.update_dialog_content(
+                                &format!("Error fetching table structure: {}", e),
+                                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();
+                        }
+                    }
+                }
+                needs_redraw = true;
+            }
+        }
+
        if let Some((profile_name, table_name)) = app_state.pending_table_structure_fetch.take() {
            if app_state.ui.show_add_logic {
-                // Ensure admin_state.add_logic_state matches the pending fetch
                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, // Pass the profile tree
+                        &app_state.profile_tree,
                    ).await.unwrap_or_else(|e| {
                        error!("Error initializing add_logic_table_data: {}", e);
                        format!("Error fetching table structure: {}", e)
@@ -196,35 +434,6 @@ pub async fn run_ui() -> Result<()> {
            }
        }

-        // --- 3. Draw UI ---
-        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,
-                    app_state.total_count,
-                    app_state.current_position,
-                    &app_state.current_dir,
-                    &event_handler.command_input,
-                    event_handler.command_mode,
-                    &event_handler.command_message,
-                    current_fps,
-                    &app_state,
-                );
-            }).context("Terminal draw call failed")?;
-            needs_redraw = false;
-        }
-
-        // --- Handle Pending Column Autocomplete for Table Selection ---
        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();
@@ -247,198 +456,46 @@ pub async fn run_ui() -> Result<()> {
            }
        }

-        // --- Cursor Visibility Logic ---
-        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")?; }
-        }
-        // --- End Cursor Visibility Logic ---
-
-        let total_count = app_state.total_count;
-        let mut current_position = app_state.current_position;
-        let position_before_event = current_position;
-        if app_state.ui.dialog.is_loading {
-            needs_redraw = true;
-        }
-
-        // --- 1. Handle Terminal Events ---
-        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(
-                event,
-                &config,
-                &mut terminal,
-                &mut grpc_client,
-                &mut command_handler,
-                &mut form_state,
-                &mut auth_state,
-                &mut login_state,
-                &mut register_state,
-                &mut intro_state,
-                &mut admin_state,
-                &mut buffer_state,
-                &mut app_state,
-                total_count,
-                &mut current_position,
-            ).await;
-        }
-
-        if event_processed {
-            needs_redraw = true;
-        }
-        app_state.current_position = current_position;
-
-        // --- Check for Login Results from Channel ---
-        match login_result_receiver.try_recv() {
-            Ok(result) => {
-                if login::handle_login_result(result, &mut app_state, &mut auth_state, &mut login_state) {
-                    needs_redraw = true;
-                }
-            }
-            Err(mpsc::error::TryRecvError::Empty) => { /* No message waiting */ }
-            Err(mpsc::error::TryRecvError::Disconnected) => {
-                error!("Login result channel disconnected unexpectedly.");
-            }
-        }
-
-        // --- Check for Register Results from Channel ---
-        match register_result_receiver.try_recv() {
-            Ok(result) => {
-                if register::handle_registration_result(result, &mut app_state, &mut register_state) {
-                    needs_redraw = true;
-                }
-            }
-            Err(mpsc::error::TryRecvError::Empty) => { /* No message waiting */ }
-            Err(mpsc::error::TryRecvError::Disconnected) => {
-                error!("Register result channel disconnected unexpectedly.");
-            }
-        }
-        // --- Check for Save Table Results ---
-        match save_table_result_receiver.try_recv() {
-            Ok(result) => {
-                app_state.hide_dialog();
-                match result {
-                    Ok(ref success_message) => {
-                        app_state.show_dialog(
-                            "Save Successful",
-                            success_message,
-                            vec!["OK".to_string()],
-                            DialogPurpose::SaveTableSuccess,
-                        );
-                        admin_state.add_table_state.has_unsaved_changes = false;
-                    }
-                    Err(e) => {
-                        event_handler.command_message = format!("Save failed: {}", e);
-                    }
-                }
-                needs_redraw = true;
-            }
-            Err(mpsc::error::TryRecvError::Empty) => {}
-            Err(mpsc::error::TryRecvError::Disconnected) => {
-                error!("Save table result channel disconnected unexpectedly.");
-            }
-        }
-
-        // --- Centralized Consequence Handling ---
-        let mut should_exit = false;
-        match event_outcome_result {
-            Ok(outcome) => match outcome {
-                EventOutcome::Ok(_message) => {
-                    // Message is often set directly in event_handler.command_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 { context: _, index: _ } => {
-                    // Handled within event_handler or specific navigation modules
-                }
-            },
-            Err(e) => {
-                event_handler.command_message = format!("Error: {}", e);
-            }
-        }
-        // --- End Consequence Handling ---
-
-        // --- Position Change Handling ---
-        let position_changed = app_state.current_position != position_before_event;
-        let current_total_count = app_state.total_count; // Use current total_count
+        let position_changed = form_state.current_position != position_before_event;
        let mut position_logic_needs_redraw = false;

-        if app_state.ui.show_form {
+        if app_state.ui.show_form && !table_just_switched {
            if position_changed && !event_handler.is_edit_mode {
-                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 = event_handler.ideal_cursor_column.min(max_cursor_pos);
                position_logic_needs_redraw = true;

-                if app_state.current_position > current_total_count + 1 {
-                    app_state.current_position = current_total_count + 1;
-                }
-
-                if app_state.current_position > current_total_count {
+                if form_state.current_position > form_state.total_count {
                    form_state.reset_to_empty();
-                    form_state.current_field = 0;
-                } else if app_state.current_position >= 1 && app_state.current_position <= current_total_count {
-                    let current_position_to_load = app_state.current_position;
-                    let load_message = UiService::load_adresar_by_position(
-                        &mut grpc_client,
-                        &mut app_state,
-                        &mut form_state,
-                        current_position_to_load,
-                    )
-                    .await.with_context(|| format!("Failed to load adresar by position: {}", current_position_to_load))?;
-
-                    let current_input_after_load = form_state.get_current_input();
-                    let max_cursor_pos_after_load = if !event_handler.is_edit_mode && !current_input_after_load.is_empty() {
-                        current_input_after_load.len() - 1
+                    event_handler.command_message = format!("New entry for {}.{}", form_state.profile_name, form_state.table_name);
                } else {
-                        current_input_after_load.len()
-                    };
-                    form_state.current_cursor_pos = event_handler.ideal_cursor_column.min(max_cursor_pos_after_load);
-
-                    if !load_message.starts_with("Loaded entry") || event_handler.command_message.is_empty() {
+                    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") {
                                event_handler.command_message = load_message;
                            }
-                } else { // current_position is 0 or invalid
-                    app_state.current_position = 1.min(current_total_count + 1);
-                    if app_state.current_position > current_total_count { // Handles empty db case
-                        form_state.reset_to_empty();
-                        form_state.current_field = 0;
                        }
-                    // If db is not empty, this will trigger load in next iteration if position changed to 1
+                        Err(e) => {
+                            event_handler.command_message = format!("Error loading data: {}", e);
                        }
+                    }
+                }
+
+                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 = 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);
+
            } else if !position_changed && !event_handler.is_edit_mode {
-                let current_input = form_state.get_current_input();
-                let max_cursor_pos = if !current_input.is_empty() { current_input.len() - 1 } else { 0 };
+                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 {
+                    current_input_len.saturating_sub(1)
+                } else {
+                    0
+                };
                form_state.current_cursor_pos = event_handler.ideal_cursor_column.min(max_cursor_pos);
            }
        } else if app_state.ui.show_register {
@@ -458,18 +515,78 @@ pub async fn run_ui() -> Result<()> {
        if position_logic_needs_redraw {
            needs_redraw = true;
        }
-        // --- End Position Change Handling ---

-        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;
        }

-        // --- FPS Calculation ---
        let now = Instant::now();
        let frame_duration = now.duration_since(last_frame_time);
        last_frame_time = now;
-        if frame_duration.as_secs_f64() > 1e-6 { // Avoid division by zero
+        if frame_duration.as_secs_f64() > 1e-6 {
            current_fps = 1.0 / frame_duration.as_secs_f64();
        }
-    } // End main loop
+
+        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/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,6 @@
+// src/utils/mod.rs
+
+pub mod columns;
+pub mod debug_logger;
+pub use columns::*;
+pub use debug_logger::*;
--- a/common/Cargo.toml
+++ b/common/Cargo.toml
@@ -9,5 +9,8 @@ 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/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/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,272 @@
+// 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 diacritics in queries (no changes here)
+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;
+
+        if query_str.trim().is_empty() {
+            return Err(Status::invalid_argument("Query cannot be empty"));
+        }
+
+        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 prefix_edge_field = schema.get_field("prefix_edge").map_err(|_| {
+            Status::internal("Schema is missing the 'prefix_edge' field.")
+        })?;
+        let prefix_full_field = schema.get_field("prefix_full").map_err(|_| {
+            Status::internal("Schema is missing the 'prefix_full' field.")
+        })?;
+        let text_ngram_field = schema.get_field("text_ngram").map_err(|_| {
+            Status::internal("Schema is missing the 'text_ngram' field.")
+        })?;
+        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,10 @@ license = "AGPL-3.0-or-later"

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

+anyhow = { workspace = true }
+tantivy = { workspace = true }
 chrono = { version = "0.4.40", features = ["serde"] }
 dotenvy = "0.15.7"
 prost = "0.13.5"
@@ -28,6 +31,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/migrations/20250528110810_create_gen_schema.sql
+++ b/server/migrations/20250528110810_create_gen_schema.sql
@@ -0,0 +1,3 @@
+-- Add migration script here
+
+CREATE SCHEMA IF NOT EXISTS gen;
--- 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/shared/mod.rs
+++ b/server/src/shared/mod.rs
@@ -1,2 +1,3 @@
 // src/shared/mod.rs
 pub mod date_utils;
+pub mod schema_qualifier;
--- a/server/src/shared/schema_qualifier.rs
+++ b/server/src/shared/schema_qualifier.rs
@@ -0,0 +1,34 @@
+// src/shared/schema_qualifier.rs
+use tonic::Status;
+
+/// Qualifies table names with the appropriate schema
+/// 
+/// Rules:
+/// - Tables created via PostTableDefinition (dynamically created tables) are in 'gen' schema
+/// - System tables (like users, profiles) remain in 'public' schema
+pub fn qualify_table_name(table_name: &str) -> String {
+    // Check if table matches the pattern of dynamically created tables (e.g., 2025_something)
+    if table_name.starts_with(|c: char| c.is_ascii_digit()) && table_name.contains('_') {
+        format!("gen.\"{}\"", table_name)
+    } else {
+        format!("\"{}\"", table_name)
+    }
+}
+
+/// Qualifies table names for data operations
+pub fn qualify_table_name_for_data(table_name: &str) -> Result<String, Status> {
+    Ok(qualify_table_name(table_name))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_qualify_table_name() {
+        assert_eq!(qualify_table_name("2025_test_schema3"), "gen.\"2025_test_schema3\"");
+        assert_eq!(qualify_table_name("users"), "\"users\"");
+        assert_eq!(qualify_table_name("profiles"), "\"profiles\"");
+        assert_eq!(qualify_table_name("adresar"), "\"adresar\"");
+    }
+}
--- a/server/src/table_definition/handlers/post_table_definition.rs
+++ b/server/src/table_definition/handlers/post_table_definition.rs
@@ -1,10 +1,11 @@
-// src/table_definition/handlers/post_table_definition.rs
 use tonic::Status;
 use sqlx::{PgPool, Transaction, Postgres};
 use serde_json::json;
 use time::OffsetDateTime;
 use common::proto::multieko2::table_definition::{PostTableDefinitionRequest, TableDefinitionResponse};

+const GENERATED_SCHEMA_NAME: &str = "gen";
+
 const PREDEFINED_FIELD_TYPES: &[(&str, &str)] = &[
    ("text", "TEXT"),
    ("psc", "TEXT"),
@@ -27,7 +28,6 @@ fn sanitize_table_name(s: &str) -> String {
    let cleaned = s.replace(|c: char| !c.is_ascii_alphanumeric() && c != '_', "")
        .trim()
        .to_lowercase();
-
    format!("{}_{}", year, cleaned)
 }

@@ -45,33 +45,46 @@ 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, // Removed `mut` since it's not needed here
+    request: PostTableDefinitionRequest,
 ) -> Result<TableDefinitionResponse, Status> {
-    // Validate and sanitize table name
-    let table_name = sanitize_table_name(&request.table_name);
-    if !is_valid_identifier(&request.table_name) {
-        return Err(Status::invalid_argument("Invalid table name"));
+    let base_name = sanitize_table_name(&request.table_name);
+    let user_part_cleaned = request.table_name
+        .replace(|c: char| !c.is_ascii_alphanumeric() && c != '_', "")
+        .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() {
+        return Err(Status::invalid_argument("Table name cannot be empty"));
    }

-    // Start a transaction to ensure atomicity
    let mut tx = db_pool.begin().await
        .map_err(|e| Status::internal(format!("Failed to start transaction: {}", e)))?;

-    // Execute all database operations within the transaction
-    let result = execute_table_definition(&mut tx, request, table_name).await;
-
-    // Commit or rollback based on the result
-    match result {
+    match execute_table_definition(&mut tx, request, base_name).await {
        Ok(response) => {
-            // Commit the transaction
            tx.commit().await
                .map_err(|e| Status::internal(format!("Failed to commit transaction: {}", e)))?;
            Ok(response)
        },
        Err(e) => {
-            // Explicitly roll back the transaction (optional but good for clarity)
            let _ = tx.rollback().await;
            Err(e)
        }
@@ -83,7 +96,6 @@ async fn execute_table_definition(
    mut request: PostTableDefinitionRequest,
    table_name: String,
 ) -> Result<TableDefinitionResponse, Status> {
-    // Lookup or create profile
    let profile = sqlx::query!(
        "INSERT INTO profiles (name) VALUES ($1)
         ON CONFLICT (name) DO UPDATE SET name = EXCLUDED.name
@@ -94,7 +106,6 @@ async fn execute_table_definition(
    .await
    .map_err(|e| Status::internal(format!("Profile error: {}", e)))?;

-    // Process table links
    let mut links = Vec::new();
    for link in request.links.drain(..) {
        let linked_table = sqlx::query!(
@@ -114,7 +125,6 @@ async fn execute_table_definition(
        links.push((linked_id, link.required));
    }

-    // Process columns
    let mut columns = Vec::new();
    for col_def in request.columns.drain(..) {
        let col_name = sanitize_identifier(&col_def.name);
@@ -125,20 +135,20 @@ async fn execute_table_definition(
        columns.push(format!("\"{}\" {}", col_name, sql_type));
    }

-    // Process indexes
    let mut indexes = Vec::new();
    for idx in request.indexes.drain(..) {
        let idx_name = sanitize_identifier(&idx);
        if !is_valid_identifier(&idx) {
            return Err(Status::invalid_argument(format!("Invalid index name: {}", idx)));
        }
+        if !columns.iter().any(|c| c.starts_with(&format!("\"{}\"", idx_name))) {
+            return Err(Status::invalid_argument(format!("Index column {} not found", idx_name)));
+        }
        indexes.push(idx_name);
    }

-    // Generate SQL with multiple links
    let (create_sql, index_sql) = generate_table_sql(tx, &table_name, &columns, &indexes, &links).await?;

-    // Store main table definition
    let table_def = sqlx::query!(
        r#"INSERT INTO table_definitions
           (profile_id, table_name, columns, indexes)
@@ -160,7 +170,6 @@ async fn execute_table_definition(
        Status::internal(format!("Database error: {}", e))
    })?;

-    // Store relationships
    for (linked_id, is_required) in links {
        sqlx::query!(
            "INSERT INTO table_definition_links
@@ -175,7 +184,6 @@ async fn execute_table_definition(
        .map_err(|e| Status::internal(format!("Failed to save link: {}", e)))?;
    }

-    // Execute generated SQL within the transaction
    sqlx::query(&create_sql)
        .execute(&mut **tx)
        .await
@@ -201,60 +209,60 @@ async fn generate_table_sql(
    indexes: &[String],
    links: &[(i64, bool)],
 ) -> Result<(String, Vec<String>), Status> {
+    let qualified_table = format!("{}.\"{}\"", GENERATED_SCHEMA_NAME, table_name);
+
    let mut system_columns = vec![
        "id BIGSERIAL PRIMARY KEY".to_string(),
        "deleted BOOLEAN NOT NULL DEFAULT FALSE".to_string(),
    ];

-    // Add foreign key columns
-    let mut link_info = Vec::new();
    for (linked_id, required) in links {
        let linked_table = get_table_name_by_id(tx, *linked_id).await?;
-
-        // Extract base name after year prefix
+        let qualified_linked_table = format!("{}.\"{}\"", GENERATED_SCHEMA_NAME, linked_table);
        let base_name = linked_table.split_once('_')
            .map(|(_, rest)| rest)
            .unwrap_or(&linked_table)
            .to_string();
        let null_clause = if *required { "NOT NULL" } else { "" };
+
        system_columns.push(
-            format!("\"{0}_id\" BIGINT {1} REFERENCES \"{2}\"(id)",
-                base_name, null_clause, linked_table
+            format!("\"{0}_id\" BIGINT {1} REFERENCES {2}(id)",
+                base_name, null_clause, qualified_linked_table
            )
        );
-        link_info.push((base_name, linked_table));
    }

-    // Combine all columns
    let all_columns = system_columns
        .iter()
        .chain(columns.iter())
        .cloned()
        .collect::<Vec<_>>();

-    // Build CREATE TABLE statement
    let create_sql = format!(
-        "CREATE TABLE \"{}\" (\n    {},\n    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP\n)",
-        table_name,
+        "CREATE TABLE {} (\n    {},\n    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP\n)",
+        qualified_table,
        all_columns.join(",\n    ")
    );

-    // Generate indexes
-    let mut system_indexes = Vec::new();
-    for (base_name, _) in &link_info {
-        system_indexes.push(format!(
-            "CREATE INDEX idx_{}_{}_fk ON \"{}\" (\"{}_id\")",
-            table_name, base_name, table_name, base_name
+    let mut all_indexes = Vec::new();
+    for (linked_id, _) in links {
+        let linked_table = get_table_name_by_id(tx, *linked_id).await?;
+        let base_name = linked_table.split_once('_')
+            .map(|(_, rest)| rest)
+            .unwrap_or(&linked_table)
+            .to_string();
+        all_indexes.push(format!(
+            "CREATE INDEX \"idx_{}_{}_fk\" ON {} (\"{}_id\")",
+            table_name, base_name, qualified_table, base_name
        ));
    }

-    let all_indexes = system_indexes
-        .into_iter()
-        .chain(indexes.iter().map(|idx| {
-            format!("CREATE INDEX idx_{}_{} ON \"{}\" (\"{}\")",
-                table_name, idx, table_name, idx)
-        }))
-        .collect();
+    for idx in indexes {
+        all_indexes.push(format!(
+            "CREATE INDEX \"idx_{}_{}\" ON {} (\"{}\")",
+            table_name, idx, qualified_table, idx
+        ));
+    }

    Ok((create_sql, all_indexes))
 }
--- a/server/src/table_structure/handlers/table_structure.rs
+++ b/server/src/table_structure/handlers/table_structure.rs
@@ -2,7 +2,7 @@
 use common::proto::multieko2::table_structure::{
    GetTableStructureRequest, TableColumn, TableStructureResponse,
 };
-use sqlx::{PgPool, Row};
+use sqlx::PgPool;
 use tonic::Status;

 // Helper struct to map query results
@@ -19,8 +19,8 @@ pub async fn get_table_structure(
    request: GetTableStructureRequest,
 ) -> Result<TableStructureResponse, Status> {
    let profile_name = request.profile_name;
-    let table_name = request.table_name; // This should be the full table name, e.g., "2025_adresar6"
-    let table_schema = "public"; // Assuming tables are in the 'public' schema
+    let table_name = request.table_name;
+    let table_schema = "gen";

    // 1. Validate Profile
    let profile = sqlx::query!(
--- a/server/src/tables_data/handlers/delete_table_data.rs
+++ b/server/src/tables_data/handlers/delete_table_data.rs
@@ -2,6 +2,7 @@
 use tonic::Status;
 use sqlx::PgPool;
 use common::proto::multieko2::tables_data::{DeleteTableDataRequest, DeleteTableDataResponse};
+use crate::shared::schema_qualifier::qualify_table_name_for_data; // Import schema qualifier

 pub async fn delete_table_data(
    db_pool: &PgPool,
@@ -36,20 +37,37 @@ pub async fn delete_table_data(
        return Err(Status::not_found("Table not found in profile"));
    }

-    // Perform soft delete
+    // Qualify table name with schema
+    let qualified_table = qualify_table_name_for_data(&request.table_name)?;
+
+    // Perform soft delete using qualified table name
    let query = format!(
-        "UPDATE \"{}\"
+        "UPDATE {}
        SET deleted = true
        WHERE id = $1 AND deleted = false",
-        request.table_name
+        qualified_table
    );

-    let rows_affected = sqlx::query(&query)
+    let result = sqlx::query(&query)
        .bind(request.record_id)
        .execute(db_pool)
-        .await
-        .map_err(|e| Status::internal(format!("Delete operation failed: {}", e)))?
-        .rows_affected();
+        .await;
+
+    let rows_affected = match result {
+        Ok(result) => result.rows_affected(),
+        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!(
+                        "Table '{}' is defined but does not physically exist in the database as {}",
+                        request.table_name, qualified_table
+                    )));
+                }
+            }
+            return Err(Status::internal(format!("Delete operation failed: {}", e)));
+        }
+    };

    Ok(DeleteTableDataResponse {
        success: rows_affected > 0,
--- a/server/src/tables_data/handlers/get_table_data.rs
+++ b/server/src/tables_data/handlers/get_table_data.rs
@@ -3,6 +3,7 @@ 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

 pub async fn get_table_data(
    db_pool: &PgPool,
@@ -55,7 +56,6 @@ pub async fn get_table_data(
    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()
@@ -69,20 +69,36 @@ pub async fn get_table_data(
        .collect::<Vec<_>>()
        .join(", ");

+    // Qualify table name with schema
+    let qualified_table = qualify_table_name_for_data(&table_name)?;
+
    let sql = format!(
-        "SELECT {} FROM \"{}\" WHERE id = $1 AND deleted = false",
-        columns_clause, table_name
+        "SELECT {} FROM {} WHERE id = $1 AND deleted = false",
+        columns_clause, qualified_table
    );

-    // Execute query
-    let row = sqlx::query(&sql)
+    // Execute query with enhanced error handling
+    let row_result = sqlx::query(&sql)
        .bind(record_id)
        .fetch_one(db_pool)
-        .await
-        .map_err(|e| match e {
-            sqlx::Error::RowNotFound => Status::not_found("Record not found"),
-            _ => Status::internal(format!("Database error: {}", e)),
-        })?;
+        .await;
+
+    let row = match row_result {
+        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!(
+                        "Table '{}' is defined but does not physically exist in the database as {}",
+                        table_name, qualified_table
+                    )));
+                }
+            }
+            return Err(Status::internal(format!("Database error: {}", e)));
+        }
+    };

    // Build response data
    let mut data = HashMap::new();
--- a/server/src/tables_data/handlers/get_table_data_by_position.rs
+++ b/server/src/tables_data/handlers/get_table_data_by_position.rs
@@ -5,6 +5,7 @@ use common::proto::multieko2::tables_data::{
    GetTableDataByPositionRequest, GetTableDataRequest, GetTableDataResponse
 };
 use super::get_table_data;
+use crate::shared::schema_qualifier::qualify_table_name_for_data; // Import schema qualifier

 pub async fn get_table_data_by_position(
    db_pool: &PgPool,
@@ -27,39 +28,55 @@ pub async fn get_table_data_by_position(

    let profile_id = profile.ok_or_else(|| Status::not_found("Profile not found"))?.id;

-    let table_exists = sqlx::query!(
+    let table_exists = sqlx::query_scalar!(
        r#"SELECT EXISTS(
            SELECT 1 FROM table_definitions
            WHERE profile_id = $1 AND table_name = $2
-        )"#,
+        ) AS "exists!""#,
        profile_id,
        table_name
    )
    .fetch_one(db_pool)
    .await
-    .map_err(|e| Status::internal(format!("Table verification error: {}", e)))?
-    .exists
-    .unwrap_or(false);
+    .map_err(|e| Status::internal(format!("Table verification error: {}", e)))?;

    if !table_exists {
        return Err(Status::not_found("Table not found"));
    }

-    let id: i64 = sqlx::query_scalar(
+    // Qualify table name with schema
+    let qualified_table = qualify_table_name_for_data(&table_name)?;
+
+    let id_result = sqlx::query_scalar(
        &format!(
-            r#"SELECT id FROM "{}" 
+            r#"SELECT id FROM {}
            WHERE deleted = FALSE
            ORDER BY id ASC
            OFFSET $1
            LIMIT 1"#,
-            table_name
+            qualified_table
        )
    )
    .bind(request.position - 1)
    .fetch_optional(db_pool)
-    .await
-    .map_err(|e| Status::internal(format!("Position query failed: {}", e)))?
-    .ok_or_else(|| Status::not_found("Position out of bounds"))?;
+    .await;
+
+    let id: i64 = match id_result {
+        Ok(Some(id)) => id,
+        Ok(None) => return Err(Status::not_found("Position out of bounds")),
+        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!(
+                        "Table '{}' is defined but does not physically exist in the database as {}",
+                        table_name, qualified_table
+                    )));
+                }
+            }
+            return Err(Status::internal(format!("Position query failed: {}", e)));
+        }
+    };

    get_table_data(
        db_pool,
--- a/server/src/tables_data/handlers/get_table_data_count.rs
+++ b/server/src/tables_data/handlers/get_table_data_count.rs
@@ -3,59 +3,93 @@ use tonic::Status;
 use sqlx::PgPool;
 use common::proto::multieko2::common::CountResponse;
 use common::proto::multieko2::tables_data::GetTableDataCountRequest;
+use crate::shared::schema_qualifier::qualify_table_name_for_data; // 1. IMPORT THE FUNCTION

 pub async fn get_table_data_count(
    db_pool: &PgPool,
    request: GetTableDataCountRequest,
 ) -> Result<CountResponse, Status> {
-    let profile_name = request.profile_name;
-    let table_name = request.table_name;
-
-    // Lookup profile
+    // We still need to verify that the table is logically defined for the profile.
+    // The schema qualifier handles *how* to access it physically, but this check
+    // ensures the request is valid in the context of the application's definitions.
    let profile = sqlx::query!(
        "SELECT id FROM profiles WHERE name = $1",
-        profile_name
+        request.profile_name
    )
    .fetch_optional(db_pool)
    .await
-    .map_err(|e| Status::internal(format!("Profile lookup error: {}", e)))?;
+    .map_err(|e| Status::internal(format!("Profile lookup error for '{}': {}", request.profile_name, e)))?;

-    let profile_id = profile.ok_or_else(|| Status::not_found("Profile not found"))?.id;
+    let profile_id = match profile {
+        Some(p) => p.id,
+        None => return Err(Status::not_found(format!("Profile '{}' not found", request.profile_name))),
+    };

-    // Verify table exists and belongs to profile
-    let table_exists = sqlx::query!(
+    let table_defined_for_profile = sqlx::query_scalar!(
        r#"SELECT EXISTS(
            SELECT 1 FROM table_definitions
            WHERE profile_id = $1 AND table_name = $2
-        )"#,
+        ) AS "exists!" "#, // Added AS "exists!" for clarity with sqlx macro
        profile_id,
-        table_name
+        request.table_name
    )
    .fetch_one(db_pool)
    .await
-    .map_err(|e| Status::internal(format!("Table verification error: {}", e)))?
-    .exists
-    .unwrap_or(false);
+    .map_err(|e| Status::internal(format!("Table definition verification error for '{}.{}': {}", request.profile_name, request.table_name, e)))?;

-    if !table_exists {
-        return Err(Status::not_found("Table not found"));
+    if !table_defined_for_profile {
+        // If the table isn't even defined for this profile in table_definitions,
+        // it's an error, regardless of whether a physical table with that name exists somewhere.
+        return Err(Status::not_found(format!(
+            "Table '{}' is not defined for profile '{}'",
+            request.table_name, request.profile_name
+        )));
    }

-    // Get count of non-deleted records
-    let query = format!(
+    // 2. QUALIFY THE TABLE NAME using the imported function
+    let qualified_table_name = qualify_table_name_for_data(&request.table_name)?;
+
+    // 3. USE THE QUALIFIED NAME in the SQL query
+    let query_sql = format!(
        r#"
        SELECT COUNT(*) AS count
-        FROM "{}"
+        FROM {}
        WHERE deleted = FALSE
        "#,
-        table_name
+        qualified_table_name // Use the schema-qualified name here
    );

-    let count: i64 = sqlx::query_scalar::<_, Option<i64>>(&query)
+    // The rest of the logic remains largely the same, but error messages can be more specific.
+    let count_result = sqlx::query_scalar::<_, Option<i64>>(&query_sql)
        .fetch_one(db_pool)
-        .await
-        .map_err(|e| Status::internal(format!("Count query failed: {}", e)))?
-        .unwrap_or(0);
+        .await;

-    Ok(CountResponse { count })
+    match count_result {
+        Ok(Some(count_val)) => Ok(CountResponse { count: count_val }),
+        Ok(None) => {
+            // This case should ideally not be reached with COUNT(*),
+            // as it always returns a row, even if the count is 0.
+            // If it does, it might indicate an issue or an empty table if the query was different.
+            // For COUNT(*), a 0 count is expected if no non-deleted rows.
+            Ok(CountResponse { count: 0 })
+        }
+        Err(e) => {
+            // Check if the error is "relation does not exist" (PostgreSQL error code 42P01)
+            if let Some(db_err) = e.as_database_error() {
+                if db_err.code() == Some(std::borrow::Cow::Borrowed("42P01")) {
+                    // This means the table (e.g., gen."2025_test_schema3") does not physically exist,
+                    // even though it was defined in table_definitions. This is an inconsistency.
+                    return Err(Status::internal(format!(
+                        "Table '{}' is defined but does not physically exist in the database as {}.",
+                        request.table_name, qualified_table_name
+                    )));
+                }
+            }
+            // For other errors, provide a general message.
+            Err(Status::internal(format!(
+                "Count query failed for table {}: {}",
+                qualified_table_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,31 +7,28 @@ 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;

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

+// Add these imports
+use crate::indexer::{IndexCommand, IndexCommandData};
+use tokio::sync::mpsc;
+use tracing::error;
+
+// MODIFIED: Function signature now accepts the indexer sender
 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);
-        }
+        data.insert(key, value.trim().to_string());
    }

    // Lookup profile
@@ -123,13 +121,12 @@ pub async fn post_table_data(

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

-
        // Execute validation script
        let script_result = execution::execute_script(
            script_record.script,
@@ -220,17 +217,51 @@ pub async fn post_table_data(
        return Err(Status::invalid_argument("No valid columns to insert"));
    }

+    // Qualify table name with schema
+    let qualified_table = qualify_table_name_for_data(&table_name)?;
+
    let sql = format!(
-        "INSERT INTO \"{}\" ({}) VALUES ({}) RETURNING id",
-        table_name,
+        "INSERT INTO {} ({}) VALUES ({}) RETURNING id",
+        qualified_table,
        columns_list.join(", "),
        placeholders.join(", ")
    );

-    let inserted_id: i64 = sqlx::query_scalar_with(&sql, params)
+    // Execute query with enhanced error handling
+    let result = sqlx::query_scalar_with::<_, i64, _>(&sql, params)
        .fetch_one(db_pool)
-        .await
-        .map_err(|e| Status::internal(format!("Insert failed: {}", e)))?;
+        .await;
+
+    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!(
+                        "Table '{}' is defined but does not physically exist in the database as {}",
+                        table_name, qualified_table
+                    )));
+                }
+            }
+            return Err(Status::internal(format!("Insert failed: {}", e)));
+        }
+    };
+
+    // After a successful insert, send a command to the indexer.
+    let command = IndexCommand::AddOrUpdate(IndexCommandData {
+        table_name: table_name.clone(),
+        row_id: inserted_id,
+    });
+
+    if let Err(e) = indexer_tx.send(command).await {
+        // If sending fails, the DB is updated but the index will be stale.
+        // This is a critical situation to log and monitor.
+        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,
--- a/server/src/tables_data/handlers/put_table_data.rs
+++ b/server/src/tables_data/handlers/put_table_data.rs
@@ -5,6 +5,7 @@ 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

 pub async fn put_table_data(
    db_pool: &PgPool,
@@ -18,15 +19,12 @@ pub async fn put_table_data(
    let mut processed_data = HashMap::new();
    let mut null_fields = Vec::new();

+    // CORRECTED: Generic handling for all fields.
+    // Any field with an empty string will be added to the null_fields list.
+    // The special, hardcoded logic for "firma" has been removed.
    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() {
+        if trimmed.is_empty() {
            null_fields.push(key);
        } else {
            processed_data.insert(key, trimmed);
@@ -72,8 +70,9 @@ pub async fn put_table_data(
        columns.push((name, sql_type));
    }

-    // Validate system columns
-    let system_columns = ["firma", "deleted"];
+    // CORRECTED: "firma" is not a system column.
+    // It should be treated as a user-defined column.
+    let system_columns = ["deleted"];
    let user_columns: Vec<&String> = columns.iter().map(|(name, _)| name).collect();

    // Validate input columns
@@ -90,9 +89,11 @@ pub async fn put_table_data(

    // Add data parameters for non-empty fields
    for (col, value) in &processed_data {
+        // CORRECTED: The logic for "firma" is removed from this match.
+        // It will now fall through to the `else` block and have its type
+        // correctly looked up from the `columns` vector.
        let sql_type = if system_columns.contains(&col.as_str()) {
            match col.as_str() {
-                "firma" => "TEXT",
                "deleted" => "BOOLEAN",
                _ => return Err(Status::invalid_argument("Invalid system column")),
            }
@@ -103,7 +104,6 @@ pub async fn put_table_data(
                .ok_or_else(|| Status::invalid_argument(format!("Column not found: {}", col)))?
        };

-        // TODO strong testing by user pick in the future
        match sql_type {
            "TEXT" | "VARCHAR(15)" | "VARCHAR(255)" => {
                if let Some(max_len) = sql_type.strip_prefix("VARCHAR(")
@@ -129,6 +129,13 @@ pub async fn put_table_data(
                params.add(dt.with_timezone(&Utc))
                    .map_err(|e| Status::internal(format!("Failed to add timestamp parameter for {}: {}", col, e)))?;
            },
+            // ADDED: BIGINT handling for completeness, if needed for other columns.
+            "BIGINT" => {
+                let val = value.parse::<i64>()
+                    .map_err(|_| Status::invalid_argument(format!("Invalid integer for {}", col)))?;
+                params.add(val)
+                    .map_err(|e| Status::internal(format!("Failed to add integer parameter for {}: {}", col, e)))?;
+            },
            _ => return Err(Status::invalid_argument(format!("Unsupported type {}", sql_type))),
        }

@@ -154,25 +161,39 @@ pub async fn put_table_data(
    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",
-        table_name,
+        "UPDATE {} SET {} WHERE id = ${} AND deleted = FALSE RETURNING id",
+        qualified_table,
        set_clause,
        param_idx
    );

    let result = sqlx::query_scalar_with::<Postgres, i64, _>(&sql, params)
        .fetch_optional(db_pool)
-        .await
-        .map_err(|e| Status::internal(format!("Update failed: {}", e)))?;
+        .await;

    match result {
-        Some(updated_id) => Ok(PutTableDataResponse {
+        Ok(Some(updated_id)) => Ok(PutTableDataResponse {
            success: true,
            message: "Data updated successfully".into(),
            updated_id,
        }),
-        None => Err(Status::not_found("Record not found or already deleted")),
+        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!(
+                        "Table '{}' is defined but does not physically exist in the database as {}",
+                        table_name, qualified_table
+                    )));
+                }
+            }
+            Err(Status::internal(format!("Update failed: {}", e)))
+        }
    }
 }
Author	SHA1	Message	Date
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
filipriec	6b5cbe854b	now working with the gen schema in the database	2025-06-02 12:39:23 +02:00
filipriec	59ed52814e	compiled, needs other fixes	2025-06-02 12:08:16 +02:00
filipriec	3488ab4f6b	hardcoded adresar to general form	2025-06-02 10:32:39 +02:00
filipriec	6e2fc5349b	code cleanup	2025-05-31 23:02:09 +02:00
filipriec	ea88c2686d	tabbing now adds / if there is nothing to tab to	2025-05-30 23:43:49 +02:00
filipriec	3df4baec92	tabbing now works perfectly well	2025-05-30 23:36:53 +02:00
filipriec	ff74e1aaa1	it works amazingly well now, we can select the table name via command line	2025-05-30 22:46:32 +02:00
filipriec	b0c865ab76	workig suggestion menu	2025-05-29 19:46:58 +02:00
filipriec	3dbc086f10	overriding overflows by using empty spaces as letters	2025-05-29 19:32:48 +02:00
filipriec	e9b4b34fb4	fixed height of the find file	2025-05-29 19:02:02 +02:00
filipriec	668eeee197	navigation in the menu but needs refactoring	2025-05-29 16:11:41 +02:00
filipriec	799d8471c9	open menu in command mode now implemented	2025-05-28 19:09:55 +02:00
filipriec	f77c16dec9	temp fix, before implementing C-x C-f	2025-05-28 15:53:33 +02:00
filipriec	45026cac6a	table schema is gen now	2025-05-28 15:40:17 +02:00
filipriec	edf6ab5bca	gen schema being created	2025-05-28 13:10:08 +02:00
filipriec	462b1f14e2	generated tables are now in gen schema, breaking change, needs crucial fixes NOW	2025-05-27 22:21:40 +02:00