more cleanup

crates/jacquard-api/Cargo.toml

···
 bytes = { workspace = true, features = ["serde"] }
 jacquard-common = { version = "0.8", path = "../jacquard-common" }
 jacquard-derive = { version = "0.8", path = "../jacquard-derive" }
-jacquard-lexicon = { version = "0.8", path = "../jacquard-lexicon" }
+jacquard-lexicon = { version = "0.8", path = "../jacquard-lexicon", default-features = false }
 miette.workspace = true
 serde.workspace = true
 serde_ipld_dagcbor.workspace = true

crates/jacquard-derive/Cargo.toml

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

crates/jacquard-lexicon/Cargo.toml

···
 exclude.workspace = true
 license.workspace = true
 
+[features]
+default = ["codegen"]
+codegen = ["dep:prettyplease", "dep:syn", "dep:quote", "dep:proc-macro2", "dep:heck"]
+
 [dependencies]
 cid.workspace = true
 dashmap.workspace = true
-heck.workspace = true
+heck = { workspace = true, optional = true }
 inventory = "0.3"
 jacquard-common = { version = "0.8", path = "../jacquard-common" }
 miette = { workspace = true }
 multihash.workspace = true
-prettyplease.workspace = true
-proc-macro2.workspace = true
-quote.workspace = true
+prettyplease = { workspace = true, optional = true }
+proc-macro2 = { workspace = true, optional = true }
+quote = { workspace = true, optional = true }
 serde.workspace = true
 serde_ipld_dagcbor.workspace = true
 serde_json.workspace = true
 serde_repr.workspace = true
 serde_with.workspace = true
 sha2.workspace = true
-syn.workspace = true
+syn = { workspace = true, optional = true }
 thiserror.workspace = true
 unicode-segmentation = "1.12"
 

crates/jacquard-lexicon/src/codegen.rs

···
 use proc_macro2::TokenStream;
 use quote::quote;
 
-pub mod builder_heuristics;
-pub mod lifetime;
-pub mod names;
-pub mod nsid_utils;
-pub mod output;
-pub mod schema_impl;
-pub mod structs;
-pub mod types;
-pub mod union_codegen;
-pub mod utils;
-pub mod xrpc;
+pub(crate) mod builder_heuristics;
+pub(crate) mod lifetime;
+pub(crate) mod names;
+pub(crate) mod nsid_utils;
+pub(crate) mod output;
+pub(crate) mod schema_impl;
+pub(crate) mod structs;
+pub(crate) mod types;
+pub(crate) mod union_codegen;
+pub(crate) mod utils;
+pub(crate) mod xrpc;
 
 /// Code generator for lexicon types
 pub struct CodeGenerator<'c> {
