chore(deps): update rust crate anyhow to v1.0.102

Signed-off-by: kjuulh <contact@kjuulh.io>

Cargo.lock

@@ -13,20 +13,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.100"
+version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
-
-[[package]]
-name = "async-trait"
-version = "0.1.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
 
 [[package]]
 name = "autocfg"
@@ -40,12 +29,6 @@ version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
 [[package]]
 name = "bytes"
 version = "1.8.0"
@@ -59,10 +42,42 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
-name = "futures"
+name = "chacha20"
-version = "0.3.31"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "rand_core",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "futures"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -75,9 +90,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -85,15 +100,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -102,15 +117,15 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
 
 [[package]]
 name = "futures-macro"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -119,21 +134,21 @@ dependencies = [
 
 [[package]]
 name = "futures-sink"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
 
 [[package]]
 name = "futures-task"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
 
 [[package]]
 name = "futures-util"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -143,34 +158,86 @@ dependencies = [
  "futures-task",
  "memchr",
  "pin-project-lite",
- "pin-utils",
  "slab",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.3.1"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a49c392881ce6d5c3b8cb70f98717b7c07aabbdff06687b9030dbfbe2725f8"
+checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec"
 dependencies = [
  "cfg-if",
  "libc",
- "wasi 0.13.3+wasi-0.2.2",
+ "r-efi",
- "windows-targets 0.52.6",
+ "rand_core",
+ "wasip2",
+ "wasip3",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "hermit-abi"
 version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
 
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
 [[package]]
 name = "lazy_static"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
 [[package]]
 name = "libc"
 version = "0.2.177"
@@ -216,16 +283,15 @@ checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec"
 dependencies = [
  "hermit-abi",
  "libc",
- "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasi",
  "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "notmad"
-version = "0.10.0"
+version = "0.11.0"
 dependencies = [
  "anyhow",
- "async-trait",
  "futures",
  "futures-util",
  "rand",
@@ -243,7 +309,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -282,25 +348,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "915a1e146535de9163f3987b8944ed8cf49a18bb0056bcebcdcece385cece4ff"
 
 [[package]]
-name = "pin-utils"
+name = "prettyplease"
-version = "0.1.0"
+version = "0.2.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
 dependencies = [
- "zerocopy 0.7.35",
+ "proc-macro2",
+ "syn",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.89"
+version = "1.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
 dependencies = [
  "unicode-ident",
 ]
@@ -315,34 +376,27 @@ dependencies = [
 ]
 
 [[package]]
-name = "rand"
+name = "r-efi"
-version = "0.9.2"
+version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
-dependencies = [
- "rand_chacha",
- "rand_core",
-]
 
 [[package]]
-name = "rand_chacha"
+name = "rand"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+checksum = "bc266eb313df6c5c09c1c7b1fbe2510961e5bcd3add930c1e31f7ed9da0feff8"
 dependencies = [
- "ppv-lite86",
+ "chacha20",
+ "getrandom",
  "rand_core",
 ]
 
 [[package]]
 name = "rand_core"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b08f3c9802962f7e1b25113931d94f43ed9725bebc59db9d0c3e9a23b67e15ff"
+checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba"
-dependencies = [
- "getrandom",
- "zerocopy 0.8.14",
-]
 
 [[package]]
 name = "redox_syscall"
@@ -376,6 +430,54 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -421,9 +523,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.87"
+version = "2.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d"
+checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -432,18 +534,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",
@@ -462,9 +564,9 @@ dependencies = [
 
 [[package]]
 name = "tokio"
-version = "1.48.0"
+version = "1.49.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408"
+checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
 dependencies = [
  "bytes",
  "libc",
@@ -490,9 +592,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",
@@ -565,9 +667,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-test"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "557b891436fe0d5e0e363427fc7f217abf9ccd510d5136549847bdcbcd011d68"
+checksum = "19a4c448db514d4f24c5ddb9f73f2ee71bfb24c526cf0c570ba142d1119e0051"
 dependencies = [
  "tracing-core",
  "tracing-subscriber",
@@ -576,9 +678,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-test-macro"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04659ddb06c87d233c566112c1c9c5b9e98256d9af50ec3bc9c8327f873a7568"
+checksum = "ad06847b7afb65c7866a36664b75c40b895e318cea4f71299f013fb22965329d"
 dependencies = [
  "quote",
  "syn",
@@ -590,6 +692,12 @@ version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
 
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
 [[package]]
 name = "valuable"
 version = "0.1.0"
@@ -603,12 +711,55 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
-name = "wasi"
+name = "wasip2"
-version = "0.13.3+wasi-0.2.2"
+version = "1.0.2+wasi-0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
 dependencies = [
- "wit-bindgen-rt",
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
 ]
 
 [[package]]
@@ -774,51 +925,95 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
 [[package]]
-name = "wit-bindgen-rt"
+name = "wit-bindgen"
-version = "0.33.0"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
 dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "prettyplease",
+ "syn",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
  "bitflags",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
 ]
 
 [[package]]
-name = "zerocopy"
+name = "wit-parser"
-version = "0.7.35"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
 dependencies = [
- "byteorder",
+ "anyhow",
- "zerocopy-derive 0.7.35",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
 ]
 
 [[package]]
-name = "zerocopy"
+name = "zmij"
-version = "0.8.14"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a367f292d93d4eab890745e75a778da40909cab4d6ff8173693812f79c4a2468"
+checksum = "4de98dfa5d5b7fef4ee834d0073d560c9ca7b6c46a71d058c48db7960f8cfaf7"
-dependencies = [
- "zerocopy-derive 0.8.14",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.8.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3931cb58c62c13adec22e38686b559c86a30565e16ad6e8510a337cedc611e1"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]

Cargo.toml

@@ -3,10 +3,9 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "0.10.0"
+version = "0.11.0"
 
 [workspace.dependencies]
-mad = { path = "crates/mad" }
 
 anyhow = { version = "1.0.71" }
 tokio = { version = "1", features = ["full"] }

README.md

@@ -4,165 +4,163 @@
 [![Documentation](https://docs.rs/notmad/badge.svg)](https://docs.rs/notmad)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-## Overview
+A simple lifecycle manager for long-running Rust applications. Run multiple services concurrently with graceful shutdown handling.
-
-MAD is a robust lifecycle manager designed for long-running Rust operations. It provides a simple, composable way to manage multiple concurrent services within your application, handling graceful startup and shutdown automatically.
-
-### Perfect for:
-- 🌐 Web servers
-- 📨 Queue consumers and message processors  
-- 🔌 gRPC servers
-- ⏰ Cron job runners
-- 🔄 Background workers
-- 📡 Any long-running async operations
-
-## Features
-
-- **Component-based architecture** - Build your application from composable, reusable components
-- **Graceful shutdown** - Automatic handling of shutdown signals with proper cleanup
-- **Concurrent execution** - Run multiple components in parallel with tokio
-- **Error handling** - Built-in error propagation and logging
-- **Cancellation tokens** - Coordinate shutdown across all components
-- **Minimal boilerplate** - Focus on your business logic, not lifecycle management
 
 ## Installation
 
-Add MAD to your `Cargo.toml`:
-
 ```toml
 [dependencies]
-notmad = "0.7.5"
+notmad = "0.10.0"
 tokio = { version = "1", features = ["full"] }
-async-trait = "0.1"
 ```
 
 ## Quick Start
 
-Here's a simple example of a component that simulates a long-running server:
-
 ```rust
-use mad::{Component, Mad};
+use notmad::{Component, Mad};
-use async_trait::async_trait;
 use tokio_util::sync::CancellationToken;
 
-// Define your component
+struct MyService;
-struct WebServer {
-    port: u16,
-}
 
-#[async_trait]
+impl Component for MyService {
-impl Component for WebServer {
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
-    fn name(&self) -> Option<String> {
+        println!("Service running...");
-        Some(format!("WebServer on port {}", self.port))
+        cancellation.cancelled().await;
-    }
+        println!("Service stopped");
-
-    async fn run(&self, cancellation: CancellationToken) -> Result<(), mad::MadError> {
-        println!("Starting web server on port {}", self.port);
-        
-        // Your server logic here
-        // The cancellation token will be triggered on shutdown
-        tokio::select! {
-            _ = cancellation.cancelled() => {
-                println!("Shutting down web server");
-            }
-            _ = self.serve() => {
-                println!("Server stopped");
-            }
-        }
-        
         Ok(())
     }
 }
 
-impl WebServer {
-    async fn serve(&self) {
-        // Simulate a running server
-        tokio::time::sleep(std::time::Duration::from_secs(3600)).await;
-    }
-}
-
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    // Build and run your application
     Mad::builder()
-        .add(WebServer { port: 8080 })
+        .add(MyService)
-        .add(WebServer { port: 8081 })  // You can add multiple instances
         .run()
         .await?;
-
     Ok(())
 }
 ```
 
-## Advanced Usage
+## Basic Usage
 
-### Custom Components
+### Axum Web Server with Graceful Shutdown
 
-Components can be anything that implements the `Component` trait:
+Here's how to run an Axum server with MAD's graceful shutdown:
 
 ```rust
-use mad::{Component, Mad};
+use axum::{Router, routing::get};
-use async_trait::async_trait;
+use notmad::{Component, ComponentInfo};
+use tokio_util::sync::CancellationToken;
 
-struct QueueProcessor {
+struct WebServer {
-    queue_name: String,
+    port: u16,
 }
 
-#[async_trait]
+impl Component for WebServer {
-impl Component for QueueProcessor {
+    fn info(&self) -> ComponentInfo {
-    fn name(&self) -> Option<String> {
+        format!("WebServer:{}", self.port).into()
-        Some(format!("QueueProcessor-{}", self.queue_name))
     }
 
-    async fn run(&self, cancellation: CancellationToken) -> Result<(), mad::MadError> {
+    async fn run(&self, cancel: CancellationToken) -> Result<(), notmad::MadError> {
-        while !cancellation.is_cancelled() {
+        let app = Router::new().route("/", get(|| async { "Hello, World!" }));
-            // Process messages from queue
+
-            self.process_next_message().await?;
+        let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", self.port))
-        }
+            .await?;
+
+        println!("Listening on http://0.0.0.0:{}", self.port);
+
+        // Run server with graceful shutdown
+        axum::serve(listener, app)
+            .with_graceful_shutdown(async move {
+                cancel.cancelled().await;
+                println!("Shutting down server...");
+            })
+            .await?;
+
         Ok(())
     }
 }
 ```
 
-### Error Handling
+### Run Multiple Services
-
-MAD provides comprehensive error handling through the `MadError` type with automatic conversion from `anyhow::Error`:
 
 ```rust
-async fn run(&self, cancellation: CancellationToken) -> Result<(), mad::MadError> {
+Mad::builder()
-    // Errors automatically convert from anyhow::Error to MadError
+    .add(WebServer { port: 8080 })
-    database_operation().await?;
+    .add(WebServer { port: 8081 })
-    
+    .run()
-    // Or return explicit errors
+    .await?;
-    if some_condition {
+```
-        return Err(anyhow::anyhow!("Something went wrong").into());
+
+### Use Functions as Components
+
+```rust
+Mad::builder()
+    .add_fn(|cancel| async move {
+        println!("Running...");
+        cancel.cancelled().await;
+        Ok(())
+    })
+    .run()
+    .await?;
+```
+
+## Lifecycle Hooks
+
+Components support optional setup and cleanup phases:
+
+```rust
+impl Component for DatabaseService {
+    async fn setup(&self) -> Result<(), notmad::MadError> {
+        println!("Connecting to database...");
+        Ok(())
+    }
+
+    async fn run(&self, cancel: CancellationToken) -> Result<(), notmad::MadError> {
+        cancel.cancelled().await;
+        Ok(())
+    }
+
+    async fn close(&self) -> Result<(), notmad::MadError> {
+        println!("Closing database connection...");
+        Ok(())
     }
-    
-    Ok(())
 }
 ```
 
+## Migration from v0.10
+
+### Breaking Changes
+
+1. **`name()` → `info()`**: Returns `ComponentInfo` instead of `Option<String>`
+   ```rust
+   // Before
+   fn name(&self) -> Option<String> { Some("my-service".into()) }
+
+   // After
+   fn info(&self) -> ComponentInfo { "my-service".into() }
+   ```
+
+2. **No more `async-trait`**: Remove the dependency and `#[async_trait]` attribute
+   ```rust
+   // Before
+   #[async_trait]
+   impl Component for MyService { }
+
+   // After
+   impl Component for MyService { }
+   ```
+
 ## Examples
 
-Check out the [examples directory](crates/mad/examples) for more detailed examples:
+See [examples directory](crates/mad/examples) for complete working examples.
-
-- **basic** - Simple component lifecycle
-- **fn** - Using functions as components
-- **signals** - Handling system signals
-- **error_log** - Error handling and logging
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
 
 ## License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+MIT - see [LICENSE](LICENSE)
 
-## Author
+## Links
 
-Created and maintained by [kjuulh](https://github.com/kjuulh)
+- [Documentation](https://docs.rs/notmad)
-
+- [Repository](https://github.com/kjuulh/mad)
-## Repository
+- [Crates.io](https://crates.io/crates/notmad)
-
-Find the source code at [https://github.com/kjuulh/mad](https://github.com/kjuulh/mad)

crates/mad/Cargo.toml

@@ -10,10 +10,9 @@ readme = "../../README.md"
 
 [dependencies]
 anyhow.workspace = true
-async-trait = "0.1.81"
 futures = "0.3.30"
 futures-util = "0.3.30"
-rand = "0.9.0"
+rand = "0.10.0"
 thiserror = "2.0.0"
 tokio.workspace = true
 tokio-util = "0.7.11"

crates/mad/examples/basic/main.rs

@@ -1,16 +1,15 @@
-use async_trait::async_trait;
+use notmad::ComponentInfo;
 use rand::Rng;
 use tokio_util::sync::CancellationToken;
 use tracing::Level;
 
 struct WaitServer {}
-#[async_trait]
 impl notmad::Component for WaitServer {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some("WaitServer".into())
+        "WaitServer".into()
     }
 
-    async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
+    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
         let millis_wait = rand::thread_rng().gen_range(500..3000);
 
         tracing::debug!("waiting: {}ms", millis_wait);

crates/mad/examples/comprehensive/main.rs

@@ -7,8 +7,7 @@
 //! - Graceful shutdown with cancellation tokens
 //! - Concurrent component execution
 
-use async_trait::async_trait;
+use notmad::{Component, ComponentInfo, Mad, MadError};
-use notmad::{Component, Mad, MadError};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use tokio::time::{Duration, interval};
@@ -21,10 +20,9 @@ struct WebServer {
     request_count: Arc<AtomicUsize>,
 }
 
-#[async_trait]
 impl Component for WebServer {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some(format!("web-server-{}", self.port))
+        format!("web-server-{}", self.port).into()
     }
 
     async fn setup(&self) -> Result<(), MadError> {
@@ -81,10 +79,9 @@ struct JobProcessor {
     processing_interval: Duration,
 }
 
-#[async_trait]
 impl Component for JobProcessor {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some(format!("job-processor-{}", self.queue_name))
+        format!("job-processor-{}", self.queue_name).into()
     }
 
     async fn setup(&self) -> Result<(), MadError> {
@@ -139,10 +136,9 @@ struct HealthChecker {
     check_interval: Duration,
 }
 
-#[async_trait]
 impl Component for HealthChecker {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some("health-checker".to_string())
+        "health-checker".into()
     }
 
     async fn run(&self, cancellation: CancellationToken) -> Result<(), MadError> {
@@ -181,10 +177,9 @@ struct FailingComponent {
     fail_after: Duration,
 }
 
-#[async_trait]
 impl Component for FailingComponent {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some("failing-component".to_string())
+        "failing-component".into()
     }
 
     async fn run(&self, cancellation: CancellationToken) -> Result<(), MadError> {
@@ -209,10 +204,9 @@ impl Component for FailingComponent {
 /// Debug component that logs system status periodically.
 struct DebugComponent;
 
-#[async_trait]
 impl Component for DebugComponent {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some("debug-component".to_string())
+        "debug-component".into()
     }
 
     async fn run(&self, cancel: CancellationToken) -> Result<(), MadError> {

crates/mad/examples/error_log/main.rs

@@ -1,16 +1,15 @@
-use async_trait::async_trait;
+use notmad::ComponentInfo;
 use rand::Rng;
 use tokio_util::sync::CancellationToken;
 use tracing::Level;
 
 struct ErrorServer {}
-#[async_trait]
 impl notmad::Component for ErrorServer {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some("ErrorServer".into())
+        "ErrorServer".into()
     }
 
-    async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
+    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
         let millis_wait = rand::thread_rng().gen_range(500..3000);
 
         tracing::debug!("waiting: {}ms", millis_wait);

crates/mad/examples/fn/main.rs

@@ -1,13 +1,12 @@
-use async_trait::async_trait;
+use notmad::ComponentInfo;
 use rand::Rng;
 use tokio_util::sync::CancellationToken;
 use tracing::Level;
 
 struct WaitServer {}
-#[async_trait]
 impl notmad::Component for WaitServer {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some("WaitServer".into())
+        "WaitServer".into()
     }
 
     async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {

crates/mad/examples/multi_service/main.rs

@@ -3,8 +3,7 @@
 //! This example shows how to run a web server, queue processor, and
 //! scheduled task together, with graceful shutdown on Ctrl+C.
 
-use async_trait::async_trait;
+use notmad::{Component, ComponentInfo, Mad, MadError};
-use notmad::{Component, Mad, MadError};
 use tokio::time::{Duration, interval};
 use tokio_util::sync::CancellationToken;
 
@@ -16,22 +15,21 @@ struct WebServer {
     port: u16,
 }
 
-#[async_trait]
 impl Component for WebServer {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some(format!("WebServer:{}", self.port))
+        format!("WebServer:{}", self.port).into()
     }
 
     async fn setup(&self) -> Result<(), MadError> {
-        println!("[{}] Binding to port...", self.name().unwrap());
+        println!("[{}] Binding to port...", self.info());
         // Simulate server setup time
         tokio::time::sleep(Duration::from_millis(100)).await;
-        println!("[{}] Ready to accept connections", self.name().unwrap());
+        println!("[{}] Ready to accept connections", self.info());
         Ok(())
     }
 
     async fn run(&self, cancellation: CancellationToken) -> Result<(), MadError> {
-        println!("[{}] Server started", self.name().unwrap());
+        println!("[{}] Server started", self.info());
 
         // Simulate handling requests until shutdown
         let mut request_id = 0;
@@ -40,12 +38,12 @@ impl Component for WebServer {
         while !cancellation.is_cancelled() {
             tokio::select! {
                 _ = cancellation.cancelled() => {
-                    println!("[{}] Shutdown signal received", self.name().unwrap());
+                    println!("[{}] Shutdown signal received", self.info());
                     break;
                 }
                 _ = interval.tick() => {
                     request_id += 1;
-                    println!("[{}] Handling request #{}", self.name().unwrap(), request_id);
+                    println!("[{}] Handling request #{}", self.info(), request_id);
                 }
             }
         }
@@ -54,10 +52,10 @@ impl Component for WebServer {
     }
 
     async fn close(&self) -> Result<(), MadError> {
-        println!("[{}] Closing connections...", self.name().unwrap());
+        println!("[{}] Closing connections...", self.info());
         // Simulate graceful connection drain
         tokio::time::sleep(Duration::from_millis(200)).await;
-        println!("[{}] Server stopped", self.name().unwrap());
+        println!("[{}] Server stopped", self.info());
         Ok(())
     }
 }
@@ -70,14 +68,13 @@ struct QueueProcessor {
     queue_name: String,
 }
 
-#[async_trait]
 impl Component for QueueProcessor {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some(format!("QueueProcessor:{}", self.queue_name))
+        format!("QueueProcessor:{}", self.queue_name).into()
     }
 
     async fn run(&self, cancellation: CancellationToken) -> Result<(), MadError> {
-        println!("[{}] Started processing", self.name().unwrap());
+        println!("[{}] Started processing", self.info());
 
         let mut message_count = 0;
 
@@ -86,19 +83,19 @@ impl Component for QueueProcessor {
             // Simulate waiting for and processing a message
             tokio::select! {
                 _ = cancellation.cancelled() => {
-                    println!("[{}] Stopping message processing", self.name().unwrap());
+                    println!("[{}] Stopping message processing", self.info());
                     break;
                 }
                 _ = tokio::time::sleep(Duration::from_secs(1)) => {
                     message_count += 1;
-                    println!("[{}] Processed message #{}", self.name().unwrap(), message_count);
+                    println!("[{}] Processed message #{}", self.info(), message_count);
                 }
             }
         }
 
         println!(
             "[{}] Processed {} messages total",
-            self.name().unwrap(),
+            self.info(),
             message_count
         );
         Ok(())
@@ -116,16 +113,15 @@ struct ScheduledTask {
     interval_secs: u64,
 }
 
-#[async_trait]
 impl Component for ScheduledTask {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some(format!("ScheduledTask:{}", self.task_name))
+        format!("ScheduledTask:{}", self.task_name).into()
     }
 
     async fn run(&self, cancellation: CancellationToken) -> Result<(), MadError> {
         println!(
             "[{}] Scheduled to run every {} seconds",
-            self.name().unwrap(),
+            self.info(),
             self.interval_secs
         );
 
@@ -135,17 +131,17 @@ impl Component for ScheduledTask {
         while !cancellation.is_cancelled() {
             tokio::select! {
                 _ = cancellation.cancelled() => {
-                    println!("[{}] Scheduler stopping", self.name().unwrap());
+                    println!("[{}] Scheduler stopping", self.info());
                     break;
                 }
                 _ = interval.tick() => {
                     run_count += 1;
-                    println!("[{}] Executing run #{}", self.name().unwrap(), run_count);
+                    println!("[{}] Executing run #{}", self.info(), run_count);
 
                     // Simulate task execution
                     tokio::time::sleep(Duration::from_millis(500)).await;
 
-                    println!("[{}] Run #{} completed", self.name().unwrap(), run_count);
+                    println!("[{}] Run #{} completed", self.info(), run_count);
                 }
             }
         }

crates/mad/examples/nested_errors/main.rs

@@ -1,14 +1,13 @@
-use async_trait::async_trait;
+use notmad::ComponentInfo;
 use tokio_util::sync::CancellationToken;
 
 struct NestedErrorComponent {
     name: String,
 }
 
-#[async_trait]
 impl notmad::Component for NestedErrorComponent {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some(self.name.clone())
+        self.name.clone().into()
     }
 
     async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
@@ -28,10 +27,9 @@ impl notmad::Component for NestedErrorComponent {
 
 struct AnotherFailingComponent;
 
-#[async_trait]
 impl notmad::Component for AnotherFailingComponent {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some("another-component".into())
+        "another-component".into()
     }
 
     async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {

crates/mad/examples/signals/main.rs

@@ -1,16 +1,15 @@
-use async_trait::async_trait;
+use notmad::ComponentInfo;
 use rand::Rng;
 use tokio_util::sync::CancellationToken;
 use tracing::Level;
 
 struct WaitServer {}
-#[async_trait]
 impl notmad::Component for WaitServer {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some("WaitServer".into())
+        "WaitServer".into()
     }
 
-    async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
+    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
         let millis_wait = rand::thread_rng().gen_range(500..3000);
 
         tracing::debug!("waiting: {}ms", millis_wait);
@@ -23,10 +22,9 @@ impl notmad::Component for WaitServer {
 }
 
 struct RespectCancel {}
-#[async_trait]
 impl notmad::Component for RespectCancel {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some("RespectCancel".into())
+        "RespectCancel".into()
     }
 
     async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
@@ -38,13 +36,12 @@ impl notmad::Component for RespectCancel {
 }
 
 struct NeverStopServer {}
-#[async_trait]
 impl notmad::Component for NeverStopServer {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some("NeverStopServer".into())
+        "NeverStopServer".into()
     }
 
-    async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
+    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
         // Simulates a server running for some time. Is normally supposed to be futures blocking indefinitely
         tokio::time::sleep(std::time::Duration::from_millis(999999999)).await;
 

crates/mad/src/lib.rs

@@ -1,42 +1,21 @@
 //! # MAD - Lifecycle Manager for Rust Applications
 //!
-//! MAD is a robust lifecycle manager designed for long-running Rust operations. It provides
+//! A simple lifecycle manager for long-running Rust applications. Run multiple services
-//! a simple, composable way to manage multiple concurrent services within your application,
+//! concurrently with graceful shutdown handling.
-//! handling graceful startup and shutdown automatically.
-//!
-//! ## Overview
-//!
-//! MAD helps you build applications composed of multiple long-running components that need
-//! to be orchestrated together. It handles:
-//!
-//! - **Concurrent execution** of multiple components
-//! - **Graceful shutdown** with cancellation tokens
-//! - **Error aggregation** from multiple components
-//! - **Lifecycle management** with setup, run, and close phases
 //!
 //! ## Quick Start
 //!
 //! ```rust,no_run
 //! use notmad::{Component, Mad};
-//! use async_trait::async_trait;
 //! use tokio_util::sync::CancellationToken;
 //!
-//! struct MyService {
+//! struct MyService;
-//!     name: String,
-//! }
 //!
-//! #[async_trait]
 //! impl Component for MyService {
-//!     fn name(&self) -> Option<String> {
+//!     async fn run(&self, cancel: CancellationToken) -> Result<(), notmad::MadError> {
-//!         Some(self.name.clone())
+//!         println!("Running...");
-//!     }
+//!         cancel.cancelled().await;
-//!
+//!         println!("Stopped");
-//!     async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
-//!         // Your service logic here
-//!         while !cancellation.is_cancelled() {
-//!             // Do work...
-//!             tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-//!         }
 //!         Ok(())
 //!     }
 //! }
@@ -44,44 +23,25 @@
 //! #[tokio::main]
 //! async fn main() -> anyhow::Result<()> {
 //!     Mad::builder()
-//!         .add(MyService { name: "service-1".into() })
+//!         .add(MyService)
-//!         .add(MyService { name: "service-2".into() })
 //!         .run()
 //!         .await?;
 //!     Ok(())
 //! }
 //! ```
 //!
-//! ## Component Lifecycle
+//! ## Features
 //!
-//! Components go through three phases:
+//! - Run multiple components concurrently
-//!
+//! - Graceful shutdown with cancellation tokens
-//! 1. **Setup**: Optional initialization phase before components start running
+//! - Optional lifecycle hooks: `setup()`, `run()`, `close()`
-//! 2. **Run**: Main execution phase where components perform their work
+//! - Automatic error aggregation
-//! 3. **Close**: Optional cleanup phase after components stop
+//! - SIGTERM and Ctrl+C signal handling
-//!
-//! ## Error Handling
-//!
-//! MAD provides comprehensive error handling through [`MadError`], which can:
-//! - Wrap errors from individual components
-//! - Aggregate multiple errors when several components fail
-//! - Automatically convert from `anyhow::Error`
-//!
-//! ## Shutdown Behavior
-//!
-//! MAD handles shutdown gracefully:
-//! - Responds to SIGTERM and Ctrl+C signals
-//! - Propagates cancellation tokens to all components
-//! - Waits for components to finish cleanup
-//! - Configurable cancellation timeout
 
 use futures::stream::FuturesUnordered;
 use futures_util::StreamExt;
-use std::{error::Error, fmt::Display, sync::Arc};
+use std::{error::Error, fmt::Display, pin::Pin, sync::Arc};
-use tokio::{
+use tokio::signal::unix::{SignalKind, signal};
-    signal::unix::{SignalKind, signal},
-    task::JoinError,
-};
 
 use tokio_util::sync::CancellationToken;
 
@@ -208,12 +168,10 @@ impl Display for AggregateError {
 ///
 /// ```rust
 /// use notmad::{Component, Mad};
-/// use async_trait::async_trait;
 /// use tokio_util::sync::CancellationToken;
 ///
 /// struct MyComponent;
 ///
-/// #[async_trait]
 /// impl Component for MyComponent {
 ///     async fn run(&self, _cancel: CancellationToken) -> Result<(), notmad::MadError> {
 ///         Ok(())
@@ -229,7 +187,7 @@ impl Display for AggregateError {
 /// # }
 /// ```
 pub struct Mad {
-    components: Vec<Arc<dyn Component + Send + Sync + 'static>>,
+    components: Vec<SharedComponent>,
 
     should_cancel: Option<std::time::Duration>,
 }
@@ -273,10 +231,8 @@ impl Mad {
     ///
     /// ```rust
     /// use notmad::{Component, Mad};
-    /// # use async_trait::async_trait;
     /// # use tokio_util::sync::CancellationToken;
     /// # struct MyService;
-    /// # #[async_trait]
     /// # impl Component for MyService {
     /// #     async fn run(&self, _: CancellationToken) -> Result<(), notmad::MadError> { Ok(()) }
     /// # }
@@ -306,10 +262,8 @@ impl Mad {
     /// ```rust
     /// use notmad::Mad;
     /// # use notmad::Component;
-    /// # use async_trait::async_trait;
     /// # use tokio_util::sync::CancellationToken;
     /// # struct DebugService;
-    /// # #[async_trait]
     /// # impl Component for DebugService {
     /// #     async fn run(&self, _: CancellationToken) -> Result<(), notmad::MadError> { Ok(()) }
     /// # }
@@ -397,7 +351,7 @@ impl Mad {
     /// # Arguments
     ///
     /// * `should_cancel` - Duration to wait after cancellation before forcing shutdown.
-    ///                     Pass `None` to wait indefinitely.
+    ///   Pass `None` to wait indefinitely.
     ///
     /// # Example
     ///
@@ -472,7 +426,7 @@ impl Mad {
         tracing::debug!("setting up components");
 
         for comp in &self.components {
-            tracing::trace!(component = &comp.name(), "mad setting up");
+            tracing::trace!(component = %comp.info(), "mad setting up");
 
             match comp.setup().await {
                 Ok(_) | Err(MadError::SetupNotDefined) => {}
@@ -502,15 +456,15 @@ impl Mad {
             channels.push(error_rx);
 
             tokio::spawn(async move {
-                let name = comp.name().clone();
+                let info = comp.info().clone();
 
-                tracing::debug!(component = name, "mad running");
+                tracing::debug!(component = %info, "mad running");
 
                 let handle = tokio::spawn(async move { comp.run(job_cancellation).await });
 
                 tokio::select! {
                     _ = cancellation_token.cancelled() => {
-                        error_tx.send(CompletionResult { res: Ok(()) , name  }).await
+                        error_tx.send(CompletionResult { res: Ok(()) , name: info.name  }).await
                     }
                     res = handle => {
                      let res = match res {
@@ -532,7 +486,7 @@ impl Mad {
                      };
 
 
-                        error_tx.send(CompletionResult { res , name  }).await
+                        error_tx.send(CompletionResult { res , name: info.name  }).await
                     }
                 }
             });
@@ -609,7 +563,7 @@ impl Mad {
         tracing::debug!("closing components");
 
         for comp in &self.components {
-            tracing::trace!(component = &comp.name(), "mad closing");
+            tracing::trace!(component = %comp.info(), "mad closing");
             match comp.close().await {
                 Ok(_) | Err(MadError::CloseNotDefined) => {}
                 Err(e) => return Err(e),
@@ -627,6 +581,46 @@ async fn signal_unix_terminate() {
     sigterm.recv().await;
 }
 
+#[derive(Default, Clone)]
+pub struct ComponentInfo {
+    name: Option<String>,
+}
+
+impl Display for ComponentInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(
+            self.name
+                .as_ref()
+                .map(|n| n.as_str())
+                .unwrap_or_else(|| "unknown"),
+        )
+    }
+}
+
+impl ComponentInfo {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn with_name(&mut self, name: impl Into<String>) -> &mut Self {
+        self.name = Some(name.into());
+        self
+    }
+}
+
+impl From<String> for ComponentInfo {
+    fn from(value: String) -> Self {
+        Self { name: Some(value) }
+    }
+}
+impl From<&str> for ComponentInfo {
+    fn from(value: &str) -> Self {
+        Self {
+            name: Some(value.into()),
+        }
+    }
+}
+
 /// Trait for implementing MAD components.
 ///
 /// Components represent individual services or tasks that run as part
@@ -636,18 +630,16 @@ async fn signal_unix_terminate() {
 /// # Example
 ///
 /// ```rust
-/// use notmad::{Component, MadError};
+/// use notmad::{Component, ComponentInfo, MadError};
-/// use async_trait::async_trait;
 /// use tokio_util::sync::CancellationToken;
 ///
 /// struct DatabaseConnection {
 ///     url: String,
 /// }
 ///
-/// #[async_trait]
 /// impl Component for DatabaseConnection {
-///     fn name(&self) -> Option<String> {
+///     fn info(&self) -> ComponentInfo {
-///         Some("database".to_string())
+///         "database".into()
 ///     }
 ///
 ///     async fn setup(&self) -> Result<(), MadError> {
@@ -669,8 +661,7 @@ async fn signal_unix_terminate() {
 ///     }
 /// }
 /// ```
-#[async_trait::async_trait]
+pub trait Component: Send + Sync + 'static {
-pub trait Component {
     /// Returns an optional name for the component.
     ///
     /// This name is used in logging and error messages to identify
@@ -679,8 +670,8 @@ pub trait Component {
     /// # Default
     ///
     /// Returns `None` if not overridden.
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        None
+        ComponentInfo::default()
     }
 
     /// Optional setup phase called before the component starts running.
@@ -698,8 +689,8 @@ pub trait Component {
     ///
     /// If setup fails with an error other than `SetupNotDefined`,
     /// the entire application will stop before any components start running.
-    async fn setup(&self) -> Result<(), MadError> {
+    fn setup(&self) -> impl Future<Output = Result<(), MadError>> + Send + '_ {
-        Err(MadError::SetupNotDefined)
+        async { Err(MadError::SetupNotDefined) }
     }
 
     /// Main execution phase of the component.
@@ -721,7 +712,10 @@ pub trait Component {
     /// # Errors
     ///
     /// Any error returned will trigger shutdown of all other components.
-    async fn run(&self, cancellation_token: CancellationToken) -> Result<(), MadError>;
+    fn run(
+        &self,
+        cancellation_token: CancellationToken,
+    ) -> impl Future<Output = Result<(), MadError>> + Send + '_;
 
     /// Optional cleanup phase called after the component stops.
     ///
@@ -738,8 +732,73 @@ pub trait Component {
     ///
     /// Errors during close are logged but don't prevent other components
     /// from closing.
+    fn close(&self) -> impl Future<Output = Result<(), MadError>> + Send + '_ {
+        async { Err(MadError::CloseNotDefined) }
+    }
+}
+
+trait AsyncComponent: Send + Sync + 'static {
+    fn info_async(&self) -> ComponentInfo;
+
+    fn setup_async(&self) -> Pin<Box<dyn Future<Output = Result<(), MadError>> + Send + '_>>;
+
+    fn run_async(
+        &self,
+        cancellation_token: CancellationToken,
+    ) -> Pin<Box<dyn Future<Output = Result<(), MadError>> + Send + '_>>;
+
+    fn close_async(&self) -> Pin<Box<dyn Future<Output = Result<(), MadError>> + Send + '_>>;
+}
+
+impl<E: Component> AsyncComponent for E {
+    #[inline(always)]
+    fn info_async(&self) -> ComponentInfo {
+        self.info()
+    }
+
+    #[inline(always)]
+    fn setup_async(&self) -> Pin<Box<dyn Future<Output = Result<(), MadError>> + Send + '_>> {
+        Box::pin(self.setup())
+    }
+
+    #[inline(always)]
+    fn run_async(
+        &self,
+        cancellation_token: CancellationToken,
+    ) -> Pin<Box<dyn Future<Output = Result<(), MadError>> + Send + '_>> {
+        Box::pin(self.run(cancellation_token))
+    }
+
+    #[inline(always)]
+    fn close_async(&self) -> Pin<Box<dyn Future<Output = Result<(), MadError>> + Send + '_>> {
+        Box::pin(self.close())
+    }
+}
+
+#[derive(Clone)]
+pub struct SharedComponent {
+    component: Arc<dyn AsyncComponent + Send + Sync + 'static>,
+}
+
+impl SharedComponent {
+    #[inline(always)]
+    pub fn info(&self) -> ComponentInfo {
+        self.component.info_async()
+    }
+
+    #[inline(always)]
+    async fn setup(&self) -> Result<(), MadError> {
+        self.component.setup_async().await
+    }
+
+    #[inline(always)]
+    async fn run(&self, cancellation_token: CancellationToken) -> Result<(), MadError> {
+        self.component.run_async(cancellation_token).await
+    }
+
+    #[inline(always)]
     async fn close(&self) -> Result<(), MadError> {
-        Err(MadError::CloseNotDefined)
+        self.component.close_async().await
     }
 }
 
@@ -753,12 +812,10 @@ pub trait Component {
 ///
 /// ```rust
 /// use notmad::{Component, IntoComponent, Mad};
-/// # use async_trait::async_trait;
 /// # use tokio_util::sync::CancellationToken;
 ///
 /// struct MyService;
 ///
-/// # #[async_trait]
 /// # impl Component for MyService {
 /// #     async fn run(&self, _: CancellationToken) -> Result<(), notmad::MadError> { Ok(()) }
 /// # }
@@ -769,12 +826,14 @@ pub trait Component {
 /// ```
 pub trait IntoComponent {
     /// Converts self into an Arc-wrapped component.
-    fn into_component(self) -> Arc<dyn Component + Send + Sync + 'static>;
+    fn into_component(self) -> SharedComponent;
 }
 
-impl<T: Component + Send + Sync + 'static> IntoComponent for T {
+impl<T: Component> IntoComponent for T {
-    fn into_component(self) -> Arc<dyn Component + Send + Sync + 'static> {
+    fn into_component(self) -> SharedComponent {
-        Arc::new(self)
+        SharedComponent {
+            component: Arc::new(self),
+        }
     }
 }
 
@@ -798,7 +857,6 @@ where
     }
 }
 
-#[async_trait::async_trait]
 impl<F, Fut> Component for ClosureComponent<F, Fut>
 where
     F: Fn(CancellationToken) -> Fut + Send + Sync + 'static,
@@ -812,7 +870,6 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use anyhow::Context;
 
     #[test]
     fn test_error_chaining_display() {
@@ -909,10 +966,9 @@ mod tests {
     async fn test_component_error_propagation() {
         struct FailingComponent;
 
-        #[async_trait::async_trait]
         impl Component for FailingComponent {
-            fn name(&self) -> Option<String> {
+            fn info(&self) -> ComponentInfo {
-                Some("test-component".to_string())
+                "test-component".into()
             }
 
             async fn run(&self, _cancel: CancellationToken) -> Result<(), MadError> {

crates/mad/src/waiter.rs

@@ -4,19 +4,15 @@
 //! without performing any work. Useful for keeping the application alive
 //! or as placeholders in conditional component loading.
 
-use std::sync::Arc;
-
-use async_trait::async_trait;
 use tokio_util::sync::CancellationToken;
 
-use crate::{Component, MadError};
+use crate::{Component, ComponentInfo, IntoComponent, MadError, SharedComponent};
 
 /// A default waiter component that panics if run.
 ///
 /// This is used internally as a placeholder that should never
 /// actually be executed.
-pub struct DefaultWaiter {}
+pub struct DefaultWaiter;
-#[async_trait]
 impl Component for DefaultWaiter {
     async fn run(&self, _cancellation_token: CancellationToken) -> Result<(), MadError> {
         panic!("should never be called");
@@ -38,13 +34,13 @@ impl Component for DefaultWaiter {
 /// let waiter = Waiter::new(service.into_component());
 /// ```
 pub struct Waiter {
-    comp: Arc<dyn Component + Send + Sync + 'static>,
+    comp: SharedComponent,
 }
 
 impl Default for Waiter {
     fn default() -> Self {
         Self {
-            comp: Arc::new(DefaultWaiter {}),
+            comp: DefaultWaiter {}.into_component(),
         }
     }
 }
@@ -54,21 +50,20 @@ impl Waiter {
     ///
     /// The wrapped component's name will be used (prefixed with "waiter/"),
     /// but its run method will not be called.
-    pub fn new(c: Arc<dyn Component + Send + Sync + 'static>) -> Self {
+    pub fn new(c: SharedComponent) -> Self {
         Self { comp: c }
     }
 }
 
-#[async_trait]
 impl Component for Waiter {
     /// Returns the name of the waiter, prefixed with "waiter/".
     ///
     /// If the wrapped component has a name, it will be "waiter/{name}".
     /// Otherwise, returns "waiter".
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        match self.comp.name() {
+        match &self.comp.info().name {
-            Some(name) => Some(format!("waiter/{name}")),
+            Some(name) => format!("waiter/{name}").into(),
-            None => Some("waiter".into()),
+            None => "waiter".into(),
         }
     }
 

crates/mad/tests/mod.rs

@@ -1,7 +1,6 @@
 use std::sync::Arc;
 
-use async_trait::async_trait;
+use notmad::{Component, ComponentInfo, Mad, MadError};
-use notmad::{Component, Mad, MadError};
 use rand::Rng;
 use tokio::sync::Mutex;
 use tokio_util::sync::CancellationToken;
@@ -9,13 +8,12 @@ use tracing_test::traced_test;
 
 struct NeverEndingRun {}
 
-#[async_trait]
 impl Component for NeverEndingRun {
-    fn name(&self) -> Option<String> {
+    fn info(&self) -> ComponentInfo {
-        Some("NeverEndingRun".into())
+        "NeverEndingRun".into()
     }
 
-    async fn run(&self, cancellation: CancellationToken) -> Result<(), notmad::MadError> {
+    async fn run(&self, _cancellation: CancellationToken) -> Result<(), notmad::MadError> {
         let millis_wait = rand::thread_rng().gen_range(50..1000);
 
         tokio::time::sleep(std::time::Duration::from_millis(millis_wait)).await;