feat(log): add bounded diagnostic transport

libs/kaptan-log-derive/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "kaptan-log-derive"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[lib]
+proc-macro = true
+
+[lints]
+workspace = true
+
+[dependencies]
+proc-macro2 = "1"
+quote = "1"
+syn = { version = "2", features = ["full"] }
+
+[dev-dependencies]
+trybuild = "1"

libs/kaptan-log-derive/src/lib.rs

@@ -0,0 +1,94 @@
+//! Derive support for static Kaptan runtime-log messages.
+
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{Data, DeriveInput, Error, Fields, parse_macro_input, parse_quote};
+
+/// Implements [`kaptan_log::ErrorReport`], [`core::fmt::Display`], and
+/// [`core::error::Error`] for enums.
+///
+/// Each enum variant receives one static message in the form
+/// `module::Type::Variant`. The derive deliberately accepts no attributes:
+/// text logging has no user-provided numeric catalog allocation.
+#[proc_macro_derive(KaptanError)]
+pub fn derive_kaptan_error(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    match expand(input) {
+        Ok(tokens) => tokens.into(),
+        Err(error) => error.into_compile_error().into(),
+    }
+}
+
+fn expand(input: DeriveInput) -> Result<proc_macro2::TokenStream, Error> {
+    let DeriveInput {
+        ident,
+        generics,
+        data,
+        ..
+    } = input;
+    let Data::Enum(data) = data else {
+        let kind = match data {
+            Data::Struct(_) => "structs",
+            Data::Union(_) => "unions",
+            Data::Enum(_) => unreachable!("enum handled above"),
+        };
+        return Err(Error::new_spanned(
+            ident,
+            format!("KaptanError can only be derived for enums, not {kind}"),
+        ));
+    };
+
+    let arms = data.variants.iter().map(|variant| {
+        let variant_ident = &variant.ident;
+        let pattern = match &variant.fields {
+            Fields::Unit => quote!(Self::#variant_ident),
+            Fields::Unnamed(_) => quote!(Self::#variant_ident(..)),
+            Fields::Named(_) => quote!(Self::#variant_ident { .. }),
+        };
+        quote! {
+            #pattern => {
+                static MESSAGE: ::kaptan_log::StaticErrorMessage =
+                    ::kaptan_log::StaticErrorMessage::new(concat!(
+                        module_path!(),
+                        "::",
+                        stringify!(#ident),
+                        "::",
+                        stringify!(#variant_ident),
+                    ));
+                &MESSAGE
+            }
+        }
+    });
+    let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
+    let mut error_generics = generics.clone();
+    error_generics
+        .make_where_clause()
+        .predicates
+        .push(parse_quote!(#ident #type_generics: ::core::fmt::Debug));
+    let (error_impl_generics, error_type_generics, error_where_clause) =
+        error_generics.split_for_impl();
+
+    Ok(quote! {
+        impl #impl_generics ::kaptan_log::ErrorReport for #ident #type_generics #where_clause {
+            fn error_message(&self) -> &'static ::kaptan_log::StaticErrorMessage {
+                match self {
+                    #(#arms),*
+                }
+            }
+        }
+
+        impl #impl_generics ::core::fmt::Display for #ident #type_generics #where_clause {
+            fn fmt(
+                &self,
+                formatter: &mut ::core::fmt::Formatter<'_>,
+            ) -> ::core::fmt::Result {
+                formatter.write_str(
+                    <Self as ::kaptan_log::ErrorReport>::error_message(self).as_str(),
+                )
+            }
+        }
+
+        impl #error_impl_generics ::core::error::Error
+            for #ident #error_type_generics #error_where_clause {}
+    })
+}

libs/kaptan-log-derive/tests/ui.rs

@@ -0,0 +1,7 @@
+#[test]
+fn kaptan_error_expands_for_enum_shapes_only() {
+    let tests = trybuild::TestCases::new();
+    tests.pass("tests/ui/enum.rs");
+    tests.compile_fail("tests/ui/struct.rs");
+    tests.compile_fail("tests/ui/union.rs");
+}

libs/kaptan-log-derive/tests/ui/enum.rs

@@ -0,0 +1,47 @@
+extern crate self as kaptan_log;
+
+use kaptan_log_derive::KaptanError;
+
+pub struct StaticErrorMessage(&'static str);
+
+impl StaticErrorMessage {
+    pub const fn new(text: &'static str) -> Self {
+        Self(text)
+    }
+
+    pub const fn as_str(&self) -> &'static str {
+        self.0
+    }
+}
+
+pub trait ErrorReport {
+    fn error_message(&self) -> &'static StaticErrorMessage;
+}
+
+#[derive(Debug, KaptanError)]
+enum Generic<'a, T>
+where
+    T: Copy,
+{
+    Unit,
+    Tuple(T, u8),
+    Named { label: &'a str },
+}
+
+fn main() {
+    fn assert_error<T: core::error::Error>() {}
+    assert_error::<Generic<'_, u8>>();
+    assert_eq!(
+        Generic::<u8>::Unit.error_message().as_str(),
+        concat!(module_path!(), "::Generic::Unit"),
+    );
+    assert_eq!(
+        Generic::Tuple(1_u8, 2).error_message().as_str(),
+        concat!(module_path!(), "::Generic::Tuple"),
+    );
+    let named: Generic<'_, u8> = Generic::Named { label: "test" };
+    assert_eq!(
+        named.to_string(),
+        concat!(module_path!(), "::Generic::Named"),
+    );
+}

libs/kaptan-log-derive/tests/ui/struct.rs

@@ -0,0 +1,8 @@
+use kaptan_log_derive::KaptanError;
+
+#[derive(KaptanError)]
+struct NotAnError {
+    code: u8,
+}
+
+fn main() {}

libs/kaptan-log-derive/tests/ui/struct.stderr

@@ -0,0 +1,5 @@
+error: KaptanError can only be derived for enums, not structs
+ --> tests/ui/struct.rs:4:8
+  |
+4 | struct NotAnError {
+  |        ^^^^^^^^^^

libs/kaptan-log-derive/tests/ui/union.rs

@@ -0,0 +1,8 @@
+use kaptan_log_derive::KaptanError;
+
+#[derive(KaptanError)]
+union NotAnError {
+    code: u8,
+}
+
+fn main() {}

libs/kaptan-log-derive/tests/ui/union.stderr

@@ -0,0 +1,5 @@
+error: KaptanError can only be derived for enums, not unions
+ --> tests/ui/union.rs:4:7
+  |
+4 | union NotAnError {
+  |       ^^^^^^^^^^