refactored derive/attribute macros

Cargo.lock

···
 version = "0.8.0"
 dependencies = [
  "jacquard-common 0.8.0",
+ "jacquard-lexicon 0.8.0",
  "proc-macro2",
  "quote",
  "serde",

crates/jacquard-api/src/app_rocksky/charts.rs

···
     PartialEq,
     Eq,
     jacquard_derive::IntoStatic,
-    Default
+    Default,
 )]
 #[serde(rename_all = "camelCase")]
 pub struct ChartsView<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub scrobbles: std::option::Option<
-        Vec<crate::app_rocksky::charts::ScrobbleViewBasic<'a>>,
-    >,
+    pub scrobbles: std::option::Option<Vec<crate::app_rocksky::charts::ScrobbleViewBasic<'a>>>,
 }
 
 #[jacquard_derive::lexicon]
···
     PartialEq,
     Eq,
     jacquard_derive::IntoStatic,
-    Default
+    Default,
 )]
 #[serde(rename_all = "camelCase")]
 pub struct ScrobbleViewBasic<'a> {
···
     /// The date of the scrobble.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     pub date: std::option::Option<jacquard_common::types::string::Datetime>,
-}
+}

crates/jacquard-api/src/tools_ozone/setting.rs

···
 
 #[jacquard_derive::lexicon]
 #[derive(
-    serde::Serialize,
-    serde::Deserialize,
-    Debug,
-    Clone,
-    PartialEq,
-    Eq,
-    jacquard_derive::IntoStatic
+    serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic,
 )]
 #[serde(rename_all = "camelCase")]
 pub struct Option<'a> {
···
     pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
     #[serde(borrow)]
     pub value: jacquard_common::types::value::Data<'a>,
-}
+}

crates/jacquard-axum/tests/extractor_tests.rs

···
 async fn test_handler(ExtractXrpc(req): ExtractXrpc<TestQueryRequest<'_>>) -> impl IntoResponse {
     Json(TestQueryResponse {
         did: req.did,
-        extra_data: BTreeMap::new(),
+        extra_data: None,
     })
 }
 

crates/jacquard-axum/tests/service_auth_tests.rs

···
             r#type: CowStr::new_static("Multikey"),
             controller: Some(CowStr::Owned(did.into())),
             public_key_multibase: Some(CowStr::Owned(multibase_key.into())),
-            extra_data: BTreeMap::new(),
+            extra_data: None,
         }]),
         service: None,
-        extra_data: BTreeMap::new(),
+        extra_data: None,
     }
 }
 

crates/jacquard-derive/Cargo.toml

···
 proc-macro = true
 
 [dependencies]
+jacquard-lexicon = { version = "0.8", path = "../jacquard-lexicon" }
 proc-macro2.workspace = true
 quote.workspace = true
 syn.workspace = true

crates/jacquard-derive/src/lib.rs

···
 //! ```
 
 use proc_macro::TokenStream;
-use quote::{format_ident, quote};
-use syn::{Attribute, Data, DeriveInput, Fields, GenericParam, Ident, LitStr, parse_macro_input};
-
-/// Helper function to check if a struct derives bon::Builder or Builder
-fn has_derive_builder(attrs: &[Attribute]) -> bool {
-    attrs.iter().any(|attr| {
-        if !attr.path().is_ident("derive") {
-            return false;
-        }
-
-        // Parse the derive attribute to check its contents
-        if let Ok(list) = attr.parse_args_with(
-            syn::punctuated::Punctuated::<syn::Path, syn::Token![,]>::parse_terminated,
-        ) {
-            list.iter().any(|path| {
-                // Check for "Builder" or "bon::Builder"
-                path.segments
-                    .last()
-                    .map(|seg| seg.ident == "Builder")
-                    .unwrap_or(false)
-            })
-        } else {
-            false
-        }
-    })
-}
-
-/// Check if struct name conflicts with types referenced by bon::Builder macro.
-/// bon::Builder generates code that uses unqualified `Option` and `Result`,
-/// so structs with these names cause compilation errors.
-fn conflicts_with_builder_macro(ident: &Ident) -> bool {
-    matches!(ident.to_string().as_str(), "Option" | "Result")
-}
 
 /// Attribute macro that adds an `extra_data` field to structs to capture unknown fields
 /// during deserialization.
 ///
-/// # Example
-/// ```ignore
-/// #[lexicon]
-/// struct Post<'s> {
-///     text: &'s str,
-/// }
-/// // Expands to:
-/// // struct Post<'s> {
-/// //     text: &'s str,
-/// //     #[serde(flatten)]
-/// //     pub extra_data: BTreeMap<SmolStr, Data<'s>>,
-/// // }
-/// ```
+/// See crate documentation for examples.
 #[proc_macro_attribute]