···
         let shared_fn = if !generated.contains(nsid) {
             generated.insert(nsid.to_string());
             // Codegen from JSON doesn't have union_fields (those are for Rust -> lexicon derive)
-            let doc_literal = crate::derive_impl::doc_to_tokens::doc_to_tokens(lex_doc, &std::collections::BTreeMap::new());
+            let doc_literal = crate::derive_impl::doc_to_tokens::doc_to_tokens(
+                lex_doc,
+                &std::collections::BTreeMap::new(),
+            );
             Some(quote! {
                 fn #shared_fn_ident() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
                     #doc_literal
···
 
         // Extract validation checks for this specific def
         let validation_checks = schema_impl::extract_validation_checks(lex_doc, def_name);
-        let validation_code = crate::derive_impl::doc_to_tokens::validations_to_tokens(&validation_checks);
+        let validation_code =
+            crate::derive_impl::doc_to_tokens::validations_to_tokens(&validation_checks);
 
         let trait_impl = quote! {
             impl #impl_generics ::jacquard_lexicon::schema::LexiconSchema for #type_ident #type_generics {
···
             LexiconCorpus::load_from_dir("tests/fixtures/test_lexicons").expect("load corpus");
         let codegen = CodeGenerator::new(&corpus, "jacquard_api");
 
-        let doc = corpus
-            .get("app.bsky.embed.images")
-            .expect("get images");
+        let doc = corpus.get("app.bsky.embed.images").expect("get images");
         let def = doc.defs.get("viewImage").expect("get viewImage def");
 
         let tokens = codegen
···
             LexiconCorpus::load_from_dir("tests/fixtures/test_lexicons").expect("load corpus");
         let codegen = CodeGenerator::new(&corpus, "jacquard_api");
 
-        let doc = corpus
-            .get("test.array.types")
-            .expect("get array types");
+        let doc = corpus.get("test.array.types").expect("get array types");
         let def = doc.defs.get("main").expect("get main def");
 
         let tokens = codegen
···
             LexiconCorpus::load_from_dir("tests/fixtures/test_lexicons").expect("load corpus");
         let codegen = CodeGenerator::new(&corpus, "jacquard_api");
 
-        let doc = corpus
-            .get("test.binary.types")
-            .expect("get binary types");
+        let doc = corpus.get("test.binary.types").expect("get binary types");
         let def = doc.defs.get("main").expect("get main def");
 
         let tokens = codegen
···
             LexiconCorpus::load_from_dir("tests/fixtures/test_lexicons").expect("load corpus");
         let codegen = CodeGenerator::new(&corpus, "jacquard_api");
 
-        let doc = corpus
-            .get("test.empty.object")
-            .expect("get empty object");
+        let doc = corpus.get("test.empty.object").expect("get empty object");
         let def = doc.defs.get("emptyDef").expect("get emptyDef");
 
         let tokens = codegen
···
         let vote_file: syn::File = syn::parse2(vote_tokens).expect("parse vote tokens");
         let vote_formatted = prettyplease::unparse(&vote_file);
         println!("\nVote:\n{}\n", vote_formatted);
-        assert!(vote_formatted.contains("struct DefinitionVote") || vote_formatted.contains("struct Vote"));
+        assert!(
+            vote_formatted.contains("struct DefinitionVote")
+                || vote_formatted.contains("struct Vote")
+        );
         assert!(vote_formatted.contains("pub poll_ref"));
         assert!(vote_formatted.contains("pub option_index"));
     }
···
         // Local ref #option should resolve to DefinitionOption type (fully qualified or local)
         assert!(
             formatted.contains("Vec<DefinitionOption")
-                || formatted.contains("Vec<jacquard_api::pub_leaflet::poll::definition::DefinitionOption")
+                || formatted
+                    .contains("Vec<jacquard_api::pub_leaflet::poll::definition::DefinitionOption")
         );
     }
 
···
             LexiconCorpus::load_from_dir("tests/fixtures/test_lexicons").expect("load corpus");
         let codegen = CodeGenerator::new(&corpus, "jacquard_api");
 
-        let doc = corpus
-            .get("test.binary.types")
-            .expect("get binary types");
+        let doc = corpus.get("test.binary.types").expect("get binary types");
         let def = doc.defs.get("main").expect("get main def");
 
         let tokens = codegen

crates/jacquard-lexicon/src/codegen/nsid_utils.rs

···
 //! Utilities for parsing and working with NSIDs and refs
-
-/// Parsed NSID components for easier manipulation
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct NsidPath<'a> {
-    nsid: &'a str,
-    segments: Vec<&'a str>,
-}
-
-impl<'a> NsidPath<'a> {
-    /// Parse an NSID into its component segments
-    pub fn parse(nsid: &'a str) -> Self {
-        let segments: Vec<&str> = nsid.split('.').collect();
-        Self { nsid, segments }
-    }
-
-    /// Get the namespace (first two segments joined with '.')
-    /// Returns "com.atproto" from "com.atproto.repo.strongRef"
-    pub fn namespace(&self) -> String {
-        if self.segments.len() >= 2 {
-            format!("{}.{}", self.segments[0], self.segments[1])
-        } else {
-            self.nsid.to_string()
-        }
-    }
-
-    /// Get the last segment of the NSID
-    pub fn last_segment(&self) -> &str {
-        self.segments.last().copied().unwrap_or(self.nsid)
-    }
-
-    /// Get all segments except the last
-    pub fn parent_segments(&self) -> &[&str] {
-        if self.segments.is_empty() {
-            &[]
-        } else {
-            &self.segments[..self.segments.len() - 1]
-        }
-    }
-
-    /// Check if this is a "defs" NSID (ends with "defs")
-    pub fn is_defs(&self) -> bool {
-        self.last_segment() == "defs"
-    }
-
-    /// Get all segments
-    pub fn segments(&self) -> &[&str] {
-        &self.segments
-    }
-
-    /// Get the original NSID string
-    pub fn as_str(&self) -> &str {
-        self.nsid
-    }
-
-    /// Get number of segments
-    pub fn len(&self) -> usize {
-        self.segments.len()
-    }
-
-    /// Check if empty (should not happen with valid NSIDs)
-    pub fn is_empty(&self) -> bool {
-        self.segments.is_empty()
-    }
-}
-
-/// Parsed reference with NSID and optional fragment
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct RefPath<'a> {
-    nsid: &'a str,
-    def: &'a str,
-}
-
-impl<'a> RefPath<'a> {
-    /// Parse a reference string, normalizing it based on current NSID context
-    pub fn parse(ref_str: &'a str, current_nsid: Option<&'a str>) -> Self {
-        if let Some(fragment) = ref_str.strip_prefix('#') {
-            // Local ref: #option → use current_nsid
-            let nsid = current_nsid.unwrap_or("");
-            Self {
-                nsid,
-                def: fragment,
-            }
-        } else if let Some((nsid, def)) = ref_str.split_once('#') {
-            // Full ref with fragment: nsid#def
-            Self { nsid, def }
-        } else {
-            // Full ref without fragment: nsid (implicit "main")
-            Self {
-                nsid: ref_str,
-                def: "main",
-            }
-        }
-    }
-
-    /// Get the NSID portion of the ref
-    pub fn nsid(&self) -> &str {
-        self.nsid
-    }
-
-    /// Get the def name (fragment) portion of the ref
-    pub fn def(&self) -> &str {
-        self.def
-    }
-
-    /// Check if this is a local ref (was parsed from #fragment)
-    pub fn is_local(&self, current_nsid: &str) -> bool {
-        self.nsid == current_nsid && self.def != "main"
-    }
-
-    /// Get the full ref string (nsid#def)
-    pub fn full_ref(&self) -> String {
-        if self.def == "main" {
-            self.nsid.to_string()
-        } else {
-            format!("{}#{}", self.nsid, self.def)
-        }
-    }
-
-    /// Normalize a local ref by prepending the current NSID if needed
-    /// Returns the normalized ref string suitable for corpus lookup
-    pub fn normalize(ref_str: &str, current_nsid: &str) -> String {
-        if ref_str.starts_with('#') {
-            format!("{}{}", current_nsid, ref_str)
-        } else {
-            ref_str.to_string()
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
+//!
+//! Re-exports core ref parsing utilities from `crate::ref_utils`.
 
-    #[test]
-    fn test_nsid_path_parse() {
-        let path = NsidPath::parse("com.atproto.repo.strongRef");
-        assert_eq!(path.segments(), &["com", "atproto", "repo", "strongRef"]);
-        assert_eq!(path.namespace(), "com.atproto");
-        assert_eq!(path.last_segment(), "strongRef");
-        assert_eq!(path.parent_segments(), &["com", "atproto", "repo"]);
-        assert!(!path.is_defs());
-    }
-
-    #[test]
-    fn test_nsid_path_defs() {
-        let path = NsidPath::parse("com.atproto.label.defs");
-        assert!(path.is_defs());
-        assert_eq!(path.last_segment(), "defs");
-    }
-
-    #[test]
-    fn test_ref_path_local() {
-        let ref_path = RefPath::parse("#option", Some("com.example.foo"));
-        assert_eq!(ref_path.nsid(), "com.example.foo");
-        assert_eq!(ref_path.def(), "option");
-        assert!(ref_path.is_local("com.example.foo"));
-        assert_eq!(ref_path.full_ref(), "com.example.foo#option");
-    }
-
-    #[test]
-    fn test_ref_path_with_fragment() {
-        let ref_path = RefPath::parse("com.example.foo#bar", None);
-        assert_eq!(ref_path.nsid(), "com.example.foo");
-        assert_eq!(ref_path.def(), "bar");
-        assert!(!ref_path.is_local("com.other.baz"));
-        assert_eq!(ref_path.full_ref(), "com.example.foo#bar");
-    }
-
-    #[test]
-    fn test_ref_path_implicit_main() {
-        let ref_path = RefPath::parse("com.example.foo", None);
-        assert_eq!(ref_path.nsid(), "com.example.foo");
-        assert_eq!(ref_path.def(), "main");
-        assert_eq!(ref_path.full_ref(), "com.example.foo");
-    }
-
-    #[test]
-    fn test_ref_path_normalize() {
-        assert_eq!(
-            RefPath::normalize("#option", "com.example.foo"),
-            "com.example.foo#option"
-        );
-        assert_eq!(
-            RefPath::normalize("com.other.bar#baz", "com.example.foo"),
-            "com.other.bar#baz"
-        );
-    }
-}
+pub use crate::ref_utils::{NsidPath, RefPath};

crates/jacquard-lexicon/src/codegen/schema_impl.rs

···
 //! Generate LexiconSchema trait implementations for generated types
 
-use crate::derive_impl::doc_to_tokens;
 use crate::lexicon::{
-    LexInteger, LexObject, LexObjectProperty, LexRecordRecord, LexString,
-    LexUserType, LexiconDoc,
+    LexInteger, LexObject, LexObjectProperty, LexRecordRecord, LexString, LexUserType, LexiconDoc,
 };
 use crate::schema::from_ast::{ConstraintCheck, ValidationCheck};
-use proc_macro2::TokenStream;
-use quote::quote;
-
-/// Generate LexiconSchema impl for a generated type
-///
-/// Takes the original lexicon doc and type metadata to generate a complete
-/// impl with const literal and validation code.
-pub fn generate_schema_impl(
-    type_name: &str,
-    doc: &LexiconDoc,
-    def_name: &str,
-    has_lifetime: bool,
-) -> TokenStream {
-    let nsid = doc.id.as_ref();
-
-    // Generate lifetime parameter
-    let (impl_generics, type_generics) = if has_lifetime {
-        (quote! { <'a> }, quote! { <'a> })
-    } else {
-        (quote! {}, quote! {})
-    };
-
-    // Generate the lexicon doc literal using existing doc_to_tokens
-    // Codegen from JSON doesn't have union_fields (those are for Rust -> lexicon derive)
-    let doc_literal = doc_to_tokens::doc_to_tokens(doc, &std::collections::BTreeMap::new());
-
-    // Extract validation checks from lexicon doc for the specific def
-    let validation_checks = extract_validation_checks(doc, def_name);
-
-    // Generate validation code using existing validations_to_tokens
-    let validation_code = doc_to_tokens::validations_to_tokens(&validation_checks);
-
-    let type_ident = syn::Ident::new(type_name, proc_macro2::Span::call_site());
-
-    quote! {
-        impl #impl_generics ::jacquard_lexicon::schema::LexiconSchema for #type_ident #type_generics {
-            fn nsid() -> &'static str {
-                #nsid
-            }
-
-            fn def_name() -> &'static str {
-                #def_name
-            }
-
-            fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
-                #doc_literal
-            }
-
-            fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
-                #validation_code
-            }
-        }
-    }
-}
 
 /// Extract validation checks from a LexiconDoc
 ///
