diff --git a/Cargo.lock b/Cargo.lock
index 3a855f6..a97000b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -361,9 +361,9 @@ dependencies = [
 
 [[package]]
 name = "axum-test"
-version = "18.6.0"
+version = "18.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b795348c3fff787072ea9b25f53cbc5591190a0efd972706556580580f5907d3"
+checksum = "0ce2a8627e8d8851f894696b39f2b67807d6375c177361d376173ace306a21e2"
 dependencies = [
  "anyhow",
  "axum",
@@ -396,9 +396,9 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "base64ct"
-version = "1.8.1"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e050f626429857a27ddccb31e0aca21356bfa709c04041aefddac081a8f068a"
+checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
 
 [[package]]
 name = "basic-async"
@@ -482,9 +482,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.51"
+version = "1.2.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a0aeaff4ff1a90589618835a598e545176939b97874f7abc7851caa0618f203"
+checksum = "755d2fce177175ffca841e9a06afdb2c4ab0f593d53b4dee48147dfaade85932"
 dependencies = [
  "find-msvc-tools",
  "shlex",
@@ -498,9 +498,9 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "chrono"
-version = "0.4.42"
+version = "0.4.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
+checksum = "fac4744fb15ae8337dc853fee7fb3f4e48c0fbaa23d0afe49c447b4fab126118"
 dependencies = [
  "iana-time-zone",
  "js-sys",
@@ -539,18 +539,18 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.53"
+version = "4.5.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9e340e012a1bf4935f5282ed1436d1489548e8f72308207ea5df0e23d2d03f8"
+checksum = "c6e6ff9dcd79cff5cd969a17a545d79e84ab086e444102a591e288a8aa3ce394"
 dependencies = [
  "clap_builder",
 ]
 
 [[package]]
 name = "clap_builder"
-version = "4.5.53"
+version = "4.5.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d76b5d13eaa18c901fd2f7fca939fefe3a0727a953561fefdf3b2922b8569d00"
+checksum = "fa42cf4d2b7a41bc8f663a7cab4031ebafa1bf3875705bfaf8466dc60ab52c00"
 dependencies = [
  "anstyle",
  "clap_lex",
@@ -558,9 +558,9 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.7.6"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
+checksum = "c3e64b0cc0439b12df2fa678eae89a1c56a529fd067a9115f7827f1fffd22b32"
 
 [[package]]
 name = "combine"
@@ -609,9 +609,9 @@ checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
 
 [[package]]
 name = "const-oid"
-version = "0.10.1"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dabb6555f92fb9ee4140454eb5dcd14c7960e1225c6d1a6cc361f032947713e"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
 
 [[package]]
 name = "const-random"
@@ -628,7 +628,7 @@ version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
 dependencies = [
- "getrandom 0.2.16",
+ "getrandom 0.2.17",
  "once_cell",
  "tiny-keccak",
 ]
@@ -788,9 +788,9 @@ dependencies = [
 
 [[package]]
 name = "crypto-common"
-version = "0.2.0-rc.8"
+version = "0.2.0-rc.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6165b8029cdc3e765b74d3548f85999ee799d5124877ce45c2c85ca78e4d4aa"
+checksum = "7d2bcc93d5cde6659e8649fc412894417ebc14dee54cfc6ee439c683a4a58342"
 dependencies = [
  "hybrid-array",
 ]
@@ -986,13 +986,13 @@ dependencies = [
 
 [[package]]
 name = "digest"
-version = "0.11.0-rc.5"
+version = "0.11.0-rc.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebf9423bafb058e4142194330c52273c343f8a5beb7176d052f0e73b17dd35b9"
+checksum = "ca14c221bd9052fd2da7c34a2eeb5ae54732db28be47c35937be71793d675422"
 dependencies = [
  "block-buffer 0.11.0",
- "const-oid 0.10.1",
- "crypto-common 0.2.0-rc.8",
+ "const-oid 0.10.2",
+ "crypto-common 0.2.0-rc.11",
  "subtle",
 ]
 
@@ -1113,7 +1113,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1181,9 +1181,9 @@ checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.6"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "645cbb3a84e60b7531617d5ae4e57f7e27308f6445f5abf653209ea76dec8dff"
+checksum = "8591b0bcc8a98a64310a2fae1bb3e9b8564dd10e381e6e28010fde8e8e8568db"
 
 [[package]]
 name = "flume"
@@ -1344,9 +1344,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.16"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
 dependencies = [
  "cfg-if",
  "libc",
@@ -1373,9 +1373,9 @@ checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
 [[package]]
 name = "h2"
-version = "0.4.12"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c0b69cfcb4e1b9f1bf2f53f95f766e4661169728ec61cd3fe5a0166f2d1386"
+checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -1383,7 +1383,7 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "http 1.4.0",
- "indexmap 2.12.1",
+ "indexmap 2.13.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -1481,7 +1481,7 @@ version = "0.13.0-rc.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f1c597ac7d6cc8143e30e83ef70915e7f883b18d8bec2e2b2bce47f5bbb06d57"
 dependencies = [
- "digest 0.11.0-rc.5",
+ "digest 0.11.0-rc.7",
 ]
 
 [[package]]
@@ -1612,7 +1612,7 @@ dependencies = [
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.5.10",
+ "socket2 0.6.1",
  "tokio",
  "tower-service",
  "tracing",
@@ -1769,9 +1769,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.12.1"
+version = "2.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
 dependencies = [
  "equivalent",
  "hashbrown 0.16.1",
@@ -1829,7 +1829,7 @@ checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
 dependencies = [
  "hermit-abi",
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1855,9 +1855,9 @@ checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 
 [[package]]
 name = "js-sys"
-version = "0.3.83"
+version = "0.3.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8"
+checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -1891,9 +1891,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.178"
+version = "0.2.180"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
+checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
 
 [[package]]
 name = "libm"
@@ -1964,7 +1964,7 @@ checksum = "a94d21414c1f4a51209ad204c1776a3d0765002c76c6abcb602a6f09f1e881c7"
 
 [[package]]
 name = "masterror"
-version = "0.27.1"
+version = "0.27.2"
 dependencies = [
  "actix-web",
  "anyhow",
@@ -2007,7 +2007,7 @@ dependencies = [
 
 [[package]]
 name = "masterror-derive"
-version = "0.11.1"
+version = "0.11.2"
 dependencies = [
  "masterror-template",
  "proc-macro2",
@@ -2128,7 +2128,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -2374,9 +2374,9 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
 [[package]]
 name = "pest"
-version = "2.8.4"
+version = "2.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbcfd20a6d4eeba40179f05735784ad32bdaef05ce8e8af05f180d45bb3e7e22"
+checksum = "2c9eb05c21a464ea704b53158d358a31e6425db2f63a1a7312268b05fe2b75f7"
 dependencies = [
  "memchr",
  "ucd-trie",
@@ -2384,9 +2384,9 @@ dependencies = [
 
 [[package]]
 name = "pest_derive"
-version = "2.8.4"
+version = "2.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51f72981ade67b1ca6adc26ec221be9f463f2b5839c7508998daa17c23d94d7f"
+checksum = "68f9dbced329c441fa79d80472764b1a2c7e57123553b8519b36663a2fb234ed"
 dependencies = [
  "pest",
  "pest_generator",
@@ -2394,9 +2394,9 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.8.4"
+version = "2.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dee9efd8cdb50d719a80088b76f81aec7c41ed6d522ee750178f83883d271625"
+checksum = "3bb96d5051a78f44f43c8f712d8e810adb0ebf923fc9ed2655a7f66f63ba8ee5"
 dependencies = [
  "pest",
  "pest_meta",
@@ -2407,9 +2407,9 @@ dependencies = [
 
 [[package]]
 name = "pest_meta"
-version = "2.8.4"
+version = "2.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf1d70880e76bdc13ba52eafa6239ce793d85c8e43896507e43dd8984ff05b82"
+checksum = "602113b5b5e8621770cfd490cfd90b9f84ab29bd2b0e49ad83eb6d186cef2365"
 dependencies = [
  "pest",
  "sha2 0.10.9",
@@ -2616,7 +2616,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
  "rand_chacha 0.9.0",
- "rand_core 0.9.3",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -2636,7 +2636,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
  "ppv-lite86",
- "rand_core 0.9.3",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -2645,14 +2645,14 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.16",
+ "getrandom 0.2.17",
 ]
 
 [[package]]
 name = "rand_core"
-version = "0.9.3"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
 dependencies = [
  "getrandom 0.3.4",
 ]
@@ -2907,7 +2907,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3107,7 +3107,7 @@ dependencies = [
  "chrono",
  "hex",
  "indexmap 1.9.3",
- "indexmap 2.12.1",
+ "indexmap 2.13.0",
  "schemars 0.9.0",
  "schemars 1.2.0",
  "serde_core",
@@ -3158,7 +3158,7 @@ checksum = "19d43dc0354d88b791216bb5c1bfbb60c0814460cc653ae0ebd71f286d0bd927"
 dependencies = [
  "cfg-if",
  "cpufeatures",
- "digest 0.11.0-rc.5",
+ "digest 0.11.0-rc.7",
 ]
 
 [[package]]
@@ -3281,7 +3281,7 @@ dependencies = [
  "futures-util",
  "hashbrown 0.15.5",
  "hashlink",
- "indexmap 2.12.1",
+ "indexmap 2.13.0",
  "log",
  "memchr",
  "native-tls",
@@ -3600,7 +3600,7 @@ dependencies = [
  "getrandom 0.3.4",
  "once_cell",
  "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3614,18 +3614,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.17"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.17"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3643,30 +3643,30 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.44"
+version = "0.3.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"
+checksum = "f9e442fc33d7fdb45aa9bfeb312c095964abdf596f7567261062b2a7107aaabd"
 dependencies = [
  "deranged",
  "itoa",
  "num-conv",
  "powerfmt",
- "serde",
+ "serde_core",
  "time-core",
  "time-macros",
 ]
 
 [[package]]
 name = "time-core"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
+checksum = "8b36ee98fd31ec7426d599183e8fe26932a8dc1fb76ddb6214d05493377d34ca"
 
 [[package]]
 name = "time-macros"
-version = "0.2.24"
+version = "0.2.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"
+checksum = "71e552d1249bf61ac2a52db88179fd0673def1e1ad8243a00d9ec9ed71fee3dd"
 dependencies = [
  "num-conv",
  "time-core",
@@ -3746,9 +3746,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.17"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
+checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -3757,9 +3757,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.17"
+version = "0.7.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2efa149fe76073d6e8fd97ef4f4eca7b67f599660115591483572e406e165594"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
 dependencies = [
  "bytes",
  "futures-core",
@@ -3774,7 +3774,7 @@ version = "0.9.11+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f3afc9a848309fe1aaffaed6e1546a7a14de1f935dc9d89d32afd9a44bab7c46"
 dependencies = [
- "indexmap 2.12.1",
+ "indexmap 2.13.0",
  "serde_core",
  "serde_spanned",
  "toml_datetime",
@@ -3844,7 +3844,7 @@ checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
 dependencies = [
  "futures-core",
  "futures-util",
- "indexmap 2.12.1",
+ "indexmap 2.13.0",
  "pin-project-lite",
  "slab",
  "sync_wrapper",
@@ -4012,9 +4012,9 @@ checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
 
 [[package]]
 name = "unicase"
-version = "2.8.1"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
+checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
 
 [[package]]
 name = "unicode-bidi"
@@ -4057,14 +4057,15 @@ checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
 [[package]]
 name = "url"
-version = "2.5.7"
+version = "2.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
 dependencies = [
  "form_urlencoded",
  "idna",
  "percent-encoding",
  "serde",
+ "serde_derive",
 ]
 
 [[package]]
@@ -4079,7 +4080,7 @@ version = "5.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2fcc29c80c21c31608227e0912b2d7fddba57ad76b606890627ba8ee7964e993"
 dependencies = [
- "indexmap 2.12.1",
+ "indexmap 2.13.0",
  "serde",
  "serde_json",
  "utoipa-gen",
@@ -4183,9 +4184,9 @@ checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
 name = "wasip2"
-version = "1.0.1+wasi-0.2.4"
+version = "1.0.2+wasi-0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
 dependencies = [
  "wit-bindgen",
 ]
@@ -4198,9 +4199,9 @@ checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.106"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd"
+checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -4211,11 +4212,12 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.56"
+version = "0.4.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "836d9622d604feee9e5de25ac10e3ea5f2d65b41eac0d9ce72eb5deae707ce7c"
+checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f"
 dependencies = [
  "cfg-if",
+ "futures-util",
  "js-sys",
  "once_cell",
  "wasm-bindgen",
@@ -4224,9 +4226,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.106"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3"
+checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -4234,9 +4236,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.106"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40"
+checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -4247,9 +4249,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.106"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4"
+checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"
 dependencies = [
  "unicode-ident",
 ]
@@ -4269,9 +4271,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.83"
+version = "0.3.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac"
+checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -4309,7 +4311,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4619,9 +4621,9 @@ dependencies = [
 
 [[package]]
 name = "wit-bindgen"
-version = "0.46.0"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
 
 [[package]]
 name = "writeable"
@@ -4677,18 +4679,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.31"
+version = "0.8.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
+checksum = "668f5168d10b9ee831de31933dc111a459c97ec93225beb307aed970d1372dfd"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.31"
+version = "0.8.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
+checksum = "2c7962b26b0a8685668b671ee4b54d007a67d4eaf05fda79ac0ecf41e32270f1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4757,6 +4759,6 @@ dependencies = [
 
 [[package]]
 name = "zmij"
-version = "1.0.3"
+version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9747e91771f56fd7893e1164abd78febd14a670ceec257caad15e051de35f06"
+checksum = "dfcd145825aace48cff44a8844de64bf75feec3080e0aa5cdbde72961ae51a65"
diff --git a/Cargo.toml b/Cargo.toml
index 2ea21d8..3b7d835 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,7 @@
 
 [package]
 name = "masterror"
-version = "0.27.1"
+version = "0.27.2"
 rust-version = "1.92"
 edition = "2024"
 license = "MIT"
@@ -13,7 +13,7 @@ readme = "README.md"
 description = "Application error types and response mapping"
 documentation = "https://docs.rs/masterror"
 build = "build.rs"
-categories = ["rust-patterns", "web-programming"]
+categories = ["rust-patterns", "web-programming", "no-std"]
 keywords = ["error", "api", "framework"]
 include = [
   "Cargo.toml",
diff --git a/README.md b/README.md
index 246baf3..bcafb01 100644
--- a/README.md
+++ b/README.md
@@ -159,9 +159,9 @@ The build script keeps the full feature snippet below in sync with
 
 ~~~toml
 [dependencies]
-masterror = { version = "0.27.1", default-features = false }
+masterror = { version = "0.27.2", default-features = false }
 # or with features:
-# masterror = { version = "0.27.1", features = [
+# masterror = { version = "0.27.2", features = [
 #   "std", "axum", "actix", "openapi",
 #   "serde_json", "tracing", "metrics", "backtrace",
 #   "colored", "sqlx", "sqlx-migrate", "reqwest",
@@ -640,7 +640,7 @@ Enable the `colored` feature for enhanced terminal output in local mode:
 
 ~~~toml
 [dependencies]
-masterror = { version = "0.27.1", features = ["colored"] }
+masterror = { version = "0.27.2", features = ["colored"] }
 ~~~
 
 With `colored` enabled, errors display with syntax highlighting:
diff --git a/masterror-derive/Cargo.toml b/masterror-derive/Cargo.toml
index ad4d16f..b175a34 100644
--- a/masterror-derive/Cargo.toml
+++ b/masterror-derive/Cargo.toml
@@ -5,7 +5,7 @@
 [package]
 name = "masterror-derive"
 rust-version = "1.92"
-version = "0.11.1"
+version = "0.11.2"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/RAprogramm/masterror"
diff --git a/masterror-derive/src/display/enum_impl.rs b/masterror-derive/src/display/enum_impl.rs
index 05390c9..f95678f 100644
--- a/masterror-derive/src/display/enum_impl.rs
+++ b/masterror-derive/src/display/enum_impl.rs
@@ -24,6 +24,7 @@ use crate::{
     input::{
         DisplaySpec, ErrorInput, Field, Fields, FormatArgsSpec, VariantData, placeholder_error
     },
+    lint::lifetime_lint_allows,
     template_support::{DisplayTemplate, TemplateIdentifierSpec}
 };
 
@@ -47,7 +48,9 @@ pub fn expand_enum(input: &ErrorInput, variants: &[VariantData]) -> Result<Token
     }
     let ident = &input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    let lint_allows = lifetime_lint_allows(&input.generics);
     Ok(quote! {
+        #lint_allows
         impl #impl_generics core::fmt::Display for #ident #ty_generics #where_clause {
             fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                 match self {
diff --git a/masterror-derive/src/display/struct_impl.rs b/masterror-derive/src/display/struct_impl.rs
index 7ae1811..bb7ad5f 100644
--- a/masterror-derive/src/display/struct_impl.rs
+++ b/masterror-derive/src/display/struct_impl.rs
@@ -21,6 +21,7 @@ use super::{
 };
 use crate::{
     input::{DisplaySpec, ErrorInput, Field, Fields, StructData, placeholder_error},
+    lint::lifetime_lint_allows,
     template_support::TemplateIdentifierSpec
 };
 
@@ -64,7 +65,9 @@ pub fn expand_struct(input: &ErrorInput, data: &StructData) -> Result<TokenStrea
     };
     let ident = &input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    let lint_allows = lifetime_lint_allows(&input.generics);
     Ok(quote! {
+        #lint_allows
         impl #impl_generics core::fmt::Display for #ident #ty_generics #where_clause {
             fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                 #body
diff --git a/masterror-derive/src/error_trait.rs b/masterror-derive/src/error_trait.rs
index b623f67..5183ef0 100644
--- a/masterror-derive/src/error_trait.rs
+++ b/masterror-derive/src/error_trait.rs
@@ -51,7 +51,10 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use syn::Error;
 
-use crate::input::{ErrorData, ErrorInput, StructData, VariantData};
+use crate::{
+    input::{ErrorData, ErrorInput, StructData, VariantData},
+    lint::lifetime_lint_allows
+};
 
 pub mod backtrace;
 pub mod binding;
@@ -107,7 +110,9 @@ fn expand_struct(input: &ErrorInput, data: &StructData) -> Result<TokenStream, E
     let provide_method = provide_method.unwrap_or_default();
     let ident = &input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    let lint_allows = lifetime_lint_allows(&input.generics);
     Ok(quote! {
+        #lint_allows
         impl #impl_generics std::error::Error for #ident #ty_generics #where_clause {
             fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
                 #body
@@ -142,7 +147,9 @@ fn expand_enum(input: &ErrorInput, variants: &[VariantData]) -> Result<TokenStre
     let provide_method = provide_method.unwrap_or_default();
     let ident = &input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    let lint_allows = lifetime_lint_allows(&input.generics);
     Ok(quote! {
+        #lint_allows
         impl #impl_generics std::error::Error for #ident #ty_generics #where_clause {
             fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
                 match self {
diff --git a/masterror-derive/src/lib.rs b/masterror-derive/src/lib.rs
index 48766bf..d64d2ba 100644
--- a/masterror-derive/src/lib.rs
+++ b/masterror-derive/src/lib.rs
@@ -12,6 +12,7 @@ mod display;
 mod error_trait;
 mod from_impl;
 mod input;
+mod lint;
 mod masterror_impl;
 mod span;
 mod template_support;
diff --git a/masterror-derive/src/lint.rs b/masterror-derive/src/lint.rs
new file mode 100644
index 0000000..fd26f97
--- /dev/null
+++ b/masterror-derive/src/lint.rs
@@ -0,0 +1,83 @@
+// SPDX-FileCopyrightText: 2025 RAprogramm <andrey.rozanov.vl@gmail.com>
+//
+// SPDX-License-Identifier: MIT
+
+//! Clippy lint suppression for generated code.
+//!
+//! When generating trait implementations for types with lifetime parameters,
+//! clippy may emit `needless_lifetimes` or `elidable_lifetime_names` warnings.
+//! These warnings conflict with project-level `forbid` directives, so we
+//! conditionally suppress them only when the type actually has lifetimes.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::Generics;
+
+/// Generates conditional clippy lint allows for lifetime-related warnings.
+///
+/// Returns `#[allow(...)]` attributes only when the generics contain lifetime
+/// parameters. This prevents conflicts with project-level `forbid` directives
+/// while still suppressing false positives in generated code.
+///
+/// # Arguments
+///
+/// * `generics` - The generics from the type definition
+///
+/// # Returns
+///
+/// Token stream with allow attributes if lifetimes present, empty otherwise
+pub fn lifetime_lint_allows(generics: &Generics) -> TokenStream {
+    if generics.lifetimes().next().is_some() {
+        quote! {
+            #[allow(clippy::elidable_lifetime_names, clippy::needless_lifetimes)]
+        }
+    } else {
+        TokenStream::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use syn::parse_quote;
+
+    use super::*;
+
+    #[test]
+    fn test_no_lifetimes_returns_empty() {
+        let generics: Generics = parse_quote!();
+        let result = lifetime_lint_allows(&generics);
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_type_params_only_returns_empty() {
+        let generics: Generics = parse_quote!(<T, U>);
+        let result = lifetime_lint_allows(&generics);
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_with_lifetime_returns_allows() {
+        let generics: Generics = parse_quote!(<'a>);
+        let result = lifetime_lint_allows(&generics);
+        let output = result.to_string();
+        assert!(output.contains("allow"));
+        assert!(output.contains("elidable_lifetime_names"));
+        assert!(output.contains("needless_lifetimes"));
+    }
+
+    #[test]
+    fn test_mixed_params_with_lifetime_returns_allows() {
+        let generics: Generics = parse_quote!(<'a, T, 'b>);
+        let result = lifetime_lint_allows(&generics);
+        let output = result.to_string();
+        assert!(output.contains("allow"));
+    }
+
+    #[test]
+    fn test_const_generics_only_returns_empty() {
+        let generics: Generics = parse_quote!(<const N: usize>);
+        let result = lifetime_lint_allows(&generics);
+        assert!(result.is_empty());
+    }
+}
diff --git a/src/app_error.rs b/src/app_error.rs
index c520a00..fffd18a 100644
--- a/src/app_error.rs
+++ b/src/app_error.rs
@@ -69,6 +69,7 @@
 mod constructors;
 mod context;
 mod core;
+mod inline_vec;
 mod metadata;
 
 pub use core::{AppError, AppResult, DisplayMode, Error, ErrorChain, MessageEditPolicy};
diff --git a/src/app_error/core/error.rs b/src/app_error/core/error.rs
index 271b89e..9bb9564 100644
--- a/src/app_error/core/error.rs
+++ b/src/app_error/core/error.rs
@@ -110,11 +110,8 @@ impl Display for Error {
                 let mut current: &dyn CoreError = source.as_ref();
                 let mut depth = 0;
                 while depth < 10 {
-                    writeln!(
-                        f,
-                        "{}",
-                        style::source_context(alloc::format!("Caused by: {}", current))
-                    )?;
+                    write!(f, "  {}: ", style::source_context("Caused by"))?;
+                    writeln!(f, "{}", style::source_context(current.to_string()))?;
                     if let Some(next) = current.source() {
                         current = next;
                         depth += 1;
diff --git a/src/app_error/inline_vec.rs b/src/app_error/inline_vec.rs
new file mode 100644
index 0000000..d24e6df
--- /dev/null
+++ b/src/app_error/inline_vec.rs
@@ -0,0 +1,536 @@
+// SPDX-FileCopyrightText: 2025 RAprogramm <andrey.rozanov.vl@gmail.com>
+//
+// SPDX-License-Identifier: MIT
+
+//! Inline vector implementation for small collections.
+//!
+//! This module provides [`InlineVec`], a vector that stores elements inline
+//! (on the stack) up to a compile-time capacity, spilling to heap only when
+//! that capacity is exceeded. This eliminates heap allocations for the common
+//! case of small collections.
+//!
+//! # Performance
+//!
+//! For collections that typically contain 0-4 elements (like error metadata),
+//! this avoids heap allocation entirely, saving ~100-200ns per error creation.
+
+use alloc::vec::Vec;
+use core::ops::{Deref, DerefMut};
+
+/// Inline capacity for metadata fields.
+///
+/// Most errors have 0-4 metadata fields, so we inline up to 4 elements.
+const INLINE_CAPACITY: usize = 4;
+
+/// A vector that stores up to 4 elements inline, spilling to heap otherwise.
+///
+/// This is optimized for the common case where collections are small. When the
+/// number of elements exceeds the inline capacity, all elements are moved to
+/// a heap-allocated [`Vec`].
+///
+/// # Examples
+///
+/// ```ignore
+/// let mut vec: InlineVec<i32> = InlineVec::new();
+/// vec.push(1);
+/// vec.push(2);
+/// assert_eq!(vec.len(), 2);
+/// assert!(vec.is_inline()); // Still on stack
+/// ```
+#[derive(Clone, Debug, PartialEq)]
+pub struct InlineVec<T> {
+    storage: Storage<T>
+}
+
+#[derive(Clone, Debug, PartialEq)]
+enum Storage<T> {
+    /// Inline storage for 0-4 elements using fixed arrays.
+    ///
+    /// We use separate variants to avoid Option overhead and keep
+    /// the common case (0-2 elements) as small as possible.
+    Empty,
+    One(T),
+    Two([T; 2]),
+    Three([T; 3]),
+    Four([T; 4]),
+    /// Heap storage when capacity is exceeded.
+    Heap(Vec<T>)
+}
+
+impl<T> InlineVec<T> {
+    /// Creates a new empty inline vector.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self {
+            storage: Storage::Empty
+        }
+    }
+
+    /// Returns the number of elements in the vector.
+    #[must_use]
+    pub fn len(&self) -> usize {
+        match &self.storage {
+            Storage::Empty => 0,
+            Storage::One(_) => 1,
+            Storage::Two(_) => 2,
+            Storage::Three(_) => 3,
+            Storage::Four(_) => 4,
+            Storage::Heap(vec) => vec.len()
+        }
+    }
+
+    /// Returns `true` if the vector contains no elements.
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        matches!(&self.storage, Storage::Empty)
+    }
+
+    /// Returns `true` if elements are stored inline (on stack).
+    #[must_use]
+    pub fn is_inline(&self) -> bool {
+        !matches!(&self.storage, Storage::Heap(_))
+    }
+
+    /// Appends an element to the back of the vector.
+    ///
+    /// If the inline capacity is exceeded, all elements are moved to heap.
+    pub fn push(&mut self, value: T) {
+        self.storage = match core::mem::take(&mut self.storage) {
+            Storage::Empty => Storage::One(value),
+            Storage::One(a) => Storage::Two([a, value]),
+            Storage::Two([a, b]) => Storage::Three([a, b, value]),
+            Storage::Three([a, b, c]) => Storage::Four([a, b, c, value]),
+            Storage::Four([a, b, c, d]) => {
+                let mut vec = Vec::with_capacity(INLINE_CAPACITY + 1);
+                vec.extend([a, b, c, d, value]);
+                Storage::Heap(vec)
+            }
+            Storage::Heap(mut vec) => {
+                vec.push(value);
+                Storage::Heap(vec)
+            }
+        };
+    }
+
+    /// Returns a reference to the element at the given index.
+    #[must_use]
+    pub fn get(&self, index: usize) -> Option<&T> {
+        match &self.storage {
+            Storage::Empty => None,
+            Storage::One(a) if index == 0 => Some(a),
+            Storage::One(_) => None,
+            Storage::Two(arr) => arr.get(index),
+            Storage::Three(arr) => arr.get(index),
+            Storage::Four(arr) => arr.get(index),
+            Storage::Heap(vec) => vec.get(index)
+        }
+    }
+
+    /// Returns a mutable reference to the element at the given index.
+    #[must_use]
+    pub fn get_mut(&mut self, index: usize) -> Option<&mut T> {
+        match &mut self.storage {
+            Storage::Empty => None,
+            Storage::One(a) if index == 0 => Some(a),
+            Storage::One(_) => None,
+            Storage::Two(arr) => arr.get_mut(index),
+            Storage::Three(arr) => arr.get_mut(index),
+            Storage::Four(arr) => arr.get_mut(index),
+            Storage::Heap(vec) => vec.get_mut(index)
+        }
+    }
+
+    /// Inserts an element at the specified index, shifting elements after it.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `index > len`.
+    pub fn insert(&mut self, index: usize, value: T) {
+        let len = self.len();
+        assert!(index <= len, "insertion index out of bounds");
+
+        self.storage = match core::mem::take(&mut self.storage) {
+            Storage::Empty => {
+                assert!(index == 0);
+                Storage::One(value)
+            }
+            Storage::One(a) => {
+                if index == 0 {
+                    Storage::Two([value, a])
+                } else {
+                    Storage::Two([a, value])
+                }
+            }
+            Storage::Two([a, b]) => match index {
+                0 => Storage::Three([value, a, b]),
+                1 => Storage::Three([a, value, b]),
+                2 => Storage::Three([a, b, value]),
+                _ => unreachable!()
+            },
+            Storage::Three([a, b, c]) => match index {
+                0 => Storage::Four([value, a, b, c]),
+                1 => Storage::Four([a, value, b, c]),
+                2 => Storage::Four([a, b, value, c]),
+                3 => Storage::Four([a, b, c, value]),
+                _ => unreachable!()
+            },
+            Storage::Four([a, b, c, d]) => {
+                let mut vec = Vec::with_capacity(INLINE_CAPACITY + 1);
+                vec.extend([a, b, c, d]);
+                vec.insert(index, value);
+                Storage::Heap(vec)
+            }
+            Storage::Heap(mut vec) => {
+                vec.insert(index, value);
+                Storage::Heap(vec)
+            }
+        };
+    }
+
+    /// Returns an iterator over the elements.
+    pub fn iter(&self) -> Iter<'_, T> {
+        Iter {
+            vec:   self,
+            index: 0
+        }
+    }
+
+    /// Returns a mutable iterator over the elements.
+    pub fn iter_mut(&mut self) -> core::slice::IterMut<'_, T> {
+        self.as_mut_slice().iter_mut()
+    }
+
+    /// Returns the elements as a mutable slice.
+    #[must_use]
+    pub fn as_mut_slice(&mut self) -> &mut [T] {
+        self
+    }
+
+    /// Clears the vector, removing all elements.
+    pub fn clear(&mut self) {
+        self.storage = Storage::Empty;
+    }
+
+    /// Binary search by a key extracted from each element.
+    ///
+    /// Returns `Ok(index)` if found, `Err(index)` for insertion point.
+    pub fn binary_search_by_key<'a, B, F>(&'a self, key: &B, mut f: F) -> Result<usize, usize>
+    where
+        B: Ord,
+        F: FnMut(&'a T) -> B
+    {
+        self.as_slice().binary_search_by(|elem| f(elem).cmp(key))
+    }
+
+    /// Returns the elements as a slice.
+    #[must_use]
+    pub fn as_slice(&self) -> &[T] {
+        self
+    }
+}
+
+impl<T> Default for InlineVec<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+// Manual Default impl to avoid requiring T: Default
+#[allow(clippy::derivable_impls)]
+impl<T> Default for Storage<T> {
+    fn default() -> Self {
+        Self::Empty
+    }
+}
+
+impl<T> Deref for InlineVec<T> {
+    type Target = [T];
+
+    fn deref(&self) -> &Self::Target {
+        match &self.storage {
+            Storage::Empty => &[],
+            Storage::One(a) => core::slice::from_ref(a),
+            Storage::Two(arr) => arr.as_slice(),
+            Storage::Three(arr) => arr.as_slice(),
+            Storage::Four(arr) => arr.as_slice(),
+            Storage::Heap(vec) => vec.as_slice()
+        }
+    }
+}
+
+impl<T> DerefMut for InlineVec<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        match &mut self.storage {
+            Storage::Empty => &mut [],
+            Storage::One(a) => core::slice::from_mut(a),
+            Storage::Two(arr) => arr.as_mut_slice(),
+            Storage::Three(arr) => arr.as_mut_slice(),
+            Storage::Four(arr) => arr.as_mut_slice(),
+            Storage::Heap(vec) => vec.as_mut_slice()
+        }
+    }
+}
+
+impl<T> FromIterator<T> for InlineVec<T> {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        let mut vec = Self::new();
+        for item in iter {
+            vec.push(item);
+        }
+        vec
+    }
+}
+
+impl<T> IntoIterator for InlineVec<T> {
+    type Item = T;
+    type IntoIter = IntoIter<T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter {
+            storage: self.storage
+        }
+    }
+}
+
+impl<'a, T> IntoIterator for &'a InlineVec<T> {
+    type Item = &'a T;
+    type IntoIter = Iter<'a, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+/// Borrowing iterator for [`InlineVec`].
+#[derive(Debug)]
+pub struct Iter<'a, T> {
+    vec:   &'a InlineVec<T>,
+    index: usize
+}
+
+impl<'a, T> Iterator for Iter<'a, T> {
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let result = self.vec.get(self.index);
+        if result.is_some() {
+            self.index += 1;
+        }
+        result
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining = self.vec.len().saturating_sub(self.index);
+        (remaining, Some(remaining))
+    }
+}
+
+impl<T> ExactSizeIterator for Iter<'_, T> {}
+
+/// Owning iterator for [`InlineVec`].
+#[derive(Debug)]
+pub struct IntoIter<T> {
+    storage: Storage<T>
+}
+
+impl<T> Iterator for IntoIter<T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match &mut self.storage {
+            Storage::Empty => None,
+            Storage::One(_) => match core::mem::take(&mut self.storage) {
+                Storage::One(a) => Some(a),
+                _ => unreachable!()
+            },
+            Storage::Two(_) | Storage::Three(_) | Storage::Four(_) => {
+                // Convert to heap storage for easier iteration
+                let items: Vec<T> = match core::mem::take(&mut self.storage) {
+                    Storage::Two([a, b]) => alloc::vec![a, b],
+                    Storage::Three([a, b, c]) => alloc::vec![a, b, c],
+                    Storage::Four([a, b, c, d]) => alloc::vec![a, b, c, d],
+                    _ => unreachable!()
+                };
+                self.storage = Storage::Heap(items);
+                self.next()
+            }
+            Storage::Heap(vec) => {
+                if vec.is_empty() {
+                    None
+                } else {
+                    Some(vec.remove(0))
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_new_is_empty() {
+        let vec: InlineVec<i32> = InlineVec::new();
+        assert!(vec.is_empty());
+        assert!(vec.is_inline());
+    }
+
+    #[test]
+    fn test_push_inline() {
+        let mut vec: InlineVec<i32> = InlineVec::new();
+        vec.push(1);
+        vec.push(2);
+        vec.push(3);
+        assert_eq!(vec.len(), 3);
+        assert!(vec.is_inline());
+        assert_eq!(&*vec, &[1, 2, 3]);
+    }
+
+    #[test]
+    fn test_push_to_capacity() {
+        let mut vec: InlineVec<i32> = InlineVec::new();
+        vec.push(1);
+        vec.push(2);
+        vec.push(3);
+        vec.push(4);
+        assert_eq!(vec.len(), 4);
+        assert!(vec.is_inline());
+    }
+
+    #[test]
+    fn test_push_spill_to_heap() {
+        let mut vec: InlineVec<i32> = InlineVec::new();
+        vec.push(1);
+        vec.push(2);
+        vec.push(3);
+        vec.push(4);
+        vec.push(5);
+        assert!(!vec.is_inline());
+        assert_eq!(&*vec, &[1, 2, 3, 4, 5]);
+    }
+
+    #[test]
+    fn test_insert_inline() {
+        let mut vec: InlineVec<i32> = InlineVec::new();
+        vec.push(1);
+        vec.push(3);
+        vec.insert(1, 2);
+        assert_eq!(&*vec, &[1, 2, 3]);
+        assert!(vec.is_inline());
+    }
+
+    #[test]
+    fn test_insert_at_start() {
+        let mut vec: InlineVec<i32> = InlineVec::new();
+        vec.push(2);
+        vec.push(3);
+        vec.insert(0, 1);
+        assert_eq!(&*vec, &[1, 2, 3]);
+    }
+
+    #[test]
+    fn test_insert_spill() {
+        let mut vec: InlineVec<i32> = InlineVec::new();
+        vec.push(1);
+        vec.push(2);
+        vec.push(3);
+        vec.push(4);
+        vec.insert(2, 99);
+        assert!(!vec.is_inline());
+        assert_eq!(&*vec, &[1, 2, 99, 3, 4]);
+    }
+
+    #[test]
+    fn test_clone() {
+        let mut vec: InlineVec<i32> = InlineVec::new();
+        vec.push(1);
+        vec.push(2);
+        let cloned = vec.clone();
+        assert_eq!(&*cloned, &*vec);
+    }
+
+    #[test]
+    fn test_iter() {
+        let mut vec: InlineVec<i32> = InlineVec::new();
+        vec.push(1);
+        vec.push(2);
+        vec.push(3);
+        let collected: alloc::vec::Vec<_> = vec.iter().copied().collect();
+        assert_eq!(collected, alloc::vec![1, 2, 3]);
+    }
+
+    #[test]
+    fn test_into_iter() {
+        let mut vec: InlineVec<i32> = InlineVec::new();
+        vec.push(1);
+        vec.push(2);
+        let collected: alloc::vec::Vec<_> = vec.into_iter().collect();
+        assert_eq!(collected, alloc::vec![1, 2]);
+    }
+
+    #[test]
+    fn test_clear() {
+        let mut vec: InlineVec<i32> = InlineVec::new();
+        vec.push(1);
+        vec.push(2);
+        vec.clear();
+        assert!(vec.is_empty());
+    }
+
+    #[test]
+    fn test_from_iter() {
+        let vec: InlineVec<i32> = [1, 2, 3].into_iter().collect();
+        assert_eq!(&*vec, &[1, 2, 3]);
+    }
+
+    #[test]
+    fn test_deref() {
+        let mut vec: InlineVec<i32> = InlineVec::new();
+        vec.push(1);
+        vec.push(2);
+        assert_eq!(vec[0], 1);
+        assert_eq!(vec[1], 2);
+    }
+
+    #[test]
+    fn test_partial_eq() {
+        let mut vec1: InlineVec<i32> = InlineVec::new();
+        vec1.push(1);
+        vec1.push(2);
+        let mut vec2: InlineVec<i32> = InlineVec::new();
+        vec2.push(1);
+        vec2.push(2);
+        assert_eq!(vec1, vec2);
+    }
+
+    #[test]
+    fn test_with_strings() {
+        let mut vec: InlineVec<alloc::string::String> = InlineVec::new();
+        vec.push(alloc::string::String::from("hello"));
+        vec.push(alloc::string::String::from("world"));
+        assert_eq!(vec[0], "hello");
+        assert_eq!(vec[1], "world");
+    }
+
+    #[test]
+    fn test_get() {
+        let mut vec: InlineVec<i32> = InlineVec::new();
+        vec.push(1);
+        vec.push(2);
+        assert_eq!(vec.get(0), Some(&1));
+        assert_eq!(vec.get(1), Some(&2));
+        assert_eq!(vec.get(2), None);
+    }
+
+    #[test]
+    fn test_get_mut() {
+        let mut vec: InlineVec<i32> = InlineVec::new();
+        vec.push(1);
+        vec.push(2);
+        if let Some(val) = vec.get_mut(0) {
+            *val = 10;
+        }
+        assert_eq!(vec[0], 10);
+    }
+}
diff --git a/src/app_error/metadata.rs b/src/app_error/metadata.rs
index 6c1f429..672fe7e 100644
--- a/src/app_error/metadata.rs
+++ b/src/app_error/metadata.rs
@@ -2,13 +2,15 @@
 //
 // SPDX-License-Identifier: MIT
 
-use alloc::{borrow::Cow, collections::BTreeMap, string::String};
+use alloc::{borrow::Cow, string::String};
 use core::{
     fmt::{Display, Formatter, Result as FmtResult, Write},
     net::IpAddr,
     time::Duration
 };
 
+use super::inline_vec::InlineVec;
+
 /// Redaction policy associated with a metadata [`Field`].
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum FieldRedaction {
@@ -285,31 +287,37 @@ fn eq_ascii_case_insensitive_bytes(left: &[u8], right: &[u8]) -> bool {
 
 /// Structured metadata attached to [`crate::AppError`].
 ///
-/// Internally backed by a deterministic [`BTreeMap`] keyed by `'static` field
-/// names. Use the helpers in [`field`] to build [`Field`] values without manual
-/// enum construction.
+/// Internally backed by a sorted inline vector for optimal performance with
+/// small field counts. Fields are kept sorted by name for deterministic
+/// iteration and O(log n) lookup via binary search.
+///
+/// # Performance
+///
+/// Most errors have 0-4 metadata fields. For these cases, all storage is
+/// inline (no heap allocation), saving ~100-200ns per error creation.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct Metadata {
-    fields: BTreeMap<&'static str, Field>
+    /// Fields stored sorted by name for binary search lookup.
+    fields: InlineVec<Field>
 }
 
 impl Metadata {
     /// Create an empty metadata container.
     #[must_use]
-    pub fn new() -> Self {
-        Self::default()
+    pub const fn new() -> Self {
+        Self {
+            fields: InlineVec::new()
+        }
     }
 
     /// Build metadata from an iterator of [`Field`] values.
     #[must_use]
     pub fn from_fields(fields: impl IntoIterator<Item = Field>) -> Self {
-        let mut map = BTreeMap::new();
+        let mut meta = Self::new();
         for field in fields {
-            map.insert(field.name, field);
-        }
-        Self {
-            fields: map
+            meta.insert(field);
         }
+        meta
     }
 
     /// Number of fields stored in the metadata.
@@ -325,10 +333,22 @@ impl Metadata {
     }
 
     /// Insert or replace a field and return the previous value.
+    ///
+    /// Fields are kept sorted by name for efficient lookup.
     pub fn insert(&mut self, field: Field) -> Option<FieldValue> {
-        self.fields
-            .insert(field.name, field)
-            .map(|previous| previous.into_value())
+        let name = field.name;
+        match self.fields.binary_search_by_key(&name, |f| f.name) {
+            Ok(idx) => {
+                // Replace existing field
+                let old = core::mem::replace(&mut self.fields[idx], field);
+                Some(old.into_value())
+            }
+            Err(idx) => {
+                // Insert at sorted position
+                self.fields.insert(idx, field);
+                None
+            }
+        }
     }
 
     /// Extend metadata with additional fields.
@@ -341,31 +361,40 @@ impl Metadata {
     /// Borrow a field value by name.
     #[must_use]
     pub fn get(&self, name: &'static str) -> Option<&FieldValue> {
-        self.fields.get(name).map(|field| field.value())
+        self.fields
+            .binary_search_by_key(&name, |f| f.name)
+            .ok()
+            .map(|idx| self.fields[idx].value())
     }
 
     /// Borrow the full field entry by name.
     #[must_use]
     pub fn get_field(&self, name: &'static str) -> Option<&Field> {
-        self.fields.get(name)
+        self.fields
+            .binary_search_by_key(&name, |f| f.name)
+            .ok()
+            .map(|idx| &self.fields[idx])
     }
 
     /// Override the redaction policy for a specific field.
     pub fn set_redaction(&mut self, name: &'static str, redaction: FieldRedaction) {
-        if let Some(field) = self.fields.get_mut(name) {
-            field.set_redaction(redaction);
+        if let Ok(idx) = self.fields.binary_search_by_key(&name, |f| f.name) {
+            self.fields[idx].set_redaction(redaction);
         }
     }
 
     /// Retrieve the redaction policy for a field if present.
     #[must_use]
     pub fn redaction(&self, name: &'static str) -> Option<FieldRedaction> {
-        self.fields.get(name).map(|field| field.redaction())
+        self.fields
+            .binary_search_by_key(&name, |f| f.name)
+            .ok()
+            .map(|idx| self.fields[idx].redaction())
     }
 
     /// Iterator over metadata fields in sorted order.
     pub fn iter(&self) -> impl Iterator<Item = (&'static str, &FieldValue)> {
-        self.fields.iter().map(|(k, v)| (*k, v.value()))
+        self.fields.iter().map(|f| (f.name, f.value()))
     }
 
     /// Iterator over metadata entries including the redaction policy.
@@ -374,24 +403,16 @@ impl Metadata {
     ) -> impl Iterator<Item = (&'static str, &FieldValue, FieldRedaction)> {
         self.fields
             .iter()
-            .map(|(name, field)| (*name, field.value(), field.redaction()))
+            .map(|f| (f.name, f.value(), f.redaction()))
     }
 }
 
 impl IntoIterator for Metadata {
     type Item = Field;
-    type IntoIter = core::iter::Map<
-        alloc::collections::btree_map::IntoIter<&'static str, Field>,
-        fn((&'static str, Field)) -> Field
-    >;
+    type IntoIter = super::inline_vec::IntoIter<Field>;
 
     fn into_iter(self) -> Self::IntoIter {
-        fn into_field(entry: (&'static str, Field)) -> Field {
-            entry.1
-        }
-        self.fields
-            .into_iter()
-            .map(into_field as fn((&'static str, Field)) -> Field)
+        self.fields.into_iter()
     }
 }