-pub fn lexicon(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(item as DeriveInput);
-
-    match &mut input.data {
-        Data::Struct(data_struct) => {
-            if let Fields::Named(fields) = &mut data_struct.fields {
-                // Check if extra_data field already exists
-                let has_extra_data = fields
-                    .named
-                    .iter()
-                    .any(|f| f.ident.as_ref().map(|i| i == "extra_data").unwrap_or(false));
-
-                if !has_extra_data {
-                    // Check if the struct derives bon::Builder and doesn't conflict with builder macro
-                    let has_bon_builder = has_derive_builder(&input.attrs)
-                        && !conflicts_with_builder_macro(&input.ident);
-
-                    // Determine the lifetime parameter to use
-                    let lifetime = if let Some(lt) = input.generics.lifetimes().next() {
-                        quote! { #lt }
-                    } else {
-                        quote! { 'static }
-                    };
-
-                    // Add the extra_data field with serde(borrow) if there's a lifetime
-                    let new_field: syn::Field = if input.generics.lifetimes().next().is_some() {
-                        if has_bon_builder {
-                            syn::parse_quote! {
-                                #[serde(flatten)]
-                                #[serde(borrow)]
-                                #[builder(default)]
-                                pub extra_data: ::std::collections::BTreeMap<
-                                    ::jacquard_common::smol_str::SmolStr,
-                                    ::jacquard_common::types::value::Data<#lifetime>
-                                >
-                            }
-                        } else {
-                            syn::parse_quote! {
-                                #[serde(flatten)]
-                                #[serde(borrow)]
-                                pub extra_data: ::std::collections::BTreeMap<
-                                    ::jacquard_common::smol_str::SmolStr,
-                                    ::jacquard_common::types::value::Data<#lifetime>
-                                >
-                            }
-                        }
-                    } else {
-                        // For types without lifetimes, make it optional to avoid lifetime conflicts
-                        if has_bon_builder {
-                            syn::parse_quote! {
-                                #[serde(flatten)]
-                                #[serde(skip_serializing_if = "std::option::Option::is_none")]
-                                #[serde(default)]
-                                #[builder(default)]
-                                pub extra_data: Option<::std::collections::BTreeMap<
-                                    ::jacquard_common::smol_str::SmolStr,
-                                    ::jacquard_common::types::value::Data<'static>
-                                >>
-                            }
-                        } else {
-                            syn::parse_quote! {
-                                #[serde(flatten)]
-                                #[serde(skip_serializing_if = "std::option::Option::is_none")]
-                                #[serde(default)]
-                                pub extra_data:Option<::std::collections::BTreeMap<
-                                    ::jacquard_common::smol_str::SmolStr,
-                                    ::jacquard_common::types::value::Data<'static>
-                                >>
-                            }
-                        }
-                    };
-                    fields.named.push(new_field);
-                }
-            } else {
-                return syn::Error::new_spanned(
-                    input,
-                    "lexicon attribute can only be used on structs with named fields",
-                )
-                .to_compile_error()
-                .into();
-            }
-
-            quote! { #input }.into()
-        }
-        _ => syn::Error::new_spanned(input, "lexicon attribute can only be used on structs")
-            .to_compile_error()
-            .into(),
-    }
+pub fn lexicon(attr: TokenStream, item: TokenStream) -> TokenStream {
+    jacquard_lexicon::derive_impl::impl_lexicon(attr.into(), item.into()).into()
 }
 
-/// Attribute macro that adds an `Other(Data)` variant to enums to make them open unions.
+/// Attribute macro that adds an `Unknown(Data)` variant to enums to make them open unions.
 ///
-/// # Example
-/// ```ignore
-/// #[open_union]
-/// enum RecordEmbed<'s> {
-///     #[serde(rename = "app.bsky.embed.images")]
-///     Images(Images),
-/// }
-/// // Expands to:
-/// // enum RecordEmbed<'s> {
-/// //     #[serde(rename = "app.bsky.embed.images")]
-/// //     Images(Images),
-/// //     #[serde(untagged)]
-/// //     Unknown(Data<'s>),
-/// // }
-/// ```
+/// See crate documentation for examples.
 #[proc_macro_attribute]
-pub fn open_union(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(item as DeriveInput);
-
-    match &mut input.data {
-        Data::Enum(data_enum) => {
-            // Check if Unknown variant already exists
-            let has_other = data_enum.variants.iter().any(|v| v.ident == "Unknown");
-
-            if !has_other {
-                // Determine the lifetime parameter to use
-                let lifetime = if let Some(lt) = input.generics.lifetimes().next() {
-                    quote! { #lt }
-                } else {
-                    quote! { 'static }
-                };
-
-                // Add the Unknown variant
-                let new_variant: syn::Variant = syn::parse_quote! {
-                    #[serde(untagged)]
-                    Unknown(::jacquard_common::types::value::Data<#lifetime>)
-                };
-                data_enum.variants.push(new_variant);
-            }
-
-            quote! { #input }.into()
-        }
-        _ => syn::Error::new_spanned(input, "open_union attribute can only be used on enums")
-            .to_compile_error()
-            .into(),
-    }
+pub fn open_union(attr: TokenStream, item: TokenStream) -> TokenStream {
+    jacquard_lexicon::derive_impl::impl_open_union(attr.into(), item.into()).into()
 }
 
 /// Derive macro for `IntoStatic` trait.
 ///
 /// Automatically implements conversion from borrowed to owned ('static) types.
-/// Works with structs and enums that have lifetime parameters.
-///
-/// # Example
-/// ```ignore
-/// #[derive(IntoStatic)]
-/// struct Post<'a> {
-///     text: CowStr<'a>,
-/// }
-/// // Generates:
-/// // impl IntoStatic for Post<'_> {
-/// //     type Output = Post<'static>;
-/// //     fn into_static(self) -> Self::Output {
-/// //         Post { text: self.text.into_static() }
-/// //     }
-/// // }
-/// ```
+/// See crate documentation for examples.
 #[proc_macro_derive(IntoStatic)]
 pub fn derive_into_static(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-
-    let name = &input.ident;
-    let generics = &input.generics;
-
-    // Build impl generics and where clause
-    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
-
-    // Build the Output type with all lifetimes replaced by 'static
-    let output_generics = generics.params.iter().map(|param| match param {
-        GenericParam::Lifetime(_) => quote! { 'static },
-        GenericParam::Type(ty) => {
-            let ident = &ty.ident;
-            quote! { #ident }
-        }
-        GenericParam::Const(c) => {
-            let ident = &c.ident;
-            quote! { #ident }
-        }
-    });
-
-    let output_type = if generics.params.is_empty() {
-        quote! { #name }
-    } else {
-        quote! { #name<#(#output_generics),*> }
-    };
-
-    // Generate the conversion body based on struct/enum
-    let conversion = match &input.data {
-        Data::Struct(data_struct) => generate_struct_conversion(name, &data_struct.fields),
-        Data::Enum(data_enum) => generate_enum_conversion(name, data_enum),
-        Data::Union(_) => {
-            return syn::Error::new_spanned(input, "IntoStatic cannot be derived for unions")
-                .to_compile_error()
-                .into();
-        }
-    };
-
-    let expanded = quote! {
-        impl #impl_generics ::jacquard_common::IntoStatic for #name #ty_generics #where_clause {
-            type Output = #output_type;
-
-            fn into_static(self) -> Self::Output {
-                #conversion
-            }
-        }
-    };
-
-    expanded.into()
-}
-
-fn generate_struct_conversion(name: &syn::Ident, fields: &Fields) -> proc_macro2::TokenStream {
-    match fields {
-        Fields::Named(fields) => {
-            let field_conversions = fields.named.iter().map(|f| {
-                let field_name = &f.ident;
-                quote! { #field_name: self.#field_name.into_static() }
-            });
-            quote! {
-                #name {
-                    #(#field_conversions),*
-                }
-            }
-        }
-        Fields::Unnamed(fields) => {
-            let field_conversions = fields.unnamed.iter().enumerate().map(|(i, _)| {
-                let index = syn::Index::from(i);
-                quote! { self.#index.into_static() }
-            });
-            quote! {
-                #name(#(#field_conversions),*)
-            }
-        }
-        Fields::Unit => {
-            quote! { #name }
-        }
-    }
-}
-
-fn generate_enum_conversion(
-    name: &syn::Ident,
-    data_enum: &syn::DataEnum,
-) -> proc_macro2::TokenStream {
-    let variants = data_enum.variants.iter().map(|variant| {
-        let variant_name = &variant.ident;
-        match &variant.fields {
-            Fields::Named(fields) => {
-                let field_names: Vec<_> = fields.named.iter().map(|f| &f.ident).collect();
-                let field_conversions = field_names.iter().map(|field_name| {
-                    quote! { #field_name: #field_name.into_static() }
-                });
-                quote! {
-                    #name::#variant_name { #(#field_names),* } => {
-                        #name::#variant_name {
-                            #(#field_conversions),*
-                        }
-                    }
-                }
-            }
-            Fields::Unnamed(fields) => {
-                let field_bindings: Vec<_> = (0..fields.unnamed.len())
-                    .map(|i| {
-                        syn::Ident::new(&format!("field_{}", i), proc_macro2::Span::call_site())
-                    })
-                    .collect();
-                let field_conversions = field_bindings.iter().map(|binding| {
-                    quote! { #binding.into_static() }
-                });
-                quote! {
-                    #name::#variant_name(#(#field_bindings),*) => {
-                        #name::#variant_name(#(#field_conversions),*)
-                    }
-                }
-            }
-            Fields::Unit => {
-                quote! {
-                    #name::#variant_name => #name::#variant_name
-                }
-            }
-        }
-    });
-
-    quote! {
-        match self {
-            #(#variants),*
-        }
-    }
+    jacquard_lexicon::derive_impl::impl_derive_into_static(input.into()).into()
 }
 
 /// Derive macro for `XrpcRequest` trait.
 ///
 /// Automatically generates the response marker struct, `XrpcResp` impl, and `XrpcRequest` impl
-/// for an XRPC endpoint. Optionally generates `XrpcEndpoint` impl for server-side usage.
-///
-/// # Attributes
-///
-/// - `nsid`: Required. The NSID string (e.g., "com.example.myMethod")
-/// - `method`: Required. Either `Query` or `Procedure`
-/// - `output`: Required. The output type (must support lifetime param if request does)
-/// - `error`: Optional. Error type (defaults to `GenericError`)
-/// - `server`: Optional flag. If present, generates `XrpcEndpoint` impl too
-///
-/// # Example
-/// ```ignore
-/// #[derive(Serialize, Deserialize, XrpcRequest)]
-/// #[xrpc(
-///     nsid = "com.example.getThing",
-///     method = Query,
-///     output = GetThingOutput,
-/// )]
-/// struct GetThing<'a> {
-///     #[serde(borrow)]
-///     pub id: CowStr<'a>,
-/// }
-/// ```
-///
-/// This generates:
-/// - `GetThingResponse` struct implementing `XrpcResp`
-/// - `XrpcRequest` impl for `GetThing`
-/// - Optionally: `GetThingEndpoint` struct implementing `XrpcEndpoint` (if `server` flag present)
+/// for an XRPC endpoint. See crate documentation for examples.
 #[proc_macro_derive(XrpcRequest, attributes(xrpc))]
 pub fn derive_xrpc_request(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-
-    match xrpc_request_impl(&input) {
-        Ok(tokens) => tokens.into(),
-        Err(e) => e.to_compile_error().into(),
-    }
-}
-
-fn xrpc_request_impl(input: &DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
-    // Parse attributes
-    let attrs = parse_xrpc_attrs(&input.attrs)?;
-
-    let name = &input.ident;
-    let generics = &input.generics;
-
-    // Detect if type has lifetime parameter
-    let has_lifetime = generics.lifetimes().next().is_some();
-    let lifetime = if has_lifetime {
-        quote! { <'_> }
-    } else {
-        quote! {}
-    };
-
-    let nsid = &attrs.nsid;
-    let method = method_expr(&attrs.method);
-    let output_ty = &attrs.output;
-    let error_ty = attrs
-        .error
-        .as_ref()
-        .map(|e| quote! { #e })
-        .unwrap_or_else(|| quote! { ::jacquard_common::xrpc::GenericError });
-
-    // Generate response marker struct name
-    let response_name = format_ident!("{}Response", name);
-
-    // Build the impls
-    let mut output = quote! {
-        /// Response marker for #name
-        pub struct #response_name;
-
-        impl ::jacquard_common::xrpc::XrpcResp for #response_name {
-            const NSID: &'static str = #nsid;
-            const ENCODING: &'static str = "application/json";
-            type Output<'de> = #output_ty<'de>;
-            type Err<'de> = #error_ty<'de>;
-        }
-
-        impl #generics ::jacquard_common::xrpc::XrpcRequest for #name #lifetime {
-            const NSID: &'static str = #nsid;
-            const METHOD: ::jacquard_common::xrpc::XrpcMethod = #method;
-            type Response = #response_name;
-        }
-    };
-
-    // Optional server-side endpoint impl
-    if attrs.server {
-        let endpoint_name = format_ident!("{}Endpoint", name);
-        let path = format!("/xrpc/{}", nsid);
-
-        // Request type with or without lifetime
-        let request_type = if has_lifetime {
-            quote! { #name<'de> }
-        } else {
-            quote! { #name }
-        };
-
-        output.extend(quote! {
-            /// Endpoint marker for #name (server-side)
-            pub struct #endpoint_name;
-
-            impl ::jacquard_common::xrpc::XrpcEndpoint for #endpoint_name {
-                const PATH: &'static str = #path;
-                const METHOD: ::jacquard_common::xrpc::XrpcMethod = #method;
-                type Request<'de> = #request_type;
-                type Response = #response_name;
-            }
-        });
-    }
-
-    Ok(output)
-}
-
-struct XrpcAttrs {
-    nsid: String,
-    method: XrpcMethod,
-    output: syn::Type,
-    error: Option<syn::Type>,
-    server: bool,
-}
-
-enum XrpcMethod {
-    Query,
-    Procedure,
-}
-
-fn parse_xrpc_attrs(attrs: &[Attribute]) -> syn::Result<XrpcAttrs> {
-    let mut nsid = None;
-    let mut method = None;
-    let mut output = None;
-    let mut error = None;
-    let mut server = false;
-
-    for attr in attrs {
-        if !attr.path().is_ident("xrpc") {
-            continue;
-        }
-
-        attr.parse_nested_meta(|meta| {
-            if meta.path.is_ident("nsid") {
-                let value = meta.value()?;
-                let s: LitStr = value.parse()?;
-                nsid = Some(s.value());
-                Ok(())
-            } else if meta.path.is_ident("method") {
-                // Parse "method = Query" or "method = Procedure"
-                let _eq = meta.input.parse::<syn::Token![=]>()?;
-                let ident: Ident = meta.input.parse()?;
-                match ident.to_string().as_str() {
-                    "Query" => {
-                        method = Some(XrpcMethod::Query);
-                        Ok(())
-                    }
-                    "Procedure" => {
-                        // Always JSON, no custom encoding support
-                        method = Some(XrpcMethod::Procedure);
-                        Ok(())
-                    }
-                    other => {
-                        Err(meta
-                            .error(format!("unknown method: {}, use Query or Procedure", other)))
-                    }
-                }
-            } else if meta.path.is_ident("output") {
-                let value = meta.value()?;
-                output = Some(value.parse()?);
-                Ok(())
-            } else if meta.path.is_ident("error") {
-                let value = meta.value()?;
-                error = Some(value.parse()?);
-                Ok(())
-            } else if meta.path.is_ident("server") {
-                server = true;
-                Ok(())
-            } else {
-                Err(meta.error("unknown xrpc attribute"))
-            }
-        })?;
-    }
-
-    let nsid = nsid.ok_or_else(|| {
-        syn::Error::new(
-            proc_macro2::Span::call_site(),
-            "missing required `nsid` attribute",
-        )
-    })?;
-    let method = method.ok_or_else(|| {
-        syn::Error::new(
-            proc_macro2::Span::call_site(),
-            "missing required `method` attribute",
-        )
-    })?;
-    let output = output.ok_or_else(|| {
-        syn::Error::new(
-            proc_macro2::Span::call_site(),
-            "missing required `output` attribute",
-        )
-    })?;
-
-    Ok(XrpcAttrs {
-        nsid,
-        method,
-        output,
-        error,
-        server,
-    })
-}
-
-fn method_expr(method: &XrpcMethod) -> proc_macro2::TokenStream {
-    match method {
-        XrpcMethod::Query => quote! { ::jacquard_common::xrpc::XrpcMethod::Query },
-        XrpcMethod::Procedure => {
-            quote! { ::jacquard_common::xrpc::XrpcMethod::Procedure("application/json") }
-        }
-    }
+    jacquard_lexicon::derive_impl::impl_derive_xrpc_request(input.into()).into()
 }

crates/jacquard-derive/tests/lexicon.rs

···
 
     assert_eq!(record.text, "hello");
     assert_eq!(record.count, 42);
-    assert_eq!(record.extra_data.len(), 2);
-    assert!(record.extra_data.contains_key("unknown"));
-    assert!(record.extra_data.contains_key("another"));
+
+    let extra_data = record.extra_data.unwrap();
+    assert_eq!(extra_data.len(), 2);
+    assert!(extra_data.contains_key("unknown"));
+    assert!(extra_data.contains_key("another"));
 }
 
 #[test]
···
             CowStr::Borrowed("value"),
         )),
     );
-    extra.insert(
-        "number".into(),
-        Data::Integer(42),
-    );
+    extra.insert("number".into(), Data::Integer(42));
     extra.insert(
         "nested".into(),
         Data::Object(jacquard_common::types::value::Object({
             let mut nested_map = BTreeMap::new();
-            nested_map.insert(
-                "inner".into(),
-                Data::Boolean(true),
-            );
+            nested_map.insert("inner".into(), Data::Boolean(true));
             nested_map
         })),
     );
···
     let record = TestRecord {
         text: "test",
         count: 100,
-        extra_data: extra,
+        extra_data: Some(extra),
     };
 
     let json = serde_json::to_string(&record).unwrap();
     let parsed: TestRecord = serde_json::from_str(&json).unwrap();
 
     assert_eq!(record, parsed);
-    assert_eq!(parsed.extra_data.len(), 3);
+    let extra_data = parsed.extra_data.unwrap();
+    assert_eq!(extra_data.len(), 3);
 
     // Verify the extra fields were preserved
-    assert!(parsed.extra_data.contains_key("custom"));
-    assert!(parsed.extra_data.contains_key("number"));
-    assert!(parsed.extra_data.contains_key("nested"));
+    assert!(extra_data.contains_key("custom"));
+    assert!(extra_data.contains_key("number"));
+    assert!(extra_data.contains_key("nested"));
 
     // Verify the values
-    if let Some(Data::String(s)) = parsed.extra_data.get("custom") {
+    if let Some(Data::String(s)) = extra_data.get("custom") {
         assert_eq!(s.as_str(), "value");
     } else {
         panic!("expected custom field to be a string");
     }
 
-    if let Some(Data::Integer(n)) = parsed.extra_data.get("number") {
+    if let Some(Data::Integer(n)) = extra_data.get("number") {
         assert_eq!(*n, 42);
     } else {
         panic!("expected number field to be an integer");
     }
 
-    if let Some(Data::Object(obj)) = parsed.extra_data.get("nested") {
+    if let Some(Data::Object(obj)) = extra_data.get("nested") {
         assert!(obj.0.contains_key("inner"));
     } else {
         panic!("expected nested field to be an object");

crates/jacquard-identity/src/resolver.rs

···
                         service_endpoint: Some(Data::String(AtprotoStr::Uri(Uri::Https(
                             Url::from_str(&mini_doc.pds).unwrap(),
                         )))),
-                        extra_data: BTreeMap::new(),
+                        extra_data: None,
                     }]),
-                    extra_data: BTreeMap::new(),
+                    extra_data: None,
                 })
             } else {
                 Err(IdentityError::missing_pds_endpoint())
···
                         service_endpoint: Some(Data::String(AtprotoStr::Uri(Uri::Https(
                             Url::from_str(&mini_doc.pds).unwrap(),
                         )))),
-                        extra_data: BTreeMap::new(),
+                        extra_data: None,
                     }]),
-                    extra_data: BTreeMap::new(),
+                    extra_data: None,
                 }
                 .into_static())
             } else {

crates/jacquard-lexicon/src/derive_impl/helpers.rs

···
+//! Shared helper functions for derive macros
+
+use syn::{Attribute, Ident};
+
+/// Helper function to check if a struct derives bon::Builder or Builder
+pub fn has_derive_builder(attrs: &[Attribute]) -> bool {
+    attrs.iter().any(|attr| {
+        if !attr.path().is_ident("derive") {
+            return false;
+        }
+
+        // Parse the derive attribute to check its contents
+        if let Ok(list) = attr.parse_args_with(
+            syn::punctuated::Punctuated::<syn::Path, syn::Token![,]>::parse_terminated,
+        ) {
+            list.iter().any(|path| {
+                // Check for "Builder" or "bon::Builder"
+                path.segments
+                    .last()
+                    .map(|seg| seg.ident == "Builder")
+                    .unwrap_or(false)
+            })
+        } else {
+            false
+        }
+    })
+}
+
+/// Check if struct name conflicts with types referenced by bon::Builder macro.
+/// bon::Builder generates code that uses unqualified `Option` and `Result`,
+/// so structs with these names cause compilation errors.
+pub fn conflicts_with_builder_macro(ident: &Ident) -> bool {
+    matches!(ident.to_string().as_str(), "Option" | "Result")
+}

crates/jacquard-lexicon/src/derive_impl/into_static.rs

···
+//! Implementation of #[derive(IntoStatic)] macro
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{parse2, Data, DeriveInput, Fields, GenericParam};
+
+/// Implementation for the IntoStatic derive macro
+pub fn impl_derive_into_static(input: TokenStream) -> TokenStream {
+    let input = match parse2::<DeriveInput>(input) {
+        Ok(input) => input,
+        Err(e) => return e.to_compile_error(),
+    };
+
+    let name = &input.ident;
+    let generics = &input.generics;
+
+    // Build impl generics and where clause
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+    // Build the Output type with all lifetimes replaced by 'static
+    let output_generics = generics.params.iter().map(|param| match param {
+        GenericParam::Lifetime(_) => quote! { 'static },
+        GenericParam::Type(ty) => {
+            let ident = &ty.ident;
+            quote! { #ident }
+        }
+        GenericParam::Const(c) => {
+            let ident = &c.ident;
+            quote! { #ident }
+        }
+    });
+
+    let output_type = if generics.params.is_empty() {
+        quote! { #name }
+    } else {
+        quote! { #name<#(#output_generics),*> }
+    };
+
+    // Generate the conversion body based on struct/enum
+    let conversion = match &input.data {
+        Data::Struct(data_struct) => generate_struct_conversion(name, &data_struct.fields),
+        Data::Enum(data_enum) => generate_enum_conversion(name, data_enum),
+        Data::Union(_) => {
+            return syn::Error::new_spanned(input, "IntoStatic cannot be derived for unions")
+                .to_compile_error();
+        }
+    };
+
+    quote! {
+        impl #impl_generics ::jacquard_common::IntoStatic for #name #ty_generics #where_clause {
+            type Output = #output_type;
+
+            fn into_static(self) -> Self::Output {
+                #conversion
+            }
+        }
+    }
+}
+
+fn generate_struct_conversion(name: &syn::Ident, fields: &Fields) -> TokenStream {
+    match fields {
+        Fields::Named(fields) => {
+            let field_conversions = fields.named.iter().map(|f| {
+                let field_name = &f.ident;
+                quote! { #field_name: self.#field_name.into_static() }
+            });
+            quote! {
+                #name {
+                    #(#field_conversions),*
+                }
+            }
+        }
+        Fields::Unnamed(fields) => {
+            let field_conversions = fields.unnamed.iter().enumerate().map(|(i, _)| {
+                let index = syn::Index::from(i);
+                quote! { self.#index.into_static() }
+            });
+            quote! {
+                #name(#(#field_conversions),*)
+            }
+        }
+        Fields::Unit => {
+            quote! { #name }
+        }
+    }
+}
+
+fn generate_enum_conversion(
+    name: &syn::Ident,
+    data_enum: &syn::DataEnum,
+) -> TokenStream {
+    let variants = data_enum.variants.iter().map(|variant| {
+        let variant_name = &variant.ident;
+        match &variant.fields {
+            Fields::Named(fields) => {
+                let field_names: Vec<_> = fields.named.iter().map(|f| &f.ident).collect();
+                let field_conversions = field_names.iter().map(|field_name| {
+                    quote! { #field_name: #field_name.into_static() }
+                });
+                quote! {
+                    #name::#variant_name { #(#field_names),* } => {
+                        #name::#variant_name {
+                            #(#field_conversions),*
+                        }
+                    }
+                }
+            }
+            Fields::Unnamed(fields) => {
+                let field_bindings: Vec<_> = (0..fields.unnamed.len())
+                    .map(|i| {
+                        syn::Ident::new(&format!("field_{}", i), proc_macro2::Span::call_site())
+                    })
+                    .collect();
+                let field_conversions = field_bindings.iter().map(|binding| {
+                    quote! { #binding.into_static() }
+                });
+                quote! {
+                    #name::#variant_name(#(#field_bindings),*) => {
+                        #name::#variant_name(#(#field_conversions),*)
+                    }
+                }
+            }
+            Fields::Unit => {
+                quote! {
+                    #name::#variant_name => #name::#variant_name
+                }
+            }
+        }
+    });
+
+    quote! {
+        match self {
+            #(#variants),*
+        }
+    }
+}

crates/jacquard-lexicon/src/derive_impl/lexicon_attr.rs

···
+//! Implementation of #[lexicon] attribute macro
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{Data, DeriveInput, Fields, parse2};
+
+use super::helpers::{conflicts_with_builder_macro, has_derive_builder};
+
+/// Implementation for the lexicon attribute macro
+pub fn impl_lexicon(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let mut input = match parse2::<DeriveInput>(item) {
+        Ok(input) => input,
+        Err(e) => return e.to_compile_error(),
+    };
+
+    match &mut input.data {
+        Data::Struct(data_struct) => {
+            if let Fields::Named(fields) = &mut data_struct.fields {
+                // Check if extra_data field already exists
+                let has_extra_data = fields
+                    .named
+                    .iter()
+                    .any(|f| f.ident.as_ref().map(|i| i == "extra_data").unwrap_or(false));
+
+                if !has_extra_data {
+                    // Check if the struct derives bon::Builder and doesn't conflict with builder macro
+                    let has_bon_builder = has_derive_builder(&input.attrs)
+                        && !conflicts_with_builder_macro(&input.ident);
+
+                    // Determine the lifetime parameter to use
+                    let lifetime = if let Some(lt) = input.generics.lifetimes().next() {
+                        quote! { #lt }
+                    } else {
+                        quote! { 'static }
+                    };
+
+                    // Add the extra_data field with serde(borrow) if there's a lifetime
+                    let new_field: syn::Field = if has_bon_builder {
+                        syn::parse_quote! {
+                            #[serde(flatten)]
+                            #[serde(borrow)]
+                            #[serde(skip_serializing_if = "std::option::Option::is_none")]
+                            #[serde(default)]
+                            pub extra_data: ::std::option::Option<::std::collections::BTreeMap<
+                                ::jacquard_common::smol_str::SmolStr,
+                                ::jacquard_common::types::value::Data<#lifetime>
+                            >>
+                        }
+                    } else {
+                        syn::parse_quote! {
+                            #[serde(flatten)]
+                            #[serde(borrow)]
+                            #[serde(skip_serializing_if = "std::option::Option::is_none")]
+                            #[serde(default)]
+                            pub extra_data: ::std::option::Option<::std::collections::BTreeMap<
+                                ::jacquard_common::smol_str::SmolStr,
+                                ::jacquard_common::types::value::Data<#lifetime>
+                            >>
+                        }
+                    };
+                    fields.named.push(new_field);
+                }
+            } else {
+                return syn::Error::new_spanned(
+                    input,
+                    "lexicon attribute can only be used on structs with named fields",
+                )
+                .to_compile_error();
+            }
+
+            quote! { #input }
+        }
+        _ => syn::Error::new_spanned(input, "lexicon attribute can only be used on structs")
+            .to_compile_error(),
+    }
+}

crates/jacquard-lexicon/src/derive_impl/mod.rs

···
+//! Implementation functions for derive macros
+//!
+//! These functions are used by the `jacquard-derive` proc-macro crate but are also
+//! available for runtime code generation in `jacquard-lexicon`.
+
+pub mod helpers;
+pub mod into_static;
+pub mod lexicon_attr;
+pub mod open_union_attr;
+pub mod xrpc_request;
+
+// Re-export the main entry points
+pub use into_static::impl_derive_into_static;
+pub use lexicon_attr::impl_lexicon;
+pub use open_union_attr::impl_open_union;
+pub use xrpc_request::impl_derive_xrpc_request;

crates/jacquard-lexicon/src/derive_impl/open_union_attr.rs

···
+//! Implementation of #[open_union] attribute macro
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{parse2, Data, DeriveInput};
+
+/// Implementation for the open_union attribute macro
+pub fn impl_open_union(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let mut input = match parse2::<DeriveInput>(item) {
+        Ok(input) => input,
+        Err(e) => return e.to_compile_error(),
+    };
+
+    match &mut input.data {
+        Data::Enum(data_enum) => {
+            // Check if Unknown variant already exists
+            let has_other = data_enum.variants.iter().any(|v| v.ident == "Unknown");
+
+            if !has_other {
+                // Determine the lifetime parameter to use
+                let lifetime = if let Some(lt) = input.generics.lifetimes().next() {
+                    quote! { #lt }
+                } else {
+                    quote! { 'static }
+                };
+
+                // Add the Unknown variant
+                let new_variant: syn::Variant = syn::parse_quote! {
+                    #[serde(untagged)]
+                    Unknown(::jacquard_common::types::value::Data<#lifetime>)
+                };
+                data_enum.variants.push(new_variant);
+            }
+
+            quote! { #input }
+        }
+        _ => syn::Error::new_spanned(input, "open_union attribute can only be used on enums")
+            .to_compile_error(),
+    }
+}

crates/jacquard-lexicon/src/derive_impl/xrpc_request.rs

···
+//! Implementation of #[derive(XrpcRequest)] macro
+
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote};
+use syn::{parse2, Attribute, DeriveInput, Ident, LitStr};
+
+/// Implementation for the XrpcRequest derive macro
+pub fn impl_derive_xrpc_request(input: TokenStream) -> TokenStream {
+    let input = match parse2::<DeriveInput>(input) {
+        Ok(input) => input,
+        Err(e) => return e.to_compile_error(),
+    };
+
+    match xrpc_request_impl(&input) {
+        Ok(tokens) => tokens,
+        Err(e) => e.to_compile_error(),
+    }
+}
+
+fn xrpc_request_impl(input: &DeriveInput) -> syn::Result<TokenStream> {
+    // Parse attributes
+    let attrs = parse_xrpc_attrs(&input.attrs)?;
+
+    let name = &input.ident;
+    let generics = &input.generics;
+
+    // Detect if type has lifetime parameter
+    let has_lifetime = generics.lifetimes().next().is_some();
+    let lifetime = if has_lifetime {
+        quote! { <'_> }
+    } else {
+        quote! {}
+    };
+
+    let nsid = &attrs.nsid;
+    let method = method_expr(&attrs.method);
+    let output_ty = &attrs.output;
+    let error_ty = attrs
+        .error
+        .as_ref()
+        .map(|e| quote! { #e })
+        .unwrap_or_else(|| quote! { ::jacquard_common::xrpc::GenericError });
+
+    // Generate response marker struct name
+    let response_name = format_ident!("{}Response", name);
+
+    // Build the impls
+    let mut output = quote! {
+        /// Response marker for #name
+        pub struct #response_name;
+
+        impl ::jacquard_common::xrpc::XrpcResp for #response_name {
+            const NSID: &'static str = #nsid;
+            const ENCODING: &'static str = "application/json";
+            type Output<'de> = #output_ty<'de>;
+            type Err<'de> = #error_ty<'de>;
+        }
+
+        impl #generics ::jacquard_common::xrpc::XrpcRequest for #name #lifetime {
+            const NSID: &'static str = #nsid;
+            const METHOD: ::jacquard_common::xrpc::XrpcMethod = #method;
+            type Response = #response_name;
+        }
+    };
+
+    // Optional server-side endpoint impl
+    if attrs.server {
+        let endpoint_name = format_ident!("{}Endpoint", name);
+        let path = format!("/xrpc/{}", nsid);
+
+        // Request type with or without lifetime
+        let request_type = if has_lifetime {
+            quote! { #name<'de> }
+        } else {
+            quote! { #name }
+        };
+
+        output.extend(quote! {
+            /// Endpoint marker for #name (server-side)
+            pub struct #endpoint_name;
+
+            impl ::jacquard_common::xrpc::XrpcEndpoint for #endpoint_name {
+                const PATH: &'static str = #path;
+                const METHOD: ::jacquard_common::xrpc::XrpcMethod = #method;
+                type Request<'de> = #request_type;
+                type Response = #response_name;
+            }
+        });
+    }
+
+    Ok(output)
+}
+
+struct XrpcAttrs {
+    nsid: String,
+    method: XrpcMethod,
+    output: syn::Type,
+    error: Option<syn::Type>,
+    server: bool,
+}
+
+enum XrpcMethod {
+    Query,
+    Procedure,
+}
+
+fn parse_xrpc_attrs(attrs: &[Attribute]) -> syn::Result<XrpcAttrs> {
+    let mut nsid = None;
+    let mut method = None;
+    let mut output = None;
+    let mut error = None;
+    let mut server = false;
+
+    for attr in attrs {
+        if !attr.path().is_ident("xrpc") {
+            continue;
+        }
+
+        attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident("nsid") {
+                let value = meta.value()?;
+                let s: LitStr = value.parse()?;
+                nsid = Some(s.value());
+                Ok(())
+            } else if meta.path.is_ident("method") {
+                // Parse "method = Query" or "method = Procedure"
+                let _eq = meta.input.parse::<syn::Token![=]>()?;
+                let ident: Ident = meta.input.parse()?;
+                match ident.to_string().as_str() {
+                    "Query" => {
+                        method = Some(XrpcMethod::Query);
+                        Ok(())
+                    }
+                    "Procedure" => {
+                        // Always JSON, no custom encoding support
+                        method = Some(XrpcMethod::Procedure);
+                        Ok(())
+                    }
+                    other => {
+                        Err(meta
+                            .error(format!("unknown method: {}, use Query or Procedure", other)))
+                    }
+                }
+            } else if meta.path.is_ident("output") {
+                let value = meta.value()?;
+                output = Some(value.parse()?);
+                Ok(())
+            } else if meta.path.is_ident("error") {
+                let value = meta.value()?;
+                error = Some(value.parse()?);
+                Ok(())
+            } else if meta.path.is_ident("server") {
+                server = true;
+                Ok(())
+            } else {
+                Err(meta.error("unknown xrpc attribute"))
+            }
+        })?;
+    }
+
+    let nsid = nsid.ok_or_else(|| {
+        syn::Error::new(
+            proc_macro2::Span::call_site(),
+            "missing required `nsid` attribute",
+        )
+    })?;
+    let method = method.ok_or_else(|| {
+        syn::Error::new(
+            proc_macro2::Span::call_site(),
+            "missing required `method` attribute",
+        )
+    })?;
+    let output = output.ok_or_else(|| {
+        syn::Error::new(
+            proc_macro2::Span::call_site(),
+            "missing required `output` attribute",
+        )
+    })?;
+
+    Ok(XrpcAttrs {
+        nsid,
+        method,
+        output,
+        error,
+        server,
+    })
+}
+
+fn method_expr(method: &XrpcMethod) -> TokenStream {
+    match method {
+        XrpcMethod::Query => quote! { ::jacquard_common::xrpc::XrpcMethod::Query },
+        XrpcMethod::Procedure => {
+            quote! { ::jacquard_common::xrpc::XrpcMethod::Procedure("application/json") }
+        }
+    }
+}

crates/jacquard-lexicon/src/lib.rs

···
 //! - [`schema`] - Schema generation from Rust types (reverse codegen)
 //! - [`union_registry`] - Tracks union types for collision detection
 //! - [`fs`] - Filesystem utilities for lexicon storage
+//! - [`derive_impl`] - Implementation functions for derive macros (used by jacquard-derive)
 
 pub mod codegen;
 pub mod corpus;
+pub mod derive_impl;
 pub mod error;
 pub mod fs;
 pub mod lexicon;

crates/jacquard-lexicon/src/schema.rs

···
 pub mod builder;
 pub mod type_mapping;
 
-use crate::lexicon::{Lexicon, LexiconDoc, LexObjectProperty, LexRef, LexUserType};
+use crate::lexicon::{LexObjectProperty, LexRef, LexUserType, Lexicon, LexiconDoc};
 use jacquard_common::smol_str::SmolStr;
 use std::borrow::Cow;
 use std::collections::{BTreeMap, HashSet};

crates/jacquard/src/client/credential_session.rs

···
             .with_options(opts)
             .send(&RefreshSession)
             .await?;
-        let refresh = response
-            .parse()
-            .map_err(|_| ClientError::auth(AuthError::RefreshFailed)
+        let refresh = response.parse().map_err(|_| {
+            ClientError::auth(AuthError::RefreshFailed)
                 .with_help("ensure refresh token is valid and not expired")
-                .with_url("com.atproto.server.refreshSession"))?;
+                .with_url("com.atproto.server.refreshSession")
+        })?;
 
         let new_session: AtpSession = refresh.into();
         let token = AuthorizationToken::Bearer(new_session.access_jwt.clone());
-        self.store
-            .set(key, new_session)
-            .await
-            .map_err(|e| ClientError::from(e)
-                .with_context("failed to persist refreshed session to store"))?;
+        self.store.set(key, new_session).await.map_err(|e| {
+            ClientError::from(e).with_context("failed to persist refreshed session to store")
+        })?;
 
         Ok(token)
     }
···
         let pds = if identifier.as_ref().starts_with("http://")
             || identifier.as_ref().starts_with("https://")
         {
-            Url::parse(identifier.as_ref())
-                .map_err(|e: url::ParseError| ClientError::from(e)
-                    .with_help("identifier should be a valid https:// URL, handle, or DID"))?
+            Url::parse(identifier.as_ref()).map_err(|e: url::ParseError| {
+                ClientError::from(e)
+                    .with_help("identifier should be a valid https:// URL, handle, or DID")
+            })?
         } else if identifier.as_ref().starts_with("did:") {
-            let did = Did::new(identifier.as_ref())
-                .map_err(|e| ClientError::invalid_request(format!("invalid did: {:?}", e))
-                    .with_help("DID format should be did:method:identifier (e.g., did:plc:abc123)"))?;
-            let resp = self
-                .client
-                .resolve_did_doc(&did)
-                .await
-                .map_err(|e| ClientError::from(e)
-                    .with_context("DID document resolution failed during login"))?;
-            resp.into_owned()?
-                .pds_endpoint()
-                .ok_or_else(|| ClientError::invalid_request("missing PDS endpoint")
-                    .with_help("DID document must include a PDS service endpoint"))?
+            let did = Did::new(identifier.as_ref()).map_err(|e| {
+                ClientError::invalid_request(format!("invalid did: {:?}", e))
+                    .with_help("DID format should be did:method:identifier (e.g., did:plc:abc123)")
+            })?;
+            let resp = self.client.resolve_did_doc(&did).await.map_err(|e| {
+                ClientError::from(e).with_context("DID document resolution failed during login")
+            })?;
+            resp.into_owned()?.pds_endpoint().ok_or_else(|| {
+                ClientError::invalid_request("missing PDS endpoint")
+                    .with_help("DID document must include a PDS service endpoint")
+            })?
         } else {
             // treat as handle
-            let handle = jacquard_common::types::string::Handle::new(identifier.as_ref())
-                .map_err(|e| ClientError::invalid_request(format!("invalid handle: {:?}", e))
-                    .with_help("handle format should be domain.tld (e.g., alice.bsky.social)"))?;
-            let did = self
-                .client
-                .resolve_handle(&handle)
-                .await
-                .map_err(|e| ClientError::from(e)
-                    .with_context("handle resolution failed during login"))?;
-            let resp = self
-                .client
-                .resolve_did_doc(&did)
-                .await
-                .map_err(|e| ClientError::from(e)
-                    .with_context("DID document resolution failed during login"))?;
-            resp.into_owned()?
-                .pds_endpoint()
-                .ok_or_else(|| ClientError::invalid_request("missing PDS endpoint")
-                    .with_help("DID document must include a PDS service endpoint"))?
+            let handle =
+                jacquard_common::types::string::Handle::new(identifier.as_ref()).map_err(|e| {
+                    ClientError::invalid_request(format!("invalid handle: {:?}", e))
+                        .with_help("handle format should be domain.tld (e.g., alice.bsky.social)")
+                })?;
+            let did = self.client.resolve_handle(&handle).await.map_err(|e| {
+                ClientError::from(e).with_context("handle resolution failed during login")
+            })?;
+            let resp = self.client.resolve_did_doc(&did).await.map_err(|e| {
+                ClientError::from(e).with_context("DID document resolution failed during login")
+            })?;
+            resp.into_owned()?.pds_endpoint().ok_or_else(|| {
+                ClientError::invalid_request("missing PDS endpoint")
+                    .with_help("DID document must include a PDS service endpoint")
+            })?
         };
 
         // Build and send createSession
···
             auth_factor_token,
             identifier: identifier.clone().into_static(),
             password: password.into_static(),
-            extra_data: BTreeMap::new(),
+            extra_data: None,
         };
 
         let resp = self
···
             .with_options(self.options.read().await.clone())
             .send(&req)
             .await?;
-        let out = resp
-            .parse()
-            .map_err(|_| ClientError::auth(AuthError::NotAuthenticated)
+        let out = resp.parse().map_err(|_| {
+            ClientError::auth(AuthError::NotAuthenticated)
                 .with_help("check identifier and password are correct")
-                .with_url("com.atproto.server.createSession"))?;
+                .with_url("com.atproto.server.createSession")
+        })?;
         let session = AtpSession::from(out);
 
         let sid = session_id.unwrap_or_else(|| CowStr::new_static("session"));
···
         self.store
             .set(key.clone(), session.clone())
             .await
-            .map_err(|e| ClientError::from(e)
-                .with_context("failed to persist session to store"))?;
+            .map_err(|e| ClientError::from(e).with_context("failed to persist session to store"))?;
         // If using FileAuthStore, persist PDS for faster resume
         if let Some(file_store) =
             (&*self.store as &dyn Any).downcast_ref::<crate::client::token::FileAuthStore>()
···
             None
         }
         .unwrap_or({
-            let resp = self
-                .client
-                .resolve_did_doc(&did)
-                .await?;
-            resp.into_owned()?
-                .pds_endpoint()
-                .ok_or_else(|| ClientError::invalid_request("missing PDS endpoint")
-                    .with_help("DID document must include a PDS service endpoint"))?
+            let resp = self.client.resolve_did_doc(&did).await?;
+            resp.into_owned()?.pds_endpoint().ok_or_else(|| {
+                ClientError::invalid_request("missing PDS endpoint")
+                    .with_help("DID document must include a PDS service endpoint")
+            })?
         });
 
         // Activate
···
             None
         }
         .unwrap_or({
-            let resp = self
-                .client
-                .resolve_did_doc(&did)
-                .await?;
-            resp.into_owned()?
-                .pds_endpoint()
-                .ok_or_else(|| ClientError::invalid_request("missing PDS endpoint")
-                    .with_help("DID document must include a PDS service endpoint"))?
+            let resp = self.client.resolve_did_doc(&did).await?;
+            resp.into_owned()?.pds_endpoint().ok_or_else(|| {
+                ClientError::invalid_request("missing PDS endpoint")
+                    .with_help("DID document must include a PDS service endpoint")
+            })?
         });
         *self.key.write().await = Some(key.clone());
         *self.endpoint.write().await = Some(pds);
···
         let Some(key) = self.key.read().await.clone() else {
             return Ok(());
         };
-        self.store
-            .del(&key)
-            .await?;
+        self.store.del(&key).await?;
         *self.key.write().await = None;
         Ok(())
     }

crates/jacquard/src/moderation/tests.rs

···
         default_setting: Some(CowStr::from("hide")),
         adult_only: Some(false),
         locales: vec![],
-        extra_data: BTreeMap::new(),
+        extra_data: None,
     };
 
     defs.insert(labeler_did.clone(), vec![spam_def]);
···
         default_setting: Some(CowStr::from("hide")),
         adult_only: Some(false),
         locales: vec![],
-        extra_data: BTreeMap::new(),
+        extra_data: None,
     };
 
     defs.insert(labeler_did.clone(), vec![def]);
···
         default_setting: Some(CowStr::from("warn")),
         adult_only: Some(false),
         locales: vec![],
-        extra_data: BTreeMap::new(),
+        extra_data: None,
     };
 
     // Content blur
···
         default_setting: Some(CowStr::from("warn")),
         adult_only: Some(false),
         locales: vec![],
-        extra_data: BTreeMap::new(),
+        extra_data: None,
     };
 
     defs.insert(labeler_did.clone(), vec![media_def, content_def]);
···
         default_setting: Some(CowStr::from("warn")),
         adult_only: Some(true),
         locales: vec![],
-        extra_data: BTreeMap::new(),
+        extra_data: None,
     };
 
     defs.insert(labeler_did.clone(), vec![adult_def]);

crates/jacquard/src/richtext.rs

···
 
                     let feature = FacetFeaturesItem::Link(Box::new(Link {
                         uri: Uri::new_owned(&url)?,
-                        extra_data: BTreeMap::new(),
+                        extra_data: None,
                     }));
                     (display_range, feature)
                 }
···
 
                     let feature = FacetFeaturesItem::Mention(Box::new(Mention {
                         did,
-                        extra_data: BTreeMap::new(),
+                        extra_data: None,
                     }));
                     (range, feature)
                 }
···
 
                     let feature = FacetFeaturesItem::Link(Box::new(Link {
                         uri: Uri::new_owned(&url)?,
-                        extra_data: BTreeMap::new(),
+                        extra_data: None,
                     }));
                     (range, feature)
                 }
···
 
                     let feature = FacetFeaturesItem::Tag(Box::new(Tag {
                         tag: CowStr::from(tag.to_smolstr()),
-                        extra_data: BTreeMap::new(),
+                        extra_data: None,
                     }));
                     (range, feature)
                 }
···
                 index: ByteSlice {
                     byte_start: range.start as i64,
                     byte_end: range.end as i64,
-                    extra_data: BTreeMap::new(),
+                    extra_data: None,
                 },
                 features: vec![feature],
-                extra_data: BTreeMap::new(),
+                extra_data: None,
             });
 
             last_end = range.end;
···
 
                     let feature = FacetFeaturesItem::Link(Box::new(Link {
                         uri: crate::types::uri::Uri::new_owned(&url)?,
-                        extra_data: BTreeMap::new(),
+                        extra_data: None,
                     }));
                     (display_range, feature)
                 }
···
 
                     let feature = FacetFeaturesItem::Mention(Box::new(Mention {
                         did,
-                        extra_data: BTreeMap::new(),
+                        extra_data: None,
                     }));
                     (range, feature)
                 }
···
 
                     let feature = FacetFeaturesItem::Link(Box::new(Link {
                         uri: crate::types::uri::Uri::new_owned(&url)?,
-                        extra_data: BTreeMap::new(),
+                        extra_data: None,
                     }));
                     (range, feature)
                 }
···
 
                     let feature = FacetFeaturesItem::Tag(Box::new(Tag {
                         tag: CowStr::from(tag.to_smolstr()),
-                        extra_data: BTreeMap::new(),
+                        extra_data: None,
                     }));
                     (range, feature)
                 }
···
                 index: ByteSlice {
                     byte_start: range.start as i64,
                     byte_end: range.end as i64,
-                    extra_data: BTreeMap::new(),
+                    extra_data: None,
                 },
                 features: vec![feature],
-                extra_data: BTreeMap::new(),
+                extra_data: None,
             });
 
             last_end = range.end;