feat: add ZodSchema impls for u8, u16, i8, i16

CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### ✨ Added
+
+#### Small Integer Type Support
+- **Added `ZodSchema` impls for `u8`, `u16`, `i8`, `i16`**: These small integer types were missing despite the README claiming "built-in support for all common Rust types". They map to `z.number()`, matching the existing impls for `i32`, `i64`, `u32`, `u64`, `f32`, `f64`. This unblocks the `#[derive(ZodSchema)]` macro on enums and structs that contain small-integer fields (e.g. byte-level protocols, packed bitfields, layer indices).
+
 ## [1.2.0] - 2025-12-05
 
 ### ✨ Added

zod_gen/src/lib.rs

@@ -261,6 +261,30 @@ impl ZodSchema for bool {
     }
 }
 
+impl ZodSchema for u8 {
+    fn zod_schema() -> String {
+        zod_number().to_string()
+    }
+}
+
+impl ZodSchema for u16 {
+    fn zod_schema() -> String {
+        zod_number().to_string()
+    }
+}
+
+impl ZodSchema for i8 {
+    fn zod_schema() -> String {
+        zod_number().to_string()
+    }
+}
+
+impl ZodSchema for i16 {
+    fn zod_schema() -> String {
+        zod_number().to_string()
+    }
+}
+
 impl<T: ZodSchema> ZodSchema for Option<T> {
     fn zod_schema() -> String {
         zod_nullable(&T::zod_schema())
@@ -297,6 +321,17 @@ mod tests {
         assert_eq!(zod_number(), "z.number()");
         assert_eq!(zod_boolean(), "z.boolean()");
         assert_eq!(zod_bigint(), "z.bigint()");
+
+        assert_eq!(i8::zod_schema(), "z.number()");
+        assert_eq!(i16::zod_schema(), "z.number()");
+        assert_eq!(i32::zod_schema(), "z.number()");
+        assert_eq!(i64::zod_schema(), "z.number()");
+        assert_eq!(u8::zod_schema(), "z.number()");
+        assert_eq!(u16::zod_schema(), "z.number()");
+        assert_eq!(u32::zod_schema(), "z.number()");
+        assert_eq!(u64::zod_schema(), "z.number()");
+        assert_eq!(f32::zod_schema(), "z.number()");
+        assert_eq!(f64::zod_schema(), "z.number()");
     }
 
     #[derive(Debug)]

zod_gen_derive/tests/derive_tests.rs

@@ -9,27 +9,65 @@ struct TestStruct {
     b: i32,
 }
 
+#[derive(ZodSchema)]
+#[allow(dead_code)]
+struct TestSmallIntegerStruct {
+    byte: u8,
+    layer: u16,
+    offset: i8,
+    temperature: i16,
+}
+
 #[derive(ZodSchema)]
 #[allow(dead_code)]
 enum TestEnum {
     Foo,
     Bar,
 }
 
+#[derive(ZodSchema)]
+#[allow(dead_code)]
+enum TestSmallIntegerEnum {
+    Byte(u8),
+    Temperature(i16),
+}
+
 #[test]
 fn test_struct_schema() {
     let schema = TestStruct::zod_schema();
     assert!(schema.contains("a: z.string()"));
     assert!(schema.contains("b: z.number()"));
 }
 
+#[test]
+fn test_small_integer_struct_schema() {
+    let schema = TestSmallIntegerStruct::zod_schema();
+    assert!(schema.contains("byte: z.number()"), "schema: {schema}");
+    assert!(schema.contains("layer: z.number()"), "schema: {schema}");
+    assert!(schema.contains("offset: z.number()"), "schema: {schema}");
+    assert!(
+        schema.contains("temperature: z.number()"),
+        "schema: {schema}"
+    );
+}
+
 #[test]
 fn test_enum_schema() {
     let schema = TestEnum::zod_schema();
     assert!(schema.contains("z.literal('Foo')"));
     assert!(schema.contains("z.literal('Bar')"));
 }
 
+#[test]
+fn test_small_integer_enum_schema() {
+    let schema = TestSmallIntegerEnum::zod_schema();
+    assert!(schema.contains("Byte: z.number()"), "schema: {schema}");
+    assert!(
+        schema.contains("Temperature: z.number()"),
+        "schema: {schema}"
+    );
+}
+
 #[derive(ZodSchema, Serialize)]
 #[allow(dead_code)]
 struct TestStructWithRename {