lexicon extraction binary

Cargo.lock

···
 
 [[package]]
 name = "cc"
-version = "1.2.41"
+version = "1.2.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac9fe6cdbb24b6ade63616c0a0688e45bb56732262c158df3c0c4bea4ca47cb7"
+checksum = "739eb0f94557554b3ca9a86d2d37bebd49c5e6d0c1d2bda35ba5bdac830befc2"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
···
 
 [[package]]
 name = "deranged"
-version = "0.5.4"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a41953f86f8a05768a6cda24def994fd2f424b04ec5c719cf89989779f199071"
+checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587"
 dependencies = [
  "powerfmt",
  "serde_core",
···
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "flate2"
-version = "1.1.4"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc5a4e564e38c699f2880d3fda590bedc2e69f3f84cd48b457bd892ce61d0aa9"
+checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb"
 dependencies = [
  "crc32fast",
  "miniz_oxide 0.8.9",
···
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.6.1",
+ "socket2 0.5.10",
  "system-configuration",
  "tokio",
  "tower-service",
···
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.62.2",
+ "windows-core",
 ]
 
 [[package]]
···
 [[package]]
 name = "jacquard-api"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#b8978f162ed3306519ec3155a5fd01fbda2390a3"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#4c31392df7f719950dabd64ef8e7c9cf84ba4212"
 dependencies = [
  "bon",
  "bytes",
···
 [[package]]
 name = "jacquard-common"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#b8978f162ed3306519ec3155a5fd01fbda2390a3"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#4c31392df7f719950dabd64ef8e7c9cf84ba4212"
 dependencies = [
  "base64 0.22.1",
  "bon",
···
 [[package]]
 name = "jacquard-derive"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#b8978f162ed3306519ec3155a5fd01fbda2390a3"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#4c31392df7f719950dabd64ef8e7c9cf84ba4212"
 dependencies = [
+ "heck 0.5.0",
+ "jacquard-lexicon 0.8.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",
  "proc-macro2",
  "quote",
  "syn 2.0.108",
···
 [[package]]
 name = "jacquard-identity"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#b8978f162ed3306519ec3155a5fd01fbda2390a3"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#4c31392df7f719950dabd64ef8e7c9cf84ba4212"
 dependencies = [
  "bon",
  "bytes",
···
  "clap_complete",
  "clap_mangen",
  "glob",
+ "inventory",
  "jacquard-api 0.8.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",
  "jacquard-common 0.8.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",
+ "jacquard-derive 0.8.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",
  "jacquard-identity 0.8.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",
  "jacquard-lexicon 0.8.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",
  "kdl",
···
 [[package]]
 name = "jacquard-lexicon"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#b8978f162ed3306519ec3155a5fd01fbda2390a3"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#4c31392df7f719950dabd64ef8e7c9cf84ba4212"
 dependencies = [
- "async-trait",
- "clap",
- "clap_complete",
- "clap_mangen",
  "glob",
  "heck 0.5.0",
- "jacquard-api 0.8.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",
+ "inventory",
  "jacquard-common 0.8.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",
- "jacquard-identity 0.8.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",
- "kdl",
  "miette",
  "prettyplease",
  "proc-macro2",
  "quote",
- "reqwest",
  "serde",
  "serde_json",
  "serde_repr",
  "serde_with",
  "syn 2.0.108",
- "tempfile",
  "thiserror 2.0.17",
- "tokio",
+ "unicode-segmentation",
  "walkdir",
 ]
 
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
···
  "quinn-udp",
  "rustc-hash",
  "rustls",
- "socket2 0.6.1",
+ "socket2 0.5.10",
  "thiserror 2.0.17",
  "tokio",
  "tracing",
···
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.6.1",
+ "socket2 0.5.10",
  "tracing",
- "windows-sys 0.60.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
···
  "errno",
  "libc",
  "linux-raw-sys 0.11.0",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
···
  "getrandom 0.3.4",
  "once_cell",
  "rustix 1.1.2",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
···
 checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
 dependencies = [
  "windows-collections",
- "windows-core 0.61.2",
+ "windows-core",
  "windows-future",
  "windows-link 0.1.3",
  "windows-numerics",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
 dependencies = [
- "windows-core 0.61.2",
+ "windows-core",
 ]
 
 [[package]]
···
  "windows-implement",
  "windows-interface",
  "windows-link 0.1.3",
- "windows-result 0.3.4",
- "windows-strings 0.4.2",
-]
-
-[[package]]
-name = "windows-core"
-version = "0.62.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
-dependencies = [
- "windows-implement",
- "windows-interface",
- "windows-link 0.2.1",
- "windows-result 0.4.1",
- "windows-strings 0.5.1",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
 dependencies = [
- "windows-core 0.61.2",
+ "windows-core",
  "windows-link 0.1.3",
  "windows-threading",
 ]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
 dependencies = [
- "windows-core 0.61.2",
+ "windows-core",
  "windows-link 0.1.3",
 ]
 
···
 checksum = "5b8a9ed28765efc97bbc954883f4e6796c33a06546ebafacbabee9696967499e"
 dependencies = [
  "windows-link 0.1.3",
- "windows-result 0.3.4",
- "windows-strings 0.4.2",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "windows-result"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
-dependencies = [
- "windows-link 0.2.1",
-]
-
-[[package]]
 name = "windows-strings"
 version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
 dependencies = [
  "windows-link 0.1.3",
-]
-
-[[package]]
-name = "windows-strings"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
-dependencies = [
- "windows-link 0.2.1",
 ]
 
 [[package]]

crates/jacquard-derive/tests/lexicon_schema_derive.rs

···
     #[derive(LexiconSchema)]
     #[lexicon(nsid = "com.example.simple", record, key = "tid")]
     struct SimpleRecord<'a> {
+        #[allow(dead_code)]
         pub text: CowStr<'a>,
+        #[allow(dead_code)]
         pub created_at: Datetime,
     }
 
···
     #[derive(LexiconSchema)]
     #[lexicon(nsid = "com.example.camel", record)]
     struct CamelCaseRecord {
+        #[allow(dead_code)]
         pub field_one: i64,
+        #[allow(dead_code)]
         pub field_two: i64,
     }
 
···
     #[lexicon(nsid = "com.example.union")]
     enum BasicUnion {
         #[nsid = "com.example.variant.one"]
+        #[allow(dead_code)]
         VariantOne,
 
         #[nsid = "com.example.variant.two"]
+        #[allow(dead_code)]
         VariantTwo,
     }
 
···
     #[open_union]
     enum OpenUnion<'a> {
         #[nsid = "com.example.variant"]
+        #[allow(dead_code)]
         Variant,
 
+        #[allow(dead_code)]
         Unknown(jacquard_common::types::value::Data<'a>),
     }
 
···
     #[lexicon(nsid = "com.example.fragments")]
     enum FragmentUnion {
         // Should generate com.example.fragments#variantOne
+        #[allow(dead_code)]
         VariantOne,
         // Should generate com.example.fragments#variantTwo
+        #[allow(dead_code)]
         VariantTwo,
     }
 

crates/jacquard-lexgen/Cargo.toml

···
 name = "lex-fetch"
 path = "src/bin/lex_fetch.rs"
 
+[[bin]]
+name = "extract-schemas"
+path = "src/bin/extract_schemas.rs"
+
 [dependencies]
 async-trait = "0.1"
 clap.workspace = true
 glob = "0.3"
+inventory = "0.3"
 jacquard-api = { version = "0.8", git = "https://tangled.org/@nonbinary.computer/jacquard" }
 jacquard-common = { version = "0.8", features = [ "reqwest-client" ], git = "https://tangled.org/@nonbinary.computer/jacquard" }
+jacquard-derive = { version = "0.8", git = "https://tangled.org/@nonbinary.computer/jacquard" }
 jacquard-identity = { version = "0.8", git = "https://tangled.org/@nonbinary.computer/jacquard" }
 jacquard-lexicon = { version = "0.8",  git = "https://tangled.org/@nonbinary.computer/jacquard" }
 kdl = "6"

crates/jacquard-lexgen/src/bin/extract_schemas.rs

···
+use clap::Parser;
+use jacquard_lexgen::schema_extraction::{ExtractOptions, SchemaExtractor};
+use miette::Result;
+
+/// Extract lexicon schemas from compiled Rust types
+#[derive(Parser, Debug)]
+#[command(name = "extract-schemas")]
+#[command(about = "Extract AT Protocol lexicon schemas from Rust types")]
+struct Args {
+    /// Output directory for generated schema files
+    #[arg(short, long, default_value = "lexicons")]
+    output: String,
+
+    /// Verbose output
+    #[arg(short, long)]
+    verbose: bool,
+
+    /// Filter by NSID prefix (e.g., "app.bsky")
+    #[arg(short, long)]
+    filter: Option<String>,
+
+    /// Validate schemas before writing
+    #[arg(short = 'V', long, default_value = "true")]
+    validate: bool,
+
+    /// Pretty-print JSON output
+    #[arg(short, long, default_value = "true")]
+    pretty: bool,
+
+    /// Watch mode - regenerate on changes
+    #[arg(short, long)]
+    watch: bool,
+}
+
+fn main() -> Result<()> {
+    let args = Args::parse();
+
+    let options = ExtractOptions {
+        output_dir: args.output.into(),
+        verbose: args.verbose,
+        filter: args.filter,
+        validate: args.validate,
+        pretty: args.pretty,
+    };
+
+    let extractor = SchemaExtractor::new(options);
+
+    if args.watch {
+        extractor.watch()?;
+    } else {
+        extractor.extract_all()?;
+    }
+
+    Ok(())
+}

crates/jacquard-lexgen/src/lib.rs

···
 //!
 //! - [`fetch`] - Ingests lexicons from git, atproto, http fetch, and other sources
 //! - [`cli`] - CLI argument parsing utilities
+//! - [`schema_extraction`] - Extract lexicon schemas from Rust types via inventory
 
 pub mod cli;
 pub mod fetch;
+pub mod schema_extraction;
+#[cfg(any(test, debug_assertions))]
+pub mod test_schemas;
 
 pub use fetch::{Config, Fetcher};

crates/jacquard-lexgen/src/schema_extraction.rs

···
+use jacquard_lexicon::lexicon::LexiconDoc;
+use jacquard_lexicon::schema::LexiconSchemaRef;
+use miette::{IntoDiagnostic, Result};
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::PathBuf;
+
+pub struct ExtractOptions {
+    pub output_dir: PathBuf,
+    pub verbose: bool,
+    pub filter: Option<String>,
+    pub validate: bool,
+    pub pretty: bool,
+}
+
+pub struct SchemaExtractor {
+    options: ExtractOptions,
+}
+
+impl SchemaExtractor {
+    pub fn new(options: ExtractOptions) -> Self {
+        Self { options }
+    }
+
+    /// Extract all schemas from inventory
+    pub fn extract_all(&self) -> Result<()> {
+        if self.options.verbose {
+            println!("Discovering schemas via inventory...");
+        }
+
+        // Collect all schema refs from inventory
+        let refs: Vec<&LexiconSchemaRef> = inventory::iter::<LexiconSchemaRef>().collect();
+
+        if self.options.verbose {
+            println!("Found {} schema types", refs.len());
+        }
+
+        // Group by base NSID
+        let grouped = self.group_by_base_nsid(&refs)?;
+
+        // Create output directory
+        fs::create_dir_all(&self.options.output_dir).into_diagnostic()?;
+
+        // Process each group
+        let mut written = 0;
+        for (base_nsid, group_refs) in grouped {
+            // Apply filter if specified
+            if let Some(filter) = &self.options.filter {
+                if !base_nsid.starts_with(filter) {
+                    continue;
+                }
+            }
+
+            if self.options.verbose {
+                println!("Processing {} ({} types)", base_nsid, group_refs.len());
+            }
+
+            self.write_lexicon(&base_nsid, &group_refs)?;
+            written += 1;
+        }
+
+        println!(
+            "✓ Wrote {} lexicon files to {}",
+            written,
+            self.options.output_dir.display()
+        );
+
+        Ok(())
+    }
+
+    /// Group refs by base NSID (strip fragment suffix)
+    fn group_by_base_nsid<'a>(
+        &self,
+        refs: &[&'a LexiconSchemaRef],
+    ) -> Result<BTreeMap<String, Vec<&'a LexiconSchemaRef>>> {
+        let mut groups: BTreeMap<String, Vec<&'a LexiconSchemaRef>> = BTreeMap::new();
+
+        for schema_ref in refs {
+            let nsid = schema_ref.nsid;
+
+            // Split on # to get base NSID
+            let base_nsid = if let Some(pos) = nsid.find('#') {
+                &nsid[..pos]
+            } else {
+                nsid
+            };
+
+            groups
+                .entry(base_nsid.to_string())
+                .or_default()
+                .push(schema_ref);
+        }
+
+        Ok(groups)
+    }
+
+    /// Write a single lexicon file
+    fn write_lexicon(&self, base_nsid: &str, refs: &[&LexiconSchemaRef]) -> Result<()> {
+        // Generate all schemas in this group
+        let mut all_defs = BTreeMap::new();
+        let mut primary_doc: Option<LexiconDoc> = None;
+
+        for schema_ref in refs {
+            let doc = (schema_ref.provider)();
+
+            // Determine if this is the primary def or a fragment
+            if schema_ref.nsid.contains('#') {
+                // Fragment - extract def name and add to defs
+                let fragment_name = schema_ref.nsid.split('#').nth(1).unwrap();
+
+                // Merge defs from fragment doc
+                for (def_name, def) in doc.defs {
+                    // Use fragment name if def is "main", otherwise use as-is
+                    let final_name = if def_name == "main" {
+                        fragment_name.to_string()
+                    } else {
+                        def_name.to_string()
+                    };
+                    all_defs.insert(final_name, def);
+                }
+            } else {
+                // Primary type - use as base doc
+                primary_doc = Some(doc);
+            }
+        }
+
+        // Build final doc
+        let mut final_doc = primary_doc.unwrap_or_else(|| {
+            // No primary doc - create one
+            use jacquard_lexicon::lexicon::Lexicon;
+            LexiconDoc {
+                lexicon: Lexicon::Lexicon1,
+                id: base_nsid.into(),
+                revision: None,
+                description: None,
+                defs: BTreeMap::new(),
+            }
+        });
+
+        // Merge in all defs (convert String keys to SmolStr)
+        for (k, v) in all_defs {
+            final_doc.defs.insert(k.into(), v);
+        }
+
+        // Validate if requested
+        if self.options.validate {
+            self.validate_schema(&final_doc)?;
+        }
+
+        // Serialize to JSON
+        let json = if self.options.pretty {
+            serde_json::to_string_pretty(&final_doc).into_diagnostic()?
+        } else {
+            serde_json::to_string(&final_doc).into_diagnostic()?
+        };
+
+        // Write to file
+        let filename = base_nsid.replace('.', "_") + ".json";
+        let path = self.options.output_dir.join(&filename);
+
+        fs::write(&path, json).into_diagnostic()?;
+
+        if self.options.verbose {
+            println!("  Wrote {} ({} defs)", filename, final_doc.defs.len());
+        }
+
+        Ok(())
+    }
+
+    /// Validate a schema document
+    fn validate_schema(&self, doc: &LexiconDoc) -> Result<()> {
+        // Must have at least one def
+        if doc.defs.is_empty() {
+            return Err(miette::miette!("lexicon {} has no defs", doc.id));
+        }
+
+        // Warn if no "main" def and doesn't follow .defs convention
+        if !doc.defs.contains_key("main") {
+            let id_str = doc.id.as_ref();
+            if !id_str.ends_with(".defs") {
+                eprintln!(
+                    "⚠️  Warning: lexicon {} has no 'main' def - consider naming it {}.defs",
+                    id_str, id_str
+                );
+                if self.options.verbose {
+                    eprintln!(
+                        "   Lexicons without a primary type should use the .defs suffix (e.g., app.bsky.actor.defs)"
+                    );
+                }
+            }
+        }
+
+        // Validate NSID format
+        if !is_valid_nsid(&doc.id) {
+            return Err(miette::miette!("invalid NSID format: {}", doc.id));
+        }
+
+        Ok(())
+    }
+
+    /// Watch mode - regenerate on file changes
+    pub fn watch(&self) -> Result<()> {
+        println!("Watch mode not yet implemented");
+        println!("Run with --help to see available options");
+        Ok(())
+    }
+}
+
+/// Validate NSID format: domain.name.record
+fn is_valid_nsid(nsid: &str) -> bool {
+    let parts: Vec<&str> = nsid.split('.').collect();
+
+    // Must have at least 3 parts
+    if parts.len() < 3 {
+        return false;
+    }
+
+    // Each part must be valid
+    for part in parts {
+        if part.is_empty() {
+            return false;
+        }
+
+        // Must be alphanumeric, hyphens, or underscores
+        if !part
+            .chars()
+            .all(|c| c.is_alphanumeric() || c == '-' || c == '_')
+        {
+            return false;
+        }
+    }
+
+    true
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_is_valid_nsid() {
+        assert!(is_valid_nsid("com.example.test"));
+        assert!(is_valid_nsid("app.bsky.feed.post"));
+        assert!(is_valid_nsid("com.example.with_underscore"));
+        assert!(is_valid_nsid("com.example.with-hyphen"));
+
+        assert!(!is_valid_nsid("com.example")); // Too short
+        assert!(!is_valid_nsid("com")); // Too short
+        assert!(!is_valid_nsid("com.example.invalid!")); // Invalid char
+        assert!(!is_valid_nsid("com..example")); // Empty segment
+    }
+
+    #[test]
+    fn test_group_by_base_nsid() {
+        let refs = vec![
+            LexiconSchemaRef {
+                nsid: "com.example.test",
+                provider: || todo!(),
+            },
+            LexiconSchemaRef {
+                nsid: "com.example.test#fragment",
+                provider: || todo!(),
+            },
+            LexiconSchemaRef {
+                nsid: "com.example.other",
+                provider: || todo!(),
+            },
+        ];
+
+        let ref_ptrs: Vec<&LexiconSchemaRef> = refs.iter().collect();
+
+        let extractor = SchemaExtractor::new(ExtractOptions {
+            output_dir: PathBuf::from("test"),
+            verbose: false,
+            filter: None,
+            validate: false,
+            pretty: true,
+        });
+
+        let grouped = extractor.group_by_base_nsid(&ref_ptrs).unwrap();
+
+        assert_eq!(grouped.len(), 2);
+        assert!(grouped.contains_key("com.example.test"));
+        assert!(grouped.contains_key("com.example.other"));
+        assert_eq!(grouped["com.example.test"].len(), 2);
+        assert_eq!(grouped["com.example.other"].len(), 1);
+    }
+}

crates/jacquard-lexgen/src/test_schemas.rs

···
+// Test schemas for verifying extraction works
+// These are only compiled in tests/dev builds
+
+use jacquard_common::CowStr;
+use jacquard_derive::LexiconSchema;
+
+#[derive(LexiconSchema)]
+#[lexicon(nsid = "com.example.testRecord", record, key = "tid")]
+pub struct TestRecord<'a> {
+    #[lexicon(max_length = 100)]
+    pub text: CowStr<'a>,
+    pub count: i64,
+}
+
+#[derive(LexiconSchema)]
+#[lexicon(nsid = "com.example.testRecord#fragment")]
+pub struct TestFragment {
+    pub field: i64,
+}
+
+#[derive(LexiconSchema)]
+#[lexicon(nsid = "com.example.testDefs.defs#defOne")]
+pub struct DefOne {
+    pub value: String,
+}
+
+#[derive(LexiconSchema)]
+#[lexicon(nsid = "com.example.testDefs.defs#defTwo")]
+pub struct DefTwo {
+    pub number: i64,
+}

crates/jacquard-lexgen/tests/schema_extraction.rs

···
+use jacquard_lexgen::schema_extraction::{ExtractOptions, SchemaExtractor};
+use tempfile::TempDir;
+
+#[test]
+fn test_extract_all_creates_output_dir() {
+    let temp_dir = TempDir::new().unwrap();
+
+    let options = ExtractOptions {
+        output_dir: temp_dir.path().to_path_buf(),
+        verbose: false,
+        filter: None,
+        validate: true,
+        pretty: true,
+    };
+
+    let extractor = SchemaExtractor::new(options);
+
+    // This will discover any schemas registered via inventory in the binary
+    // In a minimal test environment, this might be 0
+    let result = extractor.extract_all();
+
+    // Should succeed even if no schemas found
+    assert!(result.is_ok());
+
+    // Directory should exist
+    assert!(temp_dir.path().exists());
+}
+
+#[test]
+fn test_extract_with_filter() {
+    let temp_dir = TempDir::new().unwrap();
+
+    let options = ExtractOptions {
+        output_dir: temp_dir.path().to_path_buf(),
+        verbose: false,
+        filter: Some("com.example.nonexistent".into()),
+        validate: true,
+        pretty: true,
+    };
+
+    let extractor = SchemaExtractor::new(options);
+    let result = extractor.extract_all();
+
+    // Should succeed (just won't write any files)
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_extract_with_verbose() {
+    let temp_dir = TempDir::new().unwrap();
+
+    let options = ExtractOptions {
+        output_dir: temp_dir.path().to_path_buf(),
+        verbose: true,
+        filter: None,
+        validate: true,
+        pretty: true,
+    };
+
+    let extractor = SchemaExtractor::new(options);
+    let result = extractor.extract_all();
+
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_extract_compact_json() {
+    let temp_dir = TempDir::new().unwrap();
+
+    let options = ExtractOptions {
+        output_dir: temp_dir.path().to_path_buf(),
+        verbose: false,
+        filter: None,
+        validate: true,
+        pretty: false, // Compact JSON
+    };
+
+    let extractor = SchemaExtractor::new(options);
+    let result = extractor.extract_all();
+
+    assert!(result.is_ok());
+}

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

···
 //! Implementation of #[derive(LexiconSchema)] macro
 
-use crate::lexicon::{
-    LexArray, LexBlob, LexBoolean, LexBytes, LexCidLink, LexInteger, LexObject, LexObjectProperty,
-    LexRef, LexRefUnion, LexString, LexStringFormat, LexUnknown, LexUserType,
-};
 use crate::schema::type_mapping::{LexiconPrimitiveType, StringFormat, rust_type_to_lexicon_type};
 use heck::{ToKebabCase, ToLowerCamelCase, ToPascalCase, ToShoutySnakeCase, ToSnakeCase};
-use jacquard_common::smol_str::{SmolStr, ToSmolStr};
 use proc_macro2::TokenStream;
-use quote::{ToTokens, quote};
+use quote::quote;
 use syn::{Attribute, Data, DeriveInput, Fields, Ident, LitStr, Type, parse2};
 
 /// Implementation for the LexiconSchema derive macro
···
                 nsid: #nsid,
                 provider: || {
                     let mut generator = ::jacquard_lexicon::schema::LexiconGenerator::new(#nsid);
-                    #name::lexicon_doc(&mut generator)
+                    <#name as ::jacquard_lexicon::schema::LexiconSchema>::lexicon_doc(&mut generator)
                 },
             }
         }
···
                 nsid: #nsid,
                 provider: || {
                     let mut generator = ::jacquard_lexicon::schema::LexiconGenerator::new(#nsid);
-                    #name::lexicon_doc(&mut generator)
+                    <#name as ::jacquard_lexicon::schema::LexiconSchema>::lexicon_doc(&mut generator)
                 },
             }
         }