add proc macros ; benchmark ; example

4 files changed, 0 insertions, 1560 deletions

diff --git a/tests/count_prefix.rs b/tests/count_prefix.rs
deleted file mode 100644
index ab25e30..0000000
--- a/tests/count_prefix.rs
+++ /dev/null
@@ -1,305 +0,0 @@
-use zr_protocol::{
-    codec::{decode::Decode, encode::Encode},
-    types::prefix::count::CountPrefix,
-};
-
-fn encode_to_bytes<T: Encode>(value: T) -> Vec<u8> {
-    let mut buf = Vec::new();
-    value.encode(&mut buf).unwrap();
-    buf
-}
-
-// ────────────────────── Vecteur vide ────────────
-
-#[test]
-fn empty_vec_u8_with_u8_count() {
-    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(vec![]);
-    let buf = encode_to_bytes(cp);
-    assert_eq!(buf, vec![0x00]);
-}
-
-#[test]
-fn empty_vec_u32_with_u16_count() {
-    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(vec![]);
-    let buf = encode_to_bytes(cp);
-    assert_eq!(buf, vec![0x00, 0x00]);
-}
-
-#[test]
-fn empty_vec_u8_with_u32_count() {
-    let cp = CountPrefix::<u8, u32, Vec<u8>>::new(vec![]);
-    let buf = encode_to_bytes(cp);
-    assert_eq!(buf, vec![0x00, 0x00, 0x00, 0x00]);
-}
-
-// ────────────────────── Un seul élément ─────────
-
-#[test]
-fn single_u8_u8_count() {
-    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(vec![42]);
-    let buf = encode_to_bytes(cp);
-    assert_eq!(buf, vec![0x01, 0x2A]);
-}
-
-#[test]
-fn single_u32_u8_count() {
-    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![0x01020304]);
-    let buf = encode_to_bytes(cp);
-    assert_eq!(buf, vec![0x01, 0x01, 0x02, 0x03, 0x04]);
-}
-
-// ────────────────────── Plusieurs éléments ──────
-
-#[test]
-fn multiple_u8_u8_count() {
-    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(vec![1, 2, 3]);
-    let buf = encode_to_bytes(cp);
-    assert_eq!(buf, vec![0x03, 0x01, 0x02, 0x03]);
-}
-
-#[test]
-fn multiple_u16_u8_count() {
-    let cp = CountPrefix::<u16, u8, Vec<u16>>::new(vec![256, 512, 1024]);
-    let buf = encode_to_bytes(cp);
-    assert_eq!(
-        buf,
-        vec![
-            0x03, // count = 3
-            0x01, 0x00, // 256
-            0x02, 0x00, // 512
-            0x04, 0x00, // 1024
-        ]
-    );
-}
-
-#[test]
-fn multiple_u32_u16_count() {
-    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(vec![100, 200, 300]);
-    let buf = encode_to_bytes(cp);
-    assert_eq!(
-        buf,
-        vec![
-            0x00, 0x03, // count = 3 (u16)
-            0x00, 0x00, 0x00, 0x64, // 100
-            0x00, 0x00, 0x00, 0xC8, // 200
-            0x00, 0x00, 0x01, 0x2C, // 300
-        ]
-    );
-}
-
-// ────────────────────── Valeurs extrêmes ────────
-
-#[test]
-fn u8_count_max_255() {
-    let data: Vec<u8> = (0..255).collect();
-    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(data.clone());
-    let buf = encode_to_bytes(cp);
-    assert_eq!(buf[0], 0xFF);
-    assert_eq!(buf.len(), 1 + 255);
-}
-
-#[test]
-fn large_u32_items_u16_count() {
-    let data: Vec<u32> = vec![u32::MAX, 0, u32::MIN + 1];
-    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(data);
-    let buf = encode_to_bytes(cp);
-    assert_eq!(buf.len(), 2 + 3 * 4);
-    assert_eq!(&buf[0..2], &[0x00, 0x03]); // count = 3
-}
-
-// ────────────────────── Roundtrip ───────────────
-
-#[test]
-fn roundtrip_u8_u8() {
-    let data = vec![10, 20, 30, 40, 50];
-    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(data.clone());
-    let buf = encode_to_bytes(cp);
-
-    let mut reader = &buf[..];
-    let decoded = CountPrefix::<u8, u8, Vec<u8>>::decode(&mut reader).unwrap();
-    assert_eq!(*decoded.as_ref(), data);
-}
-
-#[test]
-fn roundtrip_u32_u16() {
-    let data = vec![1, 2, 3, 4, 5];
-    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(data.clone());
-    let buf = encode_to_bytes(cp);
-
-    let mut reader = &buf[..];
-    let decoded = CountPrefix::<u32, u16, Vec<u32>>::decode(&mut reader).unwrap();
-    assert_eq!(*decoded.as_ref(), data);
-}
-
-#[test]
-fn roundtrip_empty() {
-    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![]);
-    let buf = encode_to_bytes(cp);
-
-    let mut reader = &buf[..];
-    let decoded = CountPrefix::<u32, u8, Vec<u32>>::decode(&mut reader).unwrap();
-    assert!(decoded.as_ref().is_empty());
-}
-
-#[test]
-fn roundtrip_single_element() {
-    let cp = CountPrefix::<u64, u8, Vec<u64>>::new(vec![u64::MAX]);
-    let buf = encode_to_bytes(cp);
-
-    let mut reader = &buf[..];
-    let decoded = CountPrefix::<u64, u8, Vec<u64>>::decode(&mut reader).unwrap();
-    assert_eq!(*decoded.as_ref(), vec![u64::MAX]);
-}
-
-#[test]
-fn roundtrip_negative_i32() {
-    let data = vec![-1, -100, 0, 100, 1];
-    let cp = CountPrefix::<i32, u16, Vec<i32>>::new(data.clone());
-    let buf = encode_to_bytes(cp);
-
-    let mut reader = &buf[..];
-    let decoded = CountPrefix::<i32, u16, Vec<i32>>::decode(&mut reader).unwrap();
-    assert_eq!(*decoded.as_ref(), data);
-}
-
-#[test]
-fn roundtrip_f64() {
-    let data = vec![0.0, 3.14, -2.71, f64::INFINITY, f64::NEG_INFINITY];
-    let cp = CountPrefix::<f64, u8, Vec<f64>>::new(data.clone());
-    let buf = encode_to_bytes(cp);
-
-    let mut reader = &buf[..];
-    let decoded = CountPrefix::<f64, u8, Vec<f64>>::decode(&mut reader).unwrap();
-    let decoded_data = decoded.as_ref().clone();
-    assert_eq!(decoded_data.len(), data.len());
-    for (a, b) in decoded_data.iter().zip(data.iter()) {
-        if a.is_nan() {
-            assert!(b.is_nan());
-        } else {
-            assert_eq!(a, b);
-        }
-    }
-}
-
-#[test]
-fn roundtrip_bool() {
-    let data = vec![true, false, true, true, false];
-    let cp = CountPrefix::<bool, u8, Vec<bool>>::new(data.clone());
-    let buf = encode_to_bytes(cp);
-
-    let mut reader = &buf[..];
-    let decoded = CountPrefix::<bool, u8, Vec<bool>>::decode(&mut reader).unwrap();
-    assert_eq!(*decoded.as_ref(), data);
-}
-
-#[test]
-fn roundtrip_large_dataset() {
-    let data: Vec<u32> = (0..1000).collect();
-    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(data.clone());
-    let buf = encode_to_bytes(cp);
-
-    let mut reader = &buf[..];
-    let decoded = CountPrefix::<u32, u16, Vec<u32>>::decode(&mut reader).unwrap();
-    assert_eq!(*decoded.as_ref(), data);
-}
-
-// ────────────────────── Imbrication ─────────────
-
-#[test]
-fn nested_count_prefix() {
-    let inner1 = CountPrefix::<u8, u8, Vec<u8>>::new(vec![1, 2, 3]);
-    let inner2 = CountPrefix::<u8, u8, Vec<u8>>::new(vec![4, 5]);
-    let outer =
-        CountPrefix::<CountPrefix<u8, u8, Vec<u8>>, u8, Vec<CountPrefix<u8, u8, Vec<u8>>>>::new(
-            vec![inner1, inner2],
-        );
-
-    let buf = encode_to_bytes(outer);
-
-    let mut reader = &buf[..];
-    let decoded_outer =
-        CountPrefix::<CountPrefix<u8, u8, Vec<u8>>, u8, Vec<CountPrefix<u8, u8, Vec<u8>>>>::decode(
-            &mut reader,
-        )
-        .unwrap();
-
-    let outer_data: Vec<_> = decoded_outer
-        .as_ref()
-        .iter()
-        .map(|c| c.as_ref().clone())
-        .collect();
-    assert_eq!(outer_data.len(), 2);
-    assert_eq!(outer_data[0], vec![1, 2, 3]);
-    assert_eq!(outer_data[1], vec![4, 5]);
-}
-
-// ────────────────────── Erreurs de décodage ─────
-
-#[test]
-fn decode_empty_buffer_fails() {
-    let result = CountPrefix::<u8, u8, Vec<u8>>::decode(&mut &[][..]);
-    assert!(result.is_err());
-}
-
-#[test]
-fn decode_truncated_data_fails() {
-    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![1, 2, 3]);
-    let buf = encode_to_bytes(cp);
-    let truncated = &buf[..buf.len() - 1];
-    let result = CountPrefix::<u32, u8, Vec<u32>>::decode(&mut &truncated[..]);
-    assert!(result.is_err());
-}
-
-#[test]
-fn decode_wrong_count_fails() {
-    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![1, 2]);
-    let mut buf = encode_to_bytes(cp);
-    buf[0] = 0x05;
-    let result = CountPrefix::<u32, u8, Vec<u32>>::decode(&mut &buf[..]);
-    assert!(result.is_err());
-}
-
-// ────────────────────── AsRef / AsMut ───────────
-
-#[test]
-fn as_ref_returns_inner_data() {
-    let data = vec![10u32, 20, 30];
-    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(data.clone());
-    assert_eq!(*cp.as_ref(), data);
-}
-
-#[test]
-fn as_mut_allows_mutation() {
-    let mut cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![1, 2, 3]);
-    cp.as_mut().push(4);
-    assert_eq!(*cp.as_ref(), vec![1, 2, 3, 4]);
-}
-
-// ────────────────────── Counts byte exactitude ──
-
-#[test]
-fn u8_count_header() {
-    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(vec![1; 10]);
-    let buf = encode_to_bytes(cp);
-    assert_eq!(buf[0], 10);
-    assert_eq!(buf.len(), 1 + 10);
-}
-
-#[test]
-fn u16_count_header() {
-    let cp = CountPrefix::<u8, u16, Vec<u8>>::new(vec![1; 300]);
-    let buf = encode_to_bytes(cp);
-    assert_eq!(buf[0], 0x01);
-    assert_eq!(buf[1], 0x2C);
-    assert_eq!(buf.len(), 2 + 300);
-}
-
-#[test]
-fn u32_count_header() {
-    let data: Vec<u8> = vec![0xAA; 300];
-    let len = data.len();
-    let cp = CountPrefix::<u8, u32, Vec<u8>>::new(data);
-    let buf = encode_to_bytes(cp);
-    assert_eq!(buf.len(), 4 + len);
-    assert_eq!(&buf[0..4], &[0x00, 0x00, 0x01, 0x2C]);
-}
diff --git a/tests/encode_decode.rs b/tests/encode_decode.rs
deleted file mode 100644
index 92a1e71..0000000
--- a/tests/encode_decode.rs
+++ /dev/null
@@ -1,589 +0,0 @@
-use std::sync::Arc;
-use zr_protocol::codec::{decode::Decode, encode::Encode};
-
-fn roundtrip<T: Encode + Decode + PartialEq + Clone + std::fmt::Debug>(value: T) {
-    let mut buf = Vec::new();
-    let written = value.clone().encode(&mut buf).expect("encode failed");
-    let decoded = T::decode(&mut &buf[..]).expect("decode failed");
-    assert_eq!(written, buf.len(), "encode returned wrong byte count");
-    assert_eq!(decoded, value, "roundtrip value mismatch");
-}
-
-// ────────────────────── u8 ──────────────────────
-
-#[test]
-fn u8_zero() {
-    roundtrip(0u8);
-}
-
-#[test]
-fn u8_one() {
-    roundtrip(1u8);
-}
-
-#[test]
-fn u8_max() {
-    roundtrip(u8::MAX);
-}
-
-#[test]
-fn u8_arbitrary() {
-    roundtrip(42u8);
-}
-
-#[test]
-fn u8_bytes() {
-    let mut buf = Vec::new();
-    255u8.encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![255]);
-}
-
-// ────────────────────── u16 ─────────────────────
-
-#[test]
-fn u16_zero() {
-    roundtrip(0u16);
-}
-
-#[test]
-fn u16_one() {
-    roundtrip(1u16);
-}
-
-#[test]
-fn u16_max() {
-    roundtrip(u16::MAX);
-}
-
-#[test]
-fn u16_big_endian_bytes() {
-    let mut buf = Vec::new();
-    256u16.encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![0x01, 0x00]);
-}
-
-#[test]
-fn u16_one_big_endian_bytes() {
-    let mut buf = Vec::new();
-    1u16.encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![0x00, 0x01]);
-}
-
-#[test]
-fn u16_arbitrary() {
-    roundtrip(1337u16);
-}
-
-// ────────────────────── u32 ─────────────────────
-
-#[test]
-fn u32_zero() {
-    roundtrip(0u32);
-}
-
-#[test]
-fn u32_max() {
-    roundtrip(u32::MAX);
-}
-
-#[test]
-fn u32_big_endian_bytes() {
-    let mut buf = Vec::new();
-    0x01020304u32.encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![0x01, 0x02, 0x03, 0x04]);
-}
-
-#[test]
-fn u32_arbitrary() {
-    roundtrip(429496729u32);
-}
-
-// ────────────────────── u64 ─────────────────────
-
-#[test]
-fn u64_zero() {
-    roundtrip(0u64);
-}
-
-#[test]
-fn u64_max() {
-    roundtrip(u64::MAX);
-}
-
-#[test]
-fn u64_big_endian_bytes() {
-    let mut buf = Vec::new();
-    0x0102030405060708u64.encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
-}
-
-#[test]
-fn u64_arbitrary() {
-    roundtrip(999_999_999_999u64);
-}
-
-// ────────────────────── u128 ────────────────────
-
-#[test]
-fn u128_zero() {
-    roundtrip(0u128);
-}
-
-#[test]
-fn u128_max() {
-    roundtrip(u128::MAX);
-}
-
-#[test]
-fn u128_arbitrary() {
-    roundtrip(170141183460469231731687303715884105727u128);
-}
-
-// ────────────────────── usize ───────────────────
-
-#[test]
-fn usize_zero() {
-    roundtrip(0usize);
-}
-
-#[test]
-fn usize_max() {
-    roundtrip(usize::MAX);
-}
-
-#[test]
-fn usize_arbitrary() {
-    roundtrip(42usize);
-}
-
-// ────────────────────── i8 ──────────────────────
-
-#[test]
-fn i8_zero() {
-    roundtrip(0i8);
-}
-
-#[test]
-fn i8_positive() {
-    roundtrip(42i8);
-}
-
-#[test]
-fn i8_negative() {
-    roundtrip(-42i8);
-}
-
-#[test]
-fn i8_min() {
-    roundtrip(i8::MIN);
-}
-
-#[test]
-fn i8_max() {
-    roundtrip(i8::MAX);
-}
-
-#[test]
-fn i8_negative_bytes() {
-    let mut buf = Vec::new();
-    (-1i8).encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![0xFF]);
-}
-
-// ────────────────────── i16 ─────────────────────
-
-#[test]
-fn i16_zero() {
-    roundtrip(0i16);
-}
-
-#[test]
-fn i16_positive() {
-    roundtrip(1234i16);
-}
-
-#[test]
-fn i16_negative() {
-    roundtrip(-1234i16);
-}
-
-#[test]
-fn i16_min() {
-    roundtrip(i16::MIN);
-}
-
-#[test]
-fn i16_max() {
-    roundtrip(i16::MAX);
-}
-
-#[test]
-fn i16_big_endian_negative() {
-    let mut buf = Vec::new();
-    (-1i16).encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![0xFF, 0xFF]);
-}
-
-#[test]
-fn i16_negative_bytes() {
-    let mut buf = Vec::new();
-    (-256i16).encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![0xFF, 0x00]);
-}
-
-// ────────────────────── i32 ─────────────────────
-
-#[test]
-fn i32_zero() {
-    roundtrip(0i32);
-}
-
-#[test]
-fn i32_positive() {
-    roundtrip(100000i32);
-}
-
-#[test]
-fn i32_negative() {
-    roundtrip(-100000i32);
-}
-
-#[test]
-fn i32_min() {
-    roundtrip(i32::MIN);
-}
-
-#[test]
-fn i32_max() {
-    roundtrip(i32::MAX);
-}
-
-// ────────────────────── i64 ─────────────────────
-
-#[test]
-fn i64_zero() {
-    roundtrip(0i64);
-}
-
-#[test]
-fn i64_positive() {
-    roundtrip(9_999_999_999i64);
-}
-
-#[test]
-fn i64_negative() {
-    roundtrip(-9_999_999_999i64);
-}
-
-#[test]
-fn i64_min() {
-    roundtrip(i64::MIN);
-}
-
-#[test]
-fn i64_max() {
-    roundtrip(i64::MAX);
-}
-
-// ────────────────────── i128 ────────────────────
-
-#[test]
-fn i128_zero() {
-    roundtrip(0i128);
-}
-
-#[test]
-fn i128_min() {
-    roundtrip(i128::MIN);
-}
-
-#[test]
-fn i128_max() {
-    roundtrip(i128::MAX);
-}
-
-#[test]
-fn i128_negative() {
-    roundtrip(-42i128);
-}
-
-// ────────────────────── isize ───────────────────
-
-#[test]
-fn isize_zero() {
-    roundtrip(0isize);
-}
-
-#[test]
-fn isize_positive() {
-    roundtrip(42isize);
-}
-
-#[test]
-fn isize_negative() {
-    roundtrip(-42isize);
-}
-
-// ────────────────────── f32 ─────────────────────
-
-#[test]
-fn f32_zero() {
-    roundtrip(0.0f32);
-}
-
-#[test]
-fn f32_positive() {
-    roundtrip(3.14f32);
-}
-
-#[test]
-fn f32_negative() {
-    roundtrip(-2.71f32);
-}
-
-#[test]
-fn f32_infinity() {
-    roundtrip(f32::INFINITY);
-}
-
-#[test]
-fn f32_neg_infinity() {
-    roundtrip(f32::NEG_INFINITY);
-}
-
-#[test]
-fn f32_nan() {
-    let mut buf = Vec::new();
-    f32::NAN.encode(&mut buf).unwrap();
-    let decoded = f32::decode(&mut &buf[..]).unwrap();
-    assert!(decoded.is_nan(), "NaN roundtrip failed");
-}
-
-#[test]
-fn f32_big_endian_bytes() {
-    let mut buf = Vec::new();
-    1.0f32.encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![0x3F, 0x80, 0x00, 0x00]);
-}
-
-// ────────────────────── f64 ─────────────────────
-
-#[test]
-fn f64_zero() {
-    roundtrip(0.0f64);
-}
-
-#[test]
-fn f64_positive() {
-    roundtrip(3.141592653589793f64);
-}
-
-#[test]
-fn f64_negative() {
-    roundtrip(-2.718281828459045f64);
-}
-
-#[test]
-fn f64_infinity() {
-    roundtrip(f64::INFINITY);
-}
-
-#[test]
-fn f64_neg_infinity() {
-    roundtrip(f64::NEG_INFINITY);
-}
-
-#[test]
-fn f64_nan() {
-    let mut buf = Vec::new();
-    f64::NAN.encode(&mut buf).unwrap();
-    let decoded = f64::decode(&mut &buf[..]).unwrap();
-    assert!(decoded.is_nan(), "NaN roundtrip failed");
-}
-
-#[test]
-fn f64_big_endian_bytes() {
-    let mut buf = Vec::new();
-    1.0f64.encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![0x3F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
-}
-
-// ────────────────────── bool ────────────────────
-
-#[test]
-fn bool_true() {
-    roundtrip(true);
-}
-
-#[test]
-fn bool_false() {
-    roundtrip(false);
-}
-
-#[test]
-fn bool_true_byte() {
-    let mut buf = Vec::new();
-    true.encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![1]);
-}
-
-#[test]
-fn bool_false_byte() {
-    let mut buf = Vec::new();
-    false.encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![0]);
-}
-
-#[test]
-fn bool_non_zero_is_true() {
-    let decoded = bool::decode(&mut &[0x42u8][..]).unwrap();
-    assert!(decoded, "any non-zero byte should decode as true");
-}
-
-// ────────────────────── [u8; S] ─────────────────
-
-#[test]
-fn array_1_byte() {
-    roundtrip([0xABu8; 1]);
-}
-
-#[test]
-fn array_4_bytes() {
-    roundtrip([0x01u8, 0x02, 0x03, 0x04]);
-}
-
-#[test]
-fn array_32_bytes() {
-    let data: [u8; 32] = std::array::from_fn(|i| i as u8);
-    roundtrip(data);
-}
-
-#[test]
-fn array_zeroes() {
-    roundtrip([0u8; 16]);
-}
-
-#[test]
-fn array_256_bytes() {
-    let data: [u8; 256] = std::array::from_fn(|i| (i % 256) as u8);
-    roundtrip(data);
-}
-
-// ────────────────────── Arc<[u8]> ───────────────
-
-#[test]
-fn arc_slice_simple() {
-    roundtrip(Arc::<[u8]>::from(vec![1, 2, 3]));
-}
-
-#[test]
-fn arc_slice_empty() {
-    roundtrip(Arc::<[u8]>::from(Vec::<u8>::new()));
-}
-
-#[test]
-fn arc_slice_large() {
-    let data: Vec<u8> = (0..1024).map(|i| (i % 256) as u8).collect();
-    roundtrip(Arc::<[u8]>::from(data));
-}
-
-// ────────────────────── Retour de bytes written ─
-
-#[test]
-fn encode_returns_correct_byte_count_u32() {
-    let mut buf = Vec::new();
-    let written = 42u32.encode(&mut buf).unwrap();
-    assert_eq!(written, 4);
-}
-
-#[test]
-fn encode_returns_correct_byte_count_bool() {
-    let mut buf = Vec::new();
-    let written = true.encode(&mut buf).unwrap();
-    assert_eq!(written, 1);
-}
-
-#[test]
-fn encode_returns_correct_byte_count_u128() {
-    let mut buf = Vec::new();
-    let written = 123u128.encode(&mut buf).unwrap();
-    assert_eq!(written, 16);
-}
-
-#[test]
-fn encode_returns_correct_byte_count_array() {
-    let mut buf = Vec::new();
-    let written = [1u8, 2, 3, 4, 5].encode(&mut buf).unwrap();
-    assert_eq!(written, 5);
-}
-
-// ────────────────────── Buffer trop court ───────
-
-#[test]
-fn decode_u16_from_empty_buffer_fails() {
-    let result = u16::decode(&mut &[][..]);
-    assert!(result.is_err(), "decoding u16 from empty buffer should fail");
-}
-
-#[test]
-fn decode_u32_from_too_short_buffer_fails() {
-    let result = u32::decode(&mut &[0x01, 0x02][..]);
-    assert!(result.is_err(), "decoding u32 from 2-byte buffer should fail");
-}
-
-#[test]
-fn decode_bool_from_empty_buffer_fails() {
-    let result = bool::decode(&mut &[][..]);
-    assert!(result.is_err(), "decoding bool from empty buffer should fail");
-}
-
-#[test]
-fn decode_array_from_short_buffer_fails() {
-    let result = <[u8; 4]>::decode(&mut &[0x01, 0x02][..]);
-    assert!(
-        result.is_err(),
-        "decoding [u8;4] from 2-byte buffer should fail"
-    );
-}
-
-// ────────────────────── Sérialisation exacte ────
-
-#[test]
-fn u16_258_bytes() {
-    let mut buf = Vec::new();
-    258u16.encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![0x01, 0x02]);
-}
-
-#[test]
-fn u32_16909060_bytes() {
-    let mut buf = Vec::new();
-    0x01020304u32.encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![1, 2, 3, 4]);
-}
-
-#[test]
-fn i16_minus_256_bytes() {
-    let mut buf = Vec::new();
-    (-256i16).encode(&mut buf).unwrap();
-    assert_eq!(buf, vec![0xFF, 0x00]);
-}
-
-// ────────────────────── Sérialisation multiple ──
-
-#[test]
-fn multiple_values_sequential_encode() {
-    let mut buf = Vec::new();
-    1u8.encode(&mut buf).unwrap();
-    2u16.encode(&mut buf).unwrap();
-    3u32.encode(&mut buf).unwrap();
-    true.encode(&mut buf).unwrap();
-
-    assert_eq!(buf.len(), 1 + 2 + 4 + 1);
-
-    let mut reader = &buf[..];
-    assert_eq!(u8::decode(&mut reader).unwrap(), 1);
-    assert_eq!(u16::decode(&mut reader).unwrap(), 2);
-    assert_eq!(u32::decode(&mut reader).unwrap(), 3);
-    assert!(bool::decode(&mut reader).unwrap());
-}
diff --git a/tests/len_prefix.rs b/tests/len_prefix.rs
deleted file mode 100644
index d9597eb..0000000
--- a/tests/len_prefix.rs
+++ /dev/null
@@ -1,310 +0,0 @@
-use zr_protocol::{
-    codec::{decode::Decode, encode::Encode},
-    types::prefix::length::LenPrefixed,
-};
-
-fn encode_to_bytes<T: Encode>(value: T) -> Vec<u8> {
-    let mut buf = Vec::new();
-    value.encode(&mut buf).unwrap();
-    buf
-}
-
-// ────────────────────── Données simples ─────────
-
-#[test]
-fn simple_u32_with_u8_length() {
-    let lp = LenPrefixed::<u8, u32>::new(42u32);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf, vec![0x04, 0x00, 0x00, 0x00, 0x2A]);
-}
-
-#[test]
-fn simple_u16_with_u16_length() {
-    let lp = LenPrefixed::<u16, u16>::new(256u16);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf, vec![0x00, 0x02, 0x01, 0x00]);
-}
-
-#[test]
-fn simple_u8_with_u8_length() {
-    let lp = LenPrefixed::<u8, u8>::new(0xABu8);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf, vec![0x01, 0xAB]);
-}
-
-#[test]
-fn simple_u64_with_u32_length() {
-    let lp = LenPrefixed::<u32, u64>::new(0x0102030405060708u64);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(
-        buf,
-        vec![0x00, 0x00, 0x00, 0x08, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]
-    );
-}
-
-// ────────────────────── Booléen ─────────────────
-
-#[test]
-fn bool_true_with_u8_length() {
-    let lp = LenPrefixed::<u8, bool>::new(true);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf, vec![0x01, 0x01]);
-}
-
-#[test]
-fn bool_false_with_u8_length() {
-    let lp = LenPrefixed::<u8, bool>::new(false);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf, vec![0x01, 0x00]);
-}
-
-// ────────────────────── Tableaux ────────────────
-
-#[test]
-fn array_4_bytes_with_u8_length() {
-    let lp = LenPrefixed::<u8, [u8; 4]>::new([0x01, 0x02, 0x03, 0x04]);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf, vec![0x04, 0x01, 0x02, 0x03, 0x04]);
-}
-
-#[test]
-fn array_16_bytes_with_u16_length() {
-    let data: [u8; 16] = std::array::from_fn(|i| i as u8);
-    let lp = LenPrefixed::<u16, [u8; 16]>::new(data);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf[0..2], [0x00, 0x10]);
-    assert_eq!(&buf[2..], &data[..]);
-}
-
-#[test]
-fn array_256_bytes_with_u16_length() {
-    let data: [u8; 256] = std::array::from_fn(|i| (i % 256) as u8);
-    let lp = LenPrefixed::<u16, [u8; 256]>::new(data);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf[0..2], [0x01, 0x00]);
-    assert_eq!(&buf[2..], &data[..]);
-}
-
-// ────────────────────── Roundtrip ───────────────
-
-#[test]
-fn roundtrip_u32_u8() {
-    let lp = LenPrefixed::<u8, u32>::new(42u32);
-    let buf = encode_to_bytes(lp);
-
-    let mut reader = &buf[..];
-    let decoded = LenPrefixed::<u8, u32>::decode(&mut reader).unwrap();
-    assert_eq!(*decoded.as_ref(), 42u32);
-}
-
-#[test]
-fn roundtrip_u64_u16() {
-    let lp = LenPrefixed::<u16, u64>::new(u64::MAX);
-    let buf = encode_to_bytes(lp);
-
-    let mut reader = &buf[..];
-    let decoded = LenPrefixed::<u16, u64>::decode(&mut reader).unwrap();
-    assert_eq!(*decoded.as_ref(), u64::MAX);
-}
-
-#[test]
-fn roundtrip_bool_u8() {
-    let lp = LenPrefixed::<u8, bool>::new(true);
-    let buf = encode_to_bytes(lp);
-
-    let mut reader = &buf[..];
-    let decoded = LenPrefixed::<u8, bool>::decode(&mut reader).unwrap();
-    assert!(*decoded.as_ref());
-}
-
-#[test]
-fn roundtrip_array_u8() {
-    let data = [0xDE, 0xAD, 0xBE, 0xEF];
-    let lp = LenPrefixed::<u8, [u8; 4]>::new(data);
-    let buf = encode_to_bytes(lp);
-
-    let mut reader = &buf[..];
-    let decoded = LenPrefixed::<u8, [u8; 4]>::decode(&mut reader).unwrap();
-    assert_eq!(*decoded.as_ref(), data);
-}
-
-#[test]
-fn roundtrip_negative_i32() {
-    let lp = LenPrefixed::<u8, i32>::new(-12345);
-    let buf = encode_to_bytes(lp);
-
-    let mut reader = &buf[..];
-    let decoded = LenPrefixed::<u8, i32>::decode(&mut reader).unwrap();
-    assert_eq!(*decoded.as_ref(), -12345);
-}
-
-#[test]
-fn roundtrip_f64() {
-    let lp = LenPrefixed::<u8, f64>::new(3.141592653589793);
-    let buf = encode_to_bytes(lp);
-
-    let mut reader = &buf[..];
-    let decoded = LenPrefixed::<u8, f64>::decode(&mut reader).unwrap();
-    assert_eq!(*decoded.as_ref(), 3.141592653589793);
-}
-
-#[test]
-fn roundtrip_u128() {
-    let lp = LenPrefixed::<u16, u128>::new(u128::MAX);
-    let buf = encode_to_bytes(lp);
-
-    let mut reader = &buf[..];
-    let decoded = LenPrefixed::<u16, u128>::decode(&mut reader).unwrap();
-    assert_eq!(*decoded.as_ref(), u128::MAX);
-}
-
-// ────────────────────── Imbrication ─────────────
-
-#[test]
-fn nested_len_prefixed_u16_u8_u32() {
-    let inner = LenPrefixed::<u8, u32>::new(42u32);
-    let outer = LenPrefixed::<u16, LenPrefixed<u8, u32>>::new(inner);
-    let buf = encode_to_bytes(outer);
-
-    // outer length = 1 (u8 prefix of inner) + 4 (u32) = 5
-    assert_eq!(buf[0..2], [0x00, 0x05]);
-    // inner length = 4
-    assert_eq!(buf[2], 0x04);
-    // inner data = 42
-    assert_eq!(&buf[3..7], &[0x00, 0x00, 0x00, 0x2A]);
-}
-
-#[test]
-fn roundtrip_nested() {
-    let inner = LenPrefixed::<u8, u16>::new(1337u16);
-    let outer = LenPrefixed::<u16, LenPrefixed<u8, u16>>::new(inner);
-    let buf = encode_to_bytes(outer);
-
-    let mut reader = &buf[..];
-    let decoded_outer = LenPrefixed::<u16, LenPrefixed<u8, u16>>::decode(&mut reader).unwrap();
-    let decoded_inner = decoded_outer.as_ref();
-    assert_eq!(decoded_inner.as_ref(), &1337u16);
-}
-
-#[test]
-fn triple_nested() {
-    let l1 = LenPrefixed::<u8, u8>::new(0xAA);
-    let l2 = LenPrefixed::<u8, LenPrefixed<u8, u8>>::new(l1);
-    let l3 = LenPrefixed::<u16, LenPrefixed<u8, LenPrefixed<u8, u8>>>::new(l2);
-    let buf = encode_to_bytes(l3);
-
-    let mut reader = &buf[..];
-    let d3 = LenPrefixed::<u16, LenPrefixed<u8, LenPrefixed<u8, u8>>>::decode(&mut reader).unwrap();
-    let d2 = d3.as_ref();
-    let d1 = d2.as_ref();
-    assert_eq!(*d1.as_ref(), 0xAAu8);
-}
-
-// ────────────────────── Erreurs de décodage ─────
-
-#[test]
-fn decode_empty_buffer_fails() {
-    let result = LenPrefixed::<u8, u32>::decode(&mut &[][..]);
-    assert!(result.is_err());
-}
-
-#[test]
-fn decode_truncated_length_fails() {
-    let result = LenPrefixed::<u16, u32>::decode(&mut &[0x01][..]);
-    assert!(result.is_err());
-}
-
-#[test]
-fn decode_length_exceeds_data_fails() {
-    let mut buf = Vec::new();
-    100u8.encode(&mut buf).unwrap();
-    buf.extend_from_slice(&[0x01, 0x02]);
-    let result = LenPrefixed::<u8, u32>::decode(&mut &buf[..]);
-    assert!(result.is_err());
-}
-
-#[test]
-fn decode_zero_length_with_zero_sized_type() {
-    let lp = LenPrefixed::<u8, [u8; 0]>::new([]);
-    let buf = encode_to_bytes(lp);
-    let mut reader = &buf[..];
-    let decoded = LenPrefixed::<u8, [u8; 0]>::decode(&mut reader).unwrap();
-    assert_eq!(*decoded.as_ref(), []);
-}
-
-// ────────────────────── AsRef / AsMut ───────────
-
-#[test]
-fn as_ref_returns_inner() {
-    let lp = LenPrefixed::<u8, u32>::new(99u32);
-    assert_eq!(*lp.as_ref(), 99u32);
-}
-
-#[test]
-fn as_mut_allows_mutation() {
-    let mut lp = LenPrefixed::<u8, u32>::new(1u32);
-    *lp.as_mut() = 42;
-    assert_eq!(*lp.as_ref(), 42);
-}
-
-// ────────────────────── Taille du buffer ────────
-
-#[test]
-fn u8_length_header_size() {
-    let lp = LenPrefixed::<u8, u8>::new(0);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf.len(), 2); // 1 byte length + 1 byte data
-}
-
-#[test]
-fn u16_length_header_size() {
-    let lp = LenPrefixed::<u16, u8>::new(0);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf.len(), 3); // 2 byte length + 1 byte data
-}
-
-#[test]
-fn u32_length_header_size() {
-    let lp = LenPrefixed::<u32, u8>::new(0);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf.len(), 5); // 4 byte length + 1 byte data
-}
-
-#[test]
-fn u64_length_header_size() {
-    let lp = LenPrefixed::<u64, u8>::new(0);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf.len(), 9); // 8 byte length + 1 byte data
-}
-
-#[test]
-fn large_data_length_correct() {
-    let data: [u8; 1000] = std::array::from_fn(|i| (i % 256) as u8);
-    let lp = LenPrefixed::<u16, [u8; 1000]>::new(data);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf.len(), 2 + 1000);
-    assert_eq!(&buf[0..2], &[0x03, 0xE8]); // 1000 in u16 big-endian
-}
-
-// ────────────────────── Sérialisation exacte ────
-
-#[test]
-fn exact_bytes_u8_prefix() {
-    let lp = LenPrefixed::<u8, u16>::new(256u16);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf, vec![0x02, 0x01, 0x00]);
-}
-
-#[test]
-fn exact_bytes_negative_i16() {
-    let lp = LenPrefixed::<u8, i16>::new(-1);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf, vec![0x02, 0xFF, 0xFF]);
-}
-
-#[test]
-fn exact_bytes_zero_u32() {
-    let lp = LenPrefixed::<u8, u32>::new(0u32);
-    let buf = encode_to_bytes(lp);
-    assert_eq!(buf, vec![0x04, 0x00, 0x00, 0x00, 0x00]);
-}
diff --git a/tests/tmp/todo.md b/tests/tmp/todo.md
deleted file mode 100644
index a0c6a83..0000000
--- a/tests/tmp/todo.md
+++ /dev/null
@@ -1,356 +0,0 @@
-# zr_protocol - Todo V1
-
-> Crate Rust de communication réseau : protocole custom, sérialisation binaire, proc-macro pour définir des packets via un format `.packet`.
-
----
-
-## Phase 0 — Workspace & Scaffold
-
-- [ ] **0.1** Créer le workspace virtuel `Cargo.toml` à la racine (members: `zr-protocol`, `zr-protocol-macros`)
-- [ ] **0.2** Créer le crate `zr-protocol/` (library, edition 2024)
-  - [ ] `Cargo.toml` avec dépendances : `bytes = "1"`, `thiserror = "2"`, features optionnelles (`tokio`, `serde`, `derive`)
-  - [ ] `src/lib.rs` avec modules déclarés : `encode`, `decode`, `packet`, `codec`, `framing`, `builder`, `error`, `impls`
-- [ ] **0.3** Créer le crate `zr-protocol-macros/` (proc-macro = true, edition 2024)
-  - [ ] `Cargo.toml` avec dépendances : `syn = { version = "2", features = ["full"] }`, `quote = "1"`, `proc-macro2 = "1"`
-  - [ ] `src/lib.rs` minimal (entry point vide)
-- [ ] **0.4** Supprimer les anciens fichiers `src/bin/client.rs` et `src/bin/server.rs` ( remplacer par des exemples dans `examples/` )
-- [ ] **0.5** Vérifier que `cargo check --workspace` compile sans erreur
-- [ ] **0.6** Créer la structure de dossiers dans les deux crates :
-  - `zr-protocol/src/encode.rs`, `decode.rs`, `packet.rs`, `codec.rs`, `framing.rs`, `builder.rs`, `error.rs`
-  - `zr-protocol/src/impls/mod.rs`, `primitives.rs`, `arrays.rs`, `option.rs`
-  - `zr-protocol-macros/src/parser/ast.rs`, `lexer.rs`, `grammar.rs`, `mod.rs`
-  - `zr-protocol-macros/src/codegen/struct_gen.rs`, `encode_gen.rs`, `decode_gen.rs`, `registry_gen.rs`, `mod.rs`
-  - `examples/login/packets/`, `examples/login/server.rs`, `examples/login/client.rs`
-  - `tests/` (racine workspace)
-
----
-
-## Phase 1 — Traits Core : `Encode` & `Decode`
-
-> Les traits fondamentaux de sérialisation/déserialization binaire.
-
-- [ ] **1.1** Définir `src/error.rs` — type d'erreur `ZrError`
-  ```rust
-  use thiserror::Error;
-  #[derive(Debug, Error)]
-  pub enum ZrError {
-      #[error("io error: {0}")]
-      Io(#[from] std::io::Error),
-      #[error("invalid packet id: 0x{0:02X}")]
-      InvalidPacketId(u32),
-      #[error("buffer underflow: expected {expected} bytes, got {got}")]
-      Underflow { expected: usize, got: usize },
-      #[error("packet too large: {0} bytes (max {1})")]
-      PacketTooLarge(usize, usize),
-      #[error("unknown field type: {0}")]
-      UnknownType(String),
-      #[error("decode error: {0}")]
-      Decode(String),
-  }
-  ```
-- [ ] **1.2** Définir `src/encode.rs` — trait `Encode`
-  ```rust
-  pub trait Encode {
-      fn encode(&self, buf: &mut BytesMut) -> io::Result<()>;
-      fn encoded_size(&self) -> usize; // optionnel, pour pré-réserver
-  }
-  ```
-- [ ] **1.3** Définir `src/decode.rs` — trait `Decode`
-  ```rust
-  pub trait Decode: Sized {
-      fn decode(buf: &mut BytesMut) -> io::Result<Self>;
-  }
-  ```
-- [ ] **1.4** Impl `Encode` pour les types primitifs dans `src/impls/primitives.rs`
-  - `u8`, `u16`, `u32`, `u64`, `u128`
-  - `i8`, `i16`, `i32`, `i64`, `i128`
-  - `bool` (1 octet : 0x00 = false, 0x01 = true)
-  - `f32`, `f64` (via `to_be_bytes()` / `to_le_bytes()`)
-  - Tous en big-endian par défaut (network byte order)
-- [ ] **1.5** Impl `Encode` pour `String` et `Vec<u8>`
-  - Format : `u32` (longueur en octets) + octets bruts
-- [ ] **1.6** Impl `Encode` pour `[u8; N]` dans `src/impls/arrays.rs` (écriture directe, pas de longueur)
-- [ ] **1.7** Impl `Encode` pour `Option<T: Encode>` dans `src/impls/option.rs`
-  - Format : `u8` tag (0x00 = None, 0x01 = Some) + données si Some
-- [ ] **1.8** Impl `Decode` pour tous les mêmes types (mirror de 1.4 à 1.7)
-  - Avec gestion propre des erreurs (underflow → `ZrError::Underflow`)
-- [ ] **1.9** Impl `Encode`/`Decode` pour `Vec<T: Encode/Decode>`
-  - Format : `u32` nombre d'éléments + sérialisation de chaque élément
-- [ ] **1.10** Tests unitaires pour chaque type implémenté
-  - Roundtrip : encode → decode → assert_eq
-  - Cas limites : chaîne vide, vec vide, None, MAX values
-
----
-
-## Phase 2 — Trait `PacketMeta` & Types Runtime
-
-> Métadonnées des packets et typage dynamique.
-
-- [ ] **2.1** Définir `src/packet.rs` — trait `PacketMeta`
-  ```rust
-  pub trait PacketMeta {
-      const ID: u32;
-      const NAME: &'static str;
-      const SIZE_HINT: Option<usize>;
-  }
-  ```
-- [ ] **2.2** Définir un enum `PacketId` (ou type alias `u32`) pour les IDs réservés
-  - Réservé `0x00` = Reserved, `0xFF` = KeepAlive/Ping
-- [ ] **2.3** Définir `pub struct ZrPacket` (wrapper type-érasé pour le codec)
-  ```rust
-  pub struct ZrPacket {
-      pub id: u32,
-      pub payload: BytesMut,
-  }
-  ```
-- [ ] **2.4** Définir `pub trait IntoZrPacket: PacketMeta + Encode` pour convertir un typed packet → `ZrPacket`
-- [ ] **2.5** Tests pour `PacketMeta` et `ZrPacket`
-
----
-
-## Phase 3 — Format `.packet` : Lexer & Parser
-
-> Parsing du format texte de définition de protocole.
-
-- [ ] **3.1** Définir l'AST dans `zr-protocol-macros/src/parser/ast.rs`
-  ```rust
-  pub struct ProtocolFile {
-      pub packets: Vec<PacketDef>,
-  }
-  pub struct PacketDef {
-      pub attributes: Vec<Attribute>,
-      pub name: Ident,
-      pub id: u32,
-      pub fields: Vec<FieldDef>,
-  }
-  pub struct FieldDef {
-      pub attributes: Vec<Attribute>,
-      pub name: Ident,
-      pub ty: TypeRef,
-  }
-  pub enum TypeRef {
-      Primitive(String),          // u32, String, bool, etc.
-      Option(Box<TypeRef>),       // Option<T>
-      Vec(Box<TypeRef>),          // Vec<T>
-      Array(String, usize),       // [u8; 64]
-      Custom(String),             // un autre type packet
-  }
-  pub struct Attribute {
-      pub name: String,
-      pub value: Option<String>,
-  }
-  ```
-- [ ] **3.2** Implémenter le lexer dans `zr-protocol-macros/src/parser/lexer.rs`
-  - Tokens : `Packet`, `Ident`, `Number` (hex 0x.. et décimal), `Colon`, `BraceOpen`, `BraceClose`, `BracketOpen`, `BracketClose`, `Eq`, `String`, `Comma`, `EndAttribute`, `Hash`
-  - Whitespace et comments (`//`) ignorés
-- [ ] **3.3** Implémenter le parser dans `zr-protocol-macros/src/parser/grammar.rs`
-  - Parse un `ProtocolFile` à partir de tokens
-  - Validation : nom unique, ID unique, types connus
-  - Erreurs avec span (ligne/colonne) pour de bons messages d'erreur
-- [ ] **3.4** Tests du parser :
-  - [ ] Format valide basique
-  - [ ] Attributs optionnels (`#[endian = "big"]`)
-  - [ ] Types `Option<T>`, `Vec<T>`, `[u8; N]`
-  - [ ] Erreur : type inconnu
-  - [ ] Erreur : syntaxe invalide
-  - [ ] Erreur : ID manquant
-  - [ ] Fichier vide (pas de packet)
-
----
-
-## Phase 4 — Proc-macro `packet!`
-
-> Génération de code Rust à partir du format `.packet`.
-
-- [ ] **4.1** Implémenter l'entry point `packet!` dans `zr-protocol-macros/src/lib.rs`
-  - Accepte `include!("path/to/file.packet")` OU du code inline
-  - Lit le fichier via `CARGO_MANIFEST_DIR` + chemin relatif
-- [ ] **4.2** Codegen struct dans `zr-protocol-macros/src/codegen/struct_gen.rs`
-  - Génère `#[derive(Debug, Clone)] pub struct NomPacket { pub field: Type, ... }`
-  - Gère `Option<T>` → `Option<T>`, `Vec<T>` → `Vec<T>`, `[u8; N]` → `[u8; N]`
-- [ ] **4.3** Codegen `impl PacketMeta` dans `zr-protocol-macros/src/codegen/registry_gen.rs`
-  - `const ID: u32 = ...; const NAME: &'static str = "..."; const SIZE_HINT: Option<usize> = None;`
-- [ ] **4.4** Codegen `impl Encode` dans `zr-protocol-macros/src/codegen/encode_gen.rs`
-  - Pour chaque champ : `Encode::encode(&self.champ, buf)?;`
-- [ ] **4.5** Codegen `impl Decode` dans `zr-protocol-macros/src/codegen/decode_gen.rs`
-  - Pour chaque champ : `champ: Decode::decode(buf)?`
-- [ ] **4.6** Codegen registry globale (un seul `match` ID → nom) dans `registry_gen.rs`
-  - Fonction `pub fn packet_name_by_id(id: u32) -> Option<&'static str>`
-- [ ] **4.7** Codegen `impl IntoZrPacket` pour chaque packet
-  - Sérialise → `ZrPacket { id, payload }`
-- [ ] **4.8** Gestion des attributs dans le codegen
-  - `#[endian = "big"]` → big-endian (défaut), `#[endian = "little"]` → little-endian
-  - `#[skip_if_none]` → ne sérialise pas le champ si `None` (sans le tag)
-- [ ] **4.9** Tests d'intégration :
-  - [ ] Un fichier `.packet` simple → compiles, encode/decode roundtrip
-  - [ ] Fichier avec `Option<T>` et `Vec<T>`
-  - [ ] Compilation échoue sur type inconnu (trybuild)
-  - [ ] Compilation échoue sur syntaxe invalide (trybuild)
-- [ ] **4.10** Macro `packet!` inline (pour les petits définitions sans fichier)
-  ```rust
-  packet! {
-      packet Ping 0xFF {
-          sequence: u32,
-      }
-  }
-  ```
-
----
-
-## Phase 5 — Builder Pattern (secondaire)
-
-> API alternative pour construire des packets sans struct literals.
-
-- [ ] **5.1** Définir le trait `PacketBuilder` dans `src/builder.rs`
-  ```rust
-  pub trait PacketBuilder: Sized {
-      type Packet: Encode + PacketMeta;
-      fn new() -> Self;
-      fn field<T: IntoFieldValue>(mut self, name: &str, value: T) -> Self;
-      fn build(self) -> io::Result<Self::Packet>;
-  }
-  ```
-- [ ] **5.2** Codegen du builder dans `zr-protocol-macros/src/codegen/builder_gen.rs`
-  - Génère une struct `NomPacketBuilder { username: Option<String>, ... }` avec chaque champ en `Option`
-  - `field()` matche sur le nom (string) et set la valeur
-  - `build()` vérifie que tous les champs sont présents, sinon erreur
-- [ ] **5.3** Opt-out via attribute : `#[packet(no_builder)]` désactive la génération du builder
-- [ ] **5.4** Tests :
-  - [ ] Builder crée un packet valide
-  - [ ] Builder erreur si champ manquant
-  - [ ] `#[packet(no_builder)]` ne génère pas le builder
-
----
-
-## Phase 6 — Feature Flags & Extensibilité
-
-> Support optionnel de crates externes.
-
-- [ ] **6.1** Feature `tokio` : active les dépendances `tokio` + `tokio-util`
-  - Active le module `codec.rs` et `framing.rs`
-- [ ] **6.2** Feature `serde` : active `serde` + `bincode`
-  - Génère `#[derive(serde::Serialize, serde::Deserialize)]` sur les structs via le proc-macro
-  - Attribut `#[packet(serde)]` pour forcer ou `#[packet(no_serde)]` pour désactiver par packet
-- [ ] **6.3** Feature `derive` : active `zr-protocol-macros`
-  - Les macros `packet!`, `include_packets!` ne sont disponibles que avec cette feature
-- [ ] **6.4** Feature `std` (défaut) : support `String`, `Vec`, etc.
-  - Feature `no_std` future (pas v1) : uniquement `[u8; N]`, `u8`, etc.
-- [ ] **6.5** Documentation des features dans le `Cargo.toml` et `lib.rs`
-
----
-
-## Phase 7 — Codec & Framing (tokio-util)
-
-> Intégration avec tokio pour la communication async.
-
-- [ ] **7.1** Implémenter `src/framing.rs` — length-prefix framing
-  - Header : `u32` big-endian = longueur du payload
-  - Configurable : taille du header (2 ou 4 octets), endianness
-  - `max_packet_size` avec défaut (ex: 16 Mo)
-- [ ] **7.2** Implémenter `src/codec.rs` — `ZrCodec`
-  - `impl Encoder<Box<dyn Encode>> for ZrCodec` — écrit header + payload
-  - `impl Decoder for ZrCodec` — lit header, vérifie taille, lit payload, retourne `ZrPacket`
-  - Gestion propre de `BytesMut` (reserve, split_to, advance)
-- [ ] **7.3** Type `FramedPacket` pour le dispatch dynamique
-  - Le codec lit l'ID depuis le payload, lookup dans la registry
-  - Retourne un `ZrPacket` (type-érasé) que l'utilisateur cast avec un match sur l'ID
-- [ ] **7.4** Helper `fn framed_read(stream) -> impl Stream<Item = ZrPacket>` (optionnel, wrapper)
-- [ ] **7.5** Tests :
-  - [ ] Roundtrip TCP : encode → send → receive → decode → assert_eq
-  - [ ] Rejet des packets trop gros
-  - [ ] Gestion des reads partiels (TCP peut diviser les données)
-
----
-
-## Phase 8 — Client & Server Helpers
-
-> Utilitaires pour simplifier l'usage réseau.
-
-- [ ] **8.1** Struct `ZrConnection` wrapper autour de `Framed<TcpStream, ZrCodec>`
-  ```rust
-  pub struct ZrConnection {
-      framed: Framed<TcpStream, ZrCodec>,
-  }
-  impl ZrConnection {
-      pub async fn connect(addr: &str) -> io::Result<Self>;
-      pub async fn send_packet<P: Encode + PacketMeta>(&mut self, packet: &P) -> io::Result<()>;
-      pub async fn next_packet(&mut self) -> io::Result<Option<ZrPacket>>;
-  }
-  ```
-- [ ] **8.2** Struct `ZrListener` wrapper autour de `TcpListener`
-  ```rust
-  pub struct ZrListener { listener: TcpListener }
-  impl ZrListener {
-      pub async fn bind(addr: &str) -> io::Result<Self>;
-      pub async fn accept(&self) -> io::Result<(ZrConnection, SocketAddr)>;
-  }
-  ```
-- [ ] **8.3** Macro `#[tokio::main]` compatible — les helpers utilisent tokio derrière
-- [ ] **8.4** Tests d'intégration : client/server qui s'échangent des packets
-
----
-
-## Phase 9 — Exemples
-
-> Démonstrations complètes d'utilisation.
-
-- [ ] **9.1** Exemple `examples/simple.rs` — packet inline, encode/decode sans réseau
-- [ ] **9.2** Exemple `examples/login/` — client/server complet
-  - Fichiers `.packet` de définition
-  - Server qui écoute, reçoit `LoginRequest`, répond `LoginResponse`
-  - Client qui se connecte, envoie `LoginRequest`, lit `LoginResponse`
-- [ ] **9.3** Exemple avec `Option<T>` et `Vec<T>` pour montrer les types composés
-- [ ] **9.4** README avec badges, description, et example usage
-
----
-
-## Phase 10 — Tests & Qualité
-
-> Fiabilité et robustesse.
-
-- [ ] **10.1** Tests unitaires : chaque type primitif encode/decode roundtrip
-- [ ] **10.2** Tests du parser lexer/grammar (bonne et mauvaise syntaxe)
-- [ ] **10.3** Tests trybuild : erreurs de compilation avec bons messages
-  - [ ] Type inconnu dans `.packet`
-  - [ ] Syntaxe invalide
-  - [ ] ID manquant
-  - [ ] Champ dupliqué
-- [ ] **10.4** Tests d'intégration TCP : client ↔ server roundtrip
-- [ ] **10.5** Benchmark (criterion) : throughput sérialisation vs bincode
-- [ ] **10.6** `cargo clippy --workspace` sans warning
-- [ ] **10.7** `cargo fmt --check` passe
-
----
-
-## Phase 11 — Documentation
-
-- [ ] **11.1** `README.md` avec description, quick start, features
-- [ ] **11.2** Doc comments (`///`) sur tous les traits publics
-- [ ] **11.3** Doc comments sur le format `.packet` (guide de syntaxe)
-- [ ] **11.4** Exemples dans les doc comments (doc-tests)
-- [ ] **11.5** CHANGELOG.md
-
----
-
-## Ordre d'exécution recommandé
-
-```
-Phase 0 → Phase 1 → Phase 2 → Phase 3 → Phase 4 → Phase 5
-                                              ↓
-                                          Phase 6 (features)
-                                              ↓
-                                          Phase 7 (codec)
-                                              ↓
-                                      Phase 8 → Phase 9 → Phase 10 → Phase 11
-```
-
-**Dépendances critiques :**
-- Phase 4 (proc-macro) dépend de Phase 1 (traits) et Phase 2 (AST)
-- Phase 7 (codec) dépend de Phase 1 (Encode/Decode) et Phase 4 (PacketMeta)
-- Phase 8 (helpers) dépend de Phase 7 (codec)
-- Phase 9-11 dépendent de tout le reste
-
-**Peut être fait en parallèle :**
-- Phase 5 (builder) peut démarrer après Phase 4
-- Phase 6 (features) peut démarrer après Phase 4
-- Les tests (Phase 10) peuvent être écrits au fur et à mesure de chaque phase