serialization of the gRPC JSONB now fully works for the validation

serde of jsonb in grpc
validation backend
2025-09-14 11:24:27 +02:00 · 2025-09-14 10:56:38 +02:00 · 2025-09-13 21:15:44 +02:00 · 2025-09-13 08:53:26 +02:00 · 2025-09-12 23:06:42 +02:00 · 2025-09-12 21:25:49 +02:00
280 changed files with 10629 additions and 18196 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -324,6 +324,27 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "bit-set"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
 [[package]]
 name = "bitflags"
 version = "2.9.1"
@@ -472,16 +493,18 @@ checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"

 [[package]]
 name = "canvas"
-version = "0.4.2"
+version = "0.5.0"
 dependencies = [
 "anyhow",
 "async-trait",
- "common",
 "crossterm",
+ "once_cell",
 "ratatui",
 "regex",
+ "ropey",
 "serde",
- "thiserror",
+ "syntect",
+ "thiserror 2.0.12",
 "tokio",
 "tokio-test",
 "toml",
@@ -561,7 +584,7 @@ dependencies = [

 [[package]]
 name = "client"
-version = "0.4.2"
+version = "0.5.0"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -572,8 +595,8 @@ dependencies = [
 "dotenvy",
 "futures",
 "lazy_static",
- "prost",
- "prost-types",
+ "prost 0.13.5",
+ "prost-types 0.13.5",
 "ratatui",
 "rstest",
 "serde",
@@ -612,11 +635,13 @@ dependencies = [

 [[package]]
 name = "common"
-version = "0.4.2"
+version = "0.5.0"
 dependencies = [
- "prost",
- "prost-types",
+ "prost 0.13.5",
+ "prost-build 0.14.1",
+ "prost-types 0.13.5",
 "serde",
+ "serde_json",
 "tantivy",
 "tonic",
 "tonic-build",
@@ -771,7 +796,7 @@ version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.1",
 "crossterm_winapi",
 "mio",
 "parking_lot",
@@ -995,7 +1020,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
 dependencies = [
 "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
 ]

 [[package]]
@@ -1020,6 +1045,16 @@ dependencies = [
 "pin-project-lite",
 ]

+[[package]]
+name = "fancy-regex"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b95f7c0680e4142284cf8b22c14a476e87d61b004a3a0861872b32ef7ead40a2"
+dependencies = [
+ "bit-set",
+ "regex",
+]
+
 [[package]]
 name = "fastdivide"
 version = "0.4.2"
@@ -1038,6 +1073,16 @@ version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"

+[[package]]
+name = "flate2"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
 [[package]]
 name = "flume"
 version = "0.11.1"
@@ -1724,7 +1769,7 @@ version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d93587f37623a1a17d94ef2bc9ada592f5465fe7732084ab7beefabe5c77c0c4"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.1",
 "cfg-if",
 "libc",
 ]
@@ -1843,7 +1888,7 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4488594b9328dee448adb906d8b126d9b7deb7cf5c22161ee591610bb1be83c0"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.1",
 "libc",
 ]

@@ -1857,6 +1902,12 @@ dependencies = [
 "vcpkg",
 ]

+[[package]]
+name = "linked-hash-map"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.4.15"
@@ -1906,6 +1957,15 @@ version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08ab2867e3eeeca90e844d1940eab391c9dc5228783db2ed999acbc0a9ed375a"

+[[package]]
+name = "matchers"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
+dependencies = [
+ "regex-automata 0.1.10",
+]
+
 [[package]]
 name = "matchit"
 version = "0.8.4"
@@ -2139,7 +2199,7 @@ version = "0.10.73"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8505734d46c8ab1e19a1dce3aef597ad87dcb4c37e7188231769bd6bd51cebf8"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.1",
 "cfg-if",
 "foreign-types",
 "libc",
@@ -2327,6 +2387,19 @@ version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"

+[[package]]
+name = "plist"
+version = "1.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3af6b589e163c5a788fab00ce0c0366f6efbb9959c2f9874b224936af7fce7e1"
+dependencies = [
+ "base64",
+ "indexmap 2.10.0",
+ "quick-xml",
+ "serde",
+ "time",
+]
+
 [[package]]
 name = "polling"
 version = "3.9.0"
@@ -2433,7 +2506,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"
 dependencies = [
 "bytes",
- "prost-derive",
+ "prost-derive 0.13.5",
+]
+
+[[package]]
+name = "prost"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7231bd9b3d3d33c86b58adbac74b5ec0ad9f496b19d22801d773636feaa95f3d"
+dependencies = [
+ "bytes",
+ "prost-derive 0.14.1",
 ]

 [[package]]
@@ -2449,8 +2532,28 @@ dependencies = [
 "once_cell",
 "petgraph",
 "prettyplease",
- "prost",
- "prost-types",
+ "prost 0.13.5",
+ "prost-types 0.13.5",
+ "regex",
+ "syn 2.0.104",
+ "tempfile",
+]
+
+[[package]]
+name = "prost-build"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac6c3320f9abac597dcbc668774ef006702672474aad53c6d596b62e487b40b1"
+dependencies = [
+ "heck",
+ "itertools 0.14.0",
+ "log",
+ "multimap",
+ "once_cell",
+ "petgraph",
+ "prettyplease",
+ "prost 0.14.1",
+ "prost-types 0.14.1",
 "regex",
 "syn 2.0.104",
 "tempfile",
@@ -2469,13 +2572,35 @@ dependencies = [
 "syn 2.0.104",
 ]

+[[package]]
+name = "prost-derive"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9120690fafc389a67ba3803df527d0ec9cbbc9cc45e4cc20b332996dfb672425"
+dependencies = [
+ "anyhow",
+ "itertools 0.14.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.104",
+]
+
 [[package]]
 name = "prost-types"
 version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16"
 dependencies = [
- "prost",
+ "prost 0.13.5",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9b4db3d6da204ed77bb26ba83b6122a73aeb2e87e25fbf7ad2e84c4ccbf8f72"
+dependencies = [
+ "prost 0.14.1",
 ]

 [[package]]
@@ -2498,6 +2623,15 @@ dependencies = [
 "syn 1.0.109",
 ]

+[[package]]
+name = "quick-xml"
+version = "0.38.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9845d9dccf565065824e69f9f235fafba1587031eda353c1f1561cd6a6be78f4"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "quickscope"
 version = "0.2.0"
@@ -2613,7 +2747,7 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eabd94c2f37801c20583fc49dd5cd6b0ba68c716787c2dd6ed18571e1e63117b"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.1",
 "cassowary",
 "compact_str",
 "crossterm",
@@ -2654,7 +2788,7 @@ version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7e8af0dde094006011e6a740d4879319439489813bd0bcdc7d821beaeeff48ec"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.1",
 ]

 [[package]]
@@ -2665,7 +2799,7 @@ checksum = "dd6f9d3d47bdd2ad6945c5015a226ec6155d0bcdfd8f7cd29f86b71f8de99d2b"
 dependencies = [
 "getrandom 0.2.16",
 "libredox",
- "thiserror",
+ "thiserror 2.0.12",
 ]

 [[package]]
@@ -2676,8 +2810,17 @@ checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
 dependencies = [
 "aho-corasick",
 "memchr",
- "regex-automata",
- "regex-syntax",
+ "regex-automata 0.4.9",
+ "regex-syntax 0.8.5",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+dependencies = [
+ "regex-syntax 0.6.29",
 ]

 [[package]]
@@ -2688,9 +2831,15 @@ checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
 dependencies = [
 "aho-corasick",
 "memchr",
- "regex-syntax",
+ "regex-syntax 0.8.5",
 ]

+[[package]]
+name = "regex-syntax"
+version = "0.6.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+
 [[package]]
 name = "regex-syntax"
 version = "0.8.5"
@@ -2764,6 +2913,16 @@ dependencies = [
 "syn 1.0.109",
 ]

+[[package]]
+name = "ropey"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93411e420bcd1a75ddd1dc3caf18c23155eda2c090631a85af21ba19e97093b5"
+dependencies = [
+ "smallvec",
+ "str_indices",
+]
+
 [[package]]
 name = "rsa"
 version = "0.9.8"
@@ -2877,11 +3036,11 @@ version = "0.38.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.1",
 "errno",
 "libc",
 "linux-raw-sys 0.4.15",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]

 [[package]]
@@ -2890,11 +3049,11 @@ version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.1",
 "errno",
 "libc",
 "linux-raw-sys 0.9.4",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
 ]

 [[package]]
@@ -2909,6 +3068,15 @@ version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"

+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "schannel"
 version = "0.1.27"
@@ -2932,11 +3100,11 @@ checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"

 [[package]]
 name = "search"
-version = "0.4.2"
+version = "0.5.0"
 dependencies = [
 "anyhow",
 "common",
- "prost",
+ "prost 0.13.5",
 "serde",
 "serde_json",
 "sqlx",
@@ -2953,7 +3121,7 @@ version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.1",
 "core-foundation",
 "core-foundation-sys",
 "libc",
@@ -3031,7 +3199,7 @@ dependencies = [

 [[package]]
 name = "server"
-version = "0.4.2"
+version = "0.5.0"
 dependencies = [
 "anyhow",
 "bcrypt",
@@ -3042,8 +3210,9 @@ dependencies = [
 "futures",
 "jsonwebtoken",
 "lazy_static",
- "prost",
- "prost-types",
+ "prost 0.13.5",
+ "prost-build 0.14.1",
+ "prost-types 0.13.5",
 "rand 0.9.2",
 "regex",
 "rstest",
@@ -3058,7 +3227,7 @@ dependencies = [
 "steel-decimal",
 "steel-derive",
 "tantivy",
- "thiserror",
+ "thiserror 2.0.12",
 "time",
 "tokio",
 "tokio-test",
@@ -3160,7 +3329,7 @@ checksum = "297f631f50729c8c99b84667867963997ec0b50f32b2a7dbcab828ef0541e8bb"
 dependencies = [
 "num-bigint",
 "num-traits",
- "thiserror",
+ "thiserror 2.0.12",
 "time",
 ]

@@ -3280,7 +3449,7 @@ dependencies = [
 "serde_json",
 "sha2",
 "smallvec",
- "thiserror",
+ "thiserror 2.0.12",
 "time",
 "tokio",
 "tokio-stream",
@@ -3335,7 +3504,7 @@ checksum = "aa003f0038df784eb8fecbbac13affe3da23b45194bd57dba231c8f48199c526"
 dependencies = [
 "atoi",
 "base64",
- "bitflags",
+ "bitflags 2.9.1",
 "byteorder",
 "bytes",
 "chrono",
@@ -3366,7 +3535,7 @@ dependencies = [
 "smallvec",
 "sqlx-core",
 "stringprep",
- "thiserror",
+ "thiserror 2.0.12",
 "time",
 "tracing",
 "uuid",
@@ -3381,7 +3550,7 @@ checksum = "db58fcd5a53cf07c184b154801ff91347e4c30d17a3562a635ff028ad5deda46"
 dependencies = [
 "atoi",
 "base64",
- "bitflags",
+ "bitflags 2.9.1",
 "byteorder",
 "chrono",
 "crc",
@@ -3407,7 +3576,7 @@ dependencies = [
 "smallvec",
 "sqlx-core",
 "stringprep",
- "thiserror",
+ "thiserror 2.0.12",
 "time",
 "tracing",
 "uuid",
@@ -3434,7 +3603,7 @@ dependencies = [
 "serde",
 "serde_urlencoded",
 "sqlx-core",
- "thiserror",
+ "thiserror 2.0.12",
 "time",
 "tracing",
 "url",
@@ -3516,7 +3685,7 @@ dependencies = [
 "rust_decimal_macros",
 "steel-core",
 "steel-derive",
- "thiserror",
+ "thiserror 2.0.12",
 ]

 [[package]]
@@ -3558,6 +3727,12 @@ dependencies = [
 "smallvec",
 ]

+[[package]]
+name = "str_indices"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d08889ec5408683408db66ad89e0e1f93dff55c73a4ccc71c427d5b277ee47e6"
+
 [[package]]
 name = "stringprep"
 version = "0.1.5"
@@ -3642,6 +3817,28 @@ dependencies = [
 "syn 2.0.104",
 ]

+[[package]]
+name = "syntect"
+version = "5.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "874dcfa363995604333cf947ae9f751ca3af4522c60886774c4963943b4746b1"
+dependencies = [
+ "bincode",
+ "bitflags 1.3.2",
+ "fancy-regex",
+ "flate2",
+ "fnv",
+ "once_cell",
+ "plist",
+ "regex-syntax 0.8.5",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "thiserror 1.0.69",
+ "walkdir",
+ "yaml-rust",
+]
+
 [[package]]
 name = "tantivy"
 version = "0.24.2"
@@ -3688,7 +3885,7 @@ dependencies = [
 "tantivy-stacker",
 "tantivy-tokenizer-api",
 "tempfile",
- "thiserror",
+ "thiserror 2.0.12",
 "time",
 "uuid",
 "winapi",
@@ -3739,7 +3936,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d60769b80ad7953d8a7b2c70cdfe722bbcdcac6bccc8ac934c40c034d866fc18"
 dependencies = [
 "byteorder",
- "regex-syntax",
+ "regex-syntax 0.8.5",
 "utf8-ranges",
 ]

@@ -3804,7 +4001,7 @@ dependencies = [
 "getrandom 0.3.3",
 "once_cell",
 "rustix 1.0.8",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]

 [[package]]
@@ -3816,13 +4013,33 @@ dependencies = [
 "winapi-util",
 ]

+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
 [[package]]
 name = "thiserror"
 version = "2.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 2.0.12",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.104",
 ]

 [[package]]
@@ -4031,7 +4248,7 @@ dependencies = [
 "hyper-util",
 "percent-encoding",
 "pin-project",
- "prost",
+ "prost 0.13.5",
 "socket2 0.5.10",
 "tokio",
 "tokio-stream",
@@ -4049,8 +4266,8 @@ checksum = "eac6f67be712d12f0b41328db3137e0d0757645d8904b4cb7d51cd9c2279e847"
 dependencies = [
 "prettyplease",
 "proc-macro2",
- "prost-build",
- "prost-types",
+ "prost-build 0.13.5",
+ "prost-types 0.13.5",
 "quote",
 "syn 2.0.104",
 ]
@@ -4061,8 +4278,8 @@ version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9687bd5bfeafebdded2356950f278bba8226f0b32109537c4253406e09aafe1"
 dependencies = [
- "prost",
- "prost-types",
+ "prost 0.13.5",
+ "prost-types 0.13.5",
 "tokio",
 "tokio-stream",
 "tonic",
@@ -4149,10 +4366,14 @@ version = "0.3.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
 dependencies = [
+ "matchers",
 "nu-ansi-term",
+ "once_cell",
+ "regex",
 "sharded-slab",
 "smallvec",
 "thread_local",
+ "tracing",
 "tracing-core",
 "tracing-log",
 ]
@@ -4347,6 +4568,16 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"

+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
 [[package]]
 name = "want"
 version = "0.3.1"
@@ -4485,7 +4716,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]]
@@ -4795,7 +5026,7 @@ version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
 dependencies = [
- "bitflags",
+ "bitflags 2.9.1",
 ]

 [[package]]
@@ -4819,6 +5050,15 @@ version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2fb433233f2df9344722454bc7e96465c9d03bff9d77c248f9e7523fe79585b5"

+[[package]]
+name = "yaml-rust"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
+dependencies = [
+ "linked-hash-map",
+]
+
 [[package]]
 name = "yoke"
 version = "0.8.0"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,7 +5,7 @@ resolver = "2"
 [workspace.package]
 # TODO: idk how to do the name, fix later
 # name = "komp_ac"
-version = "0.4.2"
+version = "0.5.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
 authors = ["Filip Priečinský <filippriec@gmail.com>"]
--- a/canvas/CANVAS_MIGRATION.md
+++ b/canvas/CANVAS_MIGRATION.md
@@ -57,7 +57,7 @@ use canvas::canvas::CanvasState;
 use canvas::canvas::CanvasAction;
 use canvas::canvas::ActionContext;
 use canvas::canvas::HighlightState;
-use canvas::canvas::CanvasTheme;
+use canvas::CanvasTheme;
 use canvas::dispatcher::ActionDispatcher;
 use canvas::canvas::ActionResult;
 ```
@@ -153,7 +153,7 @@ if editor.is_suggestions_active() {
 **New rendering:**
 ```rust
 // Canvas handles everything
-use canvas::canvas::render_canvas;
+use canvas::render_canvas_default;

 let active_field_rect = render_canvas(f, area, form_state, theme, edit_mode, highlight_state);

--- a/canvas/Cargo.toml
+++ b/canvas/Cargo.toml
@@ -2,15 +2,14 @@
 name = "canvas"
 version.workspace = true
 edition.workspace = true
-license.workspace = true
+license = "MIT OR Apache-2.0"
 authors.workspace = true
-description.workspace = true
+description = "Form/textarea for TUI"
 readme.workspace = true
 repository.workspace = true
 categories.workspace = true

 [dependencies]
-common = { path = "../common" }
 ratatui = { workspace = true, optional = true }
 crossterm = { workspace = true, optional = true }
 anyhow.workspace = true
@@ -24,6 +23,9 @@ tracing = "0.1.41"
 tracing-subscriber = "0.3.19"
 async-trait.workspace = true
 regex = { workspace = true, optional = true }
+ropey = { version = "1.6.1", optional = true }
+once_cell = "1.21.3"
+syntect = { version = "5.2.0", optional = true, default-features = false, features = ["default-fancy"] }

 [dev-dependencies]
 tokio-test = "0.4.4"
@@ -35,7 +37,9 @@ suggestions = ["tokio"]
 cursor-style = ["crossterm"]
 validation = ["regex"]
 computed = []
-textarea = ["gui"]
+textarea = ["dep:ropey","gui"]
+syntect = ["dep:syntect", "gui", "textarea"]
+keymap = ["gui"]

 # text modes (mutually exclusive; default to vim)
 textmode-vim = []
@@ -47,7 +51,8 @@ all-nontextmodes = [
    "cursor-style",
    "validation",
    "computed",
-    "textarea"
+    "textarea",
+    "keymap"
 ]

 [[example]]
@@ -98,3 +103,13 @@ path = "examples/textarea_vim.rs"
 name = "textarea_normal"
 required-features = ["gui", "cursor-style", "textarea", "textmode-normal"]
 path = "examples/textarea_normal.rs"
+
+[[example]]
+name = "textarea_syntax"
+required-features = ["gui", "cursor-style", "textarea", "textmode-normal", "syntect"]
+path = "examples/textarea_syntax.rs"
+
+[[example]]
+name = "canvas_keymap"
+required-features = ["gui", "keymap", "cursor-style"]
+path = "examples/canvas_keymap.rs"
--- a/canvas/README.md
+++ b/canvas/README.md
@@ -1,337 +1,113 @@
-# Canvas 🎨
+# Canvas

-A reusable, type-safe canvas system for building form-based TUI applications with vim-like modal editing.
+Canvas is a Rust library for building form‑based and textarea‑driven terminal user interfaces.
+It provides the core logic for text editing, validation, suggestions, and cursor management.

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

 ---

-Built with ❤️ for the Rust TUI community
+## Overview
+
+Canvas is designed for applications that require structured text input in a terminal environment.
+It provides:
+
+- Text editing modes (Vim‑like or normal)
+- Validation (regex, masks, limits, formatting)
+- Suggestions (asynchronous dropdowns)
+- Computed fields (derived values)
+- Textarea widget with cursor management
+- Syntax highlighting (via syntect)
+- Extensible architecture for custom behaviors
+
+---
+
+## Installation
+
+Add the dependency to your `Cargo.toml`:
+
+```toml
+[dependencies]
+canvas = { version = "0.x", features = ["gui", "cursor-style", "textarea", "validation"] }
+```
+
+---
+
+## Features
+
+The library is feature‑gated. Enable only what you need:
+
+- `gui` – terminal rendering support (ratatui + crossterm)
+- `cursor-style` – styled cursor support
+- `validation` – regex, masks, limits, formatting
+- `suggestions` – asynchronous suggestions dropdowns
+- `computed` – derived fields
+- `textarea` – textarea widget
+- `syntect` – syntax highlighting support
+- `textmode-vim` – Vim‑like editing (default)
+- `textmode-normal` – normal editing mode
+
+**Note:** `textmode-vim` and `textmode-normal` are mutually exclusive. Enable exactly one.
+
+The default feature set is `["textmode-vim"]`.
+
+---
+
+## Running Examples
+
+The repository includes several examples. Each requires specific feature flags.
+Use the following commands to run them:
+
+```bash
+# Textarea with Vim mode
+cargo run --example textarea_vim --features "gui cursor-style textarea textmode-vim"
+
+# Textarea with Normal mode
+cargo run --example textarea_normal --features "gui cursor-style textarea textmode-normal"
+
+# Textarea with syntax highlighting
+cargo run --example textarea_syntax --features "gui cursor-style textarea syntect textmode-normal"
+
+# Validation examples
+cargo run --example validation_1 --features "gui validation cursor-style"
+cargo run --example validation_2 --features "gui validation cursor-style"
+cargo run --example validation_3 --features "gui validation cursor-style"
+cargo run --example validation_4 --features "gui validation cursor-style"
+cargo run --example validation_5 --features "gui validation cursor-style"
+
+# Suggestions
+cargo run --example suggestions --features "suggestions gui cursor-style"
+cargo run --example suggestions2 --features "suggestions gui cursor-style"
+
+# Cursor auto movement
+cargo run --example canvas_cursor_auto --features "gui cursor-style"
+
+# Computed fields
+cargo run --example computed_fields --features "gui computed"
+```
+
+---
+
+## Documentation
+
+- API documentation: `cargo doc --open`
+- Migration notes: `CANVAS_MIGRATION.md`
+
+---
+
+## License
+
+Licensed under either of:
+- Apache License, Version 2.0
+- MIT License
+
+at your option.
+
+---
+
+## Contributing
+
+Contributions are welcome. Please follow the existing code structure and feature‑gating conventions.
--- a/canvas/examples/canvas_cursor_auto.rs
+++ b/canvas/examples/canvas_cursor_auto.rs
@@ -38,7 +38,7 @@ use ratatui::{
 use canvas::{
    canvas::{
        gui::render_canvas_default,
-        modes::{AppMode, ModeManager, HighlightState},
+        modes::AppMode,
        CursorManager, // This import only exists when cursor-style feature is enabled
    },
    DataProvider, FormEditor,
@@ -205,7 +205,7 @@ impl<D: DataProvider> AutoCursorFormEditor<D> {
            self.has_unsaved_changes = true;
            self.debug_message = "⌫ Deleted character backward".to_string();
        }
-        Ok(result?)
+        result
    }

    fn delete_forward(&mut self) -> anyhow::Result<()> {
@@ -214,7 +214,7 @@ impl<D: DataProvider> AutoCursorFormEditor<D> {
            self.has_unsaved_changes = true;
            self.debug_message = "⌦ Deleted character forward".to_string();
        }
-        Ok(result?)
+        result
    }

    // === MODE TRANSITIONS WITH AUTOMATIC CURSOR MANAGEMENT ===
@@ -240,7 +240,7 @@ impl<D: DataProvider> AutoCursorFormEditor<D> {
        if result.is_ok() {
            self.has_unsaved_changes = true;
        }
-        Ok(result?)
+        result
    }

    // === MANUAL CURSOR OVERRIDE DEMONSTRATION ===
@@ -429,13 +429,13 @@ fn handle_key_press(

        (AppMode::ReadOnly, KeyCode::Char('o'), _) => {
            if let Err(e) = editor.open_line_below() {
-                editor.set_debug_message(format!("Error opening line below: {}", e));
+                editor.set_debug_message(format!("Error opening line below: {e}"));
            }
            editor.clear_command_buffer();
        }
        (AppMode::ReadOnly, KeyCode::Char('O'), _) => {
            if let Err(e) = editor.open_line_above() {
-                editor.set_debug_message(format!("Error opening line above: {}", e));
+                editor.set_debug_message(format!("Error opening line above: {e}"));
            }
            editor.clear_command_buffer();
        }
@@ -694,8 +694,7 @@ fn handle_key_press(
                editor.set_debug_message("Invalid command sequence".to_string());
            } else {
                editor.set_debug_message(format!(
-                    "Unhandled: {:?} + {:?} in {:?} mode",
-                    key, modifiers, mode
+                    "Unhandled: {key:?} + {modifiers:?} in {mode:?} mode"
                ));
            }
        }
@@ -719,7 +718,7 @@ fn run_app<B: Backend>(
                    }
                }
                Err(e) => {
-                    editor.set_debug_message(format!("Error: {}", e));
+                    editor.set_debug_message(format!("Error: {e}"));
                }
            }
        }
@@ -858,7 +857,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    terminal.show_cursor()?;

    if let Err(err) = res {
-        println!("{:?}", err);
+        println!("{err:?}");
    }

    println!("🎯 Cursor automatically reset to default!");
--- a/canvas/examples/canvas_keymap.rs
+++ b/canvas/examples/canvas_keymap.rs
@@ -0,0 +1,376 @@
+// examples/canvas_keymap.rs
+//! Demonstrates the centralized keymap system for canvas interactions
+//!
+//! This example shows how to use the canvas-keymap feature to delegate
+//! all canvas key handling to the library, supporting complex sequences
+//! like "gg", "ge", etc.
+//!
+//! Run with:
+//! cargo run --example canvas_keymap --features "gui,keymap,cursor-style"
+
+#[cfg(not(feature = "keymap"))]
+compile_error!(
+    "This example requires the 'keymap' feature. \
+     Run with: cargo run --example canvas_keymap --features \"gui,keymap,cursor-style\""
+);
+
+use std::collections::HashMap;
+use std::io;
+use crossterm::{
+    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyEvent},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+};
+use ratatui::{
+    backend::{Backend, CrosstermBackend},
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Style},
+    text::{Line, Span},
+    widgets::{Block, Borders, Paragraph},
+    Frame, Terminal,
+};
+
+use canvas::{
+    canvas::{gui::render_canvas_default, modes::AppMode},
+    keymap::{CanvasKeyMap, KeyEventOutcome},
+    DataProvider, FormEditor,
+};
+
+/// Demo application using centralized keymap system
+struct KeymapDemoApp {
+    editor: FormEditor<DemoData>,
+    message: String,
+    quit: bool,
+}
+
+impl KeymapDemoApp {
+    fn new() -> Self {
+        let data = DemoData::new();
+        let mut editor = FormEditor::new(data);
+        
+        // Build and inject the keymap from our config
+        let keymap = Self::build_demo_keymap();
+        editor.set_keymap(keymap);
+        
+        Self {
+            editor,
+            message: "🎯 Keymap system loaded! Try: gg, ge, hjkl, w/b/e, v, i, etc.".to_string(),
+            quit: false,
+        }
+    }
+
+    /// Build a comprehensive keymap configuration
+    fn build_demo_keymap() -> CanvasKeyMap {
+        let mut read_only = HashMap::new();
+        let mut edit = HashMap::new();
+        let mut highlight = HashMap::new();
+
+        // === READ-ONLY MODE KEYBINDINGS ===
+        
+        // Basic movement
+        read_only.insert("move_left".to_string(), vec!["h".to_string(), "Left".to_string()]);
+        read_only.insert("move_right".to_string(), vec!["l".to_string(), "Right".to_string()]);
+        read_only.insert("move_up".to_string(), vec!["k".to_string(), "Up".to_string()]);
+        read_only.insert("move_down".to_string(), vec!["j".to_string(), "Down".to_string()]);
+
+        // Word movement
+        read_only.insert("move_word_next".to_string(), vec!["w".to_string()]);
+        read_only.insert("move_word_prev".to_string(), vec!["b".to_string()]);
+        read_only.insert("move_word_end".to_string(), vec!["e".to_string()]);
+        read_only.insert("move_word_end_prev".to_string(), vec!["ge".to_string()]); // Multi-key!
+
+        // Big word movement  
+        read_only.insert("move_big_word_next".to_string(), vec!["W".to_string()]);
+        read_only.insert("move_big_word_prev".to_string(), vec!["B".to_string()]);
+        read_only.insert("move_big_word_end".to_string(), vec!["E".to_string()]);
+        read_only.insert("move_big_word_end_prev".to_string(), vec!["gE".to_string()]); // Multi-key!
+
+        // Line movement
+        read_only.insert("move_line_start".to_string(), vec!["0".to_string(), "Home".to_string()]);
+        read_only.insert("move_line_end".to_string(), vec!["$".to_string(), "End".to_string()]);
+        
+        // Field movement
+        read_only.insert("move_first_line".to_string(), vec!["gg".to_string()]); // Multi-key!
+        read_only.insert("move_last_line".to_string(), vec!["G".to_string()]);
+        read_only.insert("next_field".to_string(), vec!["Tab".to_string()]);
+        read_only.insert("prev_field".to_string(), vec!["Shift+Tab".to_string()]);
+
+        // Mode transitions
+        read_only.insert("enter_edit_mode_before".to_string(), vec!["i".to_string()]);
+        read_only.insert("enter_edit_mode_after".to_string(), vec!["a".to_string()]);
+        read_only.insert("enter_highlight_mode".to_string(), vec!["v".to_string()]);
+        read_only.insert("enter_highlight_mode_linewise".to_string(), vec!["V".to_string()]);
+
+        // Editing actions in normal mode
+        read_only.insert("delete_char_forward".to_string(), vec!["x".to_string()]);
+        read_only.insert("delete_char_backward".to_string(), vec!["X".to_string()]);
+        read_only.insert("open_line_below".to_string(), vec!["o".to_string()]);
+        read_only.insert("open_line_above".to_string(), vec!["O".to_string()]);
+
+        // === EDIT MODE KEYBINDINGS ===
+        
+        edit.insert("exit_edit_mode".to_string(), vec!["esc".to_string()]);
+        edit.insert("move_left".to_string(), vec!["Left".to_string()]);
+        edit.insert("move_right".to_string(), vec!["Right".to_string()]);
+        edit.insert("move_up".to_string(), vec!["Up".to_string()]);
+        edit.insert("move_down".to_string(), vec!["Down".to_string()]);
+        edit.insert("move_line_start".to_string(), vec!["Home".to_string()]);
+        edit.insert("move_line_end".to_string(), vec!["End".to_string()]);
+        edit.insert("move_word_next".to_string(), vec!["Ctrl+Right".to_string()]);
+        edit.insert("move_word_prev".to_string(), vec!["Ctrl+Left".to_string()]);
+        edit.insert("next_field".to_string(), vec!["Tab".to_string()]);
+        edit.insert("prev_field".to_string(), vec!["Shift+Tab".to_string()]);
+        edit.insert("delete_char_backward".to_string(), vec!["Backspace".to_string()]);
+        edit.insert("delete_char_forward".to_string(), vec!["Delete".to_string()]);
+
+        // === HIGHLIGHT MODE KEYBINDINGS ===
+        
+        highlight.insert("exit_highlight_mode".to_string(), vec!["esc".to_string()]);
+        highlight.insert("enter_highlight_mode_linewise".to_string(), vec!["V".to_string()]);
+        
+        // Movement (extends selection)
+        highlight.insert("move_left".to_string(), vec!["h".to_string(), "Left".to_string()]);
+        highlight.insert("move_right".to_string(), vec!["l".to_string(), "Right".to_string()]);
+        highlight.insert("move_up".to_string(), vec!["k".to_string(), "Up".to_string()]);
+        highlight.insert("move_down".to_string(), vec!["j".to_string(), "Down".to_string()]);
+        highlight.insert("move_word_next".to_string(), vec!["w".to_string()]);
+        highlight.insert("move_word_prev".to_string(), vec!["b".to_string()]);
+        highlight.insert("move_word_end".to_string(), vec!["e".to_string()]);
+        highlight.insert("move_word_end_prev".to_string(), vec!["ge".to_string()]);
+        highlight.insert("move_line_start".to_string(), vec!["0".to_string()]);
+        highlight.insert("move_line_end".to_string(), vec!["$".to_string()]);
+        highlight.insert("move_first_line".to_string(), vec!["gg".to_string()]);
+        highlight.insert("move_last_line".to_string(), vec!["G".to_string()]);
+
+        CanvasKeyMap::from_mode_maps(&read_only, &edit, &highlight)
+    }
+
+    fn handle_key_event(&mut self, key_event: KeyEvent) -> io::Result<()> {
+        // First, try canvas keymap
+        match self.editor.handle_key_event(key_event) {
+            KeyEventOutcome::Consumed(Some(msg)) => {
+                self.message = format!("🎯 Canvas: {}", msg);
+                return Ok(());
+            }
+            KeyEventOutcome::Consumed(None) => {
+                self.message = "🎯 Canvas action executed".to_string();
+                return Ok(());
+            }
+            KeyEventOutcome::Pending => {
+                self.message = "⏳ Waiting for next key in sequence...".to_string();
+                return Ok(());
+            }
+            KeyEventOutcome::NotMatched => {
+                // Fall through to client actions
+            }
+        }
+
+        // Handle client-specific actions (non-canvas)
+        use crossterm::event::{KeyCode, KeyModifiers};
+        match (key_event.code, key_event.modifiers) {
+            (KeyCode::Char('q'), KeyModifiers::CONTROL) |
+            (KeyCode::Char('c'), KeyModifiers::CONTROL) => {
+                self.quit = true;
+                self.message = "👋 Goodbye!".to_string();
+            }
+            (KeyCode::F(1), _) => {
+                self.message = "ℹ️  F1: This is a client action (not handled by canvas keymap)".to_string();
+            }
+            (KeyCode::F(2), _) => {
+                // Demonstrate saving
+                self.message = "💾 F2: Save action (client-side)".to_string();
+            }
+            (KeyCode::Char('?'), _) if self.editor.mode() == AppMode::ReadOnly => {
+                self.show_help();
+            }
+            _ => {
+                // Unknown key
+                self.message = format!(
+                    "❓ Unhandled key: {:?} (mode: {:?})",
+                    key_event.code,
+                    self.editor.mode()
+                );
+            }
+        }
+
+        Ok(())
+    }
+
+    fn show_help(&mut self) {
+        self.message = "📖 Help: Multi-key sequences work! Try gg, ge, gE. Also: hjkl, w/b/e, v/V, i/a/o".to_string();
+    }
+
+    fn should_quit(&self) -> bool {
+        self.quit
+    }
+
+    fn editor(&self) -> &FormEditor<DemoData> {
+        &self.editor
+    }
+
+    fn message(&self) -> &str {
+        &self.message
+    }
+}
+
+/// Demo form data with interesting examples for keymap testing
+struct DemoData {
+    fields: Vec<(String, String)>,
+}
+
+impl DemoData {
+    fn new() -> Self {
+        Self {
+            fields: vec![
+                ("🎯 Name".to_string(), "John-Paul McDonald-Smith".to_string()),
+                ("📧 Email".to_string(), "user@long-domain-name.example.com".to_string()),
+                ("📱 Phone".to_string(), "+1 (555) 123-4567 ext. 890".to_string()),
+                ("🏠 Address".to_string(), "123 Main Street, Apartment 4B, Suite 100".to_string()),
+                ("🏷️  Tags".to_string(), "urgent,important,follow-up,high-priority".to_string()),
+                ("📝 Notes".to_string(), "Test word movements: w=next-word, b=prev-word, e=word-end, ge=prev-word-end".to_string()),
+                ("🔥 Multi-key".to_string(), "Try multi-key sequences: gg=first-field, ge=prev-word-end, gE=prev-WORD-end".to_string()),
+                ("⚡ Vim Actions".to_string(), "Normal mode: x=delete-char, o=open-line-below, v=visual, i=insert".to_string()),
+            ],
+        }
+    }
+}
+
+impl DataProvider for DemoData {
+    fn field_count(&self) -> usize {
+        self.fields.len()
+    }
+
+    fn field_name(&self, index: usize) -> &str {
+        &self.fields[index].0
+    }
+
+    fn field_value(&self, index: usize) -> &str {
+        &self.fields[index].1
+    }
+
+    fn set_field_value(&mut self, index: usize, value: String) {
+        self.fields[index].1 = value;
+    }
+}
+
+fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: KeymapDemoApp) -> io::Result<()> {
+    loop {
+        terminal.draw(|f| ui(f, &app))?;
+
+        if let Event::Key(key) = event::read()? {
+            app.handle_key_event(key)?;
+            if app.should_quit() {
+                break;
+            }
+        }
+    }
+    Ok(())
+}
+
+fn ui(f: &mut Frame, app: &KeymapDemoApp) {
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([Constraint::Min(8), Constraint::Length(12)])
+        .split(f.area());
+
+    // Render the canvas
+    render_canvas_default(f, chunks[0], app.editor());
+
+    // Render status and help
+    render_status_and_help(f, chunks[1], app);
+}
+
+fn render_status_and_help(f: &mut Frame, area: ratatui::layout::Rect, app: &KeymapDemoApp) {
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([Constraint::Length(3), Constraint::Min(9)])
+        .split(area);
+
+    // Status message
+    let status_text = format!(
+        "Mode: {:?} | Field: {}/{} | Pos: {} | {}",
+        app.editor().mode(),
+        app.editor().current_field() + 1,
+        app.editor().data_provider().field_count(),
+        app.editor().cursor_position(),
+        app.message()
+    );
+
+    let status = Paragraph::new(Line::from(Span::raw(status_text)))
+        .block(Block::default().borders(Borders::ALL).title("🎯 Keymap Demo Status"));
+
+    f.render_widget(status, chunks[0]);
+
+    // Help text based on current mode
+    let help_text = match app.editor().mode() {
+        AppMode::ReadOnly => {
+            "🎯 KEYMAP DEMO - All keys handled by centralized keymap system!\n\
+             \n\
+             📍 MOVEMENT: hjkl(basic) | w/b/e(words) | W/B/E(WORDS) | 0/$(line) | gg/G(fields)\n\
+             🔥 MULTI-KEY: gg=first-field, ge=prev-word-end, gE=prev-WORD-end\n\
+             ✏️  MODES: i/a(insert) | v/V(visual) | o/O(open-line)\n\
+             🗑️  DELETE: x/X(delete-char)\n\
+             📂 FIELDS: Tab/Shift+Tab\n\
+             \n\
+             💡 Try multi-key sequences like 'gg' or 'ge' - watch the status for 'Waiting...'\n\
+             🚪 Ctrl+C=quit | ?=help | F1/F2=client actions (not canvas)"
+        }
+        AppMode::Edit => {
+            "✏️  INSERT MODE - Keys handled by keymap system\n\
+             \n\
+             🔄 NAVIGATION: arrows | Ctrl+arrows(words) | Home/End(line) | Tab/Shift+Tab(fields)\n\
+             🗑️  DELETE: Backspace/Delete\n\
+             🚪 EXIT: Esc=normal\n\
+             \n\
+             💡 Type text normally - the keymap handles navigation!"
+        }
+        AppMode::Highlight => {
+            "🎯 VISUAL MODE - Selection extended by keymap movements\n\
+             \n\
+             📍 EXTEND: hjkl(basic) | w/b/e(words) | 0/$(line) | gg/G(fields)\n\
+             🔄 SWITCH: V=toggle-line-mode\n\
+             🚪 EXIT: Esc=normal\n\
+             \n\
+             💡 All movements extend the selection automatically!"
+        }
+        _ => "🎯 Keymap system active!"
+    };
+
+    let help = Paragraph::new(help_text)
+        .block(Block::default().borders(Borders::ALL).title("🚀 Centralized Keymap System"))
+        .style(Style::default().fg(Color::Gray));
+
+    f.render_widget(help, chunks[1]);
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("🎯 Canvas Keymap Demo");
+    println!("✅ canvas-keymap feature: ENABLED");
+    println!("🚀 Centralized key handling: ACTIVE");
+    println!("📖 Multi-key sequences: SUPPORTED (gg, ge, gE, etc.)");
+    println!();
+
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    let app = KeymapDemoApp::new();
+    let res = run_app(&mut terminal, app);
+
+    disable_raw_mode()?;
+    execute!(
+        terminal.backend_mut(),
+        LeaveAlternateScreen,
+        DisableMouseCapture
+    )?;
+    terminal.show_cursor()?;
+
+    if let Err(err) = res {
+        println!("{err:?}");
+    }
+
+    println!("🎯 Keymap demo completed!");
+    Ok(())
+}
--- a/canvas/examples/computed_fields.rs
+++ b/canvas/examples/computed_fields.rs
@@ -133,7 +133,7 @@ impl ComputedProvider for InvoiceCalculator {
                if qty == 0.0 || price == 0.0 {
                    "".to_string()  // Show empty if no meaningful calculation
                } else {
-                    format!("{:.2}", subtotal)
+                    format!("{subtotal:.2}")
                }
            }
            5 => {
@@ -147,7 +147,7 @@ impl ComputedProvider for InvoiceCalculator {
                if subtotal == 0.0 || tax_rate == 0.0 {
                    "".to_string()
                } else {
-                    format!("{:.2}", tax_amount)
+                    format!("{tax_amount:.2}")
                }
            }
            6 => {
@@ -162,7 +162,7 @@ impl ComputedProvider for InvoiceCalculator {
                } else {
                    let tax_amount = subtotal * (tax_rate / 100.0);
                    let total = subtotal + tax_amount;
-                    format!("{:.2}", total)
+                    format!("{total:.2}")
                }
            }
            _ => "".to_string(),
@@ -170,7 +170,7 @@ impl ComputedProvider for InvoiceCalculator {
    }
    
    fn handles_field(&self, field_index: usize) -> bool {
-        matches!(field_index, 4 | 5 | 6) // Subtotal, Tax Amount, Total
+        matches!(field_index, 4..=6) // Subtotal, Tax Amount, Total
    }
    
    fn field_dependencies(&self, field_index: usize) -> Vec<usize> {
@@ -244,13 +244,13 @@ impl<D: DataProvider> ComputedFieldsEditor<D> {
                
                let mut parts = Vec::new();
                if !subtotal.is_empty() {
-                    parts.push(format!("Subtotal=${}", subtotal));
+                    parts.push(format!("Subtotal=${subtotal}"));
                }
                if !tax.is_empty() {
-                    parts.push(format!("Tax=${}", tax));
+                    parts.push(format!("Tax=${tax}"));
                }
                if !total.is_empty() {
-                    parts.push(format!("Total=${}", total));
+                    parts.push(format!("Total=${total}"));
                }
                
                if !parts.is_empty() {
@@ -268,7 +268,7 @@ impl<D: DataProvider> ComputedFieldsEditor<D> {
        let current_field = self.editor.current_field();
        let result = self.editor.insert_char(ch);

-        if result.is_ok() && matches!(current_field, 1 | 2 | 3) {
+        if result.is_ok() && matches!(current_field, 1..=3) {
            self.editor.on_field_changed(&mut self.calculator, current_field);
            self.update_computed_fields();
        }
@@ -280,7 +280,7 @@ impl<D: DataProvider> ComputedFieldsEditor<D> {
        let current_field = self.editor.current_field();
        let result = self.editor.delete_backward();

-        if result.is_ok() && matches!(current_field, 1 | 2 | 3) {
+        if result.is_ok() && matches!(current_field, 1..=3) {
            self.editor.on_field_changed(&mut self.calculator, current_field);
            self.update_computed_fields();
        }
@@ -292,7 +292,7 @@ impl<D: DataProvider> ComputedFieldsEditor<D> {
        let current_field = self.editor.current_field();
        let result = self.editor.delete_forward();

-        if result.is_ok() && matches!(current_field, 1 | 2 | 3) {
+        if result.is_ok() && matches!(current_field, 1..=3) {
            self.editor.on_field_changed(&mut self.calculator, current_field);
            self.update_computed_fields();
        }
@@ -312,7 +312,7 @@ impl<D: DataProvider> ComputedFieldsEditor<D> {
            } else {
                "editable"
            };
-            self.debug_message = format!("→ {} - {} field", field_name, field_type);
+            self.debug_message = format!("→ {field_name} - {field_type} field");
        }
    }

@@ -328,7 +328,7 @@ impl<D: DataProvider> ComputedFieldsEditor<D> {
            } else {
                "editable"
            };
-            self.debug_message = format!("← {} - {} field", field_name, field_type);
+            self.debug_message = format!("← {field_name} - {field_type} field");
        }
    }

@@ -339,15 +339,14 @@ impl<D: DataProvider> ComputedFieldsEditor<D> {
        if self.editor.data_provider().is_computed_field(current) || self.is_computed_field(current) {
            let field_name = self.editor.data_provider().field_name(current);
            self.debug_message = format!(
-                "🚫 {} is computed (read-only) - Press Tab to move to editable fields",
-                field_name
+                "🚫 {field_name} is computed (read-only) - Press Tab to move to editable fields"
            );
            return;
        }
        
        self.editor.enter_edit_mode();
        let field_name = self.editor.data_provider().field_name(current);
-        self.debug_message = format!("✏️ Editing {} - Type to see calculations update", field_name);
+        self.debug_message = format!("✏️ Editing {field_name} - Type to see calculations update");
    }

    fn enter_append_mode(&mut self) {
@@ -356,22 +355,21 @@ impl<D: DataProvider> ComputedFieldsEditor<D> {
        if self.editor.data_provider().is_computed_field(current) || self.is_computed_field(current) {
            let field_name = self.editor.data_provider().field_name(current);
            self.debug_message = format!(
-                "🚫 {} is computed (read-only) - Press Tab to move to editable fields",
-                field_name
+                "🚫 {field_name} is computed (read-only) - Press Tab to move to editable fields"
            );
            return;
        }
        
        self.editor.enter_append_mode();
        let field_name = self.editor.data_provider().field_name(current);
-        self.debug_message = format!("✏️ Appending to {} - Type to see calculations", field_name);
+        self.debug_message = format!("✏️ Appending to {field_name} - Type to see calculations");
    }

    fn exit_edit_mode(&mut self) {
        let current_field = self.editor.current_field();
        self.editor.exit_edit_mode();

-        if matches!(current_field, 1 | 2 | 3) {
+        if matches!(current_field, 1..=3) {
            self.editor.on_field_changed(&mut self.calculator, current_field);
            self.update_computed_fields();
        }
@@ -503,7 +501,7 @@ fn run_app<B: Backend>(
                    }
                }
                Err(e) => {
-                    editor.debug_message = format!("Error: {}", e);
+                    editor.debug_message = format!("Error: {e}");
                }
            }
        }
@@ -615,7 +613,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    terminal.show_cursor()?;

    if let Err(err) = res {
-        println!("{:?}", err);
+        println!("{err:?}");
    }

    println!("💰 Demo completed! Computed fields should have updated in real-time!");
--- a/canvas/examples/full_canvas_demo.rs
+++ b/canvas/examples/full_canvas_demo.rs
@@ -1,724 +0,0 @@
-// examples/full_canvas_demo.rs
-//! Demonstrates the FULL potential of the canvas library using the native API
-
-use std::io;
-use crossterm::{
-    cursor::SetCursorStyle,
-    event::{
-        self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyModifiers,
-    },
-    execute,
-    terminal::{
-        disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen,
-    },
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
-    layout::{Constraint, Direction, Layout},
-    style::{Color, Style},
-    text::{Line, Span},
-    widgets::{Block, Borders, Paragraph},
-    Frame, Terminal,
-};
-
-use canvas::{
-    canvas::{
-        gui::render_canvas_default,
-        modes::{AppMode, ModeManager, HighlightState},
-    },
-    DataProvider, FormEditor,
-};
-
-/// Update cursor style based on current AppMode
-fn update_cursor_for_mode(mode: AppMode) -> io::Result<()> {
-    let style = match mode {
-        AppMode::Edit => SetCursorStyle::SteadyBar,           // Thin line for insert mode
-        AppMode::ReadOnly => SetCursorStyle::SteadyBlock,     // Block for normal mode  
-        AppMode::Highlight => SetCursorStyle::BlinkingBlock,  // Blinking block for visual mode
-        AppMode::General => SetCursorStyle::SteadyBlock,      // Block for general mode
-        AppMode::Command => SetCursorStyle::SteadyUnderScore, // Underscore for command mode
-    };
-    
-    execute!(io::stdout(), style)
-}
-
-// Enhanced FormEditor that adds visual mode and status tracking
-struct EnhancedFormEditor<D: DataProvider> {
-    editor: FormEditor<D>,
-    highlight_state: HighlightState,
-    has_unsaved_changes: bool,
-    debug_message: String,
-    command_buffer: String, // For multi-key vim commands like "gg"
-}
-
-impl<D: DataProvider> EnhancedFormEditor<D> {
-    fn new(data_provider: D) -> Self {
-        Self {
-            editor: FormEditor::new(data_provider),
-            highlight_state: HighlightState::Off,
-            has_unsaved_changes: false,
-            debug_message: "Full Canvas Demo - All features enabled".to_string(),
-            command_buffer: String::new(),
-        }
-    }
-
-    // === COMMAND BUFFER HANDLING ===
-
-    fn clear_command_buffer(&mut self) {
-        self.command_buffer.clear();
-    }
-
-    fn add_to_command_buffer(&mut self, ch: char) {
-        self.command_buffer.push(ch);
-    }
-
-    fn get_command_buffer(&self) -> &str {
-        &self.command_buffer
-    }
-
-    fn has_pending_command(&self) -> bool {
-        !self.command_buffer.is_empty()
-    }
-
-    // === VISUAL/HIGHLIGHT MODE SUPPORT ===
-
-    fn enter_visual_mode(&mut self) {
-        if ModeManager::can_enter_highlight_mode(self.editor.mode()) {
-            self.editor.set_mode(AppMode::Highlight);
-            self.highlight_state = HighlightState::Characterwise {
-                anchor: (
-                    self.editor.current_field(),
-                    self.editor.cursor_position(),
-                ),
-            };
-            self.debug_message = "-- VISUAL --".to_string();
-        }
-    }
-
-    fn enter_visual_line_mode(&mut self) {
-        if ModeManager::can_enter_highlight_mode(self.editor.mode()) {
-            self.editor.set_mode(AppMode::Highlight);
-            self.highlight_state =
-                HighlightState::Linewise { anchor_line: self.editor.current_field() };
-            self.debug_message = "-- VISUAL LINE --".to_string();
-        }
-    }
-
-    fn exit_visual_mode(&mut self) {
-        self.highlight_state = HighlightState::Off;
-        if self.editor.mode() == AppMode::Highlight {
-            self.editor.set_mode(AppMode::ReadOnly);
-            self.debug_message = "Visual mode exited".to_string();
-        }
-    }
-
-    fn update_visual_selection(&mut self) {
-        if self.editor.mode() == AppMode::Highlight {
-            match &self.highlight_state {
-                HighlightState::Characterwise { anchor: _ } => {
-                    self.debug_message = format!(
-                        "Visual selection: char {} in field {}",
-                        self.editor.cursor_position(),
-                        self.editor.current_field()
-                    );
-                }
-                HighlightState::Linewise { anchor_line: _ } => {
-                    self.debug_message = format!(
-                        "Visual line selection: field {}",
-                        self.editor.current_field()
-                    );
-                }
-                _ => {}
-            }
-        }
-    }
-
-    // === ENHANCED MOVEMENT WITH VISUAL UPDATES ===
-
-    fn move_left(&mut self) {
-        self.editor.move_left();
-        self.update_visual_selection();
-    }
-
-    fn move_right(&mut self) {
-        self.editor.move_right();
-        self.update_visual_selection();
-    }
-
-    fn move_up(&mut self) {
-        self.editor.move_up();
-        self.update_visual_selection();
-    }
-
-    fn move_down(&mut self) {
-        self.editor.move_down();
-        self.update_visual_selection();
-    }
-
-    fn move_word_next(&mut self) {
-        self.editor.move_word_next();
-        self.update_visual_selection();
-    }
-
-    fn move_word_prev(&mut self) {
-        self.editor.move_word_prev();
-        self.update_visual_selection();
-    }
-
-    fn move_word_end(&mut self) {
-        self.editor.move_word_end();
-        self.update_visual_selection();
-    }
-
-    fn move_word_end_prev(&mut self) {
-        self.editor.move_word_end_prev();
-        self.update_visual_selection();
-    }
-
-    fn move_line_start(&mut self) {
-        self.editor.move_line_start();
-        self.update_visual_selection();
-    }
-
-    fn move_line_end(&mut self) {
-        self.editor.move_line_end();
-        self.update_visual_selection();
-    }
-
-    fn move_first_line(&mut self) {
-        self.editor.move_first_line();
-        self.update_visual_selection();
-    }
-
-    fn move_last_line(&mut self) {
-        self.editor.move_last_line();
-        self.update_visual_selection();
-    }
-
-    fn prev_field(&mut self) {
-        self.editor.prev_field();
-        self.update_visual_selection();
-    }
-
-    fn next_field(&mut self) {
-        self.editor.next_field();
-        self.update_visual_selection();
-    }
-
-    // === DELETE OPERATIONS ===
-
-    fn delete_backward(&mut self) -> anyhow::Result<()> {
-        let result = self.editor.delete_backward();
-        if result.is_ok() {
-            self.has_unsaved_changes = true;
-            self.debug_message = "Deleted character backward".to_string();
-        }
-        Ok(result?)
-    }
-
-    fn delete_forward(&mut self) -> anyhow::Result<()> {
-        let result = self.editor.delete_forward();
-        if result.is_ok() {
-            self.has_unsaved_changes = true;
-            self.debug_message = "Deleted character forward".to_string();
-        }
-        Ok(result?)
-    }
-
-    // === MODE TRANSITIONS ===
-
-    fn enter_edit_mode(&mut self) {
-        self.editor.enter_edit_mode();
-        self.debug_message = "-- INSERT --".to_string();
-    }
-
-    fn exit_edit_mode(&mut self) {
-        self.editor.exit_edit_mode();
-        self.exit_visual_mode();
-        self.debug_message = "".to_string();
-    }
-
-    fn insert_char(&mut self, ch: char) -> anyhow::Result<()> {
-        let result = self.editor.insert_char(ch);
-        if result.is_ok() {
-            self.has_unsaved_changes = true;
-        }
-        Ok(result?)
-    }
-
-    // === DELEGATE TO ORIGINAL EDITOR ===
-
-    fn current_field(&self) -> usize {
-        self.editor.current_field()
-    }
-
-    fn cursor_position(&self) -> usize {
-        self.editor.cursor_position()
-    }
-
-    fn mode(&self) -> AppMode {
-        self.editor.mode()
-    }
-
-    fn current_text(&self) -> &str {
-        self.editor.current_text()
-    }
-
-    fn data_provider(&self) -> &D {
-        self.editor.data_provider()
-    }
-
-    fn ui_state(&self) -> &canvas::EditorState {
-        self.editor.ui_state()
-    }
-
-    fn set_mode(&mut self, mode: AppMode) {
-        self.editor.set_mode(mode);
-        if mode != AppMode::Highlight {
-            self.exit_visual_mode();
-        }
-    }
-
-    // === STATUS AND DEBUG ===
-
-    fn set_debug_message(&mut self, msg: String) {
-        self.debug_message = msg;
-    }
-
-    fn debug_message(&self) -> &str {
-        &self.debug_message
-    }
-
-    fn highlight_state(&self) -> &HighlightState {
-        &self.highlight_state
-    }
-
-    fn has_unsaved_changes(&self) -> bool {
-        self.has_unsaved_changes
-    }
-}
-
-// Demo form data with interesting text for word movement
-struct FullDemoData {
-    fields: Vec<(String, String)>,
-}
-
-impl FullDemoData {
-    fn new() -> Self {
-        Self {
-            fields: vec![
-                ("Name".to_string(), "John-Paul McDonald".to_string()),
-                (
-                    "Email".to_string(),
-                    "user@example-domain.com".to_string(),
-                ),
-                ("Phone".to_string(), "+1 (555) 123-4567".to_string()),
-                ("Address".to_string(), "123 Main St, Apt 4B".to_string()),
-                (
-                    "Tags".to_string(),
-                    "urgent,important,follow-up".to_string(),
-                ),
-                (
-                    "Notes".to_string(),
-                    "This is a sample note with multiple words, punctuation! And symbols @#$"
-                        .to_string(),
-                ),
-            ],
-        }
-    }
-}
-
-impl DataProvider for FullDemoData {
-    fn field_count(&self) -> usize {
-        self.fields.len()
-    }
-
-    fn field_name(&self, index: usize) -> &str {
-        &self.fields[index].0
-    }
-
-    fn field_value(&self, index: usize) -> &str {
-        &self.fields[index].1
-    }
-
-    fn set_field_value(&mut self, index: usize, value: String) {
-        self.fields[index].1 = value;
-    }
-
-    fn supports_suggestions(&self, _field_index: usize) -> bool {
-        false
-    }
-
-    fn display_value(&self, _index: usize) -> Option<&str> {
-        None
-    }
-}
-
-/// Full vim-like key handling using the native FormEditor API
-fn handle_key_press(
-    key: KeyCode,
-    modifiers: KeyModifiers,
-    editor: &mut EnhancedFormEditor<FullDemoData>,
-) -> anyhow::Result<bool> {
-    let old_mode = editor.mode(); // Store mode before processing
-
-    // Quit handling
-    if (key == KeyCode::Char('q') && modifiers.contains(KeyModifiers::CONTROL))
-        || (key == KeyCode::Char('c') && modifiers.contains(KeyModifiers::CONTROL))
-        || key == KeyCode::F(10)
-    {
-        return Ok(false);
-    }
-
-    match (old_mode, key, modifiers) {
-        // === MODE TRANSITIONS ===
-        (AppMode::ReadOnly, KeyCode::Char('i'), _) => {
-            editor.enter_edit_mode();
-            editor.clear_command_buffer();
-        }
-        (AppMode::ReadOnly, KeyCode::Char('a'), _) => {
-            editor.move_right(); // Move after current character
-            editor.enter_edit_mode();
-            editor.set_debug_message("-- INSERT -- (append)".to_string());
-            editor.clear_command_buffer();
-        }
-        (AppMode::ReadOnly, KeyCode::Char('A'), _) => {
-            editor.move_line_end();
-            editor.enter_edit_mode();
-            editor.set_debug_message("-- INSERT -- (end of line)".to_string());
-            editor.clear_command_buffer();
-        }
-        (AppMode::ReadOnly, KeyCode::Char('o'), _) => {
-            editor.move_line_end();
-            editor.enter_edit_mode();
-            editor.set_debug_message("-- INSERT -- (open line)".to_string());
-            editor.clear_command_buffer();
-        }
-        (AppMode::ReadOnly, KeyCode::Char('v'), _) => {
-            editor.enter_visual_mode();
-            editor.clear_command_buffer();
-        }
-        (AppMode::ReadOnly, KeyCode::Char('V'), _) => {
-            editor.enter_visual_line_mode();
-            editor.clear_command_buffer();
-        }
-        (_, KeyCode::Esc, _) => {
-            editor.exit_edit_mode();
-            editor.clear_command_buffer();
-        }
-
-        // === MOVEMENT: VIM-STYLE NAVIGATION ===
-
-        // Basic movement (hjkl and arrows)
-        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('h'), _)
-        | (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Left, _) => {
-            editor.move_left();
-            editor.set_debug_message("← left".to_string());
-            editor.clear_command_buffer();
-        }
-        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('l'), _)
-        | (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Right, _) => {
-            editor.move_right();
-            editor.set_debug_message("→ right".to_string());
-            editor.clear_command_buffer();
-        }
-        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('j'), _)
-        | (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Down, _) => {
-            editor.move_down();
-            editor.set_debug_message("↓ next field".to_string());
-            editor.clear_command_buffer();
-        }
-        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('k'), _)
-        | (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Up, _) => {
-            editor.move_up();
-            editor.set_debug_message("↑ previous field".to_string());
-            editor.clear_command_buffer();
-        }
-
-        // Word movement - Full vim word navigation
-        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('w'), _) => {
-            editor.move_word_next();
-            editor.set_debug_message("w: next word start".to_string());
-            editor.clear_command_buffer();
-        }
-        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('b'), _) => {
-            editor.move_word_prev();
-            editor.set_debug_message("b: previous word start".to_string());
-            editor.clear_command_buffer();
-        }
-        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('e'), _) => {
-            editor.move_word_end();
-            editor.set_debug_message("e: word end".to_string());
-            editor.clear_command_buffer();
-        }
-        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('W'), _) => {
-            editor.move_word_end_prev();
-            editor.set_debug_message("W: previous word end".to_string());
-            editor.clear_command_buffer();
-        }
-
-        // Line movement
-        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('0'), _)
-        | (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Home, _) => {
-            editor.move_line_start();
-            editor.set_debug_message("0: line start".to_string());
-        }
-        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('$'), _)
-        | (AppMode::ReadOnly | AppMode::Highlight, KeyCode::End, _) => {
-            editor.move_line_end();
-            editor.set_debug_message("$: line end".to_string());
-        }
-
-        // Field/document movement
-        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('g'), _) => {
-            if editor.get_command_buffer() == "g" {
-                // Second 'g' - execute "gg" command
-                editor.move_first_line();
-                editor.set_debug_message("gg: first field".to_string());
-                editor.clear_command_buffer();
-            } else {
-                // First 'g' - start command buffer
-                editor.clear_command_buffer();
-                editor.add_to_command_buffer('g');
-                editor.set_debug_message("g".to_string());
-            }
-        }
-        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('G'), _) => {
-            editor.move_last_line();
-            editor.set_debug_message("G: last field".to_string());
-            editor.clear_command_buffer();
-        }
-
-        // === EDIT MODE MOVEMENT ===
-        (AppMode::Edit, KeyCode::Left, m) if m.contains(KeyModifiers::CONTROL) => {
-            editor.move_word_prev();
-            editor.set_debug_message("Ctrl+← word back".to_string());
-        }
-        (AppMode::Edit, KeyCode::Right, m) if m.contains(KeyModifiers::CONTROL) => {
-            editor.move_word_next();
-            editor.set_debug_message("Ctrl+→ word forward".to_string());
-        }
-        (AppMode::Edit, KeyCode::Left, _) => {
-            editor.move_left();
-        }
-        (AppMode::Edit, KeyCode::Right, _) => {
-            editor.move_right();
-        }
-        (AppMode::Edit, KeyCode::Up, _) => {
-            editor.move_up();
-        }
-        (AppMode::Edit, KeyCode::Down, _) => {
-            editor.move_down();
-        }
-        (AppMode::Edit, KeyCode::Home, _) => {
-            editor.move_line_start();
-        }
-        (AppMode::Edit, KeyCode::End, _) => {
-            editor.move_line_end();
-        }
-
-        // === DELETE OPERATIONS ===
-        (AppMode::Edit, KeyCode::Backspace, _) => {
-            editor.delete_backward()?;
-        }
-        (AppMode::Edit, KeyCode::Delete, _) => {
-            editor.delete_forward()?;
-        }
-
-        // Delete operations in normal mode (vim x)
-        (AppMode::ReadOnly, KeyCode::Char('x'), _) => {
-            editor.delete_forward()?;
-            editor.set_debug_message("x: deleted character".to_string());
-        }
-        (AppMode::ReadOnly, KeyCode::Char('X'), _) => {
-            editor.delete_backward()?;
-            editor.set_debug_message("X: deleted character backward".to_string());
-        }
-
-        // === TAB NAVIGATION ===
-        (_, KeyCode::Tab, _) => {
-            editor.next_field();
-            editor.set_debug_message("Tab: next field".to_string());
-        }
-        (_, KeyCode::BackTab, _) => {
-            editor.prev_field();
-            editor.set_debug_message("Shift+Tab: previous field".to_string());
-        }
-
-        // === CHARACTER INPUT ===
-        (AppMode::Edit, KeyCode::Char(c), m) if !m.contains(KeyModifiers::CONTROL) => {
-            editor.insert_char(c)?;
-        }
-
-        // === DEBUG/INFO COMMANDS ===
-        (AppMode::ReadOnly, KeyCode::Char('?'), _) => {
-            editor.set_debug_message(format!(
-                "Field {}/{}, Pos {}, Mode: {:?}",
-                editor.current_field() + 1,
-                editor.data_provider().field_count(),
-                editor.cursor_position(),
-                editor.mode()
-            ));
-        }
-
-        _ => {
-            // If we have a pending command and this key doesn't complete it, clear the buffer
-            if editor.has_pending_command() {
-                editor.clear_command_buffer();
-                editor.set_debug_message("Invalid command sequence".to_string());
-            } else {
-                editor.set_debug_message(format!(
-                    "Unhandled: {:?} + {:?} in {:?} mode",
-                    key, modifiers, old_mode
-                ));
-            }
-        }
-    }
-
-    // Update cursor if mode changed
-    let new_mode = editor.mode();
-    if old_mode != new_mode {
-        update_cursor_for_mode(new_mode)?;
-    }
-
-    Ok(true)
-}
-
-fn run_app<B: Backend>(
-    terminal: &mut Terminal<B>,
-    mut editor: EnhancedFormEditor<FullDemoData>,
-) -> io::Result<()> {
-    loop {
-        terminal.draw(|f| ui(f, &editor))?;
-
-        if let Event::Key(key) = event::read()? {
-            match handle_key_press(key.code, key.modifiers, &mut editor) {
-                Ok(should_continue) => {
-                    if !should_continue {
-                        break;
-                    }
-                }
-                Err(e) => {
-                    editor.set_debug_message(format!("Error: {}", e));
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
-
-fn ui(f: &mut Frame, editor: &EnhancedFormEditor<FullDemoData>) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Min(8), Constraint::Length(8)])
-        .split(f.area());
-
-    render_enhanced_canvas(f, chunks[0], editor);
-    render_status_and_help(f, chunks[1], editor);
-}
-
-fn render_enhanced_canvas(
-    f: &mut Frame,
-    area: ratatui::layout::Rect,
-    editor: &EnhancedFormEditor<FullDemoData>,
-) {
-    render_canvas_default(f, area, &editor.editor);
-}
-
-fn render_status_and_help(
-    f: &mut Frame,
-    area: ratatui::layout::Rect,
-    editor: &EnhancedFormEditor<FullDemoData>,
-) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Length(3), Constraint::Length(5)])
-        .split(area);
-
-    // Status bar
-    let mode_text = match editor.mode() {
-        AppMode::Edit => "INSERT",
-        AppMode::ReadOnly => "NORMAL",
-        AppMode::Highlight => match editor.highlight_state() {
-            HighlightState::Characterwise { .. } => "VISUAL",
-            HighlightState::Linewise { .. } => "VISUAL LINE",
-            _ => "VISUAL",
-        },
-        _ => "NORMAL",
-    };
-
-    let status_text = if editor.has_pending_command() {
-        format!("-- {} -- {} [{}]", mode_text, editor.debug_message(), editor.get_command_buffer())
-    } else if editor.has_unsaved_changes() {
-        format!("-- {} -- [Modified] {}", mode_text, editor.debug_message())
-    } else {
-        format!("-- {} -- {}", mode_text, editor.debug_message())
-    };
-
-    let status = Paragraph::new(Line::from(Span::raw(status_text)))
-        .block(Block::default().borders(Borders::ALL).title("Status"));
-
-    f.render_widget(status, chunks[0]);
-
-    // Help text
-    let help_text = match editor.mode() {
-        AppMode::ReadOnly => {
-            if editor.has_pending_command() {
-                match editor.get_command_buffer() {
-                    "g" => "Press 'g' again for first field, or any other key to cancel",
-                    _ => "Pending command... (Esc to cancel)"
-                }
-            } else {
-                "Normal: hjkl/arrows=move, w/b/e=words, 0/$=line, gg/G=first/last, i/a/A=insert, v/V=visual, x/X=delete, ?=info"
-            }
-        }
-        AppMode::Edit => {
-            "Insert: arrows=move, Ctrl+arrows=words, Backspace/Del=delete, Esc=normal, Tab/Shift+Tab=fields"
-        }
-        AppMode::Highlight => {
-            "Visual: hjkl/arrows=extend selection, w/b/e=word selection, Esc=normal"
-        }
-        _ => "Press ? for help"
-    };
-
-    let help = Paragraph::new(Line::from(Span::raw(help_text)))
-        .block(Block::default().borders(Borders::ALL).title("Commands"))
-        .style(Style::default().fg(Color::Gray));
-
-    f.render_widget(help, chunks[1]);
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    enable_raw_mode()?;
-    let mut stdout = io::stdout();
-    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
-    let backend = CrosstermBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-
-    let data = FullDemoData::new();
-    let mut editor = EnhancedFormEditor::new(data);
-    editor.set_mode(AppMode::ReadOnly); // Start in normal mode
-    
-    // Set initial cursor style
-    update_cursor_for_mode(editor.mode())?;
-
-    let res = run_app(&mut terminal, editor);
-
-    // Reset cursor style on exit
-    execute!(io::stdout(), SetCursorStyle::DefaultUserShape)?;
-
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
-
-    if let Err(err) = res {
-        println!("{:?}", err);
-    }
-
-    Ok(())
-}
--- a/canvas/examples/suggestions.rs
+++ b/canvas/examples/suggestions.rs
@@ -218,7 +218,7 @@ impl<D: DataProvider> AutoCursorFormEditor<D> {
            self.has_unsaved_changes = true;
            self.debug_message = "⌫ Deleted character backward".to_string();
        }
-        Ok(result?)
+        result
    }

    fn delete_forward(&mut self) -> anyhow::Result<()> {
@@ -227,7 +227,7 @@ impl<D: DataProvider> AutoCursorFormEditor<D> {
            self.has_unsaved_changes = true;
            self.debug_message = "⌦ Deleted character forward".to_string();
        }
-        Ok(result?)
+        result
    }

    // === SUGGESTIONS CONTROL WRAPPERS ===
@@ -259,7 +259,7 @@ impl<D: DataProvider> AutoCursorFormEditor<D> {
        if result.is_ok() {
            self.has_unsaved_changes = true;
        }
-        Ok(result?)
+        result
    }

    // === MANUAL CURSOR OVERRIDE DEMONSTRATION ===
@@ -562,7 +562,7 @@ impl ProductionSuggestionsProvider {
                query.is_empty() || item.to_lowercase().starts_with(&query_lower)
            })
            .map(|(item, description)| SuggestionItem {
-                display_text: format!("{} - {}", item, description),
+                display_text: format!("{item} - {description}"),
                value_to_store: item.to_string(),
            })
            .collect()
@@ -625,7 +625,7 @@ async fn handle_key_press(
                            }
                        }
                        Err(e) => {
-                            editor.set_debug_message(format!("❌ Suggestion error: {}", e));
+                            editor.set_debug_message(format!("❌ Suggestion error: {e}"));
                        }
                    }
                }
@@ -639,7 +639,7 @@ async fn handle_key_press(
        (_, KeyCode::Enter, _) => {
            if editor.is_suggestions_active() {
                if let Some(applied) = editor.apply_suggestion() {
-                    editor.set_debug_message(format!("✅ Selected: {}", applied));
+                    editor.set_debug_message(format!("✅ Selected: {applied}"));
                } else {
                    editor.set_debug_message("❌ No suggestion selected".to_string());
                }
@@ -647,7 +647,7 @@ async fn handle_key_press(
                editor.next_field();
                let field_names = ["Fruit", "Job", "Language", "Country", "Color"];
                let field_name = field_names.get(editor.current_field()).unwrap_or(&"Field");
-                editor.set_debug_message(format!("Enter: moved to {} field", field_name));
+                editor.set_debug_message(format!("Enter: moved to {field_name} field"));
            }
        }

@@ -726,7 +726,7 @@ async fn handle_key_press(
            editor.move_down();
            let field_names = ["Fruit", "Job", "Language", "Country", "Color"];
            let field_name = field_names.get(editor.current_field()).unwrap_or(&"Field");
-            editor.set_debug_message(format!("↓ moved to {} field", field_name));
+            editor.set_debug_message(format!("↓ moved to {field_name} field"));
            editor.clear_command_buffer();
        }
        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('k'), _)
@@ -734,7 +734,7 @@ async fn handle_key_press(
            editor.move_up();
            let field_names = ["Fruit", "Job", "Language", "Country", "Color"];
            let field_name = field_names.get(editor.current_field()).unwrap_or(&"Field");
-            editor.set_debug_message(format!("↑ moved to {} field", field_name));
+            editor.set_debug_message(format!("↑ moved to {field_name} field"));
            editor.clear_command_buffer();
        }

@@ -829,7 +829,7 @@ async fn handle_key_press(
                            }
                        }
                        Err(e) => {
-                            editor.set_debug_message(format!("❌ Suggestion error: {}", e));
+                            editor.set_debug_message(format!("❌ Suggestion error: {e}"));
                        }
                    }
                }
@@ -850,7 +850,7 @@ async fn handle_key_press(
                            }
                        }
                        Err(e) => {
-                            editor.set_debug_message(format!("❌ Suggestion error: {}", e));
+                            editor.set_debug_message(format!("❌ Suggestion error: {e}"));
                        }
                    }
                }
@@ -883,7 +883,7 @@ async fn handle_key_press(
                            }
                        }
                        Err(e) => {
-                            editor.set_debug_message(format!("❌ Suggestion error: {}", e));
+                            editor.set_debug_message(format!("❌ Suggestion error: {e}"));
                        }
                    }
                }
@@ -912,8 +912,7 @@ async fn handle_key_press(
                let field_names = ["Fruit", "Job", "Language", "Country", "Color"];
                let current_field = field_names.get(editor.current_field()).unwrap_or(&"Field");
                editor.set_debug_message(format!(
-                    "{} field - Try: i=insert, Tab=suggestions, j/k=move. Key: {:?}",
-                    current_field, key
+                    "{current_field} field - Try: i=insert, Tab=suggestions, j/k=move. Key: {key:?}"
                ));
            }
        }
@@ -939,7 +938,7 @@ async fn run_app<B: Backend>(
                    }
                }
                Err(e) => {
-                    editor.set_debug_message(format!("Error: {}", e));
+                    editor.set_debug_message(format!("Error: {e}"));
                }
            }
        }
@@ -962,7 +961,7 @@ fn ui(f: &mut Frame, editor: &AutoCursorFormEditor<ApplicationData>) {
            f,
            chunks[0],
            input_rect,
-            &canvas::canvas::theme::DefaultCanvasTheme::default(),
+            &canvas::canvas::theme::DefaultCanvasTheme,
            editor.inner(),
        );
    }
@@ -1110,7 +1109,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
    terminal.show_cursor()?;

    if let Err(err) = res {
-        println!("{:?}", err);
+        println!("{err:?}");
    }

    println!("🚀 Ready to integrate this architecture into your production app!");
--- a/canvas/examples/suggestions2.rs
+++ b/canvas/examples/suggestions2.rs
@@ -210,7 +210,7 @@ impl<D: DataProvider> AutoCursorFormEditor<D> {
            self.has_unsaved_changes = true;
            self.debug_message = "⌫ Deleted character backward".to_string();
        }
-        Ok(result?)
+        result
    }

    fn delete_forward(&mut self) -> anyhow::Result<()> {
@@ -219,7 +219,7 @@ impl<D: DataProvider> AutoCursorFormEditor<D> {
            self.has_unsaved_changes = true;
            self.debug_message = "⌦ Deleted character forward".to_string();
        }
-        Ok(result?)
+        result
    }

    // === SUGGESTIONS CONTROL WRAPPERS ===
@@ -251,7 +251,7 @@ impl<D: DataProvider> AutoCursorFormEditor<D> {
        if result.is_ok() {
            self.has_unsaved_changes = true;
        }
-        Ok(result?)
+        result
    }

    // === PRODUCTION-READY NON-BLOCKING SUGGESTIONS ===
@@ -275,7 +275,7 @@ impl<D: DataProvider> AutoCursorFormEditor<D> {
                    if applied {
                        self.editor.update_inline_completion();
                        if self.editor.suggestions().is_empty() {
-                            self.set_debug_message(format!("🔍 No matches for '{}'", query));
+                            self.set_debug_message(format!("🔍 No matches for '{query}'"));
                        } else {
                            self.set_debug_message(format!("✨ {} matches for '{}'", self.editor.suggestions().len(), query));
                        }
@@ -283,7 +283,7 @@ impl<D: DataProvider> AutoCursorFormEditor<D> {
                    // If not applied, results were stale (user kept typing)
                }
                Err(e) => {
-                    self.set_debug_message(format!("❌ Suggestion error: {}", e));
+                    self.set_debug_message(format!("❌ Suggestion error: {e}"));
                }
            }
        }
@@ -574,7 +574,7 @@ impl ProductionSuggestionsProvider {
                query.is_empty() || item.to_lowercase().starts_with(&query_lower)
            })
            .map(|(item, description)| SuggestionItem {
-                display_text: format!("{} - {}", item, description),
+                display_text: format!("{item} - {description}"),
                value_to_store: item.to_string(),
            })
            .collect()
@@ -634,7 +634,7 @@ async fn handle_key_press(
        (_, KeyCode::Enter, _) => {
            if editor.is_suggestions_active() {
                if let Some(applied) = editor.apply_suggestion() {
-                    editor.set_debug_message(format!("✅ Selected: {}", applied));
+                    editor.set_debug_message(format!("✅ Selected: {applied}"));
                } else {
                    editor.set_debug_message("❌ No suggestion selected".to_string());
                }
@@ -642,7 +642,7 @@ async fn handle_key_press(
                editor.next_field();
                let field_names = ["Fruit", "Job", "Language", "Country", "Color"];
                let field_name = field_names.get(editor.current_field()).unwrap_or(&"Field");
-                editor.set_debug_message(format!("Enter: moved to {} field", field_name));
+                editor.set_debug_message(format!("Enter: moved to {field_name} field"));
            }
        }

@@ -722,7 +722,7 @@ async fn handle_key_press(
            editor.move_down();
            let field_names = ["Fruit", "Job", "Language", "Country", "Color"];
            let field_name = field_names.get(editor.current_field()).unwrap_or(&"Field");
-            editor.set_debug_message(format!("↓ moved to {} field", field_name));
+            editor.set_debug_message(format!("↓ moved to {field_name} field"));
            editor.clear_command_buffer();
        }
        (AppMode::ReadOnly | AppMode::Highlight, KeyCode::Char('k'), _)
@@ -730,7 +730,7 @@ async fn handle_key_press(
            editor.move_up();
            let field_names = ["Fruit", "Job", "Language", "Country", "Color"];
            let field_name = field_names.get(editor.current_field()).unwrap_or(&"Field");
-            editor.set_debug_message(format!("↑ moved to {} field", field_name));
+            editor.set_debug_message(format!("↑ moved to {field_name} field"));
            editor.clear_command_buffer();
        }

@@ -872,8 +872,7 @@ async fn handle_key_press(
                let field_names = ["Fruit", "Job", "Language", "Country", "Color"];
                let current_field = field_names.get(editor.current_field()).unwrap_or(&"Field");
                editor.set_debug_message(format!(
-                    "{} field - Try: i=insert, Tab=suggestions, j/k=move. Key: {:?}",
-                    current_field, key
+                    "{current_field} field - Try: i=insert, Tab=suggestions, j/k=move. Key: {key:?}"
                ));
            }
        }
@@ -899,7 +898,7 @@ async fn run_app<B: Backend>(
                    }
                }
                Err(e) => {
-                    editor.set_debug_message(format!("Error: {}", e));
+                    editor.set_debug_message(format!("Error: {e}"));
                }
            }
        }
@@ -922,7 +921,7 @@ fn ui(f: &mut Frame, editor: &AutoCursorFormEditor<ApplicationData>) {
            f,
            chunks[0],
            input_rect,
-            &canvas::canvas::theme::DefaultCanvasTheme::default(),
+            &canvas::canvas::theme::DefaultCanvasTheme,
            &editor.editor,
        );
    }
@@ -1071,7 +1070,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
    terminal.show_cursor()?;

    if let Err(err) = res {
-        println!("{:?}", err);
+        println!("{err:?}");
    }

    println!("🚀 Ready to integrate this architecture into your production app!");
--- a/canvas/examples/textarea_normal.rs
+++ b/canvas/examples/textarea_normal.rs
@@ -35,7 +35,7 @@ use ratatui::{
 };

 use canvas::{
-    canvas::{modes::AppMode, CursorManager},
+    canvas::CursorManager,
    textarea::{TextArea, TextAreaState},
 };

@@ -291,7 +291,7 @@ fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut editor: AutoCursorTextAre
                    }
                }
                Err(e) => {
-                    editor.set_debug_message(format!("Error: {}", e));
+                    editor.set_debug_message(format!("Error: {e}"));
                }
            }
        }
@@ -389,7 +389,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    terminal.show_cursor()?;

    if let Err(err) = res {
-        println!("{:?}", err);
+        println!("{err:?}");
    }

    println!("🎯 Cursor automatically reset to default!");
--- a/canvas/examples/textarea_syntax.rs
+++ b/canvas/examples/textarea_syntax.rs
@@ -0,0 +1,413 @@
+// examples/textarea_syntax.rs
+//! Demonstrates syntax highlighting with the textarea widget
+//!
+//! This example REQUIRES the `syntect` feature to compile.
+//!
+//! Run with:
+//! cargo run --example textarea_syntax --features "gui,cursor-style,textarea,syntect,textmode-normal"
+
+#[cfg(not(feature = "syntect"))]
+compile_error!(
+    "This example requires the 'syntect' feature. \
+     Run with: cargo run --example textarea_syntax --features \"gui,cursor-style,textarea,syntect,textmode-normal\""
+);
+
+use std::io;
+use crossterm::{
+    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEvent, KeyModifiers},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+};
+use ratatui::{
+    backend::{Backend, CrosstermBackend},
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Style},
+    text::{Line, Span},
+    widgets::{Block, Borders, Paragraph},
+    Frame, Terminal,
+};
+
+use canvas::{
+    canvas::CursorManager,
+    textarea::highlight::{TextAreaSyntax, TextAreaSyntaxState},
+};
+
+/// Syntax highlighting TextArea demo
+struct SyntaxTextAreaDemo {
+    textarea: TextAreaSyntaxState,
+    has_unsaved_changes: bool,
+    debug_message: String,
+    current_language: String,
+    current_theme: String,
+}
+
+impl SyntaxTextAreaDemo {
+    fn new() -> Self {
+        let initial_text = r#"// 🎯 Multi-language Syntax Highlighting Demo
+// ==========================
+// Rust
+// ==========================
+fn main() {
+    println!("Hello, Rust 🦀");
+    let nums = vec![1, 2, 3, 4, 5];
+    for n in nums {
+        println!("n = {}", n);
+    }
+}
+
+// ==========================
+// Python
+// ==========================
+# 🐍 Python example
+def fib(n):
+    if n <= 1:
+        return n
+    return fib(n-1) + fib(n-2)
+
+print([fib(i) for i in range(6)])
+
+# ==========================
+// JavaScript
+// ==========================
+ // 🟨 JavaScript example
+function greet(name) {
+    console.log(`Hello, ${name}!`);
+}
+greet("World");
+
+// ==========================
+// Scheme
+// ==========================
+;; 🎭 Scheme example
+(define (square x) (* x x))
+(display (square 5))
+(newline)
+"#;
+
+        let mut textarea = TextAreaSyntaxState::from_text(initial_text);
+        textarea.set_placeholder("Start typing code...");
+
+        // Pick a colorful default theme
+        let default_theme = "base16-ocean.dark";
+        let _ = textarea.set_syntax_theme(default_theme);
+        // Default to Rust syntax
+        let _ = textarea.set_syntax_by_extension("rs");
+
+        Self {
+            textarea,
+            has_unsaved_changes: false,
+            debug_message: format!("🎯 Syntax highlighting enabled - Rust ({})", default_theme),
+            current_language: "Rust".to_string(),
+            current_theme: default_theme.to_string(),
+        }
+    }
+
+    fn handle_textarea_input(&mut self, key: KeyEvent) {
+        self.textarea.input(key);
+        self.has_unsaved_changes = true;
+    }
+
+    fn switch_to_rust(&mut self) {
+        let _ = self.textarea.set_syntax_by_extension("rs");
+        self.current_language = "Rust".to_string();
+        self.debug_message = format!("🦀 Switched to Rust syntax ({})", self.current_theme);
+        
+        let rust_code = r#"// Rust example
+fn fibonacci(n: u32) -> u32 {
+    match n {
+        0 => 0,
+        1 => 1,
+        _ => fibonacci(n - 1) + fibonacci(n - 2),
+    }
+}
+
+fn main() {
+    for i in 0..10 {
+        println!("fib({}) = {}", i, fibonacci(i));
+    }
+}"#;
+        self.textarea.set_text(rust_code);
+        self.has_unsaved_changes = false;
+    }
+
+    fn switch_to_python(&mut self) {
+        let _ = self.textarea.set_syntax_by_extension("py");
+        self.current_language = "Python".to_string();
+        self.debug_message = format!("🐍 Switched to Python syntax ({})", self.current_theme);
+        
+        let python_code = r#"# Python example
+def fibonacci(n):
+    if n <= 1:
+        return n
+    return fibonacci(n - 1) + fibonacci(n - 2)
+
+def main():
+    for i in range(10):
+        print(f"fib({i}) = {fibonacci(i)}")
+
+if __name__ == "__main__":
+    main()"#;
+        self.textarea.set_text(python_code);
+        self.has_unsaved_changes = false;
+    }
+
+    fn switch_to_javascript(&mut self) {
+        let _ = self.textarea.set_syntax_by_extension("js");
+        self.current_language = "JavaScript".to_string();
+        self.debug_message = format!("🟨 Switched to JavaScript syntax ({})", self.current_theme);
+        
+        let js_code = r#"// JavaScript example
+function fibonacci(n) {
+    if (n <= 1) return n;
+    return fibonacci(n - 1) + fibonacci(n - 2);
+}
+
+function main() {
+    for (let i = 0; i < 10; i++) {
+        console.log(`fib(${i}) = ${fibonacci(i)}`);
+    }
+}
+
+main();"#;
+        self.textarea.set_text(js_code);
+        self.has_unsaved_changes = false;
+    }
+
+    fn switch_to_scheme(&mut self) {
+        let _ = self.textarea.set_syntax_by_name("Scheme");
+        self.current_language = "Scheme".to_string();
+        self.debug_message = format!("🎭 Switched to Scheme syntax ({})", self.current_theme);
+        
+        let scheme_code = r#";; Scheme example
+(define (fibonacci n)
+  (cond ((= n 0) 0)
+        ((= n 1) 1)
+        (else (+ (fibonacci (- n 1))
+                 (fibonacci (- n 2))))))
+
+(define (main)
+  (do ((i 0 (+ i 1)))
+      ((= i 10))
+    (display (format "fib(~a) = ~a~n" i (fibonacci i)))))
+
+(main)"#;
+        self.textarea.set_text(scheme_code);
+        self.has_unsaved_changes = false;
+    }
+
+    fn cycle_theme(&mut self) {
+        let themes = [
+            "InspiredGitHub",
+            "base16-ocean.dark",
+            "base16-eighties.dark",
+            "Solarized (dark)",
+            "Monokai Extended",
+        ];
+        let current_pos = themes.iter().position(|t| *t == self.current_theme);
+        let next_pos = match current_pos {
+            Some(p) => (p + 1) % themes.len(),
+            None => 0,
+        };
+        let next_theme = themes[next_pos];
+        let _ = self.textarea.set_syntax_theme(next_theme);
+        self.current_theme = next_theme.to_string();
+        self.debug_message = format!("🎨 Theme switched to {}", next_theme);
+    }
+
+    fn get_cursor_info(&self) -> String {
+        format!(
+            "Line {}, Col {} | Lang: {} | Theme: {}",
+            self.textarea.current_field() + 1,
+            self.textarea.cursor_position() + 1,
+            self.current_language,
+            self.current_theme
+        )
+    }
+
+    fn debug_message(&self) -> &str {
+        &self.debug_message
+    }
+
+    fn set_debug_message(&mut self, msg: String) {
+        self.debug_message = msg;
+    }
+
+    fn has_unsaved_changes(&self) -> bool {
+        self.has_unsaved_changes
+    }
+}
+
+fn handle_key_press(
+    key_event: KeyEvent,
+    editor: &mut SyntaxTextAreaDemo,
+) -> anyhow::Result<bool> {
+    let KeyEvent {
+        code: key,
+        modifiers,
+        ..
+    } = key_event;
+
+    // Quit
+    if (key == KeyCode::Char('q') && modifiers.contains(KeyModifiers::CONTROL))
+        || (key == KeyCode::Char('c') && modifiers.contains(KeyModifiers::CONTROL))
+        || key == KeyCode::F(10)
+    {
+        return Ok(false);
+    }
+
+    match (key, modifiers) {
+        // Language switching
+        (KeyCode::F(5), _) => editor.switch_to_rust(),
+        (KeyCode::F(6), _) => editor.switch_to_python(),
+        (KeyCode::F(7), _) => editor.switch_to_javascript(),
+        (KeyCode::F(8), _) => editor.switch_to_scheme(),
+
+        // Theme cycling
+        (KeyCode::F(9), _) => editor.cycle_theme(),
+
+        // Overflow modes
+        (KeyCode::F(1), _) => {
+            editor.textarea.use_overflow_indicator('$');
+            editor.set_debug_message(format!("Overflow: indicator '$' (wrap OFF) | Theme: {}", editor.current_theme));
+        }
+        (KeyCode::F(2), _) => {
+            editor.textarea.use_wrap();
+            editor.set_debug_message(format!("Overflow: wrap ON | Theme: {}", editor.current_theme));
+        }
+
+        // Wrap indent
+        (KeyCode::F(3), _) => {
+            editor.textarea.set_wrap_indent_cols(4);
+            editor.set_debug_message(format!("Wrap indent: 4 columns | Theme: {}", editor.current_theme));
+        }
+        (KeyCode::F(4), _) => {
+            editor.textarea.set_wrap_indent_cols(0);
+            editor.set_debug_message(format!("Wrap indent: 0 columns | Theme: {}", editor.current_theme));
+        }
+
+        // Info
+        (KeyCode::Char('?'), _) => {
+            editor.set_debug_message(format!(
+                "{} | Syntax highlighting enabled",
+                editor.get_cursor_info()
+            ));
+        }
+
+        // Default: pass to textarea
+        _ => editor.handle_textarea_input(key_event),
+    }
+
+    Ok(true)
+}
+
+fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut editor: SyntaxTextAreaDemo) -> io::Result<()> {
+    loop {
+        terminal.draw(|f| ui(f, &mut editor))?;
+
+        if let Event::Key(key) = event::read()? {
+            match handle_key_press(key, &mut editor) {
+                Ok(should_continue) => {
+                    if !should_continue {
+                        break;
+                    }
+                }
+                Err(e) => {
+                    editor.set_debug_message(format!("Error: {e}"));
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn ui(f: &mut Frame, editor: &mut SyntaxTextAreaDemo) {
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([Constraint::Min(8), Constraint::Length(8)])
+        .split(f.area());
+
+    render_textarea(f, chunks[0], editor);
+    render_status_and_help(f, chunks[1], editor);
+}
+
+fn render_textarea(f: &mut Frame, area: ratatui::layout::Rect, editor: &mut SyntaxTextAreaDemo) {
+    let block = Block::default()
+        .borders(Borders::ALL)
+        .title("🎨 Syntax Highlighted Code Editor");
+
+    let textarea_widget = TextAreaSyntax::default().block(block.clone());
+    f.render_stateful_widget(textarea_widget, area, &mut editor.textarea);
+
+    // Reuse cursor calculation from the wrapped textarea
+    let (cx, cy) = editor.textarea.cursor(area, Some(&block));
+    f.set_cursor_position((cx, cy));
+}
+
+fn render_status_and_help(f: &mut Frame, area: ratatui::layout::Rect, editor: &SyntaxTextAreaDemo) {
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([Constraint::Length(3), Constraint::Length(5)])
+        .split(area);
+
+    let status_text = if editor.has_unsaved_changes() {
+        format!(
+            "-- SYNTAX MODE (highlighting enabled) -- [Modified] {} | {}",
+            editor.debug_message(),
+            editor.get_cursor_info()
+        )
+    } else {
+        format!(
+            "-- SYNTAX MODE (highlighting enabled) -- {} | {}",
+            editor.debug_message(),
+            editor.get_cursor_info()
+        )
+    };
+
+    let status = Paragraph::new(Line::from(Span::raw(status_text)))
+        .block(Block::default().borders(Borders::ALL).title("🎨 Syntax Status"));
+
+    f.render_widget(status, chunks[0]);
+
+    let help_text = "🎨 SYNTAX HIGHLIGHTING DEMO\n\
+F5=Rust, F6=Python, F7=JavaScript, F8=Scheme\n\
+F1/F2=overflow modes, F3/F4=wrap indent\n\
+F9=cycle themes, ?=info, Ctrl+Q=quit";
+
+    let help = Paragraph::new(help_text)
+        .block(Block::default().borders(Borders::ALL).title("🚀 Help"))
+        .style(Style::default().fg(Color::Cyan));
+
+    f.render_widget(help, chunks[1]);
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("🎨 Canvas Textarea Syntax Highlighting Demo");
+    println!("✅ cursor-style feature: ENABLED");
+    println!("✅ textarea feature: ENABLED");
+    println!("✅ syntect feature: ENABLED");
+    println!("🎨 Syntax highlighting active");
+    println!();
+
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    let editor = SyntaxTextAreaDemo::new();
+
+    let res = run_app(&mut terminal, editor);
+
+    CursorManager::reset()?;
+
+    disable_raw_mode()?;
+    execute!(terminal.backend_mut(), LeaveAlternateScreen, DisableMouseCapture)?;
+    terminal.show_cursor()?;
+
+    if let Err(err) = res {
+        println!("{err:?}");
+    }
+
+    println!("🎨 Syntax highlighting demo complete!");
+    Ok(())
+}
--- a/canvas/examples/textarea_vim.rs
+++ b/canvas/examples/textarea_vim.rs
@@ -339,13 +339,13 @@ fn handle_key_press(
        // Vim o/O commands
        (AppMode::ReadOnly, KeyCode::Char('o'), _) => {
            if let Err(e) = editor.open_line_below() {
-                editor.set_debug_message(format!("Error opening line below: {}", e));
+                editor.set_debug_message(format!("Error opening line below: {e}"));
            }
            editor.clear_command_buffer();
        }
        (AppMode::ReadOnly, KeyCode::Char('O'), _) => {
            if let Err(e) = editor.open_line_above() {
-                editor.set_debug_message(format!("Error opening line above: {}", e));
+                editor.set_debug_message(format!("Error opening line above: {e}"));
            }
            editor.clear_command_buffer();
        }
@@ -482,8 +482,7 @@ fn handle_key_press(
                editor.set_debug_message("Invalid command sequence".to_string());
            } else {
                editor.set_debug_message(format!(
-                    "Unhandled: {:?} + {:?} in {:?} mode",
-                    key, modifiers, mode
+                    "Unhandled: {key:?} + {modifiers:?} in {mode:?} mode"
                ));
            }
        }
@@ -507,7 +506,7 @@ fn run_app<B: Backend>(
                    }
                }
                Err(e) => {
-                    editor.set_debug_message(format!("Error: {}", e));
+                    editor.set_debug_message(format!("Error: {e}"));
                }
            }
        }
@@ -645,7 +644,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    terminal.show_cursor()?;

    if let Err(err) = res {
-        println!("{:?}", err);
+        println!("{err:?}");
    }

    println!("🎯 Cursor automatically reset to default!");
--- a/canvas/examples/validation_1.rs
+++ b/canvas/examples/validation_1.rs
@@ -141,10 +141,10 @@ impl<D: DataProvider> ValidationFormEditor<D> {
                self.debug_message = "✅ Current field is valid!".to_string();
            }
            ValidationResult::Warning { message } => {
-                self.debug_message = format!("⚠️  Warning: {}", message);
+                self.debug_message = format!("⚠️  Warning: {message}");
            }
            ValidationResult::Error { message } => {
-                self.debug_message = format!("❌ Error: {}", message);
+                self.debug_message = format!("❌ Error: {message}");
            }
        }
    }
@@ -189,7 +189,7 @@ impl<D: DataProvider> ValidationFormEditor<D> {
            Err(e) => {
                self.field_switch_blocked = true;
                self.block_reason = Some(e.to_string());
-                self.debug_message = format!("🚫 Field switch blocked: {}", e);
+                self.debug_message = format!("🚫 Field switch blocked: {e}");
            }
        }
    }
@@ -204,7 +204,7 @@ impl<D: DataProvider> ValidationFormEditor<D> {
            Err(e) => {
                self.field_switch_blocked = true;
                self.block_reason = Some(e.to_string());
-                self.debug_message = format!("🚫 Field switch blocked: {}", e);
+                self.debug_message = format!("🚫 Field switch blocked: {e}");
            }
        }
    }
@@ -289,19 +289,19 @@ impl<D: DataProvider> ValidationFormEditor<D> {
                        if let Some(status) = limits.status_text(
                            self.editor.data_provider().field_value(field_index)
                        ) {
-                            self.debug_message = format!("✏️  {}", status);
+                            self.debug_message = format!("✏️  {status}");
                        }
                    }
                }
                ValidationResult::Warning { message } => {
-                    self.debug_message = format!("⚠️  {}", message);
+                    self.debug_message = format!("⚠️  {message}");
                }
                ValidationResult::Error { message } => {
-                    self.debug_message = format!("❌ {}", message);
+                    self.debug_message = format!("❌ {message}");
                }
            }
        }
-        Ok(result?)
+        result
    }

    fn get_current_field_limits(&self) -> Option<&CharacterLimits> {
@@ -317,7 +317,7 @@ impl<D: DataProvider> ValidationFormEditor<D> {
            self.has_unsaved_changes = true;
            self.debug_message = "⌫ Deleted character".to_string();
        }
-        Ok(result?)
+        result
    }

    fn delete_forward(&mut self) -> anyhow::Result<()> {
@@ -326,7 +326,7 @@ impl<D: DataProvider> ValidationFormEditor<D> {
            self.has_unsaved_changes = true;
            self.debug_message = "⌦ Deleted character".to_string();
        }
-        Ok(result?)
+        result
    }

    // === DELEGATE TO ORIGINAL EDITOR ===
@@ -370,7 +370,7 @@ impl<D: DataProvider> ValidationFormEditor<D> {
            Err(e) => {
                self.field_switch_blocked = true;
                self.block_reason = Some(e.to_string());
-                self.debug_message = format!("🚫 Cannot move to next field: {}", e);
+                self.debug_message = format!("🚫 Cannot move to next field: {e}");
            }
        }
    }
@@ -385,7 +385,7 @@ impl<D: DataProvider> ValidationFormEditor<D> {
            Err(e) => {
                self.field_switch_blocked = true;
                self.block_reason = Some(e.to_string());
-                self.debug_message = format!("🚫 Cannot move to previous field: {}", e);
+                self.debug_message = format!("🚫 Cannot move to previous field: {e}");
            }
        }
    }
@@ -644,7 +644,7 @@ fn run_app<B: Backend>(
                    }
                }
                Err(e) => {
-                    editor.set_debug_message(format!("Error: {}", e));
+                    editor.set_debug_message(format!("Error: {e}"));
                }
            }
        }
@@ -823,7 +823,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    terminal.show_cursor()?;

    if let Err(err) = res {
-        println!("{:?}", err);
+        println!("{err:?}");
    }

    println!("🔍 Validation demo completed!");
--- a/canvas/examples/validation_2.rs
+++ b/canvas/examples/validation_2.rs
@@ -93,14 +93,14 @@ impl<D: DataProvider> AdvancedPatternFormEditor<D> {
    fn move_up(&mut self) {
        match self.editor.move_up() {
            Ok(()) => { self.update_field_validation_status(); self.field_switch_blocked = false; self.block_reason = None; }
-            Err(e) => { self.field_switch_blocked = true; self.block_reason = Some(e.to_string()); self.debug_message = format!("🚫 Field switch blocked: {}", e); }
+            Err(e) => { self.field_switch_blocked = true; self.block_reason = Some(e.to_string()); self.debug_message = format!("🚫 Field switch blocked: {e}"); }
        }
    }

    fn move_down(&mut self) {
        match self.editor.move_down() {
            Ok(()) => { self.update_field_validation_status(); self.field_switch_blocked = false; self.block_reason = None; }
-            Err(e) => { self.field_switch_blocked = true; self.block_reason = Some(e.to_string()); self.debug_message = format!("🚫 Field switch blocked: {}", e); }
+            Err(e) => { self.field_switch_blocked = true; self.block_reason = Some(e.to_string()); self.debug_message = format!("🚫 Field switch blocked: {e}"); }
        }
    }

@@ -132,23 +132,23 @@ impl<D: DataProvider> AdvancedPatternFormEditor<D> {
            let validation_result = self.editor.validate_current_field();
            match validation_result {
                ValidationResult::Valid => { self.debug_message = "✅ Character accepted".to_string(); }
-                ValidationResult::Warning { message } => { self.debug_message = format!("⚠️  Warning: {}", message); }
-                ValidationResult::Error { message } => { self.debug_message = format!("❌ Pattern violation: {}", message); }
+                ValidationResult::Warning { message } => { self.debug_message = format!("⚠️  Warning: {message}"); }
+                ValidationResult::Error { message } => { self.debug_message = format!("❌ Pattern violation: {message}"); }
            }
        }
-        Ok(result?)
+        result
    }

    fn delete_backward(&mut self) -> anyhow::Result<()> {
        let result = self.editor.delete_backward();
        if result.is_ok() { self.debug_message = "⌫ Character deleted".to_string(); }
-        Ok(result?)
+        result
    }

    fn delete_forward(&mut self) -> anyhow::Result<()> {
        let result = self.editor.delete_forward();
        if result.is_ok() { self.debug_message = "⌦ Character deleted".to_string(); }
-        Ok(result?)
+        result
    }

    // Delegate methods
@@ -166,14 +166,14 @@ impl<D: DataProvider> AdvancedPatternFormEditor<D> {
    fn next_field(&mut self) {
        match self.editor.next_field() {
            Ok(()) => { self.update_field_validation_status(); self.field_switch_blocked = false; self.block_reason = None; }
-            Err(e) => { self.field_switch_blocked = true; self.block_reason = Some(e.to_string()); self.debug_message = format!("🚫 Cannot move to next field: {}", e); }
+            Err(e) => { self.field_switch_blocked = true; self.block_reason = Some(e.to_string()); self.debug_message = format!("🚫 Cannot move to next field: {e}"); }
        }
    }

    fn prev_field(&mut self) {
        match self.editor.prev_field() {
            Ok(()) => { self.update_field_validation_status(); self.field_switch_blocked = false; self.block_reason = None; }
-            Err(e) => { self.field_switch_blocked = true; self.block_reason = Some(e.to_string()); self.debug_message = format!("🚫 Cannot move to previous field: {}", e); }
+            Err(e) => { self.field_switch_blocked = true; self.block_reason = Some(e.to_string()); self.debug_message = format!("🚫 Cannot move to previous field: {e}"); }
        }
    }

@@ -492,7 +492,7 @@ fn run_app<B: Backend>(
                    }
                }
                Err(e) => {
-                    editor.set_debug_message(format!("Error: {}", e));
+                    editor.set_debug_message(format!("Error: {e}"));
                }
            }
        }
@@ -654,7 +654,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    terminal.show_cursor()?;

    if let Err(err) = res {
-        println!("{:?}", err);
+        println!("{err:?}");
    }

    println!("🚀 Advanced pattern validation demo completed!");
--- a/canvas/examples/validation_3.rs
+++ b/canvas/examples/validation_3.rs
@@ -54,7 +54,6 @@ use canvas::{
    },
    DataProvider, FormEditor,
    ValidationConfig, ValidationConfigBuilder, DisplayMask,
-    validation::mask::MaskDisplayMode,
 };

 // Enhanced FormEditor wrapper for mask demonstration
@@ -144,14 +143,14 @@ impl<D: DataProvider> MaskDemoFormEditor<D> {
    fn move_up(&mut self) {
        match self.editor.move_up() {
            Ok(()) => { self.update_field_info(); }
-            Err(e) => { self.debug_message = format!("🚫 Field switch blocked: {}", e); }
+            Err(e) => { self.debug_message = format!("🚫 Field switch blocked: {e}"); }
        }
    }

    fn move_down(&mut self) {
        match self.editor.move_down() {
            Ok(()) => { self.update_field_info(); }
-            Err(e) => { self.debug_message = format!("🚫 Field switch blocked: {}", e); }
+            Err(e) => { self.debug_message = format!("🚫 Field switch blocked: {e}"); }
        }
    }

@@ -170,16 +169,16 @@ impl<D: DataProvider> MaskDemoFormEditor<D> {
            let raw_pos = self.editor.cursor_position();
            let display_pos = self.editor.display_cursor_position();
            if raw_pos != display_pos {
-                self.debug_message = format!("📍 Cursor: Raw pos {} → Display pos {} (mask active)", raw_pos, display_pos);
+                self.debug_message = format!("📍 Cursor: Raw pos {raw_pos} → Display pos {display_pos} (mask active)");
            } else {
-                self.debug_message = format!("📍 Cursor at position {} (no mask offset)", raw_pos);
+                self.debug_message = format!("📍 Cursor at position {raw_pos} (no mask offset)");
            }
        }
    }

    fn update_field_info(&mut self) {
        let field_name = self.editor.data_provider().field_name(self.editor.current_field());
-        self.debug_message = format!("📝 Switched to: {}", field_name);
+        self.debug_message = format!("📝 Switched to: {field_name}");
    }

    // === MODE TRANSITIONS ===
@@ -206,12 +205,12 @@ impl<D: DataProvider> MaskDemoFormEditor<D> {
        if result.is_ok() {
            let (raw, display, _) = self.get_current_field_info();
            if raw != display {
-                self.debug_message = format!("✏️ Added '{}': Raw='{}' Display='{}'", ch, raw, display);
+                self.debug_message = format!("✏️ Added '{ch}': Raw='{raw}' Display='{display}'");
            } else {
-                self.debug_message = format!("✏️ Added '{}': '{}'", ch, raw);
+                self.debug_message = format!("✏️ Added '{ch}': '{raw}'");
            }
        }
-        Ok(result?)
+        result
    }

    // === DELETE OPERATIONS ===
@@ -221,7 +220,7 @@ impl<D: DataProvider> MaskDemoFormEditor<D> {
            self.debug_message = "⌫ Character deleted".to_string();
            self.update_cursor_info();
        }
-        Ok(result?)
+        result
    }

    fn delete_forward(&mut self) -> anyhow::Result<()> {
@@ -230,7 +229,7 @@ impl<D: DataProvider> MaskDemoFormEditor<D> {
            self.debug_message = "⌦ Character deleted".to_string();
            self.update_cursor_info();
        }
-        Ok(result?)
+        result
    }

    // === DELEGATE TO ORIGINAL EDITOR ===
@@ -251,14 +250,14 @@ impl<D: DataProvider> MaskDemoFormEditor<D> {
    fn next_field(&mut self) {
        match self.editor.next_field() {
            Ok(()) => { self.update_field_info(); }
-            Err(e) => { self.debug_message = format!("🚫 Cannot move to next field: {}", e); }
+            Err(e) => { self.debug_message = format!("🚫 Cannot move to next field: {e}"); }
        }
    }

    fn prev_field(&mut self) {
        match self.editor.prev_field() {
            Ok(()) => { self.update_field_info(); }
-            Err(e) => { self.debug_message = format!("🚫 Cannot move to previous field: {}", e); }
+            Err(e) => { self.debug_message = format!("🚫 Cannot move to previous field: {e}"); }
        }
    }

@@ -287,7 +286,7 @@ impl<D: DataProvider> MaskDemoFormEditor<D> {
            }
        }

-        format!("🎭 {} MASKS", mask_count)
+        format!("🎭 {mask_count} MASKS")
    }
 }

@@ -549,7 +548,7 @@ fn run_app<B: Backend>(
                    }
                }
                Err(e) => {
-                    editor.set_debug_message(format!("Error: {}", e));
+                    editor.set_debug_message(format!("Error: {e}"));
                }
            }
        }
@@ -726,7 +725,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    CursorManager::reset()?;

    if let Err(err) = res {
-        println!("{:?}", err);
+        println!("{err:?}");
    }

    println!("🎭 Display mask demo completed!");
--- a/canvas/examples/validation_4.rs
+++ b/canvas/examples/validation_4.rs
@@ -97,7 +97,7 @@ impl CustomFormatter for PhoneFormatter {
        let len = raw.chars().count();
        match len {
            0 => FormattingResult::success(""),
-            1..=3 => FormattingResult::success(format!("({})", raw)),
+            1..=3 => FormattingResult::success(format!("({raw})")),
            4..=6 => FormattingResult::success(format!("({}) {}", &raw[..3], &raw[3..])),
            7..=10 => FormattingResult::success(format!("({}) {}-{}", &raw[..3], &raw[3..6], &raw[6..])),
            10 => {
@@ -135,7 +135,7 @@ impl CustomFormatter for CreditCardFormatter {

        let len = raw.chars().count();
        match len {
-            0..=15 => FormattingResult::warning(formatted, format!("Card incomplete ({}/16 digits)", len)),
+            0..=15 => FormattingResult::warning(formatted, format!("Card incomplete ({len}/16 digits)")),
            16 => FormattingResult::success(formatted),
            _ => FormattingResult::warning(formatted, "Card too long (extra digits shown)"),
        }
@@ -177,16 +177,16 @@ impl CustomFormatter for DateFormatter {

                if m == 0 || m > 12 {
                    FormattingResult::warning(
-                        format!("{}/{}/{}", month, day, year),
+                        format!("{month}/{day}/{year}"),
                        "Invalid month (01-12)"
                    )
                } else if d == 0 || d > 31 {
                    FormattingResult::warning(
-                        format!("{}/{}/{}", month, day, year),
+                        format!("{month}/{day}/{year}"),
                        "Invalid day (01-31)"
                    )
                } else {
-                    FormattingResult::success(format!("{}/{}/{}", month, day, year))
+                    FormattingResult::success(format!("{month}/{day}/{year}"))
                }
            },
            _ => FormattingResult::error("Date too long (MMDDYYYY format)"),
@@ -384,7 +384,7 @@ impl<D: DataProvider> EnhancedDemoEditor<D> {

        let warning = if self.validation_enabled && self.has_formatter() {
            // Check if there are any formatting warnings
-            if raw.len() > 0 {
+            if !raw.is_empty() {
                match self.editor.current_field() {
                    0 if raw.len() < 5 => Some(format!("PSC incomplete: {}/5", raw.len())),
                    1 if raw.len() < 10 => Some(format!("Phone incomplete: {}/10", raw.len())),
@@ -408,7 +408,7 @@ impl<D: DataProvider> EnhancedDemoEditor<D> {
        self.editor.enter_edit_mode();
        let field_type = self.current_field_type();
        let rules = self.get_input_rules();
-        self.debug_message = format!("✏️ INSERT MODE - Cursor: Steady Bar | - {} - {}", field_type, rules);
+        self.debug_message = format!("✏️ INSERT MODE - Cursor: Steady Bar | - {field_type} - {rules}");
    }

    fn exit_edit_mode(&mut self) {
@@ -429,9 +429,9 @@ impl<D: DataProvider> EnhancedDemoEditor<D> {
        if result.is_ok() {
            let (raw, display, _, _) = self.get_current_field_analysis();
            if raw != display && self.validation_enabled {
-                self.debug_message = format!("✏️ '{}' added - Real-time formatting active", ch);
+                self.debug_message = format!("✏️ '{ch}' added - Real-time formatting active");
            } else {
-                self.debug_message = format!("✏️ '{}' added", ch);
+                self.debug_message = format!("✏️ '{ch}' added");
            }
        }
        result
@@ -459,7 +459,7 @@ impl<D: DataProvider> EnhancedDemoEditor<D> {
                display.chars().nth(display_pos).unwrap_or('∅')
            );
        } else {
-            self.debug_message = format!("📍 Cursor at position {} (no mapping needed)", raw_pos);
+            self.debug_message = format!("📍 Cursor at position {raw_pos} (no mapping needed)");
        }
    }

@@ -530,7 +530,7 @@ fn handle_key_press(
        // Field analysis
        (AppMode::ReadOnly, KeyCode::Char('?'), _) => {
            let (raw, display, status, warning) = editor.get_current_field_analysis();
-            let warning_text = warning.map(|w| format!(" ⚠️ {}", w)).unwrap_or_default();
+            let warning_text = warning.map(|w| format!(" ⚠️ {w}")).unwrap_or_default();
            editor.debug_message = format!(
                "🔍 Field {}: {} | Raw: '{}' | Display: '{}'{}",
                editor.current_field() + 1, status, raw, display, warning_text
@@ -558,7 +558,7 @@ fn run_app<B: Backend>(
                    }
                }
                Err(e) => {
-                    editor.debug_message = format!("❌ Error: {}", e);
+                    editor.debug_message = format!("❌ Error: {e}");
                }
            }
        }
@@ -627,11 +627,11 @@ fn render_enhanced_status(
    ];

    if editor.show_raw_data || editor.mode() == AppMode::Edit {
-        analysis_lines.push(format!("💾 Raw Data: '{}'", raw));
-        analysis_lines.push(format!("✨ Display: '{}'", display));
+        analysis_lines.push(format!("💾 Raw Data: '{raw}'"));
+        analysis_lines.push(format!("✨ Display: '{display}'"));
    } else {
-        analysis_lines.push(format!("✨ User Sees: '{}'", display));
-        analysis_lines.push(format!("💾 Stored As: '{}'", raw));
+        analysis_lines.push(format!("✨ User Sees: '{display}'"));
+        analysis_lines.push(format!("💾 Stored As: '{raw}'"));
    }

    if editor.show_cursor_details {
@@ -643,7 +643,7 @@ fn render_enhanced_status(
    }

    if let Some(ref warn) = warning {
-        analysis_lines.push(format!("⚠️ Warning: {}", warn));
+        analysis_lines.push(format!("⚠️ Warning: {warn}"));
    }

    let analysis_color = if warning.is_some() {
@@ -742,7 +742,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    CursorManager::reset()?;

    if let Err(err) = res {
-        println!("{:?}", err);
+        println!("{err:?}");
    }

    println!("🧩 Enhanced custom formatter demo completed!");
--- a/canvas/examples/validation_5.rs
+++ b/canvas/examples/validation_5.rs
@@ -203,7 +203,7 @@ impl ValidationServices {

    /// PSC validation: simulates postal service API lookup
    fn validate_psc(&mut self, psc: &str) -> ExternalValidationState {
-        let cache_key = format!("psc:{}", psc);
+        let cache_key = format!("psc:{psc}");
        if let Some(cached) = self.cache.get(&cache_key) {
            return cached.clone();
        }
@@ -244,7 +244,7 @@ impl ValidationServices {
                    "20" | "21" => "Brno region",
                    _ => "Valid postal region"
                };
-                ExternalValidationState::Valid(Some(format!("{} - verified", region)))
+                ExternalValidationState::Valid(Some(format!("{region} - verified")))
            }
        };

@@ -254,7 +254,7 @@ impl ValidationServices {

    /// Email validation: simulates domain checking
    fn validate_email(&mut self, email: &str) -> ExternalValidationState {
-        let cache_key = format!("email:{}", email);
+        let cache_key = format!("email:{email}");
        if let Some(cached) = self.cache.get(&cache_key) {
            return cached.clone();
        }
@@ -315,7 +315,7 @@ impl ValidationServices {

    /// Username validation: simulates availability checking
    fn validate_username(&mut self, username: &str) -> ExternalValidationState {
-        let cache_key = format!("username:{}", username);
+        let cache_key = format!("username:{username}");
        if let Some(cached) = self.cache.get(&cache_key) {
            return cached.clone();
        }
@@ -371,7 +371,7 @@ impl ValidationServices {

    /// API Key validation: simulates authentication service
    fn validate_api_key(&mut self, key: &str) -> ExternalValidationState {
-        let cache_key = format!("apikey:{}", key);
+        let cache_key = format!("apikey:{key}");
        if let Some(cached) = self.cache.get(&cache_key) {
            return cached.clone();
        }
@@ -429,7 +429,7 @@ impl ValidationServices {

    /// Credit Card validation: simulates bank verification
    fn validate_credit_card(&mut self, card: &str) -> ExternalValidationState {
-        let cache_key = format!("card:{}", card);
+        let cache_key = format!("card:{card}");
        if let Some(cached) = self.cache.get(&cache_key) {
            return cached.clone();
        }
@@ -724,8 +724,7 @@ impl<D: DataProvider> ValidationDemoEditor<D> {
        let duration_ms = result.duration().as_millis();
        let cached_text = if result.cached { " (cached)" } else { "" };
        self.debug_message = format!(
-            "🔍 {} validation completed in {}ms{} (manual)",
-            validation_type, duration_ms, cached_text
+            "🔍 {validation_type} validation completed in {duration_ms}ms{cached_text} (manual)"
        );
    }

@@ -812,7 +811,7 @@ impl<D: DataProvider> ValidationDemoEditor<D> {
            0
        };

-        format!("Total: {} validations, Avg: {}ms", total_validations, avg_time_ms)
+        format!("Total: {total_validations} validations, Avg: {avg_time_ms}ms")
    }

    fn get_field_validation_state(&self, field_index: usize) -> ExternalValidationState {
@@ -1032,8 +1031,8 @@ fn render_validation_panel(
        };

        let field_line = Line::from(vec![
-            Span::styled(format!("{}{}: ", indicator, field_name), Style::default().fg(Color::White)),
-            Span::raw(format!("'{}' → ", value_display)),
+            Span::styled(format!("{indicator}{field_name}: "), Style::default().fg(Color::White)),
+            Span::raw(format!("'{value_display}' → ")),
            Span::styled(state_text.to_string(), Style::default().fg(color)),
        ]);

@@ -1077,8 +1076,7 @@ fn render_validation_panel(
                };

                ListItem::new(format!(
-                    "{}: '{}' → {} ({}ms{})",
-                    field_name, short_value, state_summary, duration_ms, cached_text
+                    "{field_name}: '{short_value}' → {state_summary} ({duration_ms}ms{cached_text})"
                ))
            })
            .collect();
@@ -1162,7 +1160,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    CursorManager::reset()?;

    if let Err(err) = res {
-        println!("{:?}", err);
+        println!("{err:?}");
    }

    println!("🧪 Enhanced fully automatic external validation demo completed!");
--- a/canvas/src/canvas/actions/mod.rs
+++ b/canvas/src/canvas/actions/mod.rs
@@ -1,4 +1,5 @@
 // src/canvas/actions/mod.rs
+//! Canvas action definitions and movement utilities

 pub mod types;
 pub mod movement;
--- a/canvas/src/canvas/actions/movement/char.rs
+++ b/canvas/src/canvas/actions/movement/char.rs
@@ -1,4 +1,5 @@
 // src/canvas/actions/movement/char.rs
+//! Character-level cursor movement functions

 /// Calculate new position when moving left
 pub fn move_left(current_pos: usize) -> usize {
--- a/canvas/src/canvas/actions/movement/line.rs
+++ b/canvas/src/canvas/actions/movement/line.rs
@@ -1,4 +1,5 @@
 // src/canvas/actions/movement/line.rs
+//! Line-level cursor movement and positioning

 /// Calculate cursor position for line start
 pub fn line_start_position() -> usize {
--- a/canvas/src/canvas/actions/movement/mod.rs
+++ b/canvas/src/canvas/actions/movement/mod.rs
@@ -1,4 +1,5 @@
 // src/canvas/actions/movement/mod.rs
+//! Movement utilities for character, word, and line navigation

 pub mod word;
 pub mod line;
--- a/canvas/src/canvas/actions/movement/word.rs
+++ b/canvas/src/canvas/actions/movement/word.rs
@@ -1,5 +1,5 @@
 // src/canvas/actions/movement/word.rs
-// Replace the entire file with this corrected version:
+//! Word-based cursor movement with vim-like semantics

 #[derive(PartialEq, Copy, Clone)]
 enum CharType {
--- a/canvas/src/canvas/actions/types.rs
+++ b/canvas/src/canvas/actions/types.rs
@@ -1,79 +1,121 @@
 // src/canvas/actions/types.rs
+//! Core action types and result handling for canvas operations.

-/// All available canvas actions
+/// All available canvas actions.
+///
+/// This enum lists high-level actions that can be performed on the canvas.
+/// Consumers can match on variants to implement custom handling or map input
+/// events to these canonical actions.
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub enum CanvasAction {
    // Movement actions
+    /// Move the cursor left by one character (or logical unit).
    MoveLeft,
+    /// Move the cursor right by one character (or logical unit).
    MoveRight,
+    /// Move the cursor up a visual line/field.
    MoveUp,
+    /// Move the cursor down a visual line/field.
    MoveDown,

    // Word movement
+    /// Move to the start of the next word.
    MoveWordNext,
+    /// Move to the start of the previous word.
    MoveWordPrev,
+    /// Move to the end of the current/next word.
    MoveWordEnd,
+    /// Move to the previous word end (vim `ge`).
    MoveWordEndPrev,

    // Line movement
+    /// Move to the start of the current line.
    MoveLineStart,
+    /// Move to the end of the current line.
    MoveLineEnd,

    // Field movement
+    /// Move to the next field.
    NextField,
+    /// Move to the previous field.
    PrevField,
+    /// Move to the first field.
    MoveFirstLine,
+    /// Move to the last field.
    MoveLastLine,

    // Editing actions
+    /// Insert a character at the cursor.
    InsertChar(char),
+    /// Delete character before the cursor.
    DeleteBackward,
+    /// Delete character under/after the cursor.
    DeleteForward,

    // Suggestions actions
-        TriggerSuggestions,
-        SuggestionUp,
-        SuggestionDown,
-        SelectSuggestion,
-        ExitSuggestions,
+    /// Trigger suggestions dropdown (e.g. Tab).
+    TriggerSuggestions,
+    /// Move selection up in suggestions dropdown.
+    SuggestionUp,
+    /// Move selection down in suggestions dropdown.
+    SuggestionDown,
+    /// Accept the selected suggestion.
+    SelectSuggestion,
+    /// Exit suggestions UI.
+    ExitSuggestions,

    // Custom actions
+    /// Custom named action for application-specific behavior.
    Custom(String),
 }

-/// Result type for canvas actions
+/// Result type for canvas actions.
+///
+/// Action handlers return an ActionResult to indicate success, user-facing
+/// messages, or errors. The enum is non-exhaustive to allow extension.
 #[non_exhaustive]
 #[derive(Debug, Clone)]
 pub enum ActionResult {
+    /// Action completed successfully.
    Success,
+    /// Action completed with a user-facing message.
    Message(String),
+    /// Action was handled by the application with an associated message.
    HandledByApp(String),
+    /// Action was handled by a feature with an associated message.
    HandledByFeature(String), // Keep for compatibility
+    /// An error occurred while handling the action.
    Error(String),
 }

 impl ActionResult {
+    /// Convenience constructor for Success.
    pub fn success() -> Self {
        Self::Success
    }

+    /// Convenience constructor for Message.
    pub fn success_with_message(msg: &str) -> Self {
        Self::Message(msg.to_string())
    }

+    /// Convenience constructor for HandledByApp.
    pub fn handled_by_app(msg: &str) -> Self {
        Self::HandledByApp(msg.to_string())
    }

+    /// Convenience constructor for Error.
    pub fn error(msg: &str) -> Self {
        Self::Error(msg.to_string())
    }

+    /// Returns true for any variant representing a success-like outcome.
    pub fn is_success(&self) -> bool {
        matches!(self, Self::Success | Self::Message(_) | Self::HandledByApp(_) | Self::HandledByFeature(_))
    }

+    /// Extract a message from the result when present.
    pub fn message(&self) -> Option<&str> {
        match self {
            Self::Message(msg) | Self::HandledByApp(msg) | Self::HandledByFeature(msg) | Self::Error(msg) => Some(msg),
@@ -83,7 +125,7 @@ impl ActionResult {
 }

 impl CanvasAction {
-    /// Get a human-readable description of this action
+    /// Get a human-readable description of this action.
    pub fn description(&self) -> &'static str {
        match self {
            Self::MoveLeft => "move left",
@@ -112,7 +154,7 @@ impl CanvasAction {
        }
    }

-    /// Get all movement-related actions
+    /// Get all movement-related actions.
    pub fn movement_actions() -> Vec<CanvasAction> {
        vec![
            Self::MoveLeft,
@@ -132,7 +174,7 @@ impl CanvasAction {
        ]
    }

-    /// Get all editing-related actions
+    /// Get all editing-related actions.
    pub fn editing_actions() -> Vec<CanvasAction> {
        vec![
            Self::InsertChar(' '), // Example char
@@ -141,7 +183,7 @@ impl CanvasAction {
        ]
    }

-    /// Get all suggestions-related actions
+    /// Get all suggestions-related actions.
    pub fn suggestions_actions() -> Vec<CanvasAction> {
        vec![
            Self::TriggerSuggestions,
@@ -152,7 +194,7 @@ impl CanvasAction {
        ]
    }

-    /// Check if this action modifies text content
+    /// Check if this action modifies text content.
    pub fn is_editing_action(&self) -> bool {
        matches!(self,
            Self::InsertChar(_) |
@@ -161,7 +203,7 @@ impl CanvasAction {
        )
    }

-    /// Check if this action moves the cursor
+    /// Check if this action moves the cursor.
    pub fn is_movement_action(&self) -> bool {
        matches!(self,
            Self::MoveLeft | Self::MoveRight | Self::MoveUp | Self::MoveDown |
--- a/canvas/src/canvas/cursor.rs
+++ b/canvas/src/canvas/cursor.rs
@@ -1,5 +1,9 @@
 // src/canvas/cursor.rs
 //! Cursor style management for different canvas modes
+//!
+//! Provides helpers to update and reset terminal cursor style when the
+//! `cursor-style` feature is enabled. When the feature is disabled the
+//! functions are no-ops.

 #[cfg(feature = "cursor-style")]
 use crossterm::{cursor::SetCursorStyle, execute};
@@ -12,14 +16,17 @@ use crate::canvas::modes::AppMode;
 pub struct CursorManager;

 impl CursorManager {
-    /// Update cursor style based on current mode
+    /// Update cursor style based on current mode.
+    ///
+    /// When the `textmode-normal` feature is enabled a fixed style is applied.
+    /// Otherwise, the cursor style is mapped to the provided AppMode.
    #[cfg(feature = "cursor-style")]
    pub fn update_for_mode(mode: AppMode) -> io::Result<()> {
        // NORMALMODE: force underscore for every mode
        #[cfg(feature = "textmode-normal")]
        {
            let style = SetCursorStyle::SteadyBar;
-            return execute!(io::stdout(), style);
+            execute!(io::stdout(), style)
        }

        // Default (not normal): original mapping
@@ -37,18 +44,19 @@ impl CursorManager {
        }
    }

-    /// No-op when cursor-style feature is disabled
+    /// No-op when cursor-style feature is disabled.
    #[cfg(not(feature = "cursor-style"))]
    pub fn update_for_mode(_mode: AppMode) -> io::Result<()> {
        Ok(())
    }

-    /// Reset cursor to default on cleanup
+    /// Reset cursor to default on cleanup.
    #[cfg(feature = "cursor-style")]
    pub fn reset() -> io::Result<()> {
        execute!(io::stdout(), SetCursorStyle::DefaultUserShape)
    }

+    /// Reset is a no-op when the cursor-style feature is disabled.
    #[cfg(not(feature = "cursor-style"))]
    pub fn reset() -> io::Result<()> {
        Ok(())
--- a/canvas/src/canvas/gui.rs
+++ b/canvas/src/canvas/gui.rs
@@ -1,5 +1,9 @@
 // src/canvas/gui.rs
 //! Canvas GUI updated to work with FormEditor
+//!
+//! This module provides rendering helpers for the canvas UI when the `gui`
+//! feature is enabled. It exposes high-level functions to render the canvas
+//! and convenience types for display options.

 #[cfg(feature = "gui")]
 use ratatui::{
@@ -22,14 +26,20 @@ use std::cmp::{max, min};

 #[cfg(feature = "gui")]
 #[derive(Debug, Clone, Copy)]
+/// How to handle overflow when rendering a field's content.
 pub enum OverflowMode {
-    Indicator(char), // default '$'
+    /// Show an indicator character at the left/right when text is truncated.
+    /// Common default is '$'.
+    Indicator(char),
+    /// Wrap content into multiple visual lines.
    Wrap,
 }

 #[cfg(feature = "gui")]
 #[derive(Debug, Clone, Copy)]
+/// Display options controlling canvas rendering behavior.
 pub struct CanvasDisplayOptions {
+    /// How to handle horizontal overflow for fields.
    pub overflow: OverflowMode,
 }

@@ -166,7 +176,6 @@ fn render_active_line_with_indicator<T: CanvasTheme>(
    if let Some(comp) = completion {
        if !comp.is_empty() && remaining_cols > 0 {
            visible_completion = slice_by_display_cols(comp, 0, remaining_cols);
-            remaining_cols = remaining_cols.saturating_sub(display_width(&visible_completion));
        }
    }

@@ -192,6 +201,9 @@ fn render_active_line_with_indicator<T: CanvasTheme>(
 }

 #[cfg(feature = "gui")]
+/// Render the canvas into the provided frame using default display options.
+///
+/// Returns the rectangle of the active input field if present.
 pub fn render_canvas<T: CanvasTheme, D: DataProvider>(
    f: &mut Frame,
    area: Rect,
@@ -203,6 +215,10 @@ pub fn render_canvas<T: CanvasTheme, D: DataProvider>(
 }

 #[cfg(feature = "gui")]
+/// Render the canvas into the provided frame with explicit display options.
+///
+/// This is the more configurable entrypoint for rendering and is useful for
+/// tests or when callers need to override overflow handling.
 pub fn render_canvas_with_options<T: CanvasTheme, D: DataProvider>(
    f: &mut Frame,
    area: Rect,
@@ -486,7 +502,7 @@ fn render_field_labels<T: CanvasTheme>(
 ) {
    for (i, field) in fields.iter().enumerate() {
        let label = Paragraph::new(Line::from(Span::styled(
-            format!("{}:", field),
+            format!("{field}:"),
            Style::default().fg(theme.fg()),
        )));
        f.render_widget(
@@ -595,50 +611,48 @@ fn apply_characterwise_highlighting<'a, T: CanvasTheme>(
                Span::styled(highlighted, highlight_style),
                Span::styled(after, normal_style),
            ])
-        } else {
-            if field_index == anchor_field {
-                if anchor_field < *current_field_idx {
-                    let clamped_start = anchor_char.min(text_len);
-                    let before: String = text.chars().take(clamped_start).collect();
-                    let highlighted: String = text.chars().skip(clamped_start).collect();
+        } else if field_index == anchor_field {
+            if anchor_field < *current_field_idx {
+                let clamped_start = anchor_char.min(text_len);
+                let before: String = text.chars().take(clamped_start).collect();
+                let highlighted: String = text.chars().skip(clamped_start).collect();

-                    Line::from(vec![
-                        Span::styled(before, normal_style),
-                        Span::styled(highlighted, highlight_style),
-                    ])
-                } else {
-                    let clamped_end = anchor_char.min(text_len);
-                    let highlighted: String = text.chars().take(clamped_end + 1).collect();
-                    let after: String = text.chars().skip(clamped_end + 1).collect();
-
-                    Line::from(vec![
-                        Span::styled(highlighted, highlight_style),
-                        Span::styled(after, normal_style),
-                    ])
-                }
-            } else if field_index == *current_field_idx {
-                if anchor_field < *current_field_idx {
-                    let clamped_end = current_cursor_pos.min(text_len);
-                    let highlighted: String = text.chars().take(clamped_end + 1).collect();
-                    let after: String = text.chars().skip(clamped_end + 1).collect();
-
-                    Line::from(vec![
-                        Span::styled(highlighted, highlight_style),
-                        Span::styled(after, normal_style),
-                    ])
-                } else {
-                    let clamped_start = current_cursor_pos.min(text_len);
-                    let before: String = text.chars().take(clamped_start).collect();
-                    let highlighted: String = text.chars().skip(clamped_start).collect();
-
-                    Line::from(vec![
-                        Span::styled(before, normal_style),
-                        Span::styled(highlighted, highlight_style),
-                    ])
-                }
+                Line::from(vec![
+                    Span::styled(before, normal_style),
+                    Span::styled(highlighted, highlight_style),
+                ])
            } else {
-                Line::from(Span::styled(text, highlight_style))
+                let clamped_end = anchor_char.min(text_len);
+                let highlighted: String = text.chars().take(clamped_end + 1).collect();
+                let after: String = text.chars().skip(clamped_end + 1).collect();
+
+                Line::from(vec![
+                    Span::styled(highlighted, highlight_style),
+                    Span::styled(after, normal_style),
+                ])
            }
+        } else if field_index == *current_field_idx {
+            if anchor_field < *current_field_idx {
+                let clamped_end = current_cursor_pos.min(text_len);
+                let highlighted: String = text.chars().take(clamped_end + 1).collect();
+                let after: String = text.chars().skip(clamped_end + 1).collect();
+
+                Line::from(vec![
+                    Span::styled(highlighted, highlight_style),
+                    Span::styled(after, normal_style),
+                ])
+            } else {
+                let clamped_start = current_cursor_pos.min(text_len);
+                let before: String = text.chars().take(clamped_start).collect();
+                let highlighted: String = text.chars().skip(clamped_start).collect();
+
+                Line::from(vec![
+                    Span::styled(before, normal_style),
+                    Span::styled(highlighted, highlight_style),
+                ])
+            }
+        } else {
+            Line::from(Span::styled(text, highlight_style))
        }
    } else {
        Line::from(Span::styled(text, normal_style))
@@ -710,6 +724,6 @@ pub fn render_canvas_default<D: DataProvider>(
    area: Rect,
    editor: &FormEditor<D>,
 ) -> Option<Rect> {
-    let theme = DefaultCanvasTheme::default();
+    let theme = DefaultCanvasTheme;
    render_canvas(f, area, editor, &theme)
 }
--- a/canvas/src/canvas/mod.rs
+++ b/canvas/src/canvas/mod.rs
@@ -1,4 +1,8 @@
 // src/canvas/mod.rs
+//! Top-level canvas module.
+//!
+//! Re-exports commonly used canvas types and modules so that downstream
+//! consumers can import them from `crate::canvas`.

 pub mod actions;
 pub mod state;
--- a/canvas/src/canvas/modes/highlight.rs
+++ b/canvas/src/canvas/modes/highlight.rs
@@ -1,15 +1,18 @@
-// src/state/app/highlight.rs
-// canvas/src/modes/highlight.rs
+// src/canvas/modes/highlight.rs
+//! Highlight state definitions for canvas visual/selection modes.

 #[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Default)]
+/// Represents the current highlight/visual selection state.
+///
+/// This enum is used by the GUI and selection logic to track whether a visual
+/// selection is active and its anchor position.
 pub enum HighlightState {
+    /// No highlighting active.
+    #[default]
    Off,
+    /// Characterwise selection with an anchor (field_index, char_position).
    Characterwise { anchor: (usize, usize) }, // (field_index, char_position)
+    /// Linewise selection anchored at a field index.
    Linewise { anchor_line: usize },          // field_index
 }
-
-impl Default for HighlightState {
-    fn default() -> Self {
-        HighlightState::Off
-    }
-}
--- a/canvas/src/canvas/modes/manager.rs
+++ b/canvas/src/canvas/modes/manager.rs
@@ -1,45 +1,66 @@
 // src/modes/handlers/mode_manager.rs
 // canvas/src/modes/manager.rs
+//! Mode manager utilities and the AppMode enum.
+//!
+//! This module defines the available canvas modes and provides helper
+//! functions to validate mode transitions and perform required side-effects
+//! such as updating cursor style when enabled.

 #[cfg(feature = "cursor-style")]
 use crate::canvas::CursorManager;

 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+/// Top-level application modes used by the canvas UI.
+///
+/// These modes control input handling, cursor behavior, and how the UI should
+/// respond to user actions.
 pub enum AppMode {
-    General,   // For intro and admin screens
-    ReadOnly,  // Canvas read-only mode
-    Edit,      // Canvas edit mode
-    Highlight, // Canvas highlight/visual mode
-    Command,   // Command mode overlay
+    /// For intro and admin screens
+    General,
+    /// Canvas read-only mode (navigation)
+    ReadOnly,
+    /// Canvas edit mode (insertion/modification)
+    Edit,
+    /// Canvas highlight/visual mode (selection)
+    Highlight,
+    /// Command mode overlay (for commands)
+    Command,
 }

 pub struct ModeManager;

 impl ModeManager {
    // Mode transition rules
+
+    /// Return true if the system can enter Command mode from the given current mode.
    pub fn can_enter_command_mode(current_mode: AppMode) -> bool {
        !matches!(current_mode, AppMode::Edit)
    }

+    /// Return true if the system can enter Edit mode from the given current mode.
    pub fn can_enter_edit_mode(current_mode: AppMode) -> bool {
        matches!(current_mode, AppMode::ReadOnly)
    }

+    /// Return true if the system can enter ReadOnly mode from the given current mode.
    pub fn can_enter_read_only_mode(current_mode: AppMode) -> bool {
        matches!(current_mode, AppMode::Edit | AppMode::Command | AppMode::Highlight)
    }

+    /// Return true if the system can enter Highlight mode from the given current mode.
    pub fn can_enter_highlight_mode(current_mode: AppMode) -> bool {
        matches!(current_mode, AppMode::ReadOnly)
    }


-    /// Transition to new mode with automatic cursor update (when cursor-style feature enabled)
+    /// Transition to new mode with automatic cursor update (when cursor-style feature enabled).
+    ///
+    /// Returns the resulting mode or an I/O error if cursor style update fails.
    pub fn transition_to_mode(current_mode: AppMode, new_mode: AppMode) -> std::io::Result<AppMode> {
        #[cfg(feature = "textmode-normal")]
        {
            // Always force Edit in normalmode
-            return Ok(AppMode::Edit);
+            Ok(AppMode::Edit)
        }

        #[cfg(not(feature = "textmode-normal"))]
@@ -54,7 +75,10 @@ impl ModeManager {
        }
    }

-    /// Enter highlight mode with cursor styling
+    /// Enter highlight mode with cursor styling.
+    ///
+    /// Returns Ok(true) if the transition succeeded (and cursor style was updated
+    /// when enabled), otherwise Ok(false) if the transition is not allowed.
    pub fn enter_highlight_mode_with_cursor(current_mode: AppMode) -> std::io::Result<bool> {
        if Self::can_enter_highlight_mode(current_mode) {
            #[cfg(feature = "cursor-style")]
@@ -67,7 +91,10 @@ impl ModeManager {
        }
    }

-    /// Exit highlight mode with cursor styling
+    /// Exit highlight mode with cursor styling and return the next mode.
+    ///
+    /// This helper returns the mode to switch to (ReadOnly) and updates cursor
+    /// style if the feature is enabled.
    pub fn exit_highlight_mode_with_cursor() -> std::io::Result<AppMode> {
        let new_mode = AppMode::ReadOnly;
        #[cfg(feature = "cursor-style")]
--- a/canvas/src/canvas/state.rs
+++ b/canvas/src/canvas/state.rs
@@ -1,10 +1,20 @@
 // src/canvas/state.rs
 //! Library-owned UI state - user never directly modifies this
+//!
+//! This module exposes the EditorState type (and related selection and
+//! suggestions types) which represent the internal UI state maintained by the
+//! canvas library. These types are intended for read-only access by callers
+//! and are mutated only through the library's APIs.

 use crate::canvas::modes::AppMode;

 /// Library-owned UI state - user never directly modifies this
 #[derive(Debug, Clone)]
+/// Internal editor UI state managed by the canvas library.
+///
+/// The fields are `pub(crate)` because they should only be modified by the
+/// library's internal action handlers. Consumers can use the provided getter
+/// methods to observe the state.
 pub struct EditorState {
    // Navigation state
    pub(crate) current_field: usize,
@@ -32,6 +42,7 @@ pub struct EditorState {

 #[cfg(feature = "suggestions")]
 #[derive(Debug, Clone)]
+/// Internal suggestions UI state used to manage the suggestions dropdown.
 pub struct SuggestionsUIState {
    pub(crate) is_active: bool,
    pub(crate) is_loading: bool,
@@ -42,13 +53,19 @@ pub struct SuggestionsUIState {
 }

 #[derive(Debug, Clone)]
+/// SelectionState represents the current selection/visual mode state used by
+/// the canvas (for example, Vim-like visual modes).
 pub enum SelectionState {
+    /// No selection is active.
    None,
+    /// Characterwise selection: (field_index, char_position)
    Characterwise { anchor: (usize, usize) },
+    /// Linewise selection anchored at a field (field index).
    Linewise { anchor_field: usize },
 }

 impl EditorState {
+    /// Create a new EditorState with default initial values.
    pub fn new() -> Self {
        Self {
            current_field: 0,
@@ -139,6 +156,10 @@ impl EditorState {
    // INTERNAL MUTATIONS: Only library modifies these
    // ===================================================================

+    /// Move internal pointer to another field index.
+    ///
+    /// This method is intended for internal library use to change the current
+    /// field and reset the cursor to a safe value.
    pub(crate) fn move_to_field(&mut self, field_index: usize, field_count: usize) {
        if field_index < field_count {
            self.current_field = field_index;
@@ -147,6 +168,11 @@ impl EditorState {
        }
    }

+    /// Set the cursor position with appropriate clamping depending on mode.
+    ///
+    /// If `for_edit_mode` is true the cursor may be positioned at the end of
+    /// the text (allowing insertion); otherwise it will be kept within the
+    /// bounds of the existing text for read-only/highlight modes.
    pub(crate) fn set_cursor(
        &mut self,
        position: usize,
--- a/canvas/src/computed/mod.rs
+++ b/canvas/src/computed/mod.rs
@@ -1,5 +1,11 @@
+//! Computed fields subsystem.
+//!
+//! This module exposes the provider trait and the internal state management
+//! for computed (display-only) fields. Computed fields are values derived
+//! from other fields in the form and are not directly editable by the user.
+
 pub mod provider;
 pub mod state;

 pub use provider::{ComputedContext, ComputedProvider};
-pub use state::ComputedState;
+pub use state::ComputedState;
--- a/canvas/src/computed/provider.rs
+++ b/canvas/src/computed/provider.rs
@@ -1,6 +1,7 @@
-// ================================================================================================
-// COMPUTED FIELDS - Provider and Context
-// ================================================================================================
+//! Provider interface and context for computed/display-only fields.
+//!
+//! Implementors provide logic to compute a field's display value from the
+//! other field values in the form.

 /// Context information provided to computed field calculations
 #[derive(Debug, Clone)]
--- a/canvas/src/computed/state.rs
+++ b/canvas/src/computed/state.rs
@@ -1,11 +1,10 @@
-/* file: canvas/src/computed/state.rs */
-/*
-Add computed state module file implementing caching and dependencies
-*/
-
-// ================================================================================================
-// COMPUTED FIELDS - State: caching and dependencies
-// ================================================================================================
+// src/computed/state.rs
+//! Computed field state: caching and dependency graph.
+//!
+//! This module holds the internal state necessary to track which fields are
+//! computed, their dependencies, and cached computed values. It is used by the
+//! editor to avoid unnecessary recomputation and to present computed fields as
+//! read-only.

 use std::collections::{HashMap, HashSet};

@@ -85,4 +84,4 @@ impl Default for ComputedState {
    fn default() -> Self {
        Self::new()
    }
-}
+}
--- a/canvas/src/editor/core.rs
+++ b/canvas/src/editor/core.rs
@@ -9,6 +9,10 @@ use crate::DataProvider;
 #[cfg(feature = "suggestions")]
 use crate::SuggestionItem;

+// NEW: Import keymap types when keymap feature is enabled
+#[cfg(feature = "keymap")]
+use crate::keymap::{CanvasKeyMap, KeySequenceTracker};
+
 pub struct FormEditor<D: DataProvider> {
    pub(crate) ui_state: EditorState,
    pub(crate) data_provider: D,
@@ -23,6 +27,12 @@ pub struct FormEditor<D: DataProvider> {
                + Sync,
        >,
    >,
+
+    // NEW: Injected keymap and sequence tracker (keymap feature only)
+    #[cfg(feature = "keymap")]
+    pub(crate) keymap: Option<CanvasKeyMap>,
+    #[cfg(feature = "keymap")]
+    pub(crate) seq_tracker: KeySequenceTracker,
 }

 impl<D: DataProvider> FormEditor<D> {
@@ -47,6 +57,11 @@ impl<D: DataProvider> FormEditor<D> {
            suggestions: Vec::new(),
            #[cfg(feature = "validation")]
            external_validation_callback: None,
+            // NEW: Initialize keymap fields
+            #[cfg(feature = "keymap")]
+            keymap: None,
+            #[cfg(feature = "keymap")]
+            seq_tracker: KeySequenceTracker::new(400), // 400ms default timeout
        };

        #[cfg(feature = "validation")]
@@ -70,6 +85,26 @@ impl<D: DataProvider> FormEditor<D> {
        }
    }

+    // NEW: Keymap management methods (keymap feature only)
+    
+    /// Set the keymap for this editor instance
+    #[cfg(feature = "keymap")]
+    pub fn set_keymap(&mut self, keymap: CanvasKeyMap) {
+        self.keymap = Some(keymap);
+    }
+
+    /// Check if this editor has a keymap configured
+    #[cfg(feature = "keymap")]
+    pub fn has_keymap(&self) -> bool {
+        self.keymap.is_some()
+    }
+
+    /// Set the timeout for multi-key sequences (in milliseconds)
+    #[cfg(feature = "keymap")]
+    pub fn set_key_sequence_timeout_ms(&mut self, timeout_ms: u64) {
+        self.seq_tracker = KeySequenceTracker::new(timeout_ms);
+    }
+
    // Library-internal, used by multiple modules
    pub(crate) fn current_text(&self) -> &str {
        let field_index = self.ui_state.current_field;
--- a/canvas/src/editor/key_input.rs
+++ b/canvas/src/editor/key_input.rs
@@ -0,0 +1,228 @@
+// src/editor/key_input.rs
+use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+
+use crate::canvas::modes::AppMode;
+use crate::editor::FormEditor;
+use crate::DataProvider;
+
+#[cfg(feature = "keymap")]
+use crate::keymap::{KeyEventOutcome, KeyStroke};
+
+impl<D: DataProvider> FormEditor<D> {
+    #[cfg(feature = "keymap")]
+    pub fn handle_key_event(&mut self, evt: KeyEvent) -> KeyEventOutcome {
+        // Check if keymap exists first
+        if self.keymap.is_none() {
+            return KeyEventOutcome::NotMatched;
+        }
+
+        let mode = self.ui_state.current_mode;
+
+        // Convert event to normalized stroke
+        let stroke = KeyStroke {
+            code: evt.code,
+            modifiers: evt.modifiers,
+        };
+
+        // Add key to sequence tracker
+        self.seq_tracker.add_key(stroke);
+
+        // Look up the action in keymap
+        let (matched, is_prefix) = {
+            let km = self.keymap.as_ref().unwrap();
+            km.lookup(mode, self.seq_tracker.sequence())
+        };
+
+        if let Some(action) = matched {
+            // Clone the action string to avoid borrow checker issues
+            let action_owned = action.to_string();
+            let msg = self.dispatch_canvas_action(&action_owned);
+            self.seq_tracker.reset();
+            return KeyEventOutcome::Consumed(msg);
+        }
+
+        if is_prefix {
+            // Wait for more keys
+            return KeyEventOutcome::Pending;
+        }
+
+        // No match: reset sequence and try insert-char fallback in Edit
+        self.seq_tracker.reset();
+
+        if mode == AppMode::Edit {
+            if let KeyCode::Char(c) = evt.code {
+                // Skip control/alt combos
+                let m = evt.modifiers;
+                let is_plain =
+                    m.is_empty() || m == KeyModifiers::SHIFT;
+                if is_plain {
+                    if self.insert_char(c).is_ok() {
+                        return KeyEventOutcome::Consumed(None);
+                    }
+                }
+            }
+        }
+
+        KeyEventOutcome::NotMatched
+    }
+
+    #[cfg(feature = "keymap")]
+    fn dispatch_canvas_action(&mut self, action: &str) -> Option<String> {
+        match action {
+            // Movement
+            "move_left" => {
+                let _ = self.move_left();
+                None
+            }
+            "move_right" => {
+                let _ = self.move_right();
+                None
+            }
+            "move_up" => {
+                let _ = self.move_up();
+                None
+            }
+            "move_down" => {
+                let _ = self.move_down();
+                None
+            }
+            "next_field" => {
+                let _ = self.next_field();
+                None
+            }
+            "prev_field" => {
+                let _ = self.prev_field();
+                None
+            }
+            "move_line_start" => {
+                self.move_line_start();
+                None
+            }
+            "move_line_end" => {
+                self.move_line_end();
+                None
+            }
+            "move_first_line" => {
+                let _ = self.move_first_line();
+                None
+            }
+            "move_last_line" => {
+                let _ = self.move_last_line();
+                None
+            }
+
+            // Word/big-word movement (cross-field aware)
+            "move_word_next" => {
+                self.move_word_next();
+                None
+            }
+            "move_word_prev" => {
+                self.move_word_prev();
+                None
+            }
+            "move_word_end" => {
+                self.move_word_end();
+                None
+            }
+            "move_word_end_prev" => {
+                self.move_word_end_prev();
+                None
+            }
+            "move_big_word_next" => {
+                self.move_big_word_next();
+                None
+            }
+            "move_big_word_prev" => {
+                self.move_big_word_prev();
+                None
+            }
+            "move_big_word_end" => {
+                self.move_big_word_end();
+                None
+            }
+            "move_big_word_end_prev" => {
+                self.move_big_word_end_prev();
+                None
+            }
+
+            // Editing
+            "delete_char_backward" => {
+                let _ = self.delete_backward();
+                None
+            }
+            "delete_char_forward" => {
+                let _ = self.delete_forward();
+                None
+            }
+            "open_line_below" => {
+                let _ = self.open_line_below();
+                None
+            }
+            "open_line_above" => {
+                let _ = self.open_line_above();
+                None
+            }
+
+            // Suggestions (only when feature is enabled)
+            #[cfg(feature = "suggestions")]
+            "open_suggestions" => {
+                let idx = self.current_field();
+                self.open_suggestions(idx);
+                None
+            }
+            #[cfg(feature = "suggestions")]
+            "apply_suggestion" | "enter_decider" => {
+                if let Some(_applied) = self.apply_suggestion() {
+                    None
+                } else {
+                    None
+                }
+            }
+            #[cfg(feature = "suggestions")]
+            "suggestion_down" => {
+                self.suggestions_next();
+                None
+            }
+            #[cfg(feature = "suggestions")]
+            "suggestion_up" => {
+                self.suggestions_prev();
+                None
+            }
+
+            // Mode transitions (vim-like)
+            "enter_edit_mode_before" => {
+                self.enter_edit_mode();
+                None
+            }
+            "enter_edit_mode_after" => {
+                // Move forward 1 char if possible (vim 'a'), then enter insert
+                let txt_len = self.current_text().chars().count();
+                let pos = self.ui_state.cursor_pos;
+                if pos < txt_len {
+                    self.ui_state.cursor_pos = pos + 1;
+                    self.ui_state.ideal_cursor_column = self.ui_state.cursor_pos;
+                }
+                self.enter_edit_mode();
+                None
+            }
+            "exit" | "exit_edit_mode" => {
+                let _ = self.exit_edit_mode();
+                None
+            }
+            "enter_highlight_mode" => {
+                self.enter_highlight_mode();
+                None
+            }
+            "enter_highlight_mode_linewise" => {
+                self.enter_highlight_line_mode();
+                None
+            }
+            "exit_highlight_mode" => {
+                self.exit_highlight_mode();
+                None
+            }
+
+            _ => None,
+        }
+    }
+}
--- a/canvas/src/editor/mod.rs
+++ b/canvas/src/editor/mod.rs
@@ -1,5 +1,9 @@
 // src/editor/mod.rs
-// Only module declarations and re-exports.
+//! Editor submodule exports.
+//!
+//! This module exposes the internal editor pieces (core, editing, movement,
+//! navigation, mode, and optional features like suggestions, validation, and
+//! computed field helpers). Only module declarations and re-exports live here.

 pub mod core;
 pub mod display;
@@ -17,5 +21,8 @@ pub mod validation_helpers;
 #[cfg(feature = "computed")]
 pub mod computed_helpers;

+#[cfg(feature = "keymap")] 
+pub mod key_input;
+
 // Re-export the main type
 pub use core::FormEditor;
--- a/canvas/src/editor/mode.rs
+++ b/canvas/src/editor/mode.rs
@@ -25,7 +25,6 @@ impl<D: DataProvider> FormEditor<D> {
            {
                let _ = CursorManager::update_for_mode(AppMode::Edit);
            }
-            return;
        }

        // Default (not normal): original vim behavior
@@ -119,7 +118,7 @@ impl<D: DataProvider> FormEditor<D> {
            {
                self.close_suggestions();
            }
-            return Ok(());
+            Ok(())
        }

        // Default (not normal): original vim behavior
@@ -155,7 +154,6 @@ impl<D: DataProvider> FormEditor<D> {
            {
                let _ = CursorManager::update_for_mode(AppMode::Edit);
            }
-            return;
        }

        // Default (not normal): vim behavior
@@ -169,7 +167,6 @@ impl<D: DataProvider> FormEditor<D> {
        // NORMALMODE: ignore request (stay in Edit)
        #[cfg(feature = "textmode-normal")]
        {
-            return;
        }

        // Default (not normal): original vim
@@ -193,7 +190,6 @@ impl<D: DataProvider> FormEditor<D> {
        // NORMALMODE: ignore
        #[cfg(feature = "textmode-normal")]
        {
-            return;
        }

        // Default (not normal): original vim
@@ -216,7 +212,6 @@ impl<D: DataProvider> FormEditor<D> {
        // NORMALMODE: ignore
        #[cfg(feature = "textmode-normal")]
        {
-            return;
        }

        // Default (not normal): original vim
@@ -237,7 +232,7 @@ impl<D: DataProvider> FormEditor<D> {
    pub fn is_highlight_mode(&self) -> bool {
        #[cfg(feature = "textmode-normal")]
        {
-            return false;
+            false
        }
        #[cfg(not(feature = "textmode-normal"))]
        {
--- a/canvas/src/editor/movement.rs
+++ b/canvas/src/editor/movement.rs
@@ -46,12 +46,11 @@ impl<D: DataProvider> FormEditor<D> {
            }
        }

-        if !moved {
-            if self.ui_state.cursor_pos > 0 {
+        if !moved
+            && self.ui_state.cursor_pos > 0 {
                self.ui_state.cursor_pos -= 1;
                self.ui_state.ideal_cursor_column = self.ui_state.cursor_pos;
            }
-        }
        Ok(())
    }

@@ -141,7 +140,7 @@ impl<D: DataProvider> FormEditor<D> {
                // Successfully moved to next field, try to find first word
                let new_text = self.current_text();
                if !new_text.is_empty() {
-                    let first_word_pos = if new_text.chars().next().map_or(false, |c| !c.is_whitespace()) {
+                    let first_word_pos = if new_text.chars().next().is_some_and(|c| !c.is_whitespace()) {
                        // Field starts with non-whitespace, go to position 0
                        0
                    } else {
@@ -177,7 +176,7 @@ impl<D: DataProvider> FormEditor<D> {
                    self.ui_state.ideal_cursor_column = 0;
                } else {
                    // Find first word in new field
-                    let first_word_pos = if new_text.chars().next().map_or(false, |c| !c.is_whitespace()) {
+                    let first_word_pos = if new_text.chars().next().is_some_and(|c| !c.is_whitespace()) {
                        // Field starts with non-whitespace, go to position 0
                        0
                    } else {
@@ -419,7 +418,7 @@ impl<D: DataProvider> FormEditor<D> {
                // Successfully moved to next field, try to find first big_word
                let new_text = self.current_text();
                if !new_text.is_empty() {
-                    let first_big_word_pos = if new_text.chars().next().map_or(false, |c| !c.is_whitespace()) {
+                    let first_big_word_pos = if new_text.chars().next().is_some_and(|c| !c.is_whitespace()) {
                        // Field starts with non-whitespace, go to position 0
                        0
                    } else {
@@ -455,7 +454,7 @@ impl<D: DataProvider> FormEditor<D> {
                    self.ui_state.ideal_cursor_column = 0;
                } else {
                    // Find first big_word in new field
-                    let first_big_word_pos = if new_text.chars().next().map_or(false, |c| !c.is_whitespace()) {
+                    let first_big_word_pos = if new_text.chars().next().is_some_and(|c| !c.is_whitespace()) {
                        // Field starts with non-whitespace, go to position 0
                        0
                    } else {
@@ -644,8 +643,8 @@ impl<D: DataProvider> FormEditor<D> {

        if current_text.is_empty() {
            let current_field = self.ui_state.current_field;
-            if self.move_up().is_ok() {
-                if self.ui_state.current_field != current_field {
+            if self.move_up().is_ok()
+                && self.ui_state.current_field != current_field {
                    let new_text = self.current_text();
                    if !new_text.is_empty() {
                        // Find first big_word end in new field
@@ -654,7 +653,6 @@ impl<D: DataProvider> FormEditor<D> {
                        self.ui_state.ideal_cursor_column = last_big_word_end;
                    }
                }
-            }
            return;
        }

@@ -664,8 +662,8 @@ impl<D: DataProvider> FormEditor<D> {
        // Only try to cross fields if we didn't move at all (stayed at same position)
        if new_pos == current_pos {
            let current_field = self.ui_state.current_field;
-            if self.move_up().is_ok() {
-                if self.ui_state.current_field != current_field {
+            if self.move_up().is_ok()
+                && self.ui_state.current_field != current_field {
                    let new_text = self.current_text();
                    if !new_text.is_empty() {
                        let last_big_word_end = find_big_word_end(new_text, 0);
@@ -673,7 +671,6 @@ impl<D: DataProvider> FormEditor<D> {
                        self.ui_state.ideal_cursor_column = last_big_word_end;
                    }
                }
-            }
        } else {
            // Normal big_word movement within current field
            let is_edit_mode = self.ui_state.current_mode == AppMode::Edit;
--- a/canvas/src/editor/suggestions.rs
+++ b/canvas/src/editor/suggestions.rs
@@ -133,6 +133,21 @@ impl<D: DataProvider> FormEditor<D> {
        self.update_inline_completion();
    }

+    pub fn suggestions_prev(&mut self) {
+        if !self.ui_state.suggestions.is_active || self.suggestions.is_empty() {
+            return;
+        }
+
+        let current = self.ui_state.suggestions.selected_index.unwrap_or(0);
+        let prev = if current == 0 {
+            self.suggestions.len() - 1
+        } else {
+            current - 1
+        };
+        self.ui_state.suggestions.selected_index = Some(prev);
+        self.update_inline_completion();
+    }
+
    pub fn apply_suggestion(&mut self) -> Option<String> {
        if let Some(selected_index) = self.ui_state.suggestions.selected_index {
            if let Some(suggestion) = self.suggestions.get(selected_index).cloned()
--- a/canvas/src/keymap/mod.rs
+++ b/canvas/src/keymap/mod.rs
@@ -0,0 +1,344 @@
+// src/keymap/mod.rs
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+use crossterm::event::{KeyCode, KeyModifiers};
+
+use crate::canvas::modes::AppMode;
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct KeyStroke {
+    pub code: KeyCode,
+    pub modifiers: KeyModifiers,
+}
+
+#[derive(Clone, Debug)]
+struct Binding {
+    action: String,
+    sequence: Vec<KeyStroke>,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct CanvasKeyMap {
+    ro: Vec<Binding>,
+    edit: Vec<Binding>,
+    hl: Vec<Binding>,
+}
+
+// FIXED: Removed Copy because Option<String> is not Copy
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum KeyEventOutcome {
+    Consumed(Option<String>),
+    Pending,
+    NotMatched,
+}
+
+#[derive(Debug, Clone)]
+pub struct KeySequenceTracker {
+    sequence: Vec<KeyStroke>,
+    last_key_time: Instant,
+    timeout: Duration,
+}
+
+impl KeySequenceTracker {
+    pub fn new(timeout_ms: u64) -> Self {
+        Self {
+            sequence: Vec::new(),
+            last_key_time: Instant::now(),
+            timeout: Duration::from_millis(timeout_ms),
+        }
+    }
+
+    pub fn reset(&mut self) {
+        self.sequence.clear();
+        self.last_key_time = Instant::now();
+    }
+
+    pub fn add_key(&mut self, stroke: KeyStroke) {
+        let now = Instant::now();
+        if now.duration_since(self.last_key_time) > self.timeout {
+            self.reset();
+        }
+        self.sequence.push(normalize_stroke(stroke));
+        self.last_key_time = now;
+    }
+
+    pub fn sequence(&self) -> &[KeyStroke] {
+        &self.sequence
+    }
+}
+
+fn normalize_stroke(mut s: KeyStroke) -> KeyStroke {
+    // Normalize Shift+Tab to BackTab
+    let is_shift_tab =
+        s.code == KeyCode::Tab && s.modifiers.contains(KeyModifiers::SHIFT);
+    if is_shift_tab {
+        s.code = KeyCode::BackTab;
+        s.modifiers.remove(KeyModifiers::SHIFT);
+        return s;
+    }
+
+    // Normalize Shift+char to uppercase char without SHIFT when possible
+    if let KeyCode::Char(c) = s.code {
+        if s.modifiers.contains(KeyModifiers::SHIFT) {
+            let mut up = c;
+            // Only letters transform meaningfully
+            if c.is_ascii_alphabetic() {
+                up = c.to_ascii_uppercase();
+            }
+            s.code = KeyCode::Char(up);
+            s.modifiers.remove(KeyModifiers::SHIFT);
+            return s;
+        }
+    }
+    s
+}
+
+impl CanvasKeyMap {
+    pub fn from_mode_maps(
+        read_only: &HashMap<String, Vec<String>>,
+        edit: &HashMap<String, Vec<String>>,
+        highlight: &HashMap<String, Vec<String>>,
+    ) -> Self {
+        let mut km = Self::default();
+        km.ro = collect_bindings(read_only);
+        km.edit = collect_bindings(edit);
+        km.hl = collect_bindings(highlight);
+        km
+    }
+
+    pub fn lookup(
+        &self,
+        mode: AppMode,
+        seq: &[KeyStroke],
+    ) -> (Option<&str>, bool) {
+        let bindings = match mode {
+            AppMode::ReadOnly => &self.ro,
+            AppMode::Edit => &self.edit,
+            AppMode::Highlight => &self.hl,
+            _ => return (None, false),
+        };
+
+        if seq.is_empty() {
+            return (None, false);
+        }
+
+        // Exact match
+        for b in bindings {
+            if sequences_equal(&b.sequence, seq) {
+                return (Some(b.action.as_str()), false);
+            }
+        }
+
+        // Prefix match
+        for b in bindings {
+            if is_prefix(&b.sequence, seq) {
+                return (None, true);
+            }
+        }
+
+        (None, false)
+    }
+}
+
+fn sequences_equal(a: &[KeyStroke], b: &[KeyStroke]) -> bool {
+    if a.len() != b.len() {
+        return false;
+    }
+    a.iter().zip(b.iter()).all(|(x, y)| strokes_equal(x, y))
+}
+
+fn strokes_equal(a: &KeyStroke, b: &KeyStroke) -> bool {
+    // Both KeyStroke are already normalized
+    a.code == b.code && a.modifiers == b.modifiers
+}
+
+fn is_prefix(binding: &[KeyStroke], seq: &[KeyStroke]) -> bool {
+    if seq.len() >= binding.len() {
+        return false;
+    }
+    binding
+        .iter()
+        .zip(seq.iter())
+        .all(|(b, s)| strokes_equal(b, s))
+}
+
+fn collect_bindings(
+    mode_map: &HashMap<String, Vec<String>>,
+) -> Vec<Binding> {
+    let mut out = Vec::new();
+    for (action, list) in mode_map {
+        for binding_str in list {
+            if let Some(seq) = parse_binding_to_sequence(binding_str) {
+                out.push(Binding {
+                    action: action.to_string(),
+                    sequence: seq,
+                });
+            }
+        }
+    }
+    out
+}
+
+fn parse_binding_to_sequence(input: &str) -> Option<Vec<KeyStroke>> {
+    let s = input.trim();
+    if s.is_empty() {
+        return None;
+    }
+
+    let has_space = s.contains(' ');
+    let has_plus = s.contains('+');
+
+    if has_space {
+        let mut seq = Vec::new();
+        for part in s.split_whitespace() {
+            if let Some(mut strokes) = parse_part_to_sequence(part) {
+                seq.append(&mut strokes);
+            } else {
+                return None;
+            }
+        }
+        return Some(seq);
+    }
+
+    if has_plus {
+        if contains_modifier_token(s) {
+            if let Some(k) = parse_chord_with_modifiers(s) {
+                return Some(vec![k]);
+            }
+            return None;
+        } else {
+            let mut seq = Vec::new();
+            for t in s.split('+') {
+                if let Some(mut strokes) = parse_part_to_sequence(t) {
+                    seq.append(&mut strokes);
+                } else {
+                    return None;
+                }
+            }
+            return Some(seq);
+        }
+    }
+
+    if is_compound_key(s) {
+        if let Some(k) = parse_simple_key(s) {
+            return Some(vec![k]);
+        }
+        return None;
+    }
+
+    if s.len() > 1 {
+        let mut seq = Vec::new();
+        for ch in s.chars() {
+            seq.push(KeyStroke {
+                code: KeyCode::Char(ch),
+                modifiers: KeyModifiers::empty(),
+            });
+        }
+        return Some(seq);
+    }
+
+    if let Some(k) = parse_simple_key(s) {
+        return Some(vec![k]);
+    }
+    None
+}
+
+fn parse_part_to_sequence(part: &str) -> Option<Vec<KeyStroke>> {
+    let p = part.trim();
+    if p.is_empty() {
+        return None;
+    }
+
+    if p.contains('+') && contains_modifier_token(p) {
+        if let Some(k) = parse_chord_with_modifiers(p) {
+            return Some(vec![k]);
+        }
+        return None;
+    }
+
+    if is_compound_key(p) {
+        if let Some(k) = parse_simple_key(p) {
+            return Some(vec![k]);
+        }
+        return None;
+    }
+
+    if p.len() > 1 {
+        let mut seq = Vec::new();
+        for ch in p.chars() {
+            seq.push(KeyStroke {
+                code: KeyCode::Char(ch),
+                modifiers: KeyModifiers::empty(),
+            });
+        }
+        return Some(seq);
+    }
+
+    parse_simple_key(p).map(|k| vec![k])
+}
+
+fn contains_modifier_token(s: &str) -> bool {
+    let low = s.to_lowercase();
+    low.contains("ctrl") || low.contains("shift") || low.contains("alt") || 
+    low.contains("super") || low.contains("cmd") || low.contains("meta")
+}
+
+fn parse_chord_with_modifiers(s: &str) -> Option<KeyStroke> {
+    let mut mods = KeyModifiers::empty();
+    let mut key: Option<KeyCode> = None;
+
+    for comp in s.split('+') {
+        match comp.to_lowercase().as_str() {
+            "ctrl" => mods |= KeyModifiers::CONTROL,
+            "shift" => mods |= KeyModifiers::SHIFT,
+            "alt" => mods |= KeyModifiers::ALT,
+            "super" | "cmd" => mods |= KeyModifiers::SUPER,
+            "meta" => mods |= KeyModifiers::META,
+            other => {
+                key = string_to_keycode(other);
+            }
+        }
+    }
+
+    key.map(|k| normalize_stroke(KeyStroke { code: k, modifiers: mods }))
+}
+
+fn is_compound_key(s: &str) -> bool {
+    matches!(s.to_lowercase().as_str(),
+        "left" | "right" | "up" | "down" | "esc" | "enter" | "backspace" | 
+        "delete" | "tab" | "home" | "end" | "$" | "0"
+    )
+}
+
+fn parse_simple_key(s: &str) -> Option<KeyStroke> {
+    if let Some(kc) = string_to_keycode(&s.to_lowercase()) {
+        return Some(KeyStroke { code: kc, modifiers: KeyModifiers::empty() });
+    }
+
+    if s.chars().count() == 1 {
+        let ch = s.chars().next().unwrap();
+        return Some(KeyStroke { code: KeyCode::Char(ch), modifiers: KeyModifiers::empty() });
+    }
+
+    None
+}
+
+fn string_to_keycode(s: &str) -> Option<KeyCode> {
+    Some(match s {
+        "left" => KeyCode::Left,
+        "right" => KeyCode::Right, 
+        "up" => KeyCode::Up,
+        "down" => KeyCode::Down,
+        "esc" => KeyCode::Esc,
+        "enter" => KeyCode::Enter,
+        "backspace" => KeyCode::Backspace,
+        "delete" => KeyCode::Delete,
+        "tab" => KeyCode::Tab,
+        "home" => KeyCode::Home,
+        "end" => KeyCode::End,
+        "$" => KeyCode::Char('$'),
+        "0" => KeyCode::Char('0'),
+        _ => return None,
+    })
+}
--- a/canvas/src/lib.rs
+++ b/canvas/src/lib.rs
@@ -4,22 +4,21 @@ pub mod canvas;
 pub mod editor;
 pub mod data_provider;

-// Only include suggestions module if feature is enabled
 #[cfg(feature = "suggestions")]
 pub mod suggestions;

-// Only include validation module if feature is enabled
 #[cfg(feature = "validation")]
 pub mod validation;

-// First-class textarea module and exports
 #[cfg(feature = "textarea")]
 pub mod textarea;

-// Only include computed module if feature is enabled
 #[cfg(feature = "computed")]
 pub mod computed;

+#[cfg(feature = "keymap")]
+pub mod keymap;
+
 #[cfg(feature = "cursor-style")]
 pub use canvas::CursorManager;

@@ -71,6 +70,8 @@ pub use canvas::gui::{CanvasDisplayOptions, OverflowMode};
 #[cfg(all(feature = "gui", feature = "suggestions"))]
 pub use suggestions::gui::render_suggestions_dropdown;

+#[cfg(feature = "keymap")]
+pub use keymap::{CanvasKeyMap, KeyEventOutcome};

 #[cfg(feature = "textarea")]
 pub use textarea::{TextArea, TextAreaProvider, TextAreaState, TextAreaEditor};
--- a/canvas/src/suggestions/gui.rs
+++ b/canvas/src/suggestions/gui.rs
@@ -149,9 +149,6 @@ fn calculate_dropdown_position(
    if dropdown_area.right() > frame_area.width {
        dropdown_area.x = frame_area.width.saturating_sub(dropdown_width);
    }
-    dropdown_area.x = dropdown_area.x.max(0);
-    dropdown_area.y = dropdown_area.y.max(0);
-
    dropdown_area
 }

--- a/canvas/src/suggestions/mod.rs
+++ b/canvas/src/suggestions/mod.rs
@@ -1,4 +1,8 @@
 // src/suggestions/mod.rs
+//! Suggestions subsystem - provider and optional GUI.
+//!
+//! Contains the suggestion provider types used by the editor and, when the GUI
+//! feature is enabled, the rendering helpers for the suggestions dropdown.

 pub mod state;
 #[cfg(feature = "gui")]
--- a/canvas/src/textarea/highlight/chunks.rs
+++ b/canvas/src/textarea/highlight/chunks.rs
@@ -0,0 +1,183 @@
+// src/textarea/highlight/chunks.rs
+use ratatui::text::{Line, Span};
+use ratatui::style::Style;
+use unicode_width::UnicodeWidthChar;
+
+#[derive(Debug, Clone)]
+pub struct StyledChunk {
+    pub text: String,
+    pub style: Style,
+}
+
+pub fn display_width_chunks(chunks: &[StyledChunk]) -> u16 {
+    chunks
+        .iter()
+        .map(|c| {
+            c.text
+                .chars()
+                .map(|ch| UnicodeWidthChar::width(ch).unwrap_or(0) as u16)
+                .sum::<u16>()
+        })
+        .sum()
+}
+
+pub fn slice_chunks_by_display_cols(
+    chunks: &[StyledChunk],
+    start_cols: u16,
+    max_cols: u16,
+) -> Vec<StyledChunk> {
+    if max_cols == 0 {
+        return Vec::new();
+    }
+
+    let mut skipped: u16 = 0;
+    let mut taken: u16 = 0;
+    let mut out: Vec<StyledChunk> = Vec::new();
+
+    for ch in chunks {
+        if taken >= max_cols {
+            break;
+        }
+
+        let mut acc = String::new();
+
+        for c in ch.text.chars() {
+            let w = UnicodeWidthChar::width(c).unwrap_or(0) as u16;
+            if skipped + w <= start_cols {
+                skipped += w;
+                continue;
+            }
+            if taken + w > max_cols {
+                break;
+            }
+            acc.push(c);
+            taken = taken.saturating_add(w);
+            if taken >= max_cols {
+                break;
+            }
+        }
+
+        if !acc.is_empty() {
+            out.push(StyledChunk {
+                text: acc,
+                style: ch.style,
+            });
+        }
+    }
+
+    out
+}
+
+pub fn clip_chunks_window_with_indicator_padded(
+    chunks: &[StyledChunk],
+    view_width: u16,
+    indicator: char,
+    start_cols: u16,
+) -> Line<'static> {
+    if view_width == 0 {
+        return Line::from("");
+    }
+
+    let total = display_width_chunks(chunks);
+    let show_left = start_cols > 0;
+    let left_cols: u16 = if show_left { 1 } else { 0 };
+
+    let cap_with_right = view_width.saturating_sub(left_cols + 1);
+    let remaining = total.saturating_sub(start_cols);
+    let show_right = remaining > cap_with_right;
+
+    let max_visible = if show_right {
+        cap_with_right
+    } else {
+        view_width.saturating_sub(left_cols)
+    };
+
+    let visible = slice_chunks_by_display_cols(chunks, start_cols, max_visible);
+    let used_cols = left_cols + display_width_chunks(&visible);
+
+    let mut spans: Vec<Span> = Vec::new();
+    if show_left {
+        spans.push(Span::raw(indicator.to_string()));
+    }
+    for v in visible {
+        spans.push(Span::styled(v.text, v.style));
+    }
+    if show_right {
+        let right_pos = view_width.saturating_sub(1);
+        let filler = right_pos.saturating_sub(used_cols);
+        if filler > 0 {
+            spans.push(Span::raw(" ".repeat(filler as usize)));
+        }
+        spans.push(Span::raw(indicator.to_string()));
+    }
+
+    Line::from(spans)
+}
+
+pub fn wrap_chunks_indented(
+    chunks: &[StyledChunk],
+    width: u16,
+    indent: u16,
+) -> Vec<Line<'static>> {
+    if width == 0 {
+        return vec![Line::from("")];
+    }
+    let indent = indent.min(width.saturating_sub(1));
+    let cont_cap = width.saturating_sub(indent);
+    let indent_str = " ".repeat(indent as usize);
+
+    let mut lines: Vec<Line> = Vec::new();
+    let mut current_spans: Vec<Span> = Vec::new();
+    let mut used: u16 = 0;
+    let mut first_line = true;
+
+    // Fixed: Restructure to avoid borrow checker issues
+    for chunk in chunks {
+        let mut buf = String::new();
+        let mut buf_style = chunk.style;
+
+        for ch in chunk.text.chars() {
+            let w = UnicodeWidthChar::width(ch).unwrap_or(0) as u16;
+            let cap = if first_line { width } else { cont_cap };
+
+            if used > 0 && used.saturating_add(w) >= cap {
+                if !buf.is_empty() {
+                    current_spans.push(Span::styled(buf.clone(), buf_style));
+                    buf.clear();
+                }
+                lines.push(Line::from(current_spans));
+                current_spans = Vec::new();
+                first_line = false;
+                used = 0;
+                
+                // Add indent directly instead of using closure
+                if !first_line && indent > 0 {
+                    current_spans.push(Span::raw(indent_str.clone()));
+                    used = indent;
+                }
+            }
+
+            if !buf.is_empty() && buf_style != chunk.style {
+                current_spans.push(Span::styled(buf.clone(), buf_style));
+                buf.clear();
+            }
+            buf_style = chunk.style;
+            
+            // Add indent if needed
+            if used == 0 && !first_line && indent > 0 {
+                current_spans.push(Span::raw(indent_str.clone()));
+                used = indent;
+            }
+            
+            buf.push(ch);
+            used = used.saturating_add(w);
+        }
+
+        if !buf.is_empty() {
+            current_spans.push(Span::styled(buf, buf_style));
+        }
+    }
+
+    lines.push(Line::from(current_spans));
+    lines
+}
--- a/canvas/src/textarea/highlight/engine.rs
+++ b/canvas/src/textarea/highlight/engine.rs
@@ -0,0 +1,294 @@
+// src/textarea/highlight/engine.rs
+#![allow(dead_code)]
+
+use std::collections::hash_map::DefaultHasher;
+use std::hash::{Hash, Hasher};
+
+use ratatui::style::{Modifier, Style};
+use syntect::{
+    highlighting::{
+        HighlightIterator, HighlightState, Highlighter, Style as SynStyle, Theme, ThemeSet,
+    },
+    parsing::{ParseState, ScopeStack, SyntaxReference, SyntaxSet},
+};
+
+use crate::data_provider::DataProvider;
+use super::chunks::StyledChunk;
+
+#[derive(Debug)]
+pub struct SyntectEngine {
+    ps: SyntaxSet,
+    ts: ThemeSet,
+    theme_name: String,
+    syntax_name: Option<String>,
+    // Cached parser state (after line i)
+    parse_after: Vec<ParseState>,
+    // Cached scope stack (after line i)
+    stack_after: Vec<ScopeStack>,
+    // Hash of line contents to detect edits
+    line_hashes: Vec<u64>,
+}
+
+impl Default for SyntectEngine {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl SyntectEngine {
+    pub fn new() -> Self {
+        let ps = SyntaxSet::load_defaults_newlines();
+        let ts = ThemeSet::load_defaults();
+        Self {
+            ps,
+            ts,
+            theme_name: "InspiredGitHub".to_string(),
+            syntax_name: None,
+            parse_after: Vec::new(),
+            stack_after: Vec::new(),
+            line_hashes: Vec::new(),
+        }
+    }
+
+    pub fn clear(&mut self) {
+        self.parse_after.clear();
+        self.stack_after.clear();
+        self.line_hashes.clear();
+    }
+
+    pub fn set_theme(&mut self, theme_name: &str) -> bool {
+        if self.ts.themes.contains_key(theme_name) {
+            self.theme_name = theme_name.to_string();
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn set_syntax_by_name(&mut self, name: &str) -> bool {
+        if self.ps.find_syntax_by_name(name).is_some() {
+            self.syntax_name = Some(name.to_string());
+            self.clear();
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn set_syntax_by_extension(&mut self, ext: &str) -> bool {
+        if let Some(s) = self.ps.find_syntax_by_extension(ext) {
+            self.syntax_name = Some(s.name.clone());
+            self.clear();
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn invalidate_from(&mut self, line_idx: usize) {
+        if line_idx < self.parse_after.len() {
+            self.parse_after.truncate(line_idx);
+        }
+        if line_idx < self.stack_after.len() {
+            self.stack_after.truncate(line_idx);
+        }
+        if line_idx < self.line_hashes.len() {
+            self.line_hashes.truncate(line_idx);
+        }
+    }
+
+    pub fn on_insert_line(&mut self, at: usize) {
+        self.invalidate_from(at);
+    }
+
+    pub fn on_delete_line(&mut self, at: usize) {
+        self.invalidate_from(at);
+    }
+
+    fn theme(&self) -> &Theme {
+        self.ts
+            .themes
+            .get(&self.theme_name)
+            .expect("theme exists")
+    }
+
+    fn syntax_ref(&self) -> &SyntaxReference {
+        if let Some(name) = &self.syntax_name {
+            if let Some(s) = self.ps.find_syntax_by_name(name) {
+                return s;
+            }
+        }
+        self.ps.find_syntax_plain_text()
+    }
+
+    fn map_syntect_style(s: SynStyle) -> Style {
+        let fg =
+            ratatui::style::Color::Rgb(s.foreground.r, s.foreground.g, s.foreground.b);
+        let mut st = Style::default().fg(fg);
+        use syntect::highlighting::FontStyle;
+        if s.font_style.contains(FontStyle::BOLD) {
+            st = st.add_modifier(Modifier::BOLD);
+        }
+        if s.font_style.contains(FontStyle::UNDERLINE) {
+            st = st.add_modifier(Modifier::UNDERLINED);
+        }
+        if s.font_style.contains(FontStyle::ITALIC) {
+            st = st.add_modifier(Modifier::ITALIC);
+        }
+        st
+    }
+
+    fn hash_line(s: &str) -> u64 {
+        let mut h = DefaultHasher::new();
+        s.hash(&mut h);
+        h.finish()
+    }
+
+    // Verify cached chain up to the nearest trusted predecessor of line_idx,
+    // using the provider to fetch the current lines.
+    fn verify_and_truncate_before(&mut self, line_idx: usize, provider: &dyn DataProvider) {
+        let mut k = std::cmp::min(line_idx, self.parse_after.len());
+        while k > 0 {
+            let j = k - 1;
+            let curr = Self::hash_line(provider.field_value(j));
+            if self.line_hashes.get(j) == Some(&curr) {
+                break;
+            }
+            self.invalidate_from(j);
+            k = j;
+        }
+    }
+
+    // Ensure we have parser + stack for lines [0..line_idx)
+    fn ensure_state_before(&mut self, line_idx: usize, provider: &dyn DataProvider) {
+        if line_idx == 0 || self.parse_after.len() >= line_idx {
+            return;
+        }
+
+        let syntax = self.syntax_ref();
+        let theme = self.theme().clone(); // Clone to avoid borrow conflicts
+        let highlighter = Highlighter::new(&theme);
+
+        let mut ps = if self.parse_after.is_empty() {
+            ParseState::new(syntax)
+        } else {
+            self.parse_after[self.parse_after.len() - 1].clone()
+        };
+        let mut stack = if self.stack_after.is_empty() {
+            ScopeStack::new()
+        } else {
+            self.stack_after[self.stack_after.len() - 1].clone()
+        };
+
+        let start = self.parse_after.len();
+        for i in start..line_idx {
+            let s = provider.field_value(i);
+            
+            // Fix: parse_line takes 2 arguments: line and &SyntaxSet
+            let ops = ps.parse_line(s, &self.ps).unwrap_or_default();
+            
+            // Fix: HighlightState::new requires &Highlighter and ScopeStack
+            let mut highlight_state = HighlightState::new(&highlighter, stack.clone());
+            
+            // Fix: HighlightIterator::new expects &mut HighlightState as first parameter
+            let it = HighlightIterator::new(&mut highlight_state, &ops[..], s, &highlighter);
+            for (_style, _text) in it {
+                // Iterate to apply ops; we don't need the tokens here.
+            }
+            
+            // Update the stack from the highlight state
+            stack = highlight_state.path.clone();
+
+            let h = Self::hash_line(s);
+
+            self.parse_after.push(ps.clone());
+            self.stack_after.push(stack.clone());
+            if i >= self.line_hashes.len() {
+                self.line_hashes.push(h);
+            } else {
+                self.line_hashes[i] = h;
+            }
+        }
+    }
+
+    // Highlight a single line using cached state; update caches for this line.
+    pub fn highlight_line_cached(
+        &mut self,
+        line_idx: usize,
+        line: &str,
+        provider: &dyn DataProvider,
+    ) -> Vec<StyledChunk> {
+        // Auto-detect prior changes and truncate cache if needed
+        self.verify_and_truncate_before(line_idx, provider);
+        // Precompute states up to line_idx
+        self.ensure_state_before(line_idx, provider);
+
+        let syntax = self.syntax_ref();
+        let theme = self.theme().clone(); // Clone to avoid borrow conflicts
+        let highlighter = Highlighter::new(&theme);
+
+        let mut ps = if line_idx == 0 {
+            ParseState::new(syntax)
+        } else if self.parse_after.len() >= line_idx {
+            self.parse_after[line_idx - 1].clone()
+        } else {
+            ParseState::new(syntax)
+        };
+
+        let stack = if line_idx == 0 {
+            ScopeStack::new()
+        } else if self.stack_after.len() >= line_idx {
+            self.stack_after[line_idx - 1].clone()
+        } else {
+            ScopeStack::new()
+        };
+
+        // Fix: parse_line takes 2 arguments: line and &SyntaxSet
+        let ops = ps.parse_line(line, &self.ps).unwrap_or_default();
+        
+        // Fix: HighlightState::new requires &Highlighter and ScopeStack
+        let mut highlight_state = HighlightState::new(&highlighter, stack);
+        
+        // Fix: HighlightIterator::new expects &mut HighlightState as first parameter
+        let iter = HighlightIterator::new(&mut highlight_state, &ops[..], line, &highlighter);
+
+        let mut out: Vec<StyledChunk> = Vec::new();
+        for (syn_style, slice) in iter {
+            if slice.is_empty() {
+                continue;
+            }
+            let text = slice.trim_end_matches('\n').to_string();
+            if text.is_empty() {
+                continue;
+            }
+            out.push(StyledChunk {
+                text,
+                style: Self::map_syntect_style(syn_style),
+            });
+        }
+
+        // Update caches for this line (state after this line)
+        let h = Self::hash_line(line);
+        if line_idx >= self.parse_after.len() {
+            self.parse_after.push(ps);
+        } else {
+            self.parse_after[line_idx] = ps;
+        }
+        
+        // Update stack from highlight state
+        let final_stack = highlight_state.path.clone();
+        if line_idx >= self.stack_after.len() {
+            self.stack_after.push(final_stack);
+        } else {
+            self.stack_after[line_idx] = final_stack;
+        }
+        
+        if line_idx >= self.line_hashes.len() {
+            self.line_hashes.push(h);
+        } else {
+            self.line_hashes[line_idx] = h;
+        }
+
+        out
+    }
+}
--- a/canvas/src/textarea/highlight/mod.rs
+++ b/canvas/src/textarea/highlight/mod.rs
@@ -0,0 +1,18 @@
+// src/textarea/highlight/mod.rs
+#[cfg(all(feature = "syntect", feature = "gui"))]
+pub mod engine;
+#[cfg(all(feature = "syntect", feature = "gui"))]
+pub mod chunks;
+#[cfg(all(feature = "syntect", feature = "gui"))]
+pub mod state;
+#[cfg(all(feature = "syntect", feature = "gui"))]
+pub mod widget;
+
+#[cfg(all(feature = "syntect", feature = "gui"))]
+pub use engine::SyntectEngine;
+#[cfg(all(feature = "syntect", feature = "gui"))]
+pub use chunks::StyledChunk;
+#[cfg(all(feature = "syntect", feature = "gui"))]
+pub use state::TextAreaSyntaxState;
+#[cfg(all(feature = "syntect", feature = "gui"))]
+pub use widget::TextAreaSyntax;
--- a/canvas/src/textarea/highlight/state.rs
+++ b/canvas/src/textarea/highlight/state.rs
@@ -0,0 +1,45 @@
+// src/textarea/highlight/state.rs
+use std::ops::{Deref, DerefMut};
+
+use super::engine::SyntectEngine;
+use crate::textarea::state::TextAreaState;
+
+// Remove Debug derive since TextAreaState doesn't implement Debug
+#[derive(Default)]
+pub struct TextAreaSyntaxState {
+    pub textarea: TextAreaState,
+    pub engine: SyntectEngine,
+}
+
+impl TextAreaSyntaxState {
+    pub fn from_text<S: Into<String>>(text: S) -> Self {
+        let mut s = Self::default();
+        s.textarea.set_text(text);
+        s
+    }
+
+    // Optional: convenience setters
+    pub fn set_syntax_theme(&mut self, theme: &str) -> bool {
+        self.engine.set_theme(theme)
+    }
+    pub fn set_syntax_by_name(&mut self, name: &str) -> bool {
+        self.engine.set_syntax_by_name(name)
+    }
+    pub fn set_syntax_by_extension(&mut self, ext: &str) -> bool {
+        self.engine.set_syntax_by_extension(ext)
+    }
+}
+
+impl Deref for TextAreaSyntaxState {
+    type Target = TextAreaState;
+    fn deref(&self) -> &Self::Target {
+        &self.textarea
+    }
+}
+
+impl DerefMut for TextAreaSyntaxState {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.textarea
+    }
+}
+
--- a/canvas/src/textarea/highlight/widget.rs
+++ b/canvas/src/textarea/highlight/widget.rs
@@ -0,0 +1,211 @@
+// src/textarea/highlight/widget.rs
+use ratatui::{
+    buffer::Buffer,
+    layout::{Alignment, Rect},
+    style::Style,
+    text::{Line, Span},
+    widgets::{Block, BorderType, Borders, Paragraph, StatefulWidget, Widget},
+};
+
+use unicode_width::UnicodeWidthChar;
+
+use super::chunks::{
+    clip_chunks_window_with_indicator_padded,
+    wrap_chunks_indented,
+};
+use super::state::TextAreaSyntaxState;
+
+use crate::data_provider::DataProvider;
+use crate::textarea::state::{
+    compute_h_scroll_with_padding, count_wrapped_rows_indented, TextOverflowMode,
+};
+
+#[derive(Debug, Clone)]
+pub struct TextAreaSyntax<'a> {
+    pub block: Option<Block<'a>>,
+    pub style: Style,
+    pub border_type: BorderType,
+}
+
+impl<'a> Default for TextAreaSyntax<'a> {
+    fn default() -> Self {
+        Self {
+            block: Some(
+                Block::default()
+                    .borders(Borders::ALL)
+                    .border_type(BorderType::Rounded),
+            ),
+            style: Style::default(),
+            border_type: BorderType::Rounded,
+        }
+    }
+}
+
+impl<'a> TextAreaSyntax<'a> {
+    pub fn block(mut self, block: Block<'a>) -> Self {
+        self.block = Some(block);
+        self
+    }
+    pub fn style(mut self, style: Style) -> Self {
+        self.style = style;
+        self
+    }
+    pub fn border_type(mut self, ty: BorderType) -> Self {
+        self.border_type = ty;
+        if let Some(b) = &mut self.block {
+            *b = b.clone().border_type(ty);
+        }
+        self
+    }
+}
+
+fn display_width(s: &str) -> u16 {
+    s.chars()
+        .map(|c| UnicodeWidthChar::width(c).unwrap_or(0) as u16)
+        .sum()
+}
+
+fn display_cols_up_to(s: &str, char_count: usize) -> u16 {
+    let mut cols: u16 = 0;
+    for (i, ch) in s.chars().enumerate() {
+        if i >= char_count {
+            break;
+        }
+        cols = cols.saturating_add(UnicodeWidthChar::width(ch).unwrap_or(0) as u16);
+    }
+    cols
+}
+
+fn resolve_start_line_and_intra_indented(
+    state: &TextAreaSyntaxState,
+    inner: Rect,
+) -> (usize, u16) {
+    let provider = state.textarea.editor.data_provider();
+    let total = provider.line_count();
+
+    if total == 0 {
+        return (0, 0);
+    }
+
+    let wrap = matches!(state.textarea.overflow_mode, TextOverflowMode::Wrap);
+    let width = inner.width;
+    let target_vis = state.textarea.scroll_y;
+
+    if !wrap {
+        let start = (target_vis as usize).min(total);
+        return (start, 0);
+    }
+
+    let indent = state.textarea.wrap_indent_cols;
+
+    let mut acc: u16 = 0;
+    for i in 0..total {
+        let s = provider.field_value(i);
+        let rows = count_wrapped_rows_indented(s, width, indent);
+        if acc.saturating_add(rows) > target_vis {
+            let intra = target_vis.saturating_sub(acc);
+            return (i, intra);
+        }
+        acc = acc.saturating_add(rows);
+    }
+
+    (total.saturating_sub(1), 0)
+}
+
+impl<'a> StatefulWidget for TextAreaSyntax<'a> {
+    type State = TextAreaSyntaxState;
+
+    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+        // Reuse existing scroll logic
+        state.textarea.ensure_visible(area, self.block.as_ref());
+
+        let inner = if let Some(b) = &self.block {
+            b.clone().render(area, buf);
+            b.inner(area)
+        } else {
+            area
+        };
+
+        let edited_now = state.textarea.take_edited_flag();
+
+        let wrap_mode = matches!(state.textarea.overflow_mode, TextOverflowMode::Wrap);
+        let provider = state.textarea.editor.data_provider();
+        let total = provider.line_count();
+
+        let (start, intra) = resolve_start_line_and_intra_indented(state, inner);
+
+        let mut display_lines: Vec<Line> = Vec::new();
+
+        if total == 0 || start >= total {
+            if let Some(ph) = &state.textarea.placeholder {
+                display_lines.push(Line::from(Span::raw(ph.clone())));
+            }
+        } else if wrap_mode {
+            let mut rows_left = inner.height;
+            let indent = state.textarea.wrap_indent_cols;
+
+            let mut i = start;
+            while i < total && rows_left > 0 {
+                let s = provider.field_value(i);
+
+                let chunks = state
+                    .engine
+                    .highlight_line_cached(i, s, provider);
+
+                let lines = wrap_chunks_indented(&chunks, inner.width, indent);
+                let skip = if i == start { intra as usize } else { 0 };
+                for l in lines.into_iter().skip(skip) {
+                    display_lines.push(l);
+                    rows_left = rows_left.saturating_sub(1);
+                    if rows_left == 0 {
+                        break;
+                    }
+                }
+                i += 1;
+            }
+        } else {
+            let end = (start.saturating_add(inner.height as usize)).min(total);
+
+            for i in start..end {
+                let s = provider.field_value(i);
+
+                let chunks = state.engine.highlight_line_cached(i, s, provider);
+
+                let fits = display_width(s) <= inner.width;
+                let start_cols = if i == state.textarea.current_field() {
+                    let col_idx = state.textarea.display_cursor_position();
+                    let cursor_cols = display_cols_up_to(s, col_idx);
+                    let (target_h, _left_cols) =
+                        compute_h_scroll_with_padding(cursor_cols, inner.width);
+
+                    if fits {
+                        if edited_now {
+                            target_h
+                        } else {
+                            0
+                        }
+                    } else {
+                        target_h.max(state.textarea.h_scroll)
+                    }
+                } else {
+                    0
+                };
+
+                if let TextOverflowMode::Indicator { ch } = state.textarea.overflow_mode {
+                    display_lines.push(clip_chunks_window_with_indicator_padded(
+                        &chunks,
+                        inner.width,
+                        ch,
+                        start_cols,
+                    ));
+                }
+            }
+        }
+
+        let p = Paragraph::new(display_lines)
+            .alignment(Alignment::Left)
+            .style(self.style);
+
+        p.render(inner, buf);
+    }
+}
--- a/canvas/src/textarea/mod.rs
+++ b/canvas/src/textarea/mod.rs
@@ -1,10 +1,15 @@
 // src/textarea/mod.rs
+//! Text area convenience exports.
+
 pub mod provider;
 pub mod state;

 #[cfg(feature = "gui")]
 pub mod widget;

+#[cfg(all(feature = "syntect", feature = "gui"))]
+pub mod highlight;
+
 pub use provider::TextAreaProvider;
 pub use state::{TextAreaEditor, TextAreaState, TextOverflowMode};

--- a/canvas/src/textarea/provider.rs
+++ b/canvas/src/textarea/provider.rs
@@ -1,121 +1,218 @@
 // src/textarea/provider.rs
 use crate::DataProvider;
+use once_cell::unsync::OnceCell;
+use ropey::Rope;
+use std::io::{self, BufReader, Read};
+use std::path::Path;

-#[derive(Debug, Clone)]
+#[derive(Debug)] // Clone removed: OnceCell<String> is not Clone
 pub struct TextAreaProvider {
-    lines: Vec<String>,
+    rope: Rope,
    name: String,
+    // Lazy per-line cache; only lines that are actually used get materialized.
+    // This keeps memory low even for very large files.
+    line_cache: Vec<OnceCell<String>>,
 }

 impl Default for TextAreaProvider {
    fn default() -> Self {
+        let rope = Rope::from_str("");
        Self {
-            lines: vec![String::new()],
+            rope,
            name: "Text".to_string(),
+            line_cache: vec![OnceCell::new()], // at least 1 logical line
        }
    }
 }

 impl TextAreaProvider {
    pub fn from_text<S: Into<String>>(text: S) -> Self {
-        let text = text.into();
-        let mut lines: Vec<String> =
-            text.split('\n').map(|s| s.to_string()).collect();
-        if lines.is_empty() {
-            lines.push(String::new());
-        }
+        let s = text.into();
+        let rope = Rope::from_str(&s);
+        let lines = rope.len_lines().max(1);
        Self {
-            lines,
+            rope,
            name: "Text".to_string(),
+            line_cache: vec![(); lines].into_iter().map(|_| OnceCell::new()).collect(),
        }
    }

    pub fn to_text(&self) -> String {
-        self.lines.join("\n")
+        self.rope.to_string()
+    }
+
+    pub fn from_file<P: AsRef<Path>>(path: P) -> io::Result<Self> {
+        let f = std::fs::File::open(path)?;
+        let mut reader = BufReader::new(f);
+        Self::from_reader(&mut reader)
+    }
+
+    pub fn from_reader<R: Read>(reader: &mut R) -> io::Result<Self> {
+        let rope = Rope::from_reader(reader)?;
+        let lines = rope.len_lines().max(1);
+        Ok(Self {
+            rope,
+            name: "Text".to_string(),
+            line_cache: vec![(); lines].into_iter().map(|_| OnceCell::new()).collect(),
+        })
    }

    pub fn set_text<S: Into<String>>(&mut self, text: S) {
-        let text = text.into();
-        self.lines = text.split('\n').map(|s| s.to_string()).collect();
-        if self.lines.is_empty() {
-            self.lines.push(String::new());
-        }
+        let s = text.into();
+        self.rope = Rope::from_str(&s);
+        self.resize_cache();
+        self.invalidate_cache_from(0);
    }

    pub fn line_count(&self) -> usize {
-        self.lines.len()
+        self.rope.len_lines().max(1)
+    }
+
+    fn resize_cache(&mut self) {
+        let want = self.line_count();
+        if self.line_cache.len() < want {
+            self.line_cache
+                .extend((0..(want - self.line_cache.len())).map(|_| OnceCell::new()));
+        } else if self.line_cache.len() > want {
+            self.line_cache.truncate(want);
+        }
+    }
+
+    fn invalidate_cache_from(&mut self, line_idx: usize) {
+        self.resize_cache();
+        if line_idx < self.line_cache.len() {
+            for cell in &mut self.line_cache[line_idx..] {
+                let _ = cell.take();
+            }
+        }
    }

    #[inline]
-    fn char_to_byte_index(s: &str, char_idx: usize) -> usize {
-        s.char_indices()
-            .nth(char_idx)
-            .map(|(i, _)| i)
-            .unwrap_or_else(|| s.len())
+    fn line_bounds_chars(&self, line_idx: usize) -> (usize, usize) {
+        // Returns [start, end) in char indices for content only (excluding newline).
+        let total_lines = self.line_count();
+        let start = self.rope.line_to_char(line_idx);
+        let end_exclusive = if line_idx + 1 < total_lines {
+            // Next line start is at the char index right after the newline.
+            // Exclude the newline itself by not including it in the range.
+            self.rope.line_to_char(line_idx + 1) - 1
+        } else {
+            self.rope.len_chars()
+        };
+        (start, end_exclusive)
    }

-    pub fn split_line_at(&mut self, line_idx: usize, at_char: usize) -> usize {
-        if line_idx >= self.lines.len() {
-            return self.lines.len().saturating_sub(1);
+    fn line_content_len_chars(&self, line_idx: usize) -> usize {
+        let slice = self.rope.line(line_idx);
+        let mut len = slice.len_chars();
+        if line_idx + 1 < self.line_count() && len > 0 {
+            // Non-final lines include a trailing '\n' char in rope; exclude it.
+            len -= 1;
        }
-        let line = &mut self.lines[line_idx];
-        let byte_idx = Self::char_to_byte_index(line, at_char);
-        let right = line[byte_idx..].to_string();
-        line.truncate(byte_idx);
-        let insert_at = line_idx + 1;
-        self.lines.insert(insert_at, right);
-        insert_at
+        len
    }

+    fn compute_line_string(&self, index: usize) -> String {
+        let mut s = self.rope.line(index).to_string();
+        // Trim trailing newline/CR if present (for non-final lines)
+        if s.ends_with('\n') {
+            s.pop();
+            if s.ends_with('\r') {
+                s.pop();
+            }
+        }
+        s
+    }
+
+    // --------------------------
+    // Editing helpers for TextAreaState (unchanged API)
+    // --------------------------
+
+    /// Split line at a character offset (within that line).
+    /// Returns the index of the newly created line (line_idx + 1).
+    pub fn split_line_at(&mut self, line_idx: usize, at_char: usize) -> usize {
+        let lines = self.line_count();
+        let clamped_line = line_idx.min(lines.saturating_sub(1));
+        let (start, end) = self.line_bounds_chars(clamped_line);
+        let line_len = end.saturating_sub(start);
+        let at = at_char.min(line_len);
+
+        let insert_at = start + at;
+        self.rope.insert(insert_at, "\n"); // rope insert at char index
+
+        self.resize_cache();
+        self.invalidate_cache_from(clamped_line);
+        clamped_line + 1
+    }
+
+    /// Join current line with the next by removing the newline.
+    /// Returns Some(new_cursor_col_on_merged_line) or None if no next line.
    pub fn join_with_next(&mut self, line_idx: usize) -> Option<usize> {
-        if line_idx + 1 >= self.lines.len() {
+        if line_idx + 1 >= self.line_count() {
            return None;
        }
-        let left_len = self.lines[line_idx].chars().count();
-        let right = self.lines.remove(line_idx + 1);
-        self.lines[line_idx].push_str(&right);
+        let newline_pos = self.rope.line_to_char(line_idx + 1) - 1; // index of '\n'
+        let left_len = self.line_content_len_chars(line_idx);
+        self.rope.remove(newline_pos..newline_pos + 1); // remove the newline
+
+        self.resize_cache();
+        self.invalidate_cache_from(line_idx);
        Some(left_len)
    }

-    pub fn join_with_prev(
-        &mut self,
-        line_idx: usize,
-    ) -> Option<(usize, usize)> {
-        if line_idx == 0 || line_idx >= self.lines.len() {
+    /// Join current line with the previous by removing the previous newline.
+    /// Returns Some((new_prev_index, cursor_col)) or None if at line 0.
+    pub fn join_with_prev(&mut self, line_idx: usize) -> Option<(usize, usize)> {
+        if line_idx == 0 || line_idx >= self.line_count() {
            return None;
        }
        let prev_idx = line_idx - 1;
-        let prev_len = self.lines[prev_idx].chars().count();
-        let curr = self.lines.remove(line_idx);
-        self.lines[prev_idx].push_str(&curr);
+        let prev_len = self.line_content_len_chars(prev_idx);
+        let newline_pos = self.rope.line_to_char(line_idx) - 1; // index of '\n' before current line
+        self.rope.remove(newline_pos..newline_pos + 1);
+
+        self.resize_cache();
+        self.invalidate_cache_from(prev_idx);
        Some((prev_idx, prev_len))
    }

-    pub fn insert_blank_line_after(&mut self, idx: usize) -> usize {
-        let clamped = idx.min(self.lines.len());
-        let insert_at = if clamped >= self.lines.len() {
-            self.lines.len()
+    /// Insert an empty line after given index.
+    /// Returns the index of the inserted blank line (line_idx + 1).
+    pub fn insert_blank_line_after(&mut self, line_idx: usize) -> usize {
+        let lines = self.line_count();
+        let clamped = line_idx.min(lines.saturating_sub(1));
+        let pos = if clamped + 1 < lines {
+            self.rope.line_to_char(clamped + 1)
        } else {
-            clamped + 1
+            self.rope.len_chars()
        };
-        if insert_at == self.lines.len() {
-            self.lines.push(String::new());
-        } else {
-            self.lines.insert(insert_at, String::new());
-        }
-        insert_at
+        self.rope.insert(pos, "\n");
+
+        self.resize_cache();
+        self.invalidate_cache_from(clamped);
+        clamped + 1
    }

-    pub fn insert_blank_line_before(&mut self, idx: usize) -> usize {
-        let insert_at = idx.min(self.lines.len());
-        self.lines.insert(insert_at, String::new());
-        insert_at
+    /// Insert an empty line before given index.
+    /// Returns the index of the inserted blank line (line_idx).
+    pub fn insert_blank_line_before(&mut self, line_idx: usize) -> usize {
+        let clamped = line_idx.min(self.line_count());
+        let pos = if clamped < self.line_count() {
+            self.rope.line_to_char(clamped)
+        } else {
+            self.rope.len_chars()
+        };
+        self.rope.insert(pos, "\n");
+
+        self.resize_cache();
+        self.invalidate_cache_from(clamped);
+        clamped
    }
 }

 impl DataProvider for TextAreaProvider {
    fn field_count(&self) -> usize {
-        self.lines.len()
+        self.line_count()
    }

    fn field_name(&self, _index: usize) -> &str {
@@ -123,12 +220,31 @@ impl DataProvider for TextAreaProvider {
    }

    fn field_value(&self, index: usize) -> &str {
-        self.lines.get(index).map(|s| s.as_str()).unwrap_or("")
+        if index >= self.line_cache.len() {
+            return "";
+        }
+        let cell = &self.line_cache[index];
+        // Fill lazily on first read, from &self (no &mut needed).
+        let s_ref = cell.get_or_init(|| self.compute_line_string(index));
+        s_ref.as_str()
    }

    fn set_field_value(&mut self, index: usize, value: String) {
-        if index < self.lines.len() {
-            self.lines[index] = value;
+        if index >= self.line_count() {
+            return;
+        }
+        // Enforce single-line invariant: strip embedded newlines
+        let clean = value.replace('\n', "");
+
+        let (start, end) = self.line_bounds_chars(index);
+        self.rope.remove(start..end);
+        self.rope.insert(start, &clean);
+
+        self.resize_cache();
+        if index < self.line_cache.len() {
+            // Replace this line’s cached string only; other lines unchanged
+            let _ = self.line_cache[index].take();
+            let _ = self.line_cache[index].set(clean);
        }
    }
 }
--- a/canvas/src/textarea/state.rs
+++ b/canvas/src/textarea/state.rs
@@ -355,7 +355,7 @@ impl TextAreaState {
    #[cfg(feature = "gui")]
    pub fn cursor(&self, area: Rect, block: Option<&Block<'_>>) -> (u16, u16) {
        let inner = if let Some(b) = block { b.inner(area) } else { area };
-        let line_idx = self.current_field() as usize;
+        let line_idx = self.current_field();

        match self.overflow_mode {
            TextOverflowMode::Wrap => {
@@ -375,7 +375,7 @@ impl TextAreaState {
                let col_chars = self.display_cursor_position();

                let (subrow, x_cols) = wrapped_rows_to_cursor_indented(
-                    &current_line,
+                    current_line,
                    width,
                    indent,
                    col_chars,
@@ -478,7 +478,7 @@ impl TextAreaState {
                }

                let indent = self.wrap_indent_cols;
-                let line_idx = self.current_field() as usize;
+                let line_idx = self.current_field();

                let prefix_rows =
                    self.visual_rows_before_line_and_intra_indented(width, line_idx);
@@ -487,7 +487,7 @@ impl TextAreaState {
                let col = self.display_cursor_position();

                let (subrow, _x_cols) =
-                    wrapped_rows_to_cursor_indented(&current_line, width, indent, col);
+                    wrapped_rows_to_cursor_indented(current_line, width, indent, col);

                let caret_vis_row = prefix_rows.saturating_add(subrow);

--- a/canvas/src/textarea/widget.rs
+++ b/canvas/src/textarea/widget.rs
@@ -314,11 +314,11 @@ impl<'a> StatefulWidget for TextArea<'a> {
                match state.overflow_mode {
                    TextOverflowMode::Wrap => unreachable!(),
                    TextOverflowMode::Indicator { ch } => {
-                        let fits = display_width(&s) <= inner.width;
+                        let fits = display_width(s) <= inner.width;

                        let start_cols = if i == state.current_field() {
                            let col_idx = state.display_cursor_position();
-                            let cursor_cols = display_cols_up_to(&s, col_idx);
+                            let cursor_cols = display_cols_up_to(s, col_idx);
                            let (target_h, _left_cols) =
                                compute_h_scroll_with_padding(cursor_cols, inner.width);

@@ -332,7 +332,7 @@ impl<'a> StatefulWidget for TextArea<'a> {
                        };

                        display_lines.push(clip_window_with_indicator_padded(
-                            &s,
+                            s,
                            inner.width,
                            ch,
                            start_cols,
--- a/canvas/src/validation/config.rs
+++ b/canvas/src/validation/config.rs
@@ -6,6 +6,49 @@ use crate::validation::{CharacterLimits, PatternFilters, DisplayMask};
 use crate::validation::{CustomFormatter, FormattingResult, PositionMapper};
 use std::sync::Arc;

+/// Whitelist of allowed exact values for a field.
+/// If configured, the field is valid when it is empty (by default) or when the
+/// content exactly matches one of the allowed values. This does not block field
+/// switching (unlike minimum length in CharacterLimits).
+#[derive(Clone, Debug)]
+pub struct AllowedValues {
+    allowed: Vec<String>,
+    allow_empty: bool,
+    case_insensitive: bool,
+}
+
+impl AllowedValues {
+    pub fn new(allowed: Vec<String>) -> Self {
+        Self {
+            allowed,
+            allow_empty: true,
+            case_insensitive: false,
+        }
+    }
+
+    /// Allow or disallow empty value to be considered valid (default: true).
+    pub fn allow_empty(mut self, allow: bool) -> Self {
+        self.allow_empty = allow;
+        self
+    }
+
+    /// Enable/disable ASCII case-insensitive matching (default: false).
+    pub fn case_insensitive(mut self, ci: bool) -> Self {
+        self.case_insensitive = ci;
+        self
+    }
+
+    fn matches(&self, text: &str) -> bool {
+        if self.case_insensitive {
+            self.allowed
+                .iter()
+                .any(|s| s.eq_ignore_ascii_case(text))
+        } else {
+            self.allowed.iter().any(|s| s == text)
+        }
+    }
+}
+
 /// Main validation configuration for a field
 #[derive(Clone, Default)]
 pub struct ValidationConfig {
@@ -22,6 +65,9 @@ pub struct ValidationConfig {
    #[cfg(feature = "validation")]
    pub custom_formatter: Option<Arc<dyn CustomFormatter + Send + Sync>>,

+    /// Optional: restrict the field to one of exact allowed values (or empty)
+    pub allowed_values: Option<AllowedValues>,
+
    /// Enable external validation indicator UI (feature 5)
    pub external_validation_enabled: bool,

@@ -50,6 +96,7 @@ impl std::fmt::Debug for ValidationConfig {
                  }
              },
          )
+          .field("allowed_values", &self.allowed_values)
          .field("external_validation_enabled", &self.external_validation_enabled)
          .field("external_validation", &self.external_validation)
          .finish()
@@ -167,6 +214,18 @@ impl ValidationConfig {
            }
        }

+        // Allowed values (whitelist) validation
+        if let Some(ref allowed) = self.allowed_values {
+            // Empty value is allowed (default) or required (if allow_empty is false)
+            if text.is_empty() {
+                if !allowed.allow_empty {
+                    return ValidationResult::warning("Value required");
+                }
+            } else if !allowed.matches(text) {
+                return ValidationResult::error("Value must be one of the allowed options");
+            }
+        }
+
        // Future: Add other validation types here

        ValidationResult::Valid
@@ -183,6 +242,12 @@ impl ValidationConfig {
                #[cfg(not(feature = "validation"))]
                { false }
            }
+            || self.allowed_values.is_some()
+    }
+
+    /// Check if whitelist is configured
+    pub fn has_allowed_values(&self) -> bool {
+        self.allowed_values.is_some()
    }

    pub fn allows_field_switch(&self, text: &str) -> bool {
@@ -289,6 +354,41 @@ impl ValidationConfigBuilder {
        self
    }

+    /// Restrict content to one of the provided exact values (or empty).
+    /// - Empty is considered valid by default.
+    /// - Matching is case-sensitive by default.
+    pub fn with_allowed_values<S>(mut self, values: Vec<S>) -> Self
+    where
+        S: Into<String>,
+    {
+        let vals: Vec<String> = values.into_iter().map(Into::into).collect();
+        self.config.allowed_values = Some(AllowedValues::new(vals));
+        self
+    }
+
+    /// Same as with_allowed_values, but case-insensitive (ASCII).
+    pub fn with_allowed_values_ci<S>(mut self, values: Vec<S>) -> Self
+    where
+        S: Into<String>,
+    {
+        let vals: Vec<String> = values.into_iter().map(Into::into).collect();
+        self.config.allowed_values = Some(AllowedValues::new(vals).case_insensitive(true));
+        self
+    }
+
+    /// Configure whether empty value should be allowed when using AllowedValues.
+    pub fn with_allowed_values_allow_empty(mut self, allow_empty: bool) -> Self {
+        if let Some(av) = self.config.allowed_values.take() {
+            self.config.allowed_values = Some(AllowedValues {
+                allow_empty,
+                ..av
+            });
+        } else {
+            self.config.allowed_values = Some(AllowedValues::new(vec![]).allow_empty(allow_empty));
+        }
+        self
+    }
+
    /// Enable or disable external validation indicator UI (feature 5)
    pub fn with_external_validation_enabled(mut self, enabled: bool) -> Self {
        self.config.external_validation_enabled = enabled;
@@ -391,6 +491,47 @@ mod tests {
        assert!(config.display_mask.is_some());
    }

+    #[test]
+    fn test_allowed_values() {
+        let config = ValidationConfigBuilder::new()
+            .with_allowed_values(vec!["alpha", "beta", "gamma", "delta", "epsilon"])
+            .build();
+
+        // Empty should be valid by default
+        let result = config.validate_content("");
+        assert!(result.is_acceptable());
+
+        // Exact allowed values are valid
+        assert!(config.validate_content("alpha").is_acceptable());
+        assert!(config.validate_content("beta").is_acceptable());
+
+        // Anything else is an error
+        let res = config.validate_content("alph");
+        assert!(res.is_error());
+        let res = config.validate_content("ALPHA");
+        assert!(res.is_error()); // case-sensitive by default
+    }
+
+    #[test]
+    fn test_allowed_values_case_insensitive_and_required() {
+        let config = ValidationConfigBuilder::new()
+            .with_allowed_values_ci(vec!["Yes", "No"])
+            .with_allowed_values_allow_empty(false)
+            .build();
+
+        // Empty is not allowed now (warning so it's still acceptable for typing)
+        let res = config.validate_content("");
+        assert!(res.is_acceptable());
+
+        // Case-insensitive matches
+        assert!(config.validate_content("yes").is_acceptable());
+        assert!(config.validate_content("NO").is_acceptable());
+
+        // Random text is an error
+        let res = config.validate_content("maybe");
+        assert!(res.is_error());
+    }
+
    #[test]
    fn test_validation_result() {
        let valid = ValidationResult::Valid;
--- a/canvas/src/validation/formatting.rs
+++ b/canvas/src/validation/formatting.rs
@@ -1,6 +1,11 @@
-/* canvas/src/validation/formatting.rs
-   Add new formatting module with CustomFormatter, PositionMapper, DefaultPositionMapper, and FormattingResult
-*/
+// src/validation/formatting.rs
+//! Custom formatting and position mapping for validation/display.
+//!
+//! This module defines the CustomFormatter trait along with helpers to map
+//! cursor positions between the raw stored text and the formatted display
+//! representation. Implementors may provide a custom PositionMapper to handle
+//! advanced formatting scenarios.
+
 use std::sync::Arc;

 /// Bidirectional mapping between raw input positions and formatted display positions.
@@ -108,7 +113,7 @@ impl FormattingResult {
    pub fn success(formatted: impl Into<String>) -> Self {
        FormattingResult::Success {
            formatted: formatted.into(),
-            mapper: Arc::new(DefaultPositionMapper::default()),
+            mapper: Arc::new(DefaultPositionMapper),
        }
    }

@@ -117,7 +122,7 @@ impl FormattingResult {
        FormattingResult::Warning {
            formatted: formatted.into(),
            message: message.into(),
-            mapper: Arc::new(DefaultPositionMapper::default()),
+            mapper: Arc::new(DefaultPositionMapper),
        }
    }

@@ -187,7 +192,7 @@ mod tests {

    #[test]
    fn default_mapper_roundtrip_basic() {
-        let mapper = DefaultPositionMapper::default();
+        let mapper = DefaultPositionMapper;
        let raw = "01001";
        let formatted = "010 01";

@@ -214,4 +219,4 @@ mod tests {
            _ => panic!("expected success"),
        }
    }
-}
+}
--- a/canvas/src/validation/limits.rs
+++ b/canvas/src/validation/limits.rs
@@ -23,8 +23,10 @@ pub struct CharacterLimits {

 /// How to count characters for limit checking
 #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[derive(Default)]
 pub enum CountMode {
    /// Count actual characters (default)
+    #[default]
    Characters,
    
    /// Count display width (useful for CJK characters)
@@ -34,11 +36,6 @@ pub enum CountMode {
    Bytes,
 }

-impl Default for CountMode {
-    fn default() -> Self {
-        CountMode::Characters
-    }
-}

 /// Result of a character limit check
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -157,9 +154,7 @@ impl CharacterLimits {
        if let Some(max) = self.max_length {
            if new_count > max {
                return Some(ValidationResult::error(format!(
-                    "Character limit exceeded: {}/{}",
-                    new_count,
-                    max
+                    "Character limit exceeded: {new_count}/{max}"
                )));
            }

@@ -167,9 +162,7 @@ impl CharacterLimits {
            if let Some(warning_threshold) = self.warning_threshold {
                if new_count >= warning_threshold && current_count < warning_threshold {
                    return Some(ValidationResult::warning(format!(
-                        "Approaching character limit: {}/{}",
-                        new_count,
-                        max
+                        "Approaching character limit: {new_count}/{max}"
                    )));
                }
            }
@@ -186,9 +179,7 @@ impl CharacterLimits {
        if let Some(min) = self.min_length {
            if count < min {
                return Some(ValidationResult::warning(format!(
-                    "Minimum length not met: {}/{}", 
-                    count, 
-                    min
+                    "Minimum length not met: {count}/{min}"
                )));
            }
        }
@@ -197,9 +188,7 @@ impl CharacterLimits {
        if let Some(max) = self.max_length {
            if count > max {
                return Some(ValidationResult::error(format!(
-                    "Character limit exceeded: {}/{}", 
-                    count, 
-                    max
+                    "Character limit exceeded: {count}/{max}"
                )));
            }
            
@@ -207,9 +196,7 @@ impl CharacterLimits {
            if let Some(warning_threshold) = self.warning_threshold {
                if count >= warning_threshold {
                    return Some(ValidationResult::warning(format!(
-                        "Approaching character limit: {}/{}", 
-                        count, 
-                        max
+                        "Approaching character limit: {count}/{max}"
                    )));
                }
            }
@@ -251,20 +238,16 @@ impl CharacterLimits {
        match self.check_limits(text) {
            LimitCheckResult::Ok => {
                // Show current/max if we have a max limit
-                if let Some(max) = self.max_length {
-                    Some(format!("{}/{}", self.count(text), max))
-                } else {
-                    None
-                }
+                self.max_length.map(|max| format!("{}/{}", self.count(text), max))
            },
            LimitCheckResult::Warning { current, max } => {
-                Some(format!("{}/{} (approaching limit)", current, max))
+                Some(format!("{current}/{max} (approaching limit)"))
            },
            LimitCheckResult::Exceeded { current, max } => {
-                Some(format!("{}/{} (exceeded)", current, max))
+                Some(format!("{current}/{max} (exceeded)"))
            },
            LimitCheckResult::TooShort { current, min } => {
-                Some(format!("{}/{} minimum", current, min))
+                Some(format!("{current}/{min} minimum"))
            },
        }
    }
@@ -284,8 +267,7 @@ impl CharacterLimits {
            let count = self.count(text);
            if count > 0 && count < min {
                return Some(format!(
-                    "Field must be empty or have at least {} characters (currently: {})",
-                    min, count
+                    "Field must be empty or have at least {min} characters (currently: {count})"
                ));
            }
        }
--- a/canvas/src/validation/mask.rs
+++ b/canvas/src/validation/mask.rs
@@ -2,9 +2,11 @@
 //! Pure display mask system - user-defined patterns only

 #[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Default)]
 pub enum MaskDisplayMode {
    /// Only show separators as user types
    /// Example: "" → "", "123" → "123", "12345" → "(123) 45"
+    #[default]
    Dynamic,
    
    /// Show full template with placeholders from start
@@ -15,11 +17,6 @@ pub enum MaskDisplayMode {
    },
 }

-impl Default for MaskDisplayMode {
-    fn default() -> Self {
-        MaskDisplayMode::Dynamic
-    }
-}

 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DisplayMask {
--- a/canvas/src/validation/mod.rs
+++ b/canvas/src/validation/mod.rs
@@ -1,6 +1,11 @@
 // src/validation/mod.rs
+//! Validation subsystem re-exports and helpers.
+//!
+//! This module collects validation-related modules (limits, masks, patterns,
+//! formatting, and state) and re-exports the most commonly used types so that
+//! callers can import them from `crate::validation`.

-// Core validation modules
+ // Core validation modules
 pub mod config;
 pub mod limits;
 pub mod state;
--- a/canvas/src/validation/patterns.rs
+++ b/canvas/src/validation/patterns.rs
@@ -49,8 +49,8 @@ impl std::fmt::Debug for CharacterFilter {
            CharacterFilter::Alphabetic => write!(f, "Alphabetic"),
            CharacterFilter::Numeric => write!(f, "Numeric"),
            CharacterFilter::Alphanumeric => write!(f, "Alphanumeric"),
-            CharacterFilter::Exact(ch) => write!(f, "Exact('{}')", ch),
-            CharacterFilter::OneOf(chars) => write!(f, "OneOf({:?})", chars),
+            CharacterFilter::Exact(ch) => write!(f, "Exact('{ch}')"),
+            CharacterFilter::OneOf(chars) => write!(f, "OneOf({chars:?})"),
            CharacterFilter::Custom(_) => write!(f, "Custom(<function>)"),
        }
    }
@@ -130,10 +130,10 @@ impl CharacterFilter {
            CharacterFilter::Alphabetic => "alphabetic characters (a-z, A-Z)".to_string(),
            CharacterFilter::Numeric => "numeric characters (0-9)".to_string(),
            CharacterFilter::Alphanumeric => "alphanumeric characters (a-z, A-Z, 0-9)".to_string(),
-            CharacterFilter::Exact(ch) => format!("exactly '{}'", ch),
+            CharacterFilter::Exact(ch) => format!("exactly '{ch}'"),
            CharacterFilter::OneOf(chars) => {
                let char_list: String = chars.iter().collect();
-                format!("one of: {}", char_list)
+                format!("one of: {char_list}")
            },
            CharacterFilter::Custom(_) => "custom filter".to_string(),
        }
@@ -207,9 +207,7 @@ impl PatternFilters {
    /// Validate entire text against all filters
    pub fn validate_text(&self, text: &str) -> Result<(), String> {
        for (position, character) in text.char_indices() {
-            if let Err(error) = self.validate_char_at_position(position, character) {
-                return Err(error);
-            }
+            self.validate_char_at_position(position, character)?
        }
        Ok(())
    }
--- a/client/.gitignore
+++ b/client/.gitignore
@@ -1 +1,2 @@
 canvas_config.toml.txt
+ui_debug.log
--- a/client/Cargo.toml
+++ b/client/Cargo.toml
@@ -8,7 +8,7 @@ license.workspace = true
 anyhow = { workspace = true }
 async-trait = "0.1.88"
 common = { path = "../common" }
-canvas = { path = "../canvas", features = ["gui"] }
+canvas = { path = "../canvas", features = ["gui", "suggestions", "cursor-style", "keymap", "validation"] }

 ratatui = { workspace = true }
 crossterm = { workspace = true }
@@ -24,14 +24,15 @@ tokio = { version = "1.44.2", features = ["full", "macros"] }
 toml = { workspace = true }
 tonic = "0.13.0"
 tracing = "0.1.41"
-tracing-subscriber = "0.3.19"
+tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
 tui-textarea = { version = "0.7.0", features = ["crossterm", "ratatui", "search"] }
 unicode-segmentation = "1.12.0"
 unicode-width.workspace = true

 [features]
-default = []
+default = ["validation"]
 ui-debug = []
+validation = []

 [dev-dependencies]
 rstest = "0.25.0"
--- a/client/config.toml
+++ b/client/config.toml
@@ -5,18 +5,17 @@ enter_command_mode = [":", "ctrl+;"]
 next_buffer = ["space+b+n"]
 previous_buffer = ["space+b+p"] 
 close_buffer = ["space+b+d"]
+revert = ["space+b+r"]

 [keybindings.general]
-move_up = ["k", "Up"]
-move_down = ["j", "Down"]
-next_option = ["l", "Right"]
-previous_option = ["h", "Left"]
+up = ["k", "Up"]
+down = ["j", "Down"]
+left = ["h", "Left"]
+right = ["l", "Right"]
+next = ["Tab"]
+previous = ["Shift+Tab"]
 select = ["Enter"]
-toggle_sidebar = ["ctrl+t"]
-toggle_buffer_list = ["ctrl+b"]
-next_field = ["Tab"]
-prev_field = ["Shift+Tab"]
-exit_table_scroll = ["esc"]
+esc = ["esc"]
 open_search = ["ctrl+f"]

 [keybindings.common]
@@ -29,7 +28,6 @@ move_up = ["Up"]
 move_down = ["Down"]
 toggle_sidebar = ["ctrl+t"]
 toggle_buffer_list = ["ctrl+b"]
-revert = ["space+b+r"]

 # MODE SPECIFIC
 # READ ONLY MODE
@@ -40,7 +38,7 @@ previous_entry = ["left","q"]
 next_entry = ["right","1"]

 enter_highlight_mode = ["v"]
-enter_highlight_mode_linewise = ["ctrl+v"]
+enter_highlight_mode_linewise = ["shift+v"]

 ### AUTOGENERATED CANVAS CONFIG
 # Required
@@ -50,7 +48,7 @@ move_right = ["l", "Right"]
 move_down = ["j", "Down"]
 # Optional
 move_line_end = ["$"]
-# move_word_next = ["w"]
+move_word_next = ["w"]
 next_field = ["Tab"]
 move_word_prev = ["b"]
 move_word_end = ["e"]
@@ -62,7 +60,7 @@ prev_field = ["Shift+Tab"]

 [keybindings.highlight]
 exit_highlight_mode = ["esc"]
-enter_highlight_mode_linewise = ["ctrl+v"]
+enter_highlight_mode_linewise = ["shift+v"]

 ### AUTOGENERATED CANVAS CONFIG
 # Required
@@ -91,23 +89,23 @@ suggestion_up = ["ctrl+p", "shift+tab"]

 ### AUTOGENERATED CANVAS CONFIG
 # Required
-move_right = ["Right", "l"]
+move_right = ["Right"]
 delete_char_backward = ["Backspace"]
 next_field = ["Tab", "Enter"]
-move_up = ["Up", "k"]
-move_down = ["Down", "j"]
+move_up = ["Up"]
+move_down = ["Down"]
 prev_field = ["Shift+Tab"]
-move_left = ["Left", "h"]
+move_left = ["Left"]
 # Optional
-move_last_line = ["Ctrl+End", "G"]
+move_last_line = ["Ctrl+End"]
 delete_char_forward = ["Delete"]
-move_word_prev = ["Ctrl+Left", "b"]
-move_word_end = ["e"]
-move_word_end_prev = ["ge"]
-move_first_line = ["Ctrl+Home", "gg"]
-move_word_next = ["Ctrl+Right", "w"]
-move_line_start = ["Home", "0"]
-move_line_end = ["End", "$"]
+move_word_prev = ["Ctrl+Left"]
+# move_word_end = ["e"]
+# move_word_end_prev = ["ge"]
+move_first_line = ["Ctrl+Home"]
+move_word_next = ["Ctrl+Right"]
+move_line_start = ["Home"]
+move_line_end = ["End"]

 [keybindings.command]
 exit_command_mode = ["ctrl+g", "esc"]
--- a/client/src/components/common/command_line.rs
+++ b/client/src/components/common/command_line.rs
--- a/client/src/components/common/find_file_palette.rs
+++ b/client/src/components/common/find_file_palette.rs
@@ -1,4 +1,4 @@
-// src/components/common/find_file_palette.rs
+// src/bottom_panel/find_file_palette.rs

 use crate::config::colors::themes::Theme;
 use crate::modes::general::command_navigation::NavigationState; // Corrected path
--- a/client/src/bottom_panel/layout.rs
+++ b/client/src/bottom_panel/layout.rs
@@ -0,0 +1,98 @@
+// src/bottom_panel/layout.rs
+
+use ratatui::{layout::Constraint, layout::Rect, Frame};
+use crate::bottom_panel::{status_line::render_status_line, command_line::render_command_line};
+use crate::bottom_panel::find_file_palette;
+use crate::config::colors::themes::Theme;
+use crate::modes::general::command_navigation::NavigationState;
+use crate::state::app::state::AppState;
+use crate::pages::routing::Router;
+
+/// Calculate the layout constraints for the bottom panel (status line + command line/palette).
+pub fn bottom_panel_constraints(
+    app_state: &AppState,
+    navigation_state: &NavigationState,
+    event_handler_command_mode_active: bool,
+) -> Vec<Constraint> {
+    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;
+            }
+        }
+    }
+
+    const PALETTE_OPTIONS_HEIGHT_FOR_LAYOUT: u16 = 15;
+    let command_palette_area_height = if navigation_state.active {
+        1 + PALETTE_OPTIONS_HEIGHT_FOR_LAYOUT
+    } else if event_handler_command_mode_active {
+        1
+    } else {
+        0
+    };
+
+    let mut constraints = vec![Constraint::Length(status_line_height)];
+    if command_palette_area_height > 0 {
+        constraints.push(Constraint::Length(command_palette_area_height));
+    }
+    constraints
+}
+
+/// Render the bottom panel (status line + command line/palette).
+pub fn render_bottom_panel(
+    f: &mut Frame,
+    root_chunks: &[Rect],
+    chunk_idx: &mut usize,
+    current_dir: &str,
+    theme: &Theme,
+    current_fps: f64,
+    app_state: &AppState,
+    router: &Router,
+    navigation_state: &NavigationState,
+    event_handler_command_input: &str,
+    event_handler_command_mode_active: bool,
+    event_handler_command_message: &str,
+) {
+    // --- Status line area ---
+    let status_line_area = root_chunks[*chunk_idx];
+    *chunk_idx += 1;
+
+    // --- Command line / palette area ---
+    let command_render_area = if root_chunks.len() > *chunk_idx {
+        Some(root_chunks[*chunk_idx])
+    } else {
+        None
+    };
+    if command_render_area.is_some() {
+        *chunk_idx += 1;
+    }
+
+    // --- Render status line ---
+    render_status_line(
+        f,
+        status_line_area,
+        current_dir,
+        theme,
+        current_fps,
+        app_state,
+        router,
+    );
+
+    // --- Render command line or palette ---
+    if let Some(area) = command_render_area {
+        if navigation_state.active {
+            find_file_palette::render_find_file_palette(f, area, theme, navigation_state);
+        } else if event_handler_command_mode_active {
+            render_command_line(
+                f,
+                area,
+                event_handler_command_input,
+                true,
+                theme,
+                event_handler_command_message,
+            );
+        }
+    }
+}
--- a/client/src/bottom_panel/mod.rs
+++ b/client/src/bottom_panel/mod.rs
@@ -0,0 +1,6 @@
+// src/bottom_panel/mod.rs
+
+pub mod status_line; 
+pub mod command_line;
+pub mod layout;
+pub mod find_file_palette;
--- a/client/src/components/common/status_line.rs
+++ b/client/src/components/common/status_line.rs
@@ -5,10 +5,11 @@ use ratatui::{
    layout::Rect,
    style::Style,
    text::{Line, Span, Text},
-    widgets::Paragraph,
+    widgets::{Paragraph, Wrap},
    Frame,
 };
-use ratatui::widgets::Wrap;
+use crate::pages::routing::Page;
+use crate::pages::routing::Router;
 use std::path::Path;
 use unicode_width::UnicodeWidthStr;

@@ -17,9 +18,9 @@ pub fn render_status_line(
    area: Rect,
    current_dir: &str,
    theme: &Theme,
-    is_edit_mode: bool,
    current_fps: f64,
    app_state: &AppState,
+    router: &Router,
 ) {
    #[cfg(feature = "ui-debug")]
    {
@@ -49,7 +50,20 @@ pub fn render_status_line(

    // --- The normal status line rendering logic (unchanged) ---
    let program_info = format!("komp_ac v{}", env!("CARGO_PKG_VERSION"));
-    let mode_text = if is_edit_mode { "[EDIT]" } else { "[READ-ONLY]" };
+    let mode_text = if let Page::Form(path) = &router.current {
+        if let Some(editor) = app_state.editor_for_path_ref(path) {
+            match editor.mode() {
+                canvas::AppMode::Edit => "[EDIT]",
+                canvas::AppMode::ReadOnly => "[READ-ONLY]",
+                canvas::AppMode::Highlight => "[VISUAL]",
+                _ => "",
+            }
+        } else {
+            ""
+        }
+    } else {
+        "" // No canvas active
+    };    

    let home_dir = dirs::home_dir()
        .map(|p| p.to_string_lossy().into_owned())
--- a/client/src/functions/common/buffer.rs
+++ b/client/src/functions/common/buffer.rs
@@ -1,13 +1,13 @@
-// src/functions/common/buffer.rs
+// src/buffer/functions/buffer.rs

-use crate::state::app::buffer::BufferState;
-use crate::state::app::buffer::AppView;
+use crate::buffer::state::BufferState;
+use crate::buffer::state::AppView;

 pub fn get_view_layer(view: &AppView) -> u8 {
    match view {
        AppView::Intro => 1,
        AppView::Login | AppView::Register | AppView::Admin | AppView::AddTable | AppView::AddLogic => 2,
-        AppView::Form | AppView::Scratch => 3,
+        AppView::Form(_) | AppView::Scratch => 3,
    }
 }

--- a/client/src/buffer/logic.rs
+++ b/client/src/buffer/logic.rs
@@ -0,0 +1,20 @@
+// src/buffer/logic.rs
+use crossterm::event::{KeyCode, KeyModifiers};
+use crate::config::binds::config::Config;
+use crate::state::app::state::UiState;
+
+/// Toggle the buffer list visibility based on keybindings.
+pub fn toggle_buffer_list(
+    ui_state: &mut UiState,
+    config: &Config,
+    key: KeyCode,
+    modifiers: KeyModifiers,
+) -> bool {
+    if let Some(action) = config.get_common_action(key, modifiers) {
+        if action == "toggle_buffer_list" {
+            ui_state.show_buffer_list = !ui_state.show_buffer_list;
+            return true;
+        }
+    }
+    false
+}
--- a/client/src/buffer/mod.rs
+++ b/client/src/buffer/mod.rs
@@ -0,0 +1,11 @@
+// src/buffer/mod.rs
+
+pub mod state;
+pub mod functions;
+pub mod ui;
+pub mod logic;
+
+pub use state::{AppView, BufferState};
+pub use functions::*;
+pub use ui::render_buffer_list;
+pub use logic::toggle_buffer_list;
--- a/client/src/state/app/buffer.rs
+++ b/client/src/state/app/buffer.rs
@@ -1,4 +1,4 @@
-// src/state/app/buffer.rs
+// src/buffer/state/buffer.rs

 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum AppView {
@@ -8,7 +8,7 @@ pub enum AppView {
    Admin,
    AddTable,
    AddLogic,
-    Form,
+    Form(String),
    Scratch,
 }

@@ -23,7 +23,7 @@ impl AppView {
            AppView::Admin => "Admin_Panel",
            AppView::AddTable => "Add_Table",
            AppView::AddLogic => "Add_Logic",
-            AppView::Form => "Form",
+            AppView::Form(_) => "Form",
            AppView::Scratch => "*scratch*",
        }
    }
@@ -31,10 +31,14 @@ impl AppView {
    /// Returns the display name with dynamic context (for Form buffers)
    pub fn display_name_with_context(&self, current_table_name: Option<&str>) -> String {
        match self {
-            AppView::Form => {
-                current_table_name
-                    .unwrap_or("Data Form")
-                    .to_string()
+            AppView::Form(path) => {
+                // Derive table name from "profile/table" path
+                let table = path.split('/').nth(1).unwrap_or("");
+                if !table.is_empty() {
+                    table.to_string()
+                } else {
+                    current_table_name.unwrap_or("Data Form").to_string()
+                }
            }
            _ => self.display_name().to_string(),
        }
--- a/client/src/components/handlers/buffer_list.rs
+++ b/client/src/components/handlers/buffer_list.rs
@@ -1,7 +1,7 @@
-// src/components/handlers/buffer_list.rs
+// src/buffer/ui.rs

 use crate::config::colors::themes::Theme;
-use crate::state::app::buffer::BufferState;
+use crate::buffer::state::BufferState;
 use crate::state::app::state::AppState;  // Add this import
 use ratatui::{
    layout::{Alignment, Rect},
@@ -11,7 +11,7 @@ use ratatui::{
    Frame,
 };
 use unicode_width::UnicodeWidthStr;
-use crate::functions::common::buffer::get_view_layer;
+use crate::buffer::functions::get_view_layer;

 pub fn render_buffer_list(
    f: &mut Frame,
--- a/client/src/components/admin.rs
+++ b/client/src/components/admin.rs
@@ -1,10 +0,0 @@
-// src/components/admin.rs
-pub mod admin_panel;
-pub mod admin_panel_admin;
-pub mod add_table;
-pub mod add_logic;
-
-pub use admin_panel::*;
-pub use admin_panel_admin::*;
-pub use add_table::*;
-pub use add_logic::*;
--- a/client/src/components/auth.rs
+++ b/client/src/components/auth.rs
@@ -1,6 +0,0 @@
-// src/components/form.rs
-pub mod login;
-pub mod register;
-
-pub use login::*;
-pub use register::*;
--- a/client/src/components/common.rs
+++ b/client/src/components/common.rs
@@ -1,18 +1,9 @@
 // src/components/common.rs
-pub mod command_line;
-pub mod status_line;
+
 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::*;
 pub use text_editor::*;
 pub use background::*;
-pub use dialog::*;
 pub use autocomplete::*;
-pub use search_palette::*;
-pub use find_file_palette::*;
--- a/client/src/components/common/autocomplete.rs
+++ b/client/src/components/common/autocomplete.rs
@@ -1,8 +1,8 @@
 // src/components/common/autocomplete.rs

 use crate::config::colors::themes::Theme;
-use crate::state::pages::form::FormState;
 use common::proto::komp_ac::search::search_response::Hit;
+use crate::pages::forms::FormState;
 use ratatui::{
    layout::Rect,
    style::{Color, Modifier, Style},
--- a/client/src/components/form.rs
+++ b/client/src/components/form.rs
@@ -1,4 +0,0 @@
-// src/components/form.rs
-pub mod form;
-
-pub use form::*;
--- a/client/src/components/handlers.rs
+++ b/client/src/components/handlers.rs
@@ -1,6 +0,0 @@
-// src/components/handlers.rs
-pub mod sidebar;
-pub mod buffer_list;
-
-pub use sidebar::*;
-pub use buffer_list::*;
--- a/client/src/components/intro.rs
+++ b/client/src/components/intro.rs
@@ -1,4 +0,0 @@
-// src/components/intro.rs
-pub mod intro;
-
-pub use intro::*;
--- a/client/src/components/mod.rs
+++ b/client/src/components/mod.rs
@@ -1,16 +1,7 @@
 // src/components/mod.rs
-pub mod handlers;
-pub mod intro;
-pub mod admin;
+
 pub mod common;
-pub mod form;
-pub mod auth;
 pub mod utils;

-pub use handlers::*;
-pub use intro::*;
-pub use admin::*;
 pub use common::*;
-pub use form::*;
-pub use auth::*;
 pub use utils::*;
--- a/client/src/config/binds/config.rs
+++ b/client/src/config/binds/config.rs
@@ -5,6 +5,7 @@ use std::collections::HashMap;
 use std::path::Path;
 use anyhow::{Context, Result};
 use crossterm::event::{KeyCode, KeyModifiers};
+use canvas::CanvasKeyMap;

 // NEW: Editor Keybinding Mode Enum
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
@@ -147,19 +148,17 @@ impl Config {
    /// Context-aware keybinding resolution
    pub fn get_action_for_current_context(
        &self,
-        is_edit_mode: bool,
        command_mode: bool,
        key: KeyCode,
        modifiers: KeyModifiers
    ) -> Option<&str> {
-        match (command_mode, is_edit_mode) {
-            (true, _) => self.get_command_action_for_key(key, modifiers),
-            (_, true) => self.get_edit_action_for_key(key, modifiers)
-                .or_else(|| self.get_common_action(key, modifiers)),
-            _ => self.get_read_only_action_for_key(key, modifiers)
+        if command_mode {
+            self.get_command_action_for_key(key, modifiers)
+        } else {
+            // fallback: read-only + common + global
+            self.get_read_only_action_for_key(key, modifiers)
                .or_else(|| self.get_common_action(key, modifiers))
-                // Add global bindings check for read-only mode
-                .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.global, key, modifiers)),
+                .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.global, key, modifiers))
        }
    }

@@ -251,28 +250,63 @@ impl Config {
        key: KeyCode,
        modifiers: KeyModifiers,
    ) -> bool {
-        // Special handling for shift+character combinations
-        if binding.to_lowercase().starts_with("shift+") {
+
+        // Normalize binding once
+        let binding_lc = binding.to_lowercase();
+
+        // Robust handling for Shift+Tab
+        // Accept either BackTab (with or without SHIFT flagged) or Tab+SHIFT
+        if binding_lc == "shift+tab" || binding_lc == "backtab" {
+            return match key {
+                KeyCode::BackTab => true,
+                KeyCode::Tab => modifiers.contains(KeyModifiers::SHIFT),
+                _ => false,
+            };
+        }
+
+        // If binding contains '+', distinguish between:
+        // - modifier combos (e.g., ctrl+shift+s) => single key + modifiers
+        // - multi-key sequences (e.g., space+b+r, g+g) => NOT a single key
+        if binding_lc.contains('+') {
+            let parts: Vec<&str> = binding_lc.split('+').collect();
+            let is_modifier = |t: &str| {
+                matches!(
+                    t,
+                    "ctrl" | "control" | "shift" | "alt" | "super" | "windows" | "cmd" | "hyper" | "meta"
+                )
+            };
+            let non_modifier_count = parts.iter().filter(|p| !is_modifier(p)).count();
+            if non_modifier_count > 1 {
+                // This is a multi-key sequence (e.g., space+b+r, g+g), not a single keybind.
+                // It must be handled by the sequence engine, not here.
+                return false;
+            }
+        }
+
+        // Robust handling for shift+<char> (letters)
+        // Many terminals send uppercase Char without SHIFT bit.
+        if binding_lc.starts_with("shift+") {
            let parts: Vec<&str> = binding.split('+').collect();
-            if parts.len() == 2 && parts[1].len() == 1 {
-                let expected_lowercase = parts[1].chars().next().unwrap().to_lowercase().next().unwrap();
-                let expected_uppercase = expected_lowercase.to_uppercase().next().unwrap();
-                if let KeyCode::Char(actual_char) = key {
-                    if actual_char == expected_uppercase && modifiers.contains(KeyModifiers::SHIFT) {
+            if parts.len() == 2 && parts[1].chars().count() == 1 {
+                let base = parts[1].chars().next().unwrap();
+                let upper = base.to_ascii_uppercase();
+                let lower = base.to_ascii_lowercase();
+                if let KeyCode::Char(actual) = key {
+                    // Accept uppercase char regardless of SHIFT bit
+                    if actual == upper {
+                        return true;
+                    }
+                    // Also accept lowercase char with SHIFT flagged (some terms do this)
+                    if actual == lower && modifiers.contains(KeyModifiers::SHIFT) {
                        return true;
                    }
                }
            }
        }

-        // Handle Shift+Tab -> BackTab
-        if binding.to_lowercase() == "shift+tab" && key == KeyCode::BackTab && modifiers.is_empty() {
-            return true;
-        }
-
        // Handle multi-character bindings (all standard keys without modifiers)
        if binding.len() > 1 && !binding.contains('+') {
-            return match binding.to_lowercase().as_str() {
+            return match binding_lc.as_str() {
                // Navigation keys
                "left" => key == KeyCode::Left,
                "right" => key == KeyCode::Right,
@@ -372,6 +406,7 @@ impl Config {
        let mut expected_key = None;

        for part in parts {
+            let part_lc = part.to_lowercase();
            match part.to_lowercase().as_str() {
                // Modifiers
                "ctrl" | "control" => expected_modifiers |= KeyModifiers::CONTROL,
@@ -760,4 +795,74 @@ impl Config {
        }
        false
    }
+
+    /// Unified action resolver for app-level actions
+    pub fn get_app_action(
+        &self,
+        key_code: crossterm::event::KeyCode,
+        modifiers: crossterm::event::KeyModifiers,
+    ) -> Option<&str> {
+        // First check common actions
+        if let Some(action) = self.get_common_action(key_code, modifiers) {
+            return Some(action);
+        }
+
+        // Then check read-only mode actions
+        if let Some(action) = self.get_read_only_action_for_key(key_code, modifiers) {
+            return Some(action);
+        }
+
+        // Then check highlight mode actions
+        if let Some(action) = self.get_highlight_action_for_key(key_code, modifiers) {
+            return Some(action);
+        }
+
+        // Then check edit mode actions
+        if let Some(action) = self.get_edit_action_for_key(key_code, modifiers) {
+            return Some(action);
+        }
+
+        None
+    }
+
+    // Normalize bindings for canvas consumption:
+    // - "shift+<char>" -> also add "<CHAR>"
+    // - "shift+tab" -> also add "backtab"
+    // This keeps your config human-friendly while making the canvas happy.
+    fn normalize_for_canvas(
+        map: &HashMap<String, Vec<String>>,
+    ) -> HashMap<String, Vec<String>> {
+        let mut out: HashMap<String, Vec<String>> = HashMap::new();
+        for (action, bindings) in map {
+            let mut new_list: Vec<String> = Vec::new();
+            for b in bindings {
+                new_list.push(b.clone());
+                let blc = b.to_lowercase();
+                if blc.starts_with("shift+") {
+                    let parts: Vec<&str> = b.split('+').collect();
+                    if parts.len() == 2 && parts[1].chars().count() == 1 {
+                        let ch = parts[1].chars().next().unwrap();
+                        new_list.push(ch.to_ascii_uppercase().to_string());
+                    }
+                    if blc == "shift+tab" {
+                        new_list.push("backtab".to_string());
+                    }
+                }
+                if blc == "shift+tab" {
+                    new_list.push("backtab".to_string());
+                }
+            }
+            out.insert(action.clone(), new_list);
+        }
+        out
+    }
+
+    pub fn build_canvas_keymap(&self) -> CanvasKeyMap {
+        let ro = Self::normalize_for_canvas(&self.keybindings.read_only);
+        let ed = Self::normalize_for_canvas(&self.keybindings.edit);
+        let hl = Self::normalize_for_canvas(&self.keybindings.highlight);
+        CanvasKeyMap::from_mode_maps(&ro, &ed, &hl)
+    }
 }
+
+
--- a/client/src/config/binds/key_sequences.rs
+++ b/client/src/config/binds/key_sequences.rs
@@ -1,6 +1,7 @@
 // client/src/config/key_sequences.rs
 use crossterm::event::{KeyCode, KeyModifiers};
 use std::time::{Duration, Instant};
+use tracing::info;

 #[derive(Debug, Clone, PartialEq)]
 pub struct ParsedKey {
@@ -25,19 +26,21 @@ impl KeySequenceTracker {
    }

    pub fn reset(&mut self) {
+        info!("KeySequenceTracker.reset() from {:?}", self.current_sequence);
        self.current_sequence.clear();
        self.last_key_time = Instant::now();
    }

    pub fn add_key(&mut self, key: KeyCode) -> bool {
-        // Check if timeout has expired
        let now = Instant::now();
        if now.duration_since(self.last_key_time) > self.timeout {
+            info!("KeySequenceTracker timeout — reset before adding {:?}", key);
            self.reset();
        }

        self.current_sequence.push(key);
        self.last_key_time = now;
+        info!("KeySequenceTracker state after add: {:?}", self.current_sequence);
        true
    }

@@ -67,6 +70,7 @@ impl KeySequenceTracker {
 // Helper function to convert any KeyCode to a string representation
 pub fn key_to_string(key: &KeyCode) -> String {
    match key {
+        KeyCode::Char(' ') => "space".to_string(),
        KeyCode::Char(c) => c.to_string(),
        KeyCode::Left => "left".to_string(),
        KeyCode::Right => "right".to_string(),
@@ -90,6 +94,7 @@ pub fn key_to_string(key: &KeyCode) -> String {
 // Helper function to convert a string to a KeyCode
 pub fn string_to_keycode(s: &str) -> Option<KeyCode> {
    match s.to_lowercase().as_str() {
+        "space" => Some(KeyCode::Char(' ')),
        "left" => Some(KeyCode::Left),
        "right" => Some(KeyCode::Right),
        "up" => Some(KeyCode::Up),
@@ -113,26 +118,21 @@ pub fn string_to_keycode(s: &str) -> Option<KeyCode> {
 pub fn parse_binding(binding: &str) -> Vec<ParsedKey> {
    let mut sequence = Vec::new();

-    // Handle different binding formats
-    let parts: Vec<String> = if binding.contains('+') {
-        // Format with explicit '+' separators like "g+left"
-        binding.split('+').map(|s| s.to_string()).collect()
-    } else if binding.contains(' ') {
-        // Format with spaces like "g left"
-        binding.split(' ').map(|s| s.to_string()).collect()
-    } else if is_compound_key(binding) {
-        // A single compound key like "left" or "enter"
-        vec![binding.to_string()]
+    // Split into multi-key sequence:
+    // - If contains space → sequence split by space
+    // - Else split by '+'
+    let parts: Vec<&str> = if binding.contains(' ') {
+        binding.split(' ').collect()
    } else {
-        // Simple character sequence like "gg"
-        binding.chars().map(|c| c.to_string()).collect()
+        binding.split('+').collect()
    };

-    for part in &parts {
-        if let Some(key) = parse_key_part(part) {
-            sequence.push(key);
+    for part in parts {
+        if let Some(parsed) = parse_key_part(part) {
+            sequence.push(parsed);
        }
    }
+
    sequence
 }

@@ -140,7 +140,7 @@ fn is_compound_key(part: &str) -> bool {
    matches!(part.to_lowercase().as_str(),
        "esc" | "up" | "down" | "left" | "right" | "enter" |
        "backspace" | "delete" | "tab" | "backtab" | "home" |
-        "end" | "pageup" | "pagedown" | "insert"
+        "end" | "pageup" | "pagedown" | "insert" | "space"
    )
 }

--- a/client/src/config/colors/themes.rs
+++ b/client/src/config/colors/themes.rs
@@ -1,6 +1,6 @@
 // src/config/colors/themes.rs
 use ratatui::style::Color;
-use canvas::canvas::CanvasTheme;
+use canvas::CanvasTheme;

 #[derive(Debug, Clone)]
 pub struct Theme {
@@ -12,7 +12,7 @@ pub struct Theme {
    pub warning: Color,
    pub border: Color,
    pub highlight_bg: Color,
-    pub inactive_highlight_bg: Color,// admin panel no idea what it really is
+    pub inactive_highlight_bg: Color, // admin panel no idea what it really is
 }

 impl Theme {
@@ -108,4 +108,9 @@ impl CanvasTheme for Theme {
    fn warning(&self) -> Color {
        self.warning
    }
+
+    fn suggestion_gray(&self) -> Color {
+        // Neutral gray for suggestions
+        Color::Rgb(128, 128, 128)
+    }
 }
--- a/client/src/dialog/functions.rs
+++ b/client/src/dialog/functions.rs
@@ -0,0 +1,82 @@
+// src/dialog/functions.rs
+
+use crate::dialog::DialogState;
+use crate::state::app::state::AppState;
+use crate::ui::handlers::context::DialogPurpose;
+
+impl AppState {
+    pub fn show_dialog(
+        &mut self,
+        title: &str,
+        message: &str,
+        buttons: Vec<String>,
+        purpose: DialogPurpose,
+    ) {
+        self.ui.dialog.dialog_title = title.to_string();
+        self.ui.dialog.dialog_message = message.to_string();
+        self.ui.dialog.dialog_buttons = buttons;
+        self.ui.dialog.dialog_active_button_index = 0;
+        self.ui.dialog.purpose = Some(purpose);
+        self.ui.dialog.is_loading = false;
+        self.ui.dialog.dialog_show = true;
+    }
+
+    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();
+        self.ui.dialog.dialog_active_button_index = 0;
+        self.ui.dialog.purpose = None;
+        self.ui.dialog.is_loading = true;
+        self.ui.dialog.dialog_show = true;
+    }
+
+    pub fn update_dialog_content(
+        &mut self,
+        message: &str,
+        buttons: Vec<String>,
+        purpose: DialogPurpose,
+    ) {
+        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;
+            self.ui.dialog.purpose = Some(purpose);
+            self.ui.dialog.is_loading = false;
+        }
+    }
+
+    pub fn hide_dialog(&mut self) {
+        self.ui.dialog.dialog_show = false;
+        self.ui.dialog.dialog_title.clear();
+        self.ui.dialog.dialog_message.clear();
+        self.ui.dialog.dialog_buttons.clear();
+        self.ui.dialog.dialog_active_button_index = 0;
+        self.ui.dialog.purpose = None;
+        self.ui.dialog.is_loading = false;
+    }
+
+    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;
+        }
+    }
+
+    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;
+        }
+    }
+
+    pub fn get_active_dialog_button_label(&self) -> Option<&str> {
+        self.ui.dialog
+            .dialog_buttons
+            .get(self.ui.dialog.dialog_active_button_index)
+            .map(|s| s.as_str())
+    }
+}
--- a/client/src/dialog/logic.rs
+++ b/client/src/dialog/logic.rs
@@ -0,0 +1,206 @@
+// src/dialog/logic.rs
+
+// TODO(dialog-refactor):
+// Currently this module (`handle_dialog_event`) contains page-specific logic
+// (e.g. Login, Register, Admin, SaveTable). This couples the dialog crate
+// to application pages and business logic.
+//
+// Refactor plan:
+// 1. Keep dialog generic: only handle navigation (next/prev/select) and return
+//    a `DialogResult` (Dismissed | Selected { purpose, index }).
+// 2. Move all page-specific actions (e.g. login::back_to_main, register::back_to_login,
+//    handle_delete_selected_columns, buffer_state.update_history) into the
+//    respective page or event handler (e.g. modes/handlers/event.rs).
+// 3. Dialog crate should only provide state, rendering, and generic navigation.
+//    Pages decide what to do when a dialog button is pressed.
+
+use crossterm::event::{Event, KeyCode};
+use crate::config::binds::config::Config;
+use crate::ui::handlers::context::DialogPurpose;
+use crate::state::app::state::AppState;
+use crate::buffer::AppView;
+use crate::buffer::state::BufferState;
+use crate::modes::handlers::event::EventOutcome;
+use crate::pages::register;
+use crate::pages::login;
+use crate::pages::admin_panel::add_table::logic::handle_delete_selected_columns;
+use crate::pages::routing::{Router, Page};
+use anyhow::Result;
+
+/// Handles key events specifically when a dialog is active.
+/// Returns Some(Result<EventOutcome, Error>) if the event was handled (consumed),
+/// otherwise returns None.
+pub async fn handle_dialog_event(
+    event: &Event,
+    config: &Config,
+    app_state: &mut AppState,
+    buffer_state: &mut BufferState,
+    router: &mut Router,
+) -> Option<Result<EventOutcome>> {
+    if let Event::Key(key) = event {
+        // Always allow Esc to dismiss
+        if key.code == KeyCode::Esc {
+            app_state.hide_dialog();
+            return Some(Ok(EventOutcome::Ok("Dialog dismissed".to_string())));
+        }
+
+        // Check general bindings for dialog actions
+        if let Some(action) = config.get_general_action(key.code, key.modifiers) {
+            match action {
+                "move_down" | "next_option" => {
+                    let current_index = app_state.ui.dialog.dialog_active_button_index;
+                    let num_buttons = app_state.ui.dialog.dialog_buttons.len();
+                    if num_buttons > 0 && current_index < num_buttons - 1 {
+                        app_state.ui.dialog.dialog_active_button_index += 1;
+                    }
+                    return Some(Ok(EventOutcome::Ok(String::new())));
+                }
+                "move_up" | "previous_option" => {
+                    let current_index = app_state.ui.dialog.dialog_active_button_index;
+                    if current_index > 0 {
+                        app_state.ui.dialog.dialog_active_button_index -= 1;
+                    }
+                    return Some(Ok(EventOutcome::Ok(String::new())));
+                }
+                "select" => {
+                    let selected_index = app_state.ui.dialog.dialog_active_button_index;
+                    let purpose = match app_state.ui.dialog.purpose {
+                        Some(p) => p,
+                        None => {
+                            app_state.hide_dialog();
+                            return Some(Ok(EventOutcome::Ok(
+                                "Internal Error: Dialog context lost".to_string(),
+                            )));
+                        }
+                    };
+
+                    // Handle Dialog Actions Directly Here
+                    match purpose {
+                        DialogPurpose::LoginSuccess => match selected_index {
+                            0 => {
+                                // "Menu" button selected
+                                app_state.hide_dialog();
+                                if let Page::Login(state) = &mut router.current {
+                                    let message =
+                                        login::back_to_main(state, app_state, buffer_state).await;
+                                    return Some(Ok(EventOutcome::Ok(message)));
+                                }
+                                return Some(Ok(EventOutcome::Ok(
+                                    "Login state not active".to_string(),
+                                )));
+                            }
+                            1 => {
+                                app_state.hide_dialog();
+                                return Some(Ok(EventOutcome::Ok("Exiting dialog".to_string())));
+                            }
+                            _ => {
+                                app_state.hide_dialog();
+                                return Some(Ok(EventOutcome::Ok(
+                                    "Unknown dialog button selected".to_string(),
+                                )));
+                            }
+                        },
+                        DialogPurpose::LoginFailed => match selected_index {
+                            0 => {
+                                // "OK" button selected
+                                app_state.hide_dialog();
+                                return Some(Ok(EventOutcome::Ok(
+                                    "Login failed dialog dismissed".to_string(),
+                                )));
+                            }
+                            _ => {
+                                app_state.hide_dialog();
+                                return Some(Ok(EventOutcome::Ok(
+                                    "Unknown dialog button selected".to_string(),
+                                )));
+                            }
+                        },
+                        DialogPurpose::RegisterSuccess => match selected_index {
+                            0 => {
+                                // "OK" button for RegisterSuccess
+                                app_state.hide_dialog();
+                                if let Page::Register(state) = &mut router.current {
+                                    let message =
+                                        register::back_to_login(state, app_state, buffer_state)
+                                            .await;
+                                    return Some(Ok(EventOutcome::Ok(message)));
+                                }
+                                return Some(Ok(EventOutcome::Ok(
+                                    "Register state not active".to_string(),
+                                )));
+                            }
+                            _ => {
+                                app_state.hide_dialog();
+                                return Some(Ok(EventOutcome::Ok(
+                                    "Unknown dialog button selected".to_string(),
+                                )));
+                            }
+                        },
+                        DialogPurpose::RegisterFailed => match selected_index {
+                            0 => {
+                                // "OK" button for RegisterFailed
+                                app_state.hide_dialog(); // Just dismiss
+                                return Some(Ok(EventOutcome::Ok(
+                                    "Register failed dialog dismissed".to_string(),
+                                )));
+                            }
+                            _ => {
+                                app_state.hide_dialog();
+                                return Some(Ok(EventOutcome::Ok(
+                                    "Unknown dialog button selected".to_string(),
+                                )));
+                            }
+                        },
+                        DialogPurpose::ConfirmDeleteColumns => match selected_index {
+                            0 => {
+                                // "Confirm" button selected
+                                if let Page::AddTable(page) = &mut router.current {
+                                    let outcome_message = handle_delete_selected_columns(&mut page.state);
+                                    app_state.hide_dialog();
+                                    return Some(Ok(EventOutcome::Ok(outcome_message)));
+                                }
+                                return Some(Ok(EventOutcome::Ok(
+                                            "AddTable page not active".to_string(),
+                                )));                                
+                            }
+                            1 => {
+                                // "Cancel" button selected
+                                app_state.hide_dialog();
+                                return Some(Ok(EventOutcome::Ok("Deletion cancelled.".to_string())));
+                            }
+                            _ => { /* Handle unexpected index */ }
+                        },
+                        DialogPurpose::SaveTableSuccess => match selected_index {
+                            0 => {
+                                // "OK" button selected
+                                app_state.hide_dialog();
+                                buffer_state.update_history(AppView::Admin); // Navigate back
+                                return Some(Ok(EventOutcome::Ok(
+                                    "Save success dialog dismissed.".to_string(),
+                                )));
+                            }
+                            _ => { /* Handle unexpected index */ }
+                        },
+                        DialogPurpose::SaveLogicSuccess => match selected_index {
+                            0 => {
+                                // "OK" button selected
+                                app_state.hide_dialog();
+                                buffer_state.update_history(AppView::Admin);
+                                return Some(Ok(EventOutcome::Ok(
+                                    "Save success dialog dismissed.".to_string(),
+                                )));
+                            }
+                            _ => { /* Handle unexpected index */ }
+                        },
+                    }
+                }
+                _ => {} // Ignore other general actions when dialog is shown
+            }
+        }
+        // If it was a key event but not handled above, consume it
+        Some(Ok(EventOutcome::Ok(String::new())))
+    } else {
+        // If it wasn't a key event, consume it too while dialog is active
+        Some(Ok(EventOutcome::Ok(String::new())))
+    }
+}
--- a/client/src/dialog/mod.rs
+++ b/client/src/dialog/mod.rs
@@ -0,0 +1,10 @@
+// src/dialog/mod.rs
+
+pub mod ui;
+pub mod logic;
+pub mod state;
+pub mod functions;
+
+pub use ui::render_dialog;
+pub use logic::handle_dialog_event;
+pub use state::DialogState;
--- a/client/src/dialog/state.rs
+++ b/client/src/dialog/state.rs
@@ -0,0 +1,26 @@
+// src/dialog/state.rs
+use crate::ui::handlers::context::DialogPurpose;
+
+pub struct DialogState {
+    pub dialog_show: bool,
+    pub dialog_title: String,
+    pub dialog_message: String,
+    pub dialog_buttons: Vec<String>,
+    pub dialog_active_button_index: usize,
+    pub purpose: Option<DialogPurpose>,
+    pub is_loading: bool,
+}
+
+impl Default for DialogState {
+    fn default() -> Self {
+        Self {
+            dialog_show: false,
+            dialog_title: String::new(),
+            dialog_message: String::new(),
+            dialog_buttons: Vec::new(),
+            dialog_active_button_index: 0,
+            purpose: None,
+            is_loading: false,
+        }
+    }
+}
--- a/client/src/components/common/dialog.rs
+++ b/client/src/components/common/dialog.rs
@@ -1,3 +1,5 @@
+// src/dialog/ui.rs
+
 use crate::config::colors::themes::Theme;
 use ratatui::{
    layout::{Constraint, Direction, Layout, Margin, Rect},
--- a/client/src/functions/common.rs
+++ b/client/src/functions/common.rs
@@ -1,5 +0,0 @@
-// src/functions/common.rs
-
-pub mod buffer;
-
-pub use buffer::*;
--- a/client/src/functions/mod.rs
+++ b/client/src/functions/mod.rs
@@ -1,6 +0,0 @@
-// src/functions/mod.rs
-
-pub mod common;
-pub mod modes;
-
-pub use modes::*;
--- a/client/src/functions/modes.rs
+++ b/client/src/functions/modes.rs
@@ -1,5 +0,0 @@
-// src/functions/modes.rs
-
-pub mod navigation;
-
-pub use navigation::*;
--- a/client/src/functions/modes/navigation.rs
+++ b/client/src/functions/modes/navigation.rs
@@ -1,5 +0,0 @@
-// src/functions/modes/navigation.rs
-
-pub mod admin_nav;
-pub mod add_table_nav;
-pub mod add_logic_nav;
--- a/client/src/functions/modes/navigation/add_logic_nav.rs
+++ b/client/src/functions/modes/navigation/add_logic_nav.rs
@@ -1,440 +0,0 @@
-// src/functions/modes/navigation/add_logic_nav.rs
-use crate::config::binds::config::{Config, EditorKeybindingMode};
-use crate::state::{
-    app::state::AppState,
-    pages::add_logic::{AddLogicFocus, AddLogicState},
-    app::buffer::AppView,
-    app::buffer::BufferState,
-};
-use crossterm::event::{KeyEvent, KeyCode, KeyModifiers};
-use crate::services::GrpcClient;
-use tokio::sync::mpsc;
-use anyhow::Result;
-use crate::components::common::text_editor::TextEditor;
-use crate::services::ui_service::UiService;
-use tui_textarea::CursorMove; // Ensure this import is present
-
-pub type SaveLogicResultSender = mpsc::Sender<Result<String>>;
-
-pub fn handle_add_logic_navigation(
-    key_event: KeyEvent,
-    config: &Config,
-    app_state: &mut AppState,
-    add_logic_state: &mut AddLogicState,
-    is_edit_mode: &mut bool,
-    buffer_state: &mut BufferState,
-    grpc_client: GrpcClient,
-    _save_logic_sender: SaveLogicResultSender, // Marked as unused
-    command_message: &mut String,
-) -> bool {
-    // === FULLSCREEN SCRIPT EDITING - COMPLETE ISOLATION ===
-    if add_logic_state.current_focus == AddLogicFocus::InsideScriptContent {
-        // === AUTOCOMPLETE HANDLING ===
-        if add_logic_state.script_editor_autocomplete_active {
-            match key_event.code {
-                // ... (Char, Backspace, Tab, Down, Up cases remain the same) ...
-                KeyCode::Char(c) if c.is_alphanumeric() || c == '_' => {
-                    add_logic_state.script_editor_filter_text.push(c);
-                    add_logic_state.update_script_editor_suggestions();
-                    {
-                        let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                        TextEditor::handle_input(
-                            &mut editor_borrow,
-                            key_event,
-                            &add_logic_state.editor_keybinding_mode,
-                            &mut add_logic_state.vim_state,
-                        );
-                    }
-                    *command_message = format!("Filtering: @{}", add_logic_state.script_editor_filter_text);
-                    return true;
-                }
-                KeyCode::Backspace => {
-                    if !add_logic_state.script_editor_filter_text.is_empty() {
-                        add_logic_state.script_editor_filter_text.pop();
-                        add_logic_state.update_script_editor_suggestions();
-                        {
-                            let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                            TextEditor::handle_input(
-                                &mut editor_borrow,
-                                key_event,
-                                &add_logic_state.editor_keybinding_mode,
-                                &mut add_logic_state.vim_state,
-                            );
-                        }
-                        *command_message = if add_logic_state.script_editor_filter_text.is_empty() {
-                            "Autocomplete: @".to_string()
-                        } else {
-                            format!("Filtering: @{}", add_logic_state.script_editor_filter_text)
-                        };
-                    } else {
-                        let should_deactivate = if let Some((trigger_line, trigger_col)) = add_logic_state.script_editor_trigger_position {
-                            let current_cursor = {
-                                let editor_borrow = add_logic_state.script_content_editor.borrow();
-                                editor_borrow.cursor()
-                            };
-                            current_cursor.0 == trigger_line && current_cursor.1 == trigger_col + 1
-                        } else {
-                            false
-                        };
-                        if should_deactivate {
-                            add_logic_state.deactivate_script_editor_autocomplete();
-                            *command_message = "Autocomplete cancelled".to_string();
-                        }
-                        {
-                            let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                            TextEditor::handle_input(
-                                &mut editor_borrow,
-                                key_event,
-                                &add_logic_state.editor_keybinding_mode,
-                                &mut add_logic_state.vim_state,
-                            );
-                        }
-                    }
-                    return true;
-                }
-                KeyCode::Tab | KeyCode::Down => {
-                    if !add_logic_state.script_editor_suggestions.is_empty() {
-                        let current = add_logic_state.script_editor_selected_suggestion_index.unwrap_or(0);
-                        let next = (current + 1) % add_logic_state.script_editor_suggestions.len();
-                        add_logic_state.script_editor_selected_suggestion_index = Some(next);
-                        *command_message = format!("Selected: {}", add_logic_state.script_editor_suggestions[next]);
-                    }
-                    return true;
-                }
-                KeyCode::Up => {
-                    if !add_logic_state.script_editor_suggestions.is_empty() {
-                        let current = add_logic_state.script_editor_selected_suggestion_index.unwrap_or(0);
-                        let prev = if current == 0 {
-                            add_logic_state.script_editor_suggestions.len() - 1
-                        } else {
-                            current - 1
-                        };
-                        add_logic_state.script_editor_selected_suggestion_index = Some(prev);
-                        *command_message = format!("Selected: {}", add_logic_state.script_editor_suggestions[prev]);
-                    }
-                    return true;
-                }
-                KeyCode::Enter => {
-                    if let Some(selected_idx) = add_logic_state.script_editor_selected_suggestion_index {
-                        if let Some(suggestion) = add_logic_state.script_editor_suggestions.get(selected_idx).cloned() {
-                            let trigger_pos = add_logic_state.script_editor_trigger_position;
-                            let filter_len = add_logic_state.script_editor_filter_text.len();
-
-                            add_logic_state.deactivate_script_editor_autocomplete();
-                            add_logic_state.has_unsaved_changes = true;
-
-                            if let Some(pos) = trigger_pos {
-                                let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-
-                                if suggestion == "sql" {
-                                    replace_autocomplete_text(&mut editor_borrow, pos, filter_len, "sql");
-                                    editor_borrow.insert_str("('')");
-                                    // Move cursor back twice to be between the single quotes
-                                    editor_borrow.move_cursor(CursorMove::Back); // Before ')'
-                                    editor_borrow.move_cursor(CursorMove::Back); // Before ''' (inside '')
-                                    *command_message = "Inserted: @sql('')".to_string();
-                                } else {
-                                    let is_table_selection = add_logic_state.is_table_name_suggestion(&suggestion);
-                                    replace_autocomplete_text(&mut editor_borrow, pos, filter_len, &suggestion);
-
-                                    if is_table_selection {
-                                        editor_borrow.insert_str(".");
-                                        let new_cursor = editor_borrow.cursor();
-                                        drop(editor_borrow); // Release borrow before calling add_logic_state methods
-
-                                        add_logic_state.script_editor_trigger_position = Some(new_cursor);
-                                        add_logic_state.script_editor_autocomplete_active = true;
-                                        add_logic_state.script_editor_filter_text.clear();
-                                        add_logic_state.trigger_column_autocomplete_for_table(suggestion.clone());
-
-                                        let profile_name = add_logic_state.profile_name.clone();
-                                        let table_name_for_fetch = suggestion.clone();
-                                        let mut client_clone = grpc_client.clone();
-                                        tokio::spawn(async move {
-                                            match UiService::fetch_columns_for_table(&mut client_clone, &profile_name, &table_name_for_fetch).await {
-                                                Ok(_columns) => {
-                                                    // Result handled by main UI loop
-                                                }
-                                                Err(e) => {
-                                                    tracing::error!("Failed to fetch columns for {}.{}: {}", profile_name, table_name_for_fetch, e);
-                                                }
-                                            }
-                                        });
-                                        *command_message = format!("Selected table '{}', fetching columns...", suggestion);
-                                    } else {
-                                        *command_message = format!("Inserted: {}", suggestion);
-                                    }
-                                }
-                            }
-                            return true;
-                        }
-                    }
-                    add_logic_state.deactivate_script_editor_autocomplete();
-                    {
-                        let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                        TextEditor::handle_input(
-                            &mut editor_borrow,
-                            key_event,
-                            &add_logic_state.editor_keybinding_mode,
-                            &mut add_logic_state.vim_state,
-                        );
-                    }
-                    return true;
-                }
-                KeyCode::Esc => {
-                    add_logic_state.deactivate_script_editor_autocomplete();
-                    *command_message = "Autocomplete cancelled".to_string();
-                }
-                _ => {
-                    add_logic_state.deactivate_script_editor_autocomplete();
-                    *command_message = "Autocomplete cancelled".to_string();
-                    {
-                        let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                        TextEditor::handle_input(
-                            &mut editor_borrow,
-                            key_event,
-                            &add_logic_state.editor_keybinding_mode,
-                            &mut add_logic_state.vim_state,
-                        );
-                    }
-                    return true;
-                }
-            }
-        }
-
-        if key_event.code == KeyCode::Char('@') && key_event.modifiers == KeyModifiers::NONE {
-            let should_trigger = match add_logic_state.editor_keybinding_mode {
-                EditorKeybindingMode::Vim => *is_edit_mode,
-                _ => true,
-            };
-            if should_trigger {
-                let cursor_before = {
-                    let editor_borrow = add_logic_state.script_content_editor.borrow();
-                    editor_borrow.cursor()
-                };
-                {
-                    let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                    TextEditor::handle_input(
-                        &mut editor_borrow,
-                        key_event,
-                        &add_logic_state.editor_keybinding_mode,
-                        &mut add_logic_state.vim_state,
-                    );
-                }
-                add_logic_state.script_editor_trigger_position = Some(cursor_before);
-                add_logic_state.script_editor_autocomplete_active = true;
-                add_logic_state.script_editor_filter_text.clear();
-                add_logic_state.update_script_editor_suggestions();
-                add_logic_state.has_unsaved_changes = true;
-                *command_message = "Autocomplete: @ (Tab/↑↓ to navigate, Enter to select, Esc to cancel)".to_string();
-                return true;
-            }
-        }
-
-        if key_event.code == KeyCode::Esc && key_event.modifiers == KeyModifiers::NONE {
-            match add_logic_state.editor_keybinding_mode {
-                EditorKeybindingMode::Vim => {
-                    if *is_edit_mode {
-                        {
-                            let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-                            TextEditor::handle_input(
-                                &mut editor_borrow,
-                                key_event,
-                                &add_logic_state.editor_keybinding_mode,
-                                &mut add_logic_state.vim_state,
-                            );
-                        }
-                        if TextEditor::is_vim_normal_mode(&add_logic_state.vim_state) {
-                            *is_edit_mode = false;
-                            *command_message = "VIM: Normal Mode. Esc again to exit script.".to_string();
-                        }
-                    } else {
-                        add_logic_state.current_focus = AddLogicFocus::ScriptContentPreview;
-                        app_state.ui.focus_outside_canvas = true;
-                        *is_edit_mode = false;
-                        *command_message = "Exited script editing.".to_string();
-                    }
-                }
-                _ => {
-                    if *is_edit_mode {
-                        *is_edit_mode = false;
-                        *command_message = "Exited script edit. Esc again to exit script.".to_string();
-                    } else {
-                        add_logic_state.current_focus = AddLogicFocus::ScriptContentPreview;
-                        app_state.ui.focus_outside_canvas = true;
-                        *is_edit_mode = false;
-                        *command_message = "Exited script editing.".to_string();
-                    }
-                }
-            }
-            return true;
-        }
-
-        let changed = {
-            let mut editor_borrow = add_logic_state.script_content_editor.borrow_mut();
-            TextEditor::handle_input(
-                &mut editor_borrow,
-                key_event,
-                &add_logic_state.editor_keybinding_mode,
-                &mut add_logic_state.vim_state,
-            )
-        };
-        if changed {
-            add_logic_state.has_unsaved_changes = true;
-        }
-        if add_logic_state.editor_keybinding_mode == EditorKeybindingMode::Vim {
-            *is_edit_mode = !TextEditor::is_vim_normal_mode(&add_logic_state.vim_state);
-        }
-        return true;
-    }
-
-    let action = config.get_general_action(key_event.code, key_event.modifiers);
-    let current_focus = add_logic_state.current_focus;
-    let mut handled = true;
-    let mut new_focus = current_focus;
-
-    match action.as_deref() {
-        Some("exit_table_scroll") => {
-            handled = false;
-        }
-        Some("move_up") => {
-            match current_focus {
-                AddLogicFocus::InputLogicName => {}
-                AddLogicFocus::InputTargetColumn => new_focus = AddLogicFocus::InputLogicName,
-                AddLogicFocus::InputDescription => new_focus = AddLogicFocus::InputTargetColumn,
-                AddLogicFocus::ScriptContentPreview => new_focus = AddLogicFocus::InputDescription,
-                AddLogicFocus::SaveButton => new_focus = AddLogicFocus::ScriptContentPreview,
-                AddLogicFocus::CancelButton => new_focus = AddLogicFocus::SaveButton,
-                _ => handled = false,
-            }
-        }
-        Some("move_down") => {
-            match current_focus {
-                AddLogicFocus::InputLogicName => new_focus = AddLogicFocus::InputTargetColumn,
-                AddLogicFocus::InputTargetColumn => new_focus = AddLogicFocus::InputDescription,
-                AddLogicFocus::InputDescription => {
-                    add_logic_state.last_canvas_field = 2;
-                    new_focus = AddLogicFocus::ScriptContentPreview;
-                },
-                AddLogicFocus::ScriptContentPreview => new_focus = AddLogicFocus::SaveButton,
-                AddLogicFocus::SaveButton => new_focus = AddLogicFocus::CancelButton,
-                AddLogicFocus::CancelButton => {}
-                _ => handled = false,
-            }
-        }
-        Some("next_option") => {
-            match current_focus {
-                AddLogicFocus::InputLogicName | AddLogicFocus::InputTargetColumn | AddLogicFocus::InputDescription =>
-                    { new_focus = AddLogicFocus::ScriptContentPreview; }
-                AddLogicFocus::ScriptContentPreview => new_focus = AddLogicFocus::SaveButton,
-                AddLogicFocus::SaveButton => new_focus = AddLogicFocus::CancelButton,
-                AddLogicFocus::CancelButton => { }
-                _ => handled = false,
-            }
-        }
-        Some("previous_option") => {
-            match current_focus {
-                AddLogicFocus::InputLogicName | AddLogicFocus::InputTargetColumn | AddLogicFocus::InputDescription =>
-                    { }
-                AddLogicFocus::ScriptContentPreview => new_focus = AddLogicFocus::InputDescription,
-                AddLogicFocus::SaveButton => new_focus = AddLogicFocus::ScriptContentPreview,
-                AddLogicFocus::CancelButton => new_focus = AddLogicFocus::SaveButton,
-                _ => handled = false,
-            }
-        }
-        Some("next_field") => {
-            new_focus = match current_focus {
-                AddLogicFocus::InputLogicName => AddLogicFocus::InputTargetColumn,
-                AddLogicFocus::InputTargetColumn => AddLogicFocus::InputDescription,
-                AddLogicFocus::InputDescription => AddLogicFocus::ScriptContentPreview,
-                AddLogicFocus::ScriptContentPreview => AddLogicFocus::SaveButton,
-                AddLogicFocus::SaveButton => AddLogicFocus::CancelButton,
-                AddLogicFocus::CancelButton => AddLogicFocus::InputLogicName,
-                _ => current_focus,
-            };
-        }
-        Some("prev_field") => {
-            new_focus = match current_focus {
-                AddLogicFocus::InputLogicName => AddLogicFocus::CancelButton,
-                AddLogicFocus::InputTargetColumn => AddLogicFocus::InputLogicName,
-                AddLogicFocus::InputDescription => AddLogicFocus::InputTargetColumn,
-                AddLogicFocus::ScriptContentPreview => AddLogicFocus::InputDescription,
-                AddLogicFocus::SaveButton => AddLogicFocus::ScriptContentPreview,
-                AddLogicFocus::CancelButton => AddLogicFocus::SaveButton,
-                _ => current_focus,
-            };
-        }
-        Some("select") => {
-            match current_focus {
-                AddLogicFocus::ScriptContentPreview => {
-                    new_focus = AddLogicFocus::InsideScriptContent;
-                    *is_edit_mode = false;
-                    app_state.ui.focus_outside_canvas = false;
-                    let mode_hint = match add_logic_state.editor_keybinding_mode {
-                        EditorKeybindingMode::Vim => "VIM mode - 'i'/'a'/'o' to edit",
-                        _ => "Enter/Ctrl+E to edit",
-                    };
-                    *command_message = format!("Fullscreen script editing. {} or Esc to exit.", mode_hint);
-                }
-                AddLogicFocus::SaveButton => {
-                    *command_message = "Save logic action".to_string();
-                }
-                AddLogicFocus::CancelButton => {
-                    buffer_state.update_history(AppView::Admin);
-                    app_state.ui.show_add_logic = false;
-                    *command_message = "Cancelled Add Logic".to_string();
-                    *is_edit_mode = false;
-                }
-                AddLogicFocus::InputLogicName | AddLogicFocus::InputTargetColumn | AddLogicFocus::InputDescription => {
-                    *is_edit_mode = !*is_edit_mode;
-                    *command_message = format!("Field edit mode: {}", if *is_edit_mode { "ON" } else { "OFF" });
-                }
-                _ => handled = false,
-            }
-        }
-        Some("toggle_edit_mode") => {
-            match current_focus {
-                AddLogicFocus::InputLogicName | AddLogicFocus::InputTargetColumn | AddLogicFocus::InputDescription => {
-                    *is_edit_mode = !*is_edit_mode;
-                    *command_message = format!("Canvas field edit mode: {}", if *is_edit_mode { "ON" } else { "OFF" });
-                }
-                _ => {
-                    *command_message = "Cannot toggle edit mode here.".to_string();
-                }
-            }
-        }
-        _ => handled = false,
-    }
-
-    if handled && current_focus != new_focus {
-        add_logic_state.current_focus = new_focus;
-        let new_is_canvas_input_focus = matches!(new_focus,
-            AddLogicFocus::InputLogicName | AddLogicFocus::InputTargetColumn | AddLogicFocus::InputDescription
-        );
-        if new_is_canvas_input_focus {
-            *is_edit_mode = false;
-            app_state.ui.focus_outside_canvas = false;
-        } else {
-            app_state.ui.focus_outside_canvas = true;
-            if matches!(new_focus, AddLogicFocus::ScriptContentPreview) {
-                *is_edit_mode = false;
-            }
-        }
-    }
-    handled
-}
-
-fn replace_autocomplete_text(
-    editor: &mut tui_textarea::TextArea,
-    trigger_pos: (usize, usize),
-    filter_len: usize,
-    replacement: &str,
-) {
-    // use tui_textarea::CursorMove; // Already imported at the top of the module
-    let filter_start_pos = (trigger_pos.0, trigger_pos.1 + 1);
-    editor.move_cursor(CursorMove::Jump(filter_start_pos.0 as u16, filter_start_pos.1 as u16));
-    for _ in 0..filter_len {
-        editor.delete_next_char();
-    }
-    editor.insert_str(replacement);
-}
--- a/client/src/functions/modes/navigation/add_table_nav.rs
+++ b/client/src/functions/modes/navigation/add_table_nav.rs
@@ -1,205 +0,0 @@
-// src/functions/modes/navigation/add_table_nav.rs
-use crate::config::binds::config::Config;
-use crate::state::{
-    app::state::AppState,
-    pages::add_table::{AddTableFocus, AddTableState},
-};
-use crossterm::event::{KeyEvent};
-use ratatui::widgets::TableState;
-use crate::tui::functions::common::add_table::{handle_add_column_action, handle_save_table_action};
-use crate::ui::handlers::context::DialogPurpose;
-use crate::services::GrpcClient;
-use tokio::sync::mpsc;
-use anyhow::Result;
-
-pub type SaveTableResultSender = mpsc::Sender<Result<String>>;
-
-fn navigate_table_up(table_state: &mut TableState, item_count: usize) -> bool {
-    if item_count == 0 { return false; }
-    let current_selection = table_state.selected();
-    match current_selection {
-        Some(index) => {
-            if index > 0 { table_state.select(Some(index - 1)); true }
-            else { false }
-        }
-        None => { table_state.select(Some(0)); true }
-    }
-}
-
-fn navigate_table_down(table_state: &mut TableState, item_count: usize) -> bool {
-     if item_count == 0 { return false; }
-    let current_selection = table_state.selected();
-    match current_selection {
-        Some(index) => {
-            if index < item_count - 1 { table_state.select(Some(index + 1)); true }
-            else { false }
-        }
-        None => { table_state.select(Some(0)); true }
-    }
-}
-
-pub fn handle_add_table_navigation(
-    key: KeyEvent,
-    config: &Config,
-    app_state: &mut AppState,
-    add_table_state: &mut AddTableState,
-    grpc_client: GrpcClient,
-    save_result_sender: SaveTableResultSender,
-    command_message: &mut String,
-) -> bool {
-    let action = config.get_general_action(key.code, key.modifiers);
-    let current_focus = add_table_state.current_focus;
-    let mut handled = true;
-    let mut new_focus = current_focus;
-
-    if matches!(current_focus, AddTableFocus::InsideColumnsTable | AddTableFocus::InsideIndexesTable | AddTableFocus::InsideLinksTable) {
-        if matches!(action.as_deref(), Some("next_option") | Some("previous_option")) {
-            *command_message = "Press Esc to exit table item navigation first.".to_string();
-            return true;
-        }
-    }
-
-    match action.as_deref() {
-       Some("exit_table_scroll") => {
-           match current_focus {
-               AddTableFocus::InsideColumnsTable => {
-                   add_table_state.column_table_state.select(None);
-                   new_focus = AddTableFocus::ColumnsTable;
-                   // *command_message = "Exited Columns Table".to_string(); // Minimal change: remove message
-               }
-               AddTableFocus::InsideIndexesTable => {
-                   add_table_state.index_table_state.select(None);
-                   new_focus = AddTableFocus::IndexesTable;
-                   // *command_message = "Exited Indexes Table".to_string();
-               }
-               AddTableFocus::InsideLinksTable => {
-                   add_table_state.link_table_state.select(None);
-                   new_focus = AddTableFocus::LinksTable;
-                   // *command_message = "Exited Links Table".to_string();
-               }
-               _ => handled = false,
-           }
-       }
-        Some("move_up") => {
-            match current_focus {
-                AddTableFocus::InputTableName => {
-                    // MINIMAL CHANGE: Do nothing, new_focus remains current_focus
-                    // *command_message = "At top of form.".to_string(); // Remove message
-                }
-                AddTableFocus::InputColumnName => new_focus = AddTableFocus::InputTableName,
-                AddTableFocus::InputColumnType => new_focus = AddTableFocus::InputColumnName,
-                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::InputColumnType,
-                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::AddColumnButton,
-                AddTableFocus::IndexesTable => new_focus = AddTableFocus::ColumnsTable,
-                AddTableFocus::LinksTable => new_focus = AddTableFocus::IndexesTable,
-                AddTableFocus::InsideColumnsTable => { navigate_table_up(&mut add_table_state.column_table_state, add_table_state.columns.len()); }
-                AddTableFocus::InsideIndexesTable => { navigate_table_up(&mut add_table_state.index_table_state, add_table_state.indexes.len()); }
-                AddTableFocus::InsideLinksTable => { navigate_table_up(&mut add_table_state.link_table_state, add_table_state.links.len()); }
-                AddTableFocus::SaveButton => new_focus = AddTableFocus::LinksTable,
-                AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::SaveButton,
-                AddTableFocus::CancelButton => new_focus = AddTableFocus::DeleteSelectedButton,
-            }
-        }
-        Some("move_down") => {
-            match current_focus {
-                AddTableFocus::InputTableName => new_focus = AddTableFocus::InputColumnName,
-                AddTableFocus::InputColumnName => new_focus = AddTableFocus::InputColumnType,
-                AddTableFocus::InputColumnType => {
-                    add_table_state.last_canvas_field = 2;
-                    new_focus = AddTableFocus::AddColumnButton;
-                },
-                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::ColumnsTable,
-                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::IndexesTable,
-                AddTableFocus::IndexesTable => new_focus = AddTableFocus::LinksTable,
-                AddTableFocus::LinksTable => new_focus = AddTableFocus::SaveButton,
-                AddTableFocus::InsideColumnsTable => { navigate_table_down(&mut add_table_state.column_table_state, add_table_state.columns.len()); }
-                AddTableFocus::InsideIndexesTable => { navigate_table_down(&mut add_table_state.index_table_state, add_table_state.indexes.len()); }
-                AddTableFocus::InsideLinksTable => { navigate_table_down(&mut add_table_state.link_table_state, add_table_state.links.len()); }
-                AddTableFocus::SaveButton => new_focus = AddTableFocus::DeleteSelectedButton,
-                AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::CancelButton,
-                AddTableFocus::CancelButton => {
-                    // MINIMAL CHANGE: Do nothing, new_focus remains current_focus
-                    // *command_message = "At bottom of form.".to_string(); // Remove message
-                }
-            }
-        }
-        Some("next_option") => { // This logic should already be non-wrapping
-            match current_focus {
-                AddTableFocus::InputTableName | AddTableFocus::InputColumnName | AddTableFocus::InputColumnType =>
-                    { new_focus = AddTableFocus::AddColumnButton; }
-                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::ColumnsTable,
-                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::IndexesTable,
-                AddTableFocus::IndexesTable => new_focus = AddTableFocus::LinksTable,
-                AddTableFocus::LinksTable => new_focus = AddTableFocus::SaveButton,
-                AddTableFocus::SaveButton => new_focus = AddTableFocus::DeleteSelectedButton,
-                AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::CancelButton,
-                AddTableFocus::CancelButton => { /* *command_message = "At last focusable area.".to_string(); */ } // No change in focus
-                _ => handled = false,
-            }
-        }
-        Some("previous_option") => { // This logic should already be non-wrapping
-            match current_focus {
-                AddTableFocus::InputTableName | AddTableFocus::InputColumnName | AddTableFocus::InputColumnType =>
-                    { /* *command_message = "At first focusable area.".to_string(); */ } // No change in focus
-                AddTableFocus::AddColumnButton => new_focus = AddTableFocus::InputColumnType,
-                AddTableFocus::ColumnsTable => new_focus = AddTableFocus::AddColumnButton,
-                AddTableFocus::IndexesTable => new_focus = AddTableFocus::ColumnsTable,
-                AddTableFocus::LinksTable => new_focus = AddTableFocus::IndexesTable,
-                AddTableFocus::SaveButton => new_focus = AddTableFocus::LinksTable,
-                AddTableFocus::DeleteSelectedButton => new_focus = AddTableFocus::SaveButton,
-                AddTableFocus::CancelButton => new_focus = AddTableFocus::DeleteSelectedButton,
-                _ => handled = false,
-            }
-        }
-        Some("next_field") => {
-            new_focus = match current_focus {
-                AddTableFocus::InputTableName => AddTableFocus::InputColumnName, AddTableFocus::InputColumnName => AddTableFocus::InputColumnType, AddTableFocus::InputColumnType => AddTableFocus::AddColumnButton, AddTableFocus::AddColumnButton => AddTableFocus::ColumnsTable,
-                AddTableFocus::ColumnsTable | AddTableFocus::InsideColumnsTable => AddTableFocus::IndexesTable, AddTableFocus::IndexesTable | AddTableFocus::InsideIndexesTable => AddTableFocus::LinksTable, AddTableFocus::LinksTable | AddTableFocus::InsideLinksTable => AddTableFocus::SaveButton,
-                AddTableFocus::SaveButton => AddTableFocus::DeleteSelectedButton, AddTableFocus::DeleteSelectedButton => AddTableFocus::CancelButton, AddTableFocus::CancelButton => AddTableFocus::InputTableName,
-            };
-        }
-        Some("prev_field") => {
-            new_focus = match current_focus {
-                AddTableFocus::InputTableName => AddTableFocus::CancelButton, AddTableFocus::InputColumnName => AddTableFocus::InputTableName, AddTableFocus::InputColumnType => AddTableFocus::InputColumnName, AddTableFocus::AddColumnButton => AddTableFocus::InputColumnType,
-                AddTableFocus::ColumnsTable | AddTableFocus::InsideColumnsTable => AddTableFocus::AddColumnButton, AddTableFocus::IndexesTable | AddTableFocus::InsideIndexesTable => AddTableFocus::ColumnsTable, AddTableFocus::LinksTable | AddTableFocus::InsideLinksTable => AddTableFocus::IndexesTable,
-                AddTableFocus::SaveButton => AddTableFocus::LinksTable, AddTableFocus::DeleteSelectedButton => AddTableFocus::SaveButton, AddTableFocus::CancelButton => AddTableFocus::DeleteSelectedButton,
-            };
-        }
-        Some("select") => {
-            match current_focus {
-                AddTableFocus::ColumnsTable => { new_focus = AddTableFocus::InsideColumnsTable; if add_table_state.column_table_state.selected().is_none() && !add_table_state.columns.is_empty() { add_table_state.column_table_state.select(Some(0)); } /* Message removed */ }
-                AddTableFocus::IndexesTable => { new_focus = AddTableFocus::InsideIndexesTable; if add_table_state.index_table_state.selected().is_none() && !add_table_state.indexes.is_empty() { add_table_state.index_table_state.select(Some(0)); } /* Message removed */ }
-                AddTableFocus::LinksTable => { new_focus = AddTableFocus::InsideLinksTable; if add_table_state.link_table_state.selected().is_none() && !add_table_state.links.is_empty() { add_table_state.link_table_state.select(Some(0)); } /* Message removed */ }
-                AddTableFocus::InsideColumnsTable => { if let Some(index) = add_table_state.column_table_state.selected() { if let Some(col) = add_table_state.columns.get_mut(index) { col.selected = !col.selected; add_table_state.has_unsaved_changes = true; /* Message removed */ }} /* else { Message removed } */ }
-                AddTableFocus::InsideIndexesTable => { if let Some(index) = add_table_state.index_table_state.selected() { if let Some(idx_def) = add_table_state.indexes.get_mut(index) { idx_def.selected = !idx_def.selected; add_table_state.has_unsaved_changes = true; /* Message removed */ }} /* else { Message removed } */ }
-                AddTableFocus::InsideLinksTable => { if let Some(index) = add_table_state.link_table_state.selected() { if let Some(link) = add_table_state.links.get_mut(index) { link.selected = !link.selected; add_table_state.has_unsaved_changes = true; /* Message removed */ }} /* else { Message removed } */ }
-                AddTableFocus::AddColumnButton => { if let Some(focus_after_add) = handle_add_column_action(add_table_state, command_message) { new_focus = focus_after_add; } else { /* Message already set by handle_add_column_action */ }}
-                AddTableFocus::SaveButton => { if add_table_state.table_name.is_empty() { *command_message = "Cannot save: Table name is empty.".to_string(); } else if add_table_state.columns.is_empty() { *command_message = "Cannot save: No columns defined.".to_string(); } else { *command_message = "Saving table...".to_string(); app_state.show_loading_dialog("Saving", "Please wait..."); let mut client_clone = grpc_client.clone(); let state_clone = add_table_state.clone(); let sender_clone = save_result_sender.clone(); tokio::spawn(async move { let result = handle_save_table_action(&mut client_clone, &state_clone).await; let _ = sender_clone.send(result).await; }); }}
-                AddTableFocus::DeleteSelectedButton => { let columns_to_delete: Vec<(usize, String, String)> = add_table_state.columns.iter().enumerate().filter(|(_, col)| col.selected).map(|(index, col)| (index, col.name.clone(), col.data_type.clone())).collect(); if columns_to_delete.is_empty() { *command_message = "No columns selected for deletion.".to_string(); } else { let column_details: String = columns_to_delete.iter().map(|(index, name, dtype)| format!("{}. {} ({})", index + 1, name, dtype)).collect::<Vec<String>>().join("\n"); let message = format!("Delete the following columns?\n\n{}", column_details); app_state.show_dialog("Confirm Deletion", &message, vec!["Confirm".to_string(), "Cancel".to_string()], DialogPurpose::ConfirmDeleteColumns); }}
-                AddTableFocus::CancelButton => { *command_message = "Action: Cancel Add Table (Not Implemented)".to_string(); }
-                _ => { handled = false; }
-            }
-        }
-        _ => handled = false,
-    }
-
-    if handled && current_focus != new_focus {
-        add_table_state.current_focus = new_focus;
-        // Minimal change: Command message update logic can be simplified or removed if not desired
-        // For now, let's keep it minimal and only update if it was truly a focus change,
-        // and not a boundary message.
-        if !command_message.starts_with("At ") && current_focus != new_focus { // Avoid overwriting boundary messages
-            // *command_message = format!("Focus: {:?}", add_table_state.current_focus); // Optional: restore if needed
-        }
-
-
-        let new_is_canvas_input_focus = matches!(new_focus,
-            AddTableFocus::InputTableName | AddTableFocus::InputColumnName | AddTableFocus::InputColumnType
-        );
-        app_state.ui.focus_outside_canvas = !new_is_canvas_input_focus;
-    }
-    // If not handled, command_message remains as it was (e.g., from a deeper function call or previous event)
-    // or can be cleared if that's the desired default. For minimal change, we leave it.
-
-    handled
-}
--- a/client/src/input/action.rs
+++ b/client/src/input/action.rs
@@ -0,0 +1,41 @@
+// src/input/action.rs
+use crate::movement::MovementAction;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BufferAction {
+  Next,
+  Previous,
+  Close,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CoreAction {
+  Save,
+  ForceQuit,
+  SaveAndQuit,
+  Revert,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum AppAction {
+  // Global/UI
+  ToggleSidebar,
+  ToggleBufferList,
+  OpenSearch,
+  FindFilePaletteToggle,
+
+  // Buffers
+  Buffer(BufferAction),
+
+  // Command mode
+  EnterCommandMode,
+  ExitCommandMode,
+  CommandExecute,
+  CommandBackspace,
+
+  // Navigation across UI
+  Navigate(MovementAction),
+
+  // Core actions
+  Core(CoreAction),
+}
--- a/client/src/input/engine.rs
+++ b/client/src/input/engine.rs
@@ -0,0 +1,195 @@
+// src/input/engine.rs
+use crate::config::binds::config::Config;
+use crate::config::binds::key_sequences::KeySequenceTracker;
+use crate::input::action::{AppAction, BufferAction, CoreAction};
+use crate::movement::MovementAction;
+use crate::modes::handlers::mode_manager::AppMode;
+use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+use crate::input::leader::{leader_has_any_start, leader_is_prefix, leader_match_action};
+use tracing::info;
+
+#[derive(Debug, Clone, Copy)]
+pub struct InputContext {
+  pub app_mode: AppMode,
+  pub overlay_active: bool,
+  pub allow_navigation_capture: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum InputOutcome {
+  Action(AppAction),
+  Pending,      // sequence in progress
+  PassThrough,  // let page/canvas handle it
+}
+
+pub struct InputEngine {
+  seq: KeySequenceTracker,
+  leader_seq: KeySequenceTracker,
+}
+
+impl InputEngine {
+    pub fn new(normal_timeout_ms: u64, leader_timeout_ms: u64) -> Self {
+        Self {
+            seq: KeySequenceTracker::new(normal_timeout_ms),
+            leader_seq: KeySequenceTracker::new(leader_timeout_ms),
+        }
+    }
+
+    pub fn reset_sequence(&mut self) {
+        info!("InputEngine.reset_sequence() leader_seq_before={:?}", self.leader_seq.current_sequence);
+        self.seq.reset();
+        self.leader_seq.reset();
+    }
+
+    pub fn has_active_sequence(&self) -> bool {
+        !self.seq.current_sequence.is_empty()
+            || !self.leader_seq.current_sequence.is_empty()
+    }
+
+    pub fn process_key(
+        &mut self,
+        key_event: KeyEvent,
+        ctx: &InputContext,
+        config: &Config,
+    ) -> InputOutcome {
+        // Command mode keys are special (exit/execute/backspace) and typed chars
+        if ctx.app_mode == AppMode::Command {
+            if config.is_exit_command_mode(key_event.code, key_event.modifiers) {
+                self.seq.reset();
+                return InputOutcome::Action(AppAction::ExitCommandMode);
+            }
+            if config.is_command_execute(key_event.code, key_event.modifiers) {
+                self.seq.reset();
+                return InputOutcome::Action(AppAction::CommandExecute);
+            }
+            if config.is_command_backspace(key_event.code, key_event.modifiers) {
+                self.seq.reset();
+                return InputOutcome::Action(AppAction::CommandBackspace);
+            }
+            // Let command-line collect characters and other keys pass through
+            self.seq.reset();
+            return InputOutcome::PassThrough;
+        }
+
+        // If overlays are active, do not intercept (palette, navigation, etc.)
+        if ctx.overlay_active {
+            self.seq.reset();
+            // Also reset leader sequence to avoid leaving a stale "space" active
+            info!("Overlay active → reset leader_seq (was {:?})", self.leader_seq.current_sequence);
+            self.leader_seq.reset();
+            return InputOutcome::PassThrough;
+        }
+
+        // Space-led multi-key sequences (leader = space)
+        let space = KeyCode::Char(' ');
+        let leader_active = !self.leader_seq.current_sequence.is_empty()
+            && self.leader_seq.current_sequence[0] == space;
+
+        // Keep collecting leader sequence even if allow_navigation_capture is false.
+        if leader_active {
+            self.leader_seq.add_key(key_event.code);
+            let sequence = self.leader_seq.get_sequence();
+            info!(
+                "Leader active updated: {:?} (added {:?})",
+                sequence, key_event.code
+            );
+
+            if let Some(action_str) = leader_match_action(config, &sequence) {
+                info!("Leader matched '{}' with sequence {:?}", action_str, sequence);
+                if let Some(app_action) = map_action_string(action_str, ctx) {
+                    self.leader_seq.reset();
+                    return InputOutcome::Action(app_action);
+                }
+                self.leader_seq.reset();
+                return InputOutcome::PassThrough;
+            }
+
+            if leader_is_prefix(config, &sequence) {
+                info!("Leader prefix continuing...");
+                return InputOutcome::Pending;
+            }
+
+            info!("Leader sequence reset (no match/prefix).");
+            self.leader_seq.reset();
+            // fall through to regular handling of this key
+        } else if ctx.allow_navigation_capture
+            && key_event.code == space
+            && leader_has_any_start(config)
+        {
+            // Start a leader sequence only if capturing is allowed
+            self.leader_seq.reset();
+            self.leader_seq.add_key(space);
+            info!("Leader started: {:?}", self.leader_seq.get_sequence());
+            return InputOutcome::Pending;
+        }
+
+        // Single-key mapping: try general binds first (arrows, open_search, enter_command_mode)
+        if let Some(action_str) =
+            config.get_general_action(key_event.code, key_event.modifiers)
+        {
+            if let Some(app_action) = map_action_string(action_str, ctx) {
+                return InputOutcome::Action(app_action);
+            }
+            // Unknown to app layer (likely canvas movement etc.) → pass
+            return InputOutcome::PassThrough;
+        }
+
+        // Then app-level common/read-only/edit/highlight for UI toggles or core actions
+        if let Some(action_str) = config.get_app_action(key_event.code, key_event.modifiers) {
+            if let Some(app_action) = map_action_string(action_str, ctx) {
+                return InputOutcome::Action(app_action);
+            }
+        }
+
+        InputOutcome::PassThrough
+    }
+}
+
+fn str_to_movement(s: &str) -> Option<MovementAction> {
+  match s {
+    "up" => Some(MovementAction::Up),
+    "down" => Some(MovementAction::Down),
+    "left" => Some(MovementAction::Left),
+    "right" => Some(MovementAction::Right),
+    "next" => Some(MovementAction::Next),
+    "previous" => Some(MovementAction::Previous),
+    "select" => Some(MovementAction::Select),
+    "esc" => Some(MovementAction::Esc),
+    _ => None,
+  }
+}
+
+fn map_action_string(action: &str, ctx: &InputContext) -> Option<AppAction> {
+  match action {
+    // Global/UI
+    "toggle_sidebar" => Some(AppAction::ToggleSidebar),
+    "toggle_buffer_list" => Some(AppAction::ToggleBufferList),
+    "open_search" => Some(AppAction::OpenSearch),
+    "find_file_palette_toggle" => Some(AppAction::FindFilePaletteToggle),
+
+    // Buffers
+    "next_buffer" => Some(AppAction::Buffer(BufferAction::Next)),
+    "previous_buffer" => Some(AppAction::Buffer(BufferAction::Previous)),
+    "close_buffer" => Some(AppAction::Buffer(BufferAction::Close)),
+
+    // Command mode
+    "enter_command_mode" => Some(AppAction::EnterCommandMode),
+    "exit_command_mode" => Some(AppAction::ExitCommandMode),
+    "command_execute" => Some(AppAction::CommandExecute),
+    "command_backspace" => Some(AppAction::CommandBackspace),
+
+    // Navigation across UI (only if allowed)
+    s if str_to_movement(s).is_some() && ctx.allow_navigation_capture => {
+      Some(AppAction::Navigate(str_to_movement(s).unwrap()))
+    }
+
+    // Core actions
+    "save" => Some(AppAction::Core(CoreAction::Save)),
+    "force_quit" => Some(AppAction::Core(CoreAction::ForceQuit)),
+    "save_and_quit" => Some(AppAction::Core(CoreAction::SaveAndQuit)),
+    "revert" => Some(AppAction::Core(CoreAction::Revert)),
+
+    // Unknown to app layer: ignore (canvas-specific actions, etc.)
+    _ => None,
+  }
+}
--- a/client/src/input/leader.rs
+++ b/client/src/input/leader.rs
@@ -0,0 +1,74 @@
+// src/input/leader.rs
+use crate::config::binds::config::Config;
+use crate::config::binds::key_sequences::parse_binding;
+use crossterm::event::KeyCode;
+
+/// Collect leader (= space-prefixed) bindings from *all* binding maps
+fn leader_bindings<'a>(config: &'a Config) -> Vec<(&'a str, Vec<KeyCode>)> {
+    let mut out = Vec::new();
+
+    // Include all keybinding maps, not just global
+    let all_modes: Vec<&std::collections::HashMap<String, Vec<String>>> = vec![
+        &config.keybindings.general,
+        &config.keybindings.read_only,
+        &config.keybindings.edit,
+        &config.keybindings.highlight,
+        &config.keybindings.command,
+        &config.keybindings.common,
+        &config.keybindings.global,
+    ];
+
+    for mode in all_modes {
+        for (action, bindings) in mode {
+            for b in bindings {
+                let parsed = parse_binding(b);
+                if parsed.first().map(|pk| pk.code) == Some(KeyCode::Char(' ')) {
+                    let codes =
+                        parsed.into_iter().map(|pk| pk.code).collect::<Vec<_>>();
+                    out.push((action.as_str(), codes));
+                }
+            }
+        }
+    }
+    out
+}
+
+/// Is there any leader binding configured at all?
+pub fn leader_has_any_start(config: &Config) -> bool {
+    leader_bindings(config)
+        .iter()
+        .any(|(_, seq)| seq.first() == Some(&KeyCode::Char(' ')))
+}
+
+/// Is `sequence` a prefix of any configured leader sequence?
+pub fn leader_is_prefix(config: &Config, sequence: &[KeyCode]) -> bool {
+    if sequence.is_empty() || sequence[0] != KeyCode::Char(' ') {
+        return false;
+    }
+    for (_, full) in leader_bindings(config) {
+        if full.len() > sequence.len()
+            && full.iter().zip(sequence.iter()).all(|(a, b)| a == b)
+        {
+            return true;
+        }
+    }
+    false
+}
+
+/// Is `sequence` an exact leader match? If yes, return the action string.
+pub fn leader_match_action<'a>(
+    config: &'a Config,
+    sequence: &[KeyCode],
+) -> Option<&'a str> {
+    if sequence.is_empty() || sequence[0] != KeyCode::Char(' ') {
+        return None;
+    }
+    for (action, full) in leader_bindings(config) {
+        if full.len() == sequence.len()
+            && full.iter().zip(sequence.iter()).all(|(a, b)| a == b)
+        {
+            return Some(action);
+        }
+    }
+    None
+}
--- a/client/src/input/mod.rs
+++ b/client/src/input/mod.rs
@@ -0,0 +1,4 @@
+// src/input/mod.rs
+pub mod action;
+pub mod engine;
+pub mod leader;
--- a/client/src/lib.rs
+++ b/client/src/lib.rs
@@ -5,9 +5,16 @@ pub mod config;
 pub mod state;
 pub mod components;
 pub mod modes;
-pub mod functions;
 pub mod services;
 pub mod utils;
+pub mod buffer;
+pub mod sidebar;
+pub mod dialog;
+pub mod search;
+pub mod bottom_panel;
+pub mod pages;
+pub mod movement;
+pub mod input;

 pub use ui::run_ui;

--- a/client/src/main.rs
+++ b/client/src/main.rs
@@ -4,26 +4,35 @@ use client::run_ui;
 use client::utils::debug_logger::UiDebugWriter;
 use dotenvy::dotenv;
 use anyhow::Result;
-use tracing_subscriber;
+use tracing_subscriber::EnvFilter;
 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();
+        use std::sync::Once;
+        static INIT_LOGGER: Once = Once::new();
+
+        INIT_LOGGER.call_once(|| {
+            let writer = UiDebugWriter::new();
+            let _ = tracing_subscriber::fmt()
+                .with_max_level(tracing::Level::DEBUG)
+                .with_target(false)
+                .without_time()
+                .with_writer(move || writer.clone())
+                // Filter out noisy grpc/h2 internals
+                .with_env_filter("client=debug,tonic=info,h2=info,tower=info")
+                .try_init();
+
+            client::utils::debug_logger::spawn_file_logger();
+        });
    }
+
    #[cfg(not(feature = "ui-debug"))]
    {
        if env::var("ENABLE_TRACING").is_ok() {
-            tracing_subscriber::fmt::init();
+            let _ = tracing_subscriber::fmt::try_init();
        }
    }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Priec	ceb560c658	serialization of the gRPC JSONB now fully works for the validation	2025-09-14 11:24:27 +02:00
Priec	d88c239bf6	serde of jsonb in grpc	2025-09-14 10:56:38 +02:00
filipriec	01c4ff2e14	validation backend	2025-09-13 21:15:44 +02:00
Priec	c2890e1f3d	tests via script and make test works now	2025-09-13 08:53:26 +02:00
Priec	e1ea44c68c	inputing data for the client for the validation	2025-09-12 23:06:42 +02:00
Priec	cec2361b00	validation1 for the form	2025-09-12 21:25:49 +02:00
Priec	9672b9949c	finally a working space	2025-09-12 19:14:21 +02:00
Priec	e4e9594a9d	minor changes	2025-09-12 19:05:17 +02:00
Priec	6daa5202b1	debug is now running properly in the background without any issues	2025-09-12 18:17:52 +02:00
Priec	cae47da5f2	reused grpc connections, not a constant refreshes anymore, all fixed now, keep on fixing other bugs	2025-09-12 18:15:46 +02:00
filipriec	85c7c89c28	space2 is now debugging better	2025-09-12 15:46:14 +02:00
Priec	0d80266e9b	space commands here we go again	2025-09-11 22:36:40 +02:00
Priec	a604d62d44	inputs from keyboard are now decoupled	2025-09-10 22:12:22 +02:00
Priec	2cbbfd21aa	revert works on login, now do the same for other pages as well	2025-09-08 22:11:53 +02:00
Priec	1c17d07497	space and revert working properly well, also shift	2025-09-08 20:05:39 +02:00
Priec	ad15becd7a	doing key sequencing via space	2025-09-08 12:56:03 +02:00
Priec	c2a6272413	buttons in add_logic and add_table works properly well now	2025-09-04 18:56:21 +02:00
Priec	c51af13fb1	intro buttons fixed	2025-09-04 17:46:32 +02:00
Priec	d9d8562539	moving the state from general to each page owning its own state of button or canvas focus	2025-09-04 17:36:13 +02:00
Priec	6891631b8d	validation of exact strings	2025-09-02 13:52:36 +02:00
Priec	738d58b5f1	moving add_table to add_logic modern architecture3	2025-09-02 11:46:35 +02:00
Priec	3081125716	moving add_table to add_logic modern architecture2	2025-09-02 00:36:49 +02:00
Priec	6073c7ab43	moving add_table to add_logic modern architecture	2025-09-02 00:23:50 +02:00
filipriec	8157dc7a60	add_table working properly well	2025-09-01 16:37:43 +02:00
filipriec	3b130e9208	add_table fixing	2025-09-01 16:30:57 +02:00
Priec	ab81434c4e	add table3	2025-09-01 07:41:13 +02:00
Priec	62c54dc1eb	moving add table to the same way as add logic	2025-08-31 23:07:57 +02:00
Priec	347802b2a4	working suggestions in add_logic	2025-08-31 21:48:54 +02:00
Priec	a5a8d98984	add Logic fully decoupled	2025-08-31 21:37:18 +02:00
filipriec	5b42da8290	separate page	2025-08-31 21:25:43 +02:00
filipriec	4e041f36ce	move out of canvas properly fixed, now working everyhing properly well	2025-08-31 10:02:48 +02:00
filipriec	22926b7266	add logic now using general movement	2025-08-30 22:38:48 +02:00
filipriec	0a7f032028	add_logic cursor when refocus is proper again	2025-08-30 21:26:20 +02:00
filipriec	4edec5e72d	add logic is now using canvas library now	2025-08-30 21:10:10 +02:00
filipriec	c7d524c76a	add table and add logic removal from ui.rs and event.rs	2025-08-30 19:47:26 +02:00
filipriec	9ed558562b	moved admin now	2025-08-30 19:26:12 +02:00
filipriec	43f5c1a764	login and register are now havving own handlers and loaders, moving logic out of event.rs and ui.rs	2025-08-30 19:13:12 +02:00
filipriec	46149c09db	event.rs and ui.rs refactor for the forms page(moved logic to the forms page dir and just calling it now)	2025-08-30 16:42:04 +02:00
filipriec	a0757efe8b	moved add_table and add_logic, needs more things done tho	2025-08-30 14:46:34 +02:00
filipriec	10f4b9d8e2	moved add_table to be feature based	2025-08-30 14:25:33 +02:00
filipriec	42db496ad7	admin page being rendered properly well now	2025-08-30 13:32:45 +02:00
filipriec	d6fd672409	roles are now better	2025-08-30 13:19:45 +02:00
filipriec	60eb1c9f51	register has dropdown now	2025-08-29 22:07:04 +02:00
filipriec	a09c804595	intro empty buffer fixed	2025-08-29 20:13:25 +02:00
filipriec	a17f73fd54	buffer bug fixed, now proper names are being displayed	2025-08-29 19:53:31 +02:00
filipriec	2373ae4b8c	form pages robust finish chnages	2025-08-29 19:49:27 +02:00
filipriec	16dd460469	we compiled but buffer doesnt work	2025-08-29 18:11:27 +02:00
filipriec	58f109ca91	adding to have multiple forms pages	2025-08-29 16:18:42 +02:00
filipriec	75da9c0f4b	login and register are sending data to the backend successfuly	2025-08-29 14:46:43 +02:00
filipriec	833b918c5b	cursor style is handled properly now	2025-08-29 12:32:33 +02:00
filipriec	72c2691a17	registration now has working form	2025-08-29 12:22:25 +02:00
filipriec	cf79bc7bd5	bottom_panel decoupled	2025-08-29 08:25:24 +02:00
filipriec	f5f2f2cdef	login page using canvas library	2025-08-28 21:26:21 +02:00
filipriec	19a9bab8c2	login page using canvas for forms	2025-08-28 21:07:23 +02:00
filipriec	6e221ef8c1	HARDEST COMMIT IN THE RECENT TIMES we fixed movement in the admin page	2025-08-28 13:43:17 +02:00
Priec	e142f56706	admin page	2025-08-28 09:15:14 +02:00
Priec	a794f22366	admin page is now featured	2025-08-27 16:32:20 +02:00
Priec	cfe4903c79	admin page is now featured	2025-08-27 16:32:09 +02:00
Priec	a0a473f96c	admin page	2025-08-27 12:14:09 +02:00
Priec	9e4dd3b4c7	intro movement fully fixed	2025-08-27 01:38:51 +02:00
Priec	e5db0334c0	fixed intro movement, select not working yet	2025-08-27 01:34:56 +02:00
Priec	d641ad1bbb	centralized general movement	2025-08-27 01:06:54 +02:00
filipriec	18393ff661	is edit mode is gone from the codebase	2025-08-24 16:54:18 +02:00
filipriec	b2a82fba30	fixing is_edit_mode flag removal	2025-08-24 16:37:30 +02:00
filipriec	f6c2fd627f	fixing is_edit_mode	2025-08-24 16:00:58 +02:00
filipriec	15d9b31cb6	removing edit mode from the codebase	2025-08-24 15:32:24 +02:00
filipriec	06cc1663b3	working general mode only with canvas, removing highlight, readonly or edit	2025-08-23 23:34:14 +02:00
filipriec	88a4b2d69c	intro is now separated	2025-08-23 21:58:29 +02:00
filipriec	e6072d25c5	register is now separated also	2025-08-23 21:47:18 +02:00
filipriec	fc2b65601e	login function moved	2025-08-23 21:05:02 +02:00
filipriec	597bdde7e1	login moved to the pages	2025-08-23 20:58:12 +02:00
filipriec	f56092e86c	login page now in a separate dir	2025-08-23 19:48:23 +02:00
filipriec	d5cfe59f47	dialog refactor comment, dialog crate finished for now	2025-08-23 13:36:46 +02:00
filipriec	f281eaa662	dialog is a feature	2025-08-23 13:29:28 +02:00
Priec	cbb3ed7c48	small cleanup	2025-08-23 00:22:07 +02:00
Priec	41a0b85376	forms page moved more2	2025-08-23 00:16:07 +02:00
Priec	b5a31ee81c	forms page	2025-08-22 23:54:22 +02:00
Priec	dceb031822	removed docs book from git history	2025-08-22 23:31:08 +02:00
Priec	78bc9fc432	router4 compiled	2025-08-22 23:27:32 +02:00
Priec	b9072e4d7c	router2, needs bug fixes3	2025-08-22 22:57:28 +02:00
Priec	5d97e63f93	router2, needs bug fixes	2025-08-22 22:52:20 +02:00
Priec	957f5bf9f0	router implementation	2025-08-22 22:19:59 +02:00
Priec	6833ac5fad	find palette in the bottom panel	2025-08-22 17:11:52 +02:00
Priec	3dff2ced6c	bottom panel moved	2025-08-22 16:48:25 +02:00
Priec	ea7ff3796f	search grpc client isolated a bit mode	2025-08-22 16:09:16 +02:00
Priec	310617d62b	cargo fix	2025-08-22 15:49:33 +02:00
Priec	1d94e82f4b	search	2025-08-22 15:48:30 +02:00
Priec	00dad5d673	fixed buffer logic	2025-08-22 14:26:58 +02:00
Priec	414c6957e7	sidebar as a feature	2025-08-22 14:11:36 +02:00
Priec	f127298e5a	buffer as a feature	2025-08-22 13:47:34 +02:00
Priec	f49899e66d	general movement now works	2025-08-22 11:23:11 +02:00
Priec	5717c88857	proper config.toml	2025-08-22 10:55:37 +02:00
Priec	ae8aa16208	working entering to the edit mode	2025-08-22 09:56:55 +02:00
Priec	4ed8e7b421	fixed form state removed, but not won, aint working yet	2025-08-22 00:27:23 +02:00
Priec	3dd6808ea2	now no need for init_form_editor everywhere	2025-08-21 21:16:59 +02:00
Priec	f2b426851b	compiled still not working	2025-08-21 13:23:21 +02:00
Priec	f9e0833bcf	working keymap	2025-08-21 12:32:36 +02:00
Priec	11b073c2fd	removing highlightmode from the app, handled by the library now	2025-08-21 10:33:52 +02:00
Priec	1320884409	more improvements	2025-08-20 23:52:14 +02:00
filipriec	aea2c39215	reverted core actions in canvas	2025-08-20 16:33:19 +02:00
filipriec	4c2464ab30	compiled	2025-08-20 16:28:31 +02:00
filipriec	26053a5fd8	fixes 9	2025-08-20 11:36:56 +02:00
filipriec	589220a2ba	fixing 8	2025-08-20 11:33:34 +02:00
filipriec	2cda54633f	not working, needs more fixes	2025-08-19 22:14:43 +02:00
filipriec	3eea6b9e88	fixes 7	2025-08-19 22:02:00 +02:00
filipriec	db9bb7e168	fixes 5	2025-08-19 20:05:18 +02:00
filipriec	3ccd094a22	fixing problems more6	2025-08-19 19:21:02 +02:00
filipriec	032f21edaa	more canvas implementation4	2025-08-19 14:43:10 +02:00
Priec	42eb087363	canvas fixes3	2025-08-19 13:25:10 +02:00
Priec	d0ff449e3b	going into a new canvas library structure	2025-08-19 13:24:48 +02:00
Priec	858f5137d8	migrating to the new canvas library	2025-08-19 10:56:54 +02:00
Priec	80d5dd0761	forgotten cargo	2025-08-19 01:15:16 +02:00
Priec	49b31c6e92	readme updated	2025-08-19 01:12:59 +02:00
Priec	8ed2fbbe34	more warnings cleared	2025-08-19 01:04:40 +02:00
Priec	5ae8d13719	clippy improvements	2025-08-19 01:03:28 +02:00
Priec	7bf2b81229	syntax highlighting example is now fine	2025-08-19 00:58:21 +02:00
Priec	0215f2824a	working syntax highlighting	2025-08-19 00:51:57 +02:00
Priec	3fdb7e4e37	syntec, but not compiling	2025-08-19 00:46:11 +02:00
Priec	a3f578ebac	using ropey for textarea	2025-08-19 00:03:04 +02:00
Priec	f0bc7abaad	closer to prod more than ever	2025-08-18 22:52:08 +02:00
Priec	f9d9231d50	more prod ready comments	2025-08-18 21:10:06 +02:00
Priec	465db82bd9	prod comments in the codebase	2025-08-18 21:00:14 +02:00
Priec	885a48bdd8	more clippy fixes	2025-08-18 19:49:08 +02:00
Priec	c915b3287b	cargo clippy ran	2025-08-18 19:42:31 +02:00