···
     // Get the specified def
     if let Some(def) = doc.defs.get(def_name) {
         match def {
-            LexUserType::Record(rec) => {
-                match &rec.record {
-                    LexRecordRecord::Object(obj) => {
-                        checks.extend(extract_object_validations(obj));
-                    }
+            LexUserType::Record(rec) => match &rec.record {
+                LexRecordRecord::Object(obj) => {
+                    checks.extend(extract_object_validations(obj));
                 }
-            }
+            },
             LexUserType::Object(obj) => {
                 checks.extend(extract_object_validations(obj));
             }
···
     use heck::ToSnakeCase;
     schema_name.to_snake_case()
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_field_name_from_schema() {
-        assert_eq!(field_name_from_schema("createdAt"), "created_at");
-        assert_eq!(field_name_from_schema("maxLength"), "max_length");
-        assert_eq!(field_name_from_schema("text"), "text");
-        assert_eq!(field_name_from_schema("ref"), "ref"); // r# added by make_ident later
-        assert_eq!(field_name_from_schema("type"), "type"); // r# added by make_ident later
-    }
-}

crates/jacquard-lexicon/src/corpus.rs

···
-use crate::codegen::nsid_utils::RefPath;
+use crate::ref_utils::RefPath;
 use crate::error::Result;
 use crate::lexicon::{LexUserType, LexiconDoc};
 use jacquard_common::{into_static::IntoStatic, smol_str::SmolStr};

crates/jacquard-lexicon/src/lib.rs

···
 //! - [`derive_impl`] - Implementation functions for derive macros (used by jacquard-derive)
 //! - [`validation`] - Runtime validation of Data against lexicon schemas
 
+#[cfg(feature = "codegen")]
 pub mod codegen;
+#[cfg(feature = "codegen")]
 pub mod corpus;
+#[cfg(feature = "codegen")]
+#[doc(hidden)]
 pub mod derive_impl;
+#[cfg(feature = "codegen")]
 pub mod error;
+#[cfg(feature = "codegen")]
 pub mod fs;
 pub mod lexicon;
+pub mod ref_utils;
 pub mod schema;
-pub mod union_registry;
 pub mod validation;

crates/jacquard-lexicon/src/ref_utils.rs

···
+//! Utilities for parsing and working with NSIDs and refs
+
+/// Parsed NSID components for easier manipulation
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct NsidPath<'a> {
+    nsid: &'a str,
+    segments: Vec<&'a str>,
+}
+
+impl<'a> NsidPath<'a> {
+    /// Parse an NSID into its component segments
+    pub fn parse(nsid: &'a str) -> Self {
+        let segments: Vec<&str> = nsid.split('.').collect();
+        Self { nsid, segments }
+    }
+
+    /// Get the namespace (first two segments joined with '.')
+    /// Returns "com.atproto" from "com.atproto.repo.strongRef"
+    pub fn namespace(&self) -> String {
+        if self.segments.len() >= 2 {
+            format!("{}.{}", self.segments[0], self.segments[1])
+        } else {
+            self.nsid.to_string()
+        }
+    }
+
+    /// Get the last segment of the NSID
+    pub fn last_segment(&self) -> &str {
+        self.segments.last().copied().unwrap_or(self.nsid)
+    }
+
+    /// Get all segments except the last
+    pub fn parent_segments(&self) -> &[&str] {
+        if self.segments.is_empty() {
+            &[]
+        } else {
+            &self.segments[..self.segments.len() - 1]
+        }
+    }
+
+    /// Check if this is a "defs" NSID (ends with "defs")
+    pub fn is_defs(&self) -> bool {
+        self.last_segment() == "defs"
+    }
+
+    /// Get all segments
+    pub fn segments(&self) -> &[&str] {
+        &self.segments
+    }
+
+    /// Get the original NSID string
+    pub fn as_str(&self) -> &str {
+        self.nsid
+    }
+
+    /// Get number of segments
+    pub fn len(&self) -> usize {
+        self.segments.len()
+    }
+
+    /// Check if empty (should not happen with valid NSIDs)
+    pub fn is_empty(&self) -> bool {
+        self.segments.is_empty()
+    }
+}
+
+/// Parsed reference with NSID and optional fragment
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RefPath<'a> {
+    nsid: &'a str,
+    def: &'a str,
+}
+
+impl<'a> RefPath<'a> {
+    /// Parse a reference string, normalizing it based on current NSID context
+    pub fn parse(ref_str: &'a str, current_nsid: Option<&'a str>) -> Self {
+        if let Some(fragment) = ref_str.strip_prefix('#') {
+            // Local ref: #option → use current_nsid
+            let nsid = current_nsid.unwrap_or("");
+            Self {
+                nsid,
+                def: fragment,
+            }
+        } else if let Some((nsid, def)) = ref_str.split_once('#') {
+            // Full ref with fragment: nsid#def
+            Self { nsid, def }
+        } else {
+            // Full ref without fragment: nsid (implicit "main")
+            Self {
+                nsid: ref_str,
+                def: "main",
+            }
+        }
+    }
+
+    /// Get the NSID portion of the ref
+    pub fn nsid(&self) -> &str {
+        self.nsid
+    }
+
+    /// Get the def name (fragment) portion of the ref
+    pub fn def(&self) -> &str {
+        self.def
+    }
+
+    /// Check if this is a local ref (was parsed from #fragment)
+    pub fn is_local(&self, current_nsid: &str) -> bool {
+        self.nsid == current_nsid && self.def != "main"
+    }
+
+    /// Get the full ref string (nsid#def)
+    pub fn full_ref(&self) -> String {
+        if self.def == "main" {
+            self.nsid.to_string()
+        } else {
+            format!("{}#{}", self.nsid, self.def)
+        }
+    }
+
+    /// Normalize a local ref by prepending the current NSID if needed
+    /// Returns the normalized ref string suitable for corpus lookup
+    pub fn normalize(ref_str: &str, current_nsid: &str) -> String {
+        if ref_str.starts_with('#') {
+            format!("{}{}", current_nsid, ref_str)
+        } else {
+            ref_str.to_string()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_nsid_path_parse() {
+        let path = NsidPath::parse("com.atproto.repo.strongRef");
+        assert_eq!(path.segments(), &["com", "atproto", "repo", "strongRef"]);
+        assert_eq!(path.namespace(), "com.atproto");
+        assert_eq!(path.last_segment(), "strongRef");
+        assert_eq!(path.parent_segments(), &["com", "atproto", "repo"]);
+        assert!(!path.is_defs());
+    }
+
+    #[test]
+    fn test_nsid_path_defs() {
+        let path = NsidPath::parse("com.atproto.label.defs");
+        assert!(path.is_defs());
+        assert_eq!(path.last_segment(), "defs");
+    }
+
+    #[test]
+    fn test_ref_path_local() {
+        let ref_path = RefPath::parse("#option", Some("com.example.foo"));
+        assert_eq!(ref_path.nsid(), "com.example.foo");
+        assert_eq!(ref_path.def(), "option");
+        assert!(ref_path.is_local("com.example.foo"));
+        assert_eq!(ref_path.full_ref(), "com.example.foo#option");
+    }
+
+    #[test]
+    fn test_ref_path_with_fragment() {
+        let ref_path = RefPath::parse("com.example.foo#bar", None);
+        assert_eq!(ref_path.nsid(), "com.example.foo");
+        assert_eq!(ref_path.def(), "bar");
+        assert!(!ref_path.is_local("com.other.baz"));
+        assert_eq!(ref_path.full_ref(), "com.example.foo#bar");
+    }
+
+    #[test]
+    fn test_ref_path_implicit_main() {
+        let ref_path = RefPath::parse("com.example.foo", None);
+        assert_eq!(ref_path.nsid(), "com.example.foo");
+        assert_eq!(ref_path.def(), "main");
+        assert_eq!(ref_path.full_ref(), "com.example.foo");
+    }
+
+    #[test]
+    fn test_ref_path_normalize() {
+        assert_eq!(
+            RefPath::normalize("#option", "com.example.foo"),
+            "com.example.foo#option"
+        );
+        assert_eq!(
+            RefPath::normalize("com.other.bar#baz", "com.example.foo"),
+            "com.other.bar#baz"
+        );
+    }
+}

crates/jacquard-lexicon/src/schema.rs

···
 //! - **Validation**: Runtime constraint checking via `validate()` method
 
 pub mod builder;
+#[cfg(feature = "codegen")]
 pub mod from_ast;
+#[cfg(feature = "codegen")]
 pub mod type_mapping;
 
 use crate::lexicon::LexiconDoc;

crates/jacquard-lexicon/src/union_registry.rs

···
-use crate::corpus::LexiconCorpus;
-use crate::lexicon::{
-    LexArrayItem, LexObjectProperty, LexUserType, LexXrpcBodySchema,
-    LexXrpcSubscriptionMessageSchema,
-};
-use jacquard_common::smol_str::{SmolStr, ToSmolStr};
-use jacquard_common::{CowStr, smol_str};
-use std::collections::{BTreeMap, BTreeSet};
-
-/// Information about a single union type found in the corpus
-#[derive(Debug, Clone)]
-pub struct UnionInfo {
-    /// NSID of the lexicon containing this union
-    pub lexicon_nsid: SmolStr,
-    /// Name of the def containing this union (e.g., "main", "replyRef")
-    pub def_name: SmolStr,
-    /// Field path within the def (e.g., "embed", "properties.embed")
-    pub field_path: CowStr<'static>,
-    /// Refs that exist in the corpus
-    pub known_refs: Vec<CowStr<'static>>,
-    /// Refs that don't exist in the corpus
-    pub unknown_refs: Vec<CowStr<'static>>,
-    /// Whether the union is closed (default true if not specified)
-    pub closed: bool,
-}
-
-impl UnionInfo {
-    /// Get the source text for this union's lexicon from the corpus
-    pub fn get_source<'c>(&self, corpus: &'c LexiconCorpus) -> Option<&'c str> {
-        corpus.get_source(&self.lexicon_nsid)
-    }
-
-    /// Check if this union has any unknown refs
-    pub fn has_unknown_refs(&self) -> bool {
-        !self.unknown_refs.is_empty()
-    }
-
-    /// Get all refs (known + unknown)
-    pub fn all_refs(&self) -> impl Iterator<Item = &CowStr<'static>> {
-        self.known_refs.iter().chain(self.unknown_refs.iter())
-    }
-}
-
-/// Registry of all union types found in the corpus
-#[derive(Debug, Clone)]
-pub struct UnionRegistry {
-    /// Map from union identifier to union info
-    /// Key is "{lexicon_nsid}#{def_name}:{field_path}"
-    unions: BTreeMap<SmolStr, UnionInfo>,
-}
-
-impl UnionRegistry {
-    /// Create a new empty union registry
-    pub fn new() -> Self {
-        Self {
-            unions: BTreeMap::new(),
-        }
-    }
-
-    /// Build a union registry from a corpus
-    pub fn from_corpus(corpus: &LexiconCorpus) -> Self {
-        let mut registry = Self::new();
-
-        for (nsid, doc) in corpus.iter() {
-            for (def_name, def) in &doc.defs {
-                registry.collect_unions_from_def(corpus, nsid, def_name, def);
-            }
-        }
-
-        registry
-    }
-
-    /// Collect unions from a single def
-    fn collect_unions_from_def(
-        &mut self,
-        corpus: &LexiconCorpus,
-        nsid: &SmolStr,
-        def_name: &SmolStr,
-        def: &LexUserType<'static>,
-    ) {
-        match def {
-            LexUserType::Record(record) => match &record.record {
-                crate::lexicon::LexRecordRecord::Object(obj) => {
-                    self.collect_unions_from_object(corpus, nsid, def_name, "", obj);
-                }
-            },
-            LexUserType::Object(obj) => {
-                self.collect_unions_from_object(corpus, nsid, def_name, "", obj);
-            }
-            LexUserType::XrpcQuery(query) => {
-                if let Some(output) = &query.output {
-                    if let Some(schema) = &output.schema {
-                        self.collect_unions_from_xrpc_body_schema(
-                            corpus, nsid, def_name, "output", schema,
-                        );
-                    }
-                }
-            }
-            LexUserType::XrpcProcedure(proc) => {
-                if let Some(input) = &proc.input {
-                    if let Some(schema) = &input.schema {
-                        self.collect_unions_from_xrpc_body_schema(
-                            corpus, nsid, def_name, "input", schema,
-                        );
-                    }
-                }
-                if let Some(output) = &proc.output {
-                    if let Some(schema) = &output.schema {
-                        self.collect_unions_from_xrpc_body_schema(
-                            corpus, nsid, def_name, "output", schema,
-                        );
-                    }
-                }
-            }
-            LexUserType::XrpcSubscription(sub) => {
-                if let Some(message) = &sub.message {
-                    if let Some(schema) = &message.schema {
-                        self.collect_unions_from_subscription_message_schema(
-                            corpus, nsid, def_name, "message", schema,
-                        );
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-
-    /// Collect unions from an object's properties
-    fn collect_unions_from_object(
-        &mut self,
-        corpus: &LexiconCorpus,
-        nsid: &SmolStr,
-        def_name: &SmolStr,
-        path_prefix: &str,
-        obj: &crate::lexicon::LexObject<'static>,
-    ) {
-        for (prop_name, prop) in &obj.properties {
-            let prop_path = if path_prefix.is_empty() {
-                prop_name.to_smolstr()
-            } else {
-                smol_str::format_smolstr!("{}.{}", path_prefix, prop_name)
-            };
-
-            match prop {
-                LexObjectProperty::Union(union) => {
-                    self.register_union(
-                        corpus,
-                        nsid,
-                        def_name,
-                        &prop_path,
-                        &union.refs,
-                        union.closed,
-                    );
-                }
-                LexObjectProperty::Array(array) => {
-                    if let LexArrayItem::Union(union) = &array.items {
-                        let array_path = format!("{}[]", prop_path);
-                        self.register_union(
-                            corpus,
-                            nsid,
-                            def_name,
-                            &array_path,
-                            &union.refs,
-                            union.closed,
-                        );
-                    }
-                }
-                LexObjectProperty::Ref(ref_type) => {
-                    // Check if ref points to a union
-                    if let Some((_, ref_def)) = corpus.resolve_ref(ref_type.r#ref.as_ref()) {
-                        if matches!(ref_def, LexUserType::Object(_)) {
-                            // Recursively check the referenced object
-                            // (we'll handle this in a future iteration if needed)
-                        }
-                    }
-                }
-                _ => {}
-            }
-        }
-    }
-
-    /// Collect unions from XRPC body schema
-    fn collect_unions_from_xrpc_body_schema(
-        &mut self,
-        corpus: &LexiconCorpus,
-        nsid: &SmolStr,
-        def_name: &SmolStr,
-        path: &str,
-        schema: &LexXrpcBodySchema<'static>,
-    ) {
-        match schema {
-            LexXrpcBodySchema::Union(union) => {
-                self.register_union(corpus, nsid, def_name, path, &union.refs, union.closed);
-            }
-            LexXrpcBodySchema::Object(obj) => {
-                self.collect_unions_from_object(corpus, nsid, def_name, path, obj);
-            }
-            _ => {}
-        }
-    }
-
-    /// Collect unions from subscription message schema
-    fn collect_unions_from_subscription_message_schema(
-        &mut self,
-        corpus: &LexiconCorpus,
-        nsid: &SmolStr,
-        def_name: &SmolStr,
-        path: &str,
-        schema: &LexXrpcSubscriptionMessageSchema<'static>,
-    ) {
-        match schema {
-            LexXrpcSubscriptionMessageSchema::Union(union) => {
-                self.register_union(corpus, nsid, def_name, path, &union.refs, union.closed);
-            }
-            LexXrpcSubscriptionMessageSchema::Object(obj) => {
-                self.collect_unions_from_object(corpus, nsid, def_name, path, obj);
-            }
-            _ => {}
-        }
-    }
-
-    /// Register a union with the registry
-    fn register_union(
-        &mut self,
-        corpus: &LexiconCorpus,
-        nsid: &SmolStr,
-        def_name: &SmolStr,
-        field_path: &str,
-        refs: &[jacquard_common::CowStr<'static>],
-        closed: Option<bool>,
-    ) {
-        let mut known_refs = Vec::new();
-        let mut unknown_refs = Vec::new();
-
-        for ref_str in refs {
-            if corpus.ref_exists(&ref_str) {
-                known_refs.push(ref_str.clone());
-            } else {
-                unknown_refs.push(ref_str.clone());
-            }
-        }
-
-        let key = smol_str::format_smolstr!("{}#{}:{}", nsid, def_name, field_path);
-        self.unions.insert(
-            key,
-            UnionInfo {
-                lexicon_nsid: nsid.clone(),
-                def_name: def_name.clone(),
-                field_path: CowStr::Owned(field_path.to_smolstr()),
-                known_refs,
-                unknown_refs,
-                closed: closed.unwrap_or(true),
-            },
-        );
-    }
-
-    /// Get all unions
-    pub fn iter(&self) -> impl Iterator<Item = (&SmolStr, &UnionInfo)> {
-        self.unions.iter()
-    }
-
-    /// Get a specific union
-    pub fn get(&self, key: &str) -> Option<&UnionInfo> {
-        self.unions.get(key)
-    }
-
-    /// Number of unions in registry
-    pub fn len(&self) -> usize {
-        self.unions.len()
-    }
-
-    /// Check if registry is empty
-    pub fn is_empty(&self) -> bool {
-        self.unions.is_empty()
-    }
-
-    /// Get all unique refs across all unions
-    pub fn all_refs(&self) -> BTreeSet<CowStr<'static>> {
-        let mut refs = BTreeSet::new();
-        for union in self.unions.values() {
-            refs.extend(union.known_refs.iter().cloned());
-            refs.extend(union.unknown_refs.iter().cloned());
-        }
-        refs
-    }
-}
-
-impl Default for UnionRegistry {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_union_registry_from_corpus() {
-        let corpus = LexiconCorpus::load_from_dir("tests/fixtures/test_lexicons")
-            .expect("failed to load lexicons");
-
-        let registry = UnionRegistry::from_corpus(&corpus);
-
-        assert!(!registry.is_empty());
-
-        // Check that we found the embed union in post
-        let post_embed = registry
-            .iter()
-            .find(|(_, info)| {
-                info.lexicon_nsid == "app.bsky.feed.post"
-                    && info.def_name == "main"
-                    && info.field_path.contains("embed")
-            })
-            .expect("should find post embed union");
-
-        let info = post_embed.1;
-        assert!(info.known_refs.contains(&"app.bsky.embed.images".into()));
-        assert!(info.known_refs.contains(&"app.bsky.embed.video".into()));
-        assert!(info.known_refs.contains(&"app.bsky.embed.external".into()));
-    }
-
-    #[test]
-    fn test_union_registry_tracks_unknown_refs() {
-        let corpus = LexiconCorpus::load_from_dir("tests/fixtures/test_lexicons")
-            .expect("failed to load lexicons");
-
-        let registry = UnionRegistry::from_corpus(&corpus);
-
-        // If there are any unknown refs, they should be tracked
-        for (_, info) in registry.iter() {
-            for unknown in &info.unknown_refs {
-                assert!(!corpus.ref_exists(unknown));
-            }
-        }
-    }
-}

crates/jacquard-lexicon/src/validation.rs

···
 //! This module provides infrastructure for validating untyped `Data` values against
 //! lexicon schemas, enabling partial deserialization, debugging, and schema migration.
 
-use crate::codegen::nsid_utils::RefPath;
 use crate::lexicon::{LexArrayItem, LexObjectProperty};
+use crate::ref_utils::RefPath;
 use crate::schema::SchemaRegistry;
 use cid::Cid as IpldCid;
 use dashmap::DashMap;