reworking schema stuff

Cargo.lock

···
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
···
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.5.10",
+ "socket2 0.6.1",
  "system-configuration",
  "tokio",
  "tower-service",
···
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core",
+ "windows-core 0.62.2",
 ]
 
 [[package]]
···
 [[package]]
 name = "jacquard-api"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#4c31392df7f719950dabd64ef8e7c9cf84ba4212"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#988f0eedfc499d0e2cdd667f6adab086465984e2"
 dependencies = [
  "bon",
  "bytes",
···
 [[package]]
 name = "jacquard-common"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#4c31392df7f719950dabd64ef8e7c9cf84ba4212"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#988f0eedfc499d0e2cdd667f6adab086465984e2"
 dependencies = [
  "base64 0.22.1",
  "bon",
···
 [[package]]
 name = "jacquard-derive"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#4c31392df7f719950dabd64ef8e7c9cf84ba4212"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#988f0eedfc499d0e2cdd667f6adab086465984e2"
 dependencies = [
  "heck 0.5.0",
  "jacquard-lexicon 0.8.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",
···
 [[package]]
 name = "jacquard-identity"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#4c31392df7f719950dabd64ef8e7c9cf84ba4212"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#988f0eedfc499d0e2cdd667f6adab086465984e2"
 dependencies = [
  "bon",
  "bytes",
···
  "reqwest",
  "serde",
  "serde_json",
+ "syn 2.0.108",
  "tempfile",
  "thiserror 2.0.17",
  "tokio",
+ "toml",
  "walkdir",
 ]
 
···
 [[package]]
 name = "jacquard-lexicon"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#4c31392df7f719950dabd64ef8e7c9cf84ba4212"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#988f0eedfc499d0e2cdd667f6adab086465984e2"
 dependencies = [
  "glob",
  "heck 0.5.0",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
···
  "quinn-udp",
  "rustc-hash",
  "rustls",
- "socket2 0.5.10",
+ "socket2 0.6.1",
  "thiserror 2.0.17",
  "tokio",
  "tracing",
···
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.5.10",
+ "socket2 0.6.1",
  "tracing",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
···
  "errno",
  "libc",
  "linux-raw-sys 0.11.0",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
 dependencies = [
+ "indexmap 2.12.0",
  "itoa",
  "memchr",
  "ryu",
···
  "getrandom 0.3.4",
  "once_cell",
  "rustix 1.1.2",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
···
  "serde",
  "serde_spanned",
  "toml_datetime",
+ "toml_write",
  "winnow 0.7.13",
 ]
 
 [[package]]
+name = "toml_write"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
+
+[[package]]
 name = "tower"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
···
 checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
 dependencies = [
  "windows-collections",
- "windows-core",
+ "windows-core 0.61.2",
  "windows-future",
  "windows-link 0.1.3",
  "windows-numerics",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
 dependencies = [
- "windows-core",
+ "windows-core 0.61.2",
 ]
 
 [[package]]
···
  "windows-implement",
  "windows-interface",
  "windows-link 0.1.3",
- "windows-result",
- "windows-strings",
+ "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",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
 dependencies = [
- "windows-core",
+ "windows-core 0.61.2",
  "windows-link 0.1.3",
  "windows-threading",
 ]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
 dependencies = [
- "windows-core",
+ "windows-core 0.61.2",
  "windows-link 0.1.3",
 ]
 
···
 checksum = "5b8a9ed28765efc97bbc954883f4e6796c33a06546ebafacbabee9696967499e"
 dependencies = [
  "windows-link 0.1.3",
- "windows-result",
- "windows-strings",
+ "windows-result 0.3.4",
+ "windows-strings 0.4.2",
 ]
 
 [[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-lexgen/Cargo.toml

···
 miette = { workspace = true, features = ["fancy"] }
 reqwest = { workspace = true, features = ["json", "http2", "system-proxy", "rustls-tls"] }
 serde.workspace = true
-serde_json.workspace = true
+serde_json = { workspace = true, features = ["preserve_order"] }
+syn.workspace = true
 tempfile = "3.23"
 thiserror.workspace = true
 tokio = { workspace = true, features = ["full"] }
+toml = "0.8"
 walkdir = "2.5"
 
 [dev-dependencies]

crates/jacquard-lexgen/SCHEMA_DISCOVERY.md

···
+# Schema Discovery Approaches
+
+Jacquard provides two complementary approaches for discovering lexicon schemas from Rust types:
+
+## 1. Inventory-Based Discovery (Link-Time)
+
+**Module:** `schema_extraction`
+
+Uses the `inventory` crate to collect schema types at link time.
+
+### Pros
+- ✅ Fast - schemas already in memory
+- ✅ Works with compiled dependencies
+- ✅ No parsing overhead
+- ✅ Guaranteed to match compiled code
+
+### Cons
+- ❌ Only discovers types that are **linked** into the binary
+- ❌ Requires creating a custom binary that imports your types
+- ❌ Won't see unused types that the linker removes
+
+### Usage
+
+```rust
+// bin/extract_schemas.rs
+use jacquard_lexgen::schema_extraction;
+use my_app::models::*;  // ← Must import to link
+
+fn main() -> miette::Result<()> {
+    schema_extraction::run("lexicons", true)
+}
+```
+
+### Best For
+- Extracting schemas from your own crate
+- When you already have types imported/used
+- Production builds where you want to match exactly what's compiled
+
+## 2. Workspace Discovery (Source Scanning)
+
+**Module:** `schema_discovery`
+
+Parses workspace source files directly using `syn`.
+
+### Pros
+- ✅ Discovers **all** types in workspace
+- ✅ No linking required
+- ✅ Works across workspace members
+- ✅ Sees types even if they're not used
+
+### Cons
+- ❌ Slower - parses all .rs files
+- ❌ Doesn't work with binary dependencies
+- ❌ Must re-parse source on every run
+
+### Usage
+
+```rust
+use jacquard_lexgen::schema_discovery::WorkspaceDiscovery;
+
+fn main() -> miette::Result<()> {
+    let schemas = WorkspaceDiscovery::new()
+        .verbose(true)
+        .scan()?;
+
+    for schema in schemas {
+        println!("{}: {}", schema.nsid, schema.type_name);
+    }
+
+    Ok(())
+}
+```
+
+### Best For
+- Workspace-wide schema auditing
+- Finding all schema types regardless of usage
+- Development workflows where you want comprehensive discovery
+- When you don't want to maintain import lists
+
+## Comparison
+
+| Feature | Inventory | Workspace Scan |
+|---------|-----------|----------------|
+| Speed | Fast (runtime) | Slower (parsing) |
+| Coverage | Linked types only | All types in workspace |
+| Binary deps | ✅ Yes | ❌ No |
+| Unused types | ❌ No | ✅ Yes |
+| Workspace-wide | ❌ No | ✅ Yes |
+| Setup complexity | Medium (need imports) | Low (just run) |
+
+## Hybrid Approach
+
+For best results, use both:
+
+1. **Development:** Use workspace scan for comprehensive discovery
+2. **CI/Production:** Use inventory for fast, exact extraction
+
+```bash
+# Development: find all schemas
+cargo run --example workspace_discovery
+
+# Production: extract linked schemas
+cargo run --bin extract-schemas
+```
+
+## Future: Schema Generation
+
+Phase 3 currently only **discovers** schemas. A future enhancement could combine
+workspace discovery with the derive macro's schema generation logic to actually
+**generate** lexicon JSON without needing to link anything.
+
+This would require:
+- Extracting schema generation logic from the derive macro
+- Calling it directly from the scanner
+- Managing dependencies between schema types
+
+Tracked in: [Issue #TBD]

crates/jacquard-lexgen/examples/workspace_discovery.rs

···
+#!/usr/bin/env cargo
+//! Example: Discover schemas across the workspace without link-time discovery
+//!
+//! Run with: cargo run --example workspace_discovery
+
+use jacquard_lexgen::schema_discovery::WorkspaceDiscovery;
+
+fn main() -> miette::Result<()> {
+    println!("Workspace Schema Discovery Example\n");
+
+    // Create workspace discovery
+    let discovery = WorkspaceDiscovery::new().verbose(true);
+
+    // Scan workspace
+    let schemas = discovery.scan()?;
+
+    println!("\n━━━ Results ━━━");
+    println!("Discovered {} schema types:\n", schemas.len());
+
+    // Group by crate
+    use std::collections::HashMap;
+    let mut by_crate: HashMap<String, Vec<_>> = HashMap::new();
+
+    for schema in &schemas {
+        let crate_name = schema
+            .source_path
+            .components()
+            .find_map(|c| {
+                let s = c.as_os_str().to_str()?;
+                if s.starts_with("jacquard-") || s == "jacquard" {
+                    Some(s.to_string())
+                } else {
+                    None
+                }
+            })
+            .unwrap_or_else(|| "unknown".to_string());
+
+        by_crate.entry(crate_name).or_default().push(schema);
+    }
+
+    for (crate_name, crate_schemas) in by_crate {
+        println!("📦 {} ({} schemas)", crate_name, crate_schemas.len());
+        for schema in crate_schemas {
+            println!("   • {} ({})", schema.nsid, schema.type_name);
+        }
+        println!();
+    }
+
+    Ok(())
+}

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

···
+//! Extract AT Protocol lexicon schemas from compiled Rust types
+//!
+//! This binary discovers types with `#[derive(LexiconSchema)]` via inventory
+//! and generates lexicon JSON files. See the `schema_extraction` module docs
+//! for usage patterns and integration examples.
+
 use clap::Parser;
-use jacquard_lexgen::schema_extraction::{ExtractOptions, SchemaExtractor};
+use jacquard_lexgen::schema_extraction::{self, 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")]
+#[command(long_about = r#"
+Discovers types implementing LexiconSchema via inventory and generates
+lexicon JSON files. The binary only discovers types that are linked,
+so you need to import your schema types in this binary or a custom one.
+
+See: https://docs.rs/jacquard-lexgen/latest/jacquard_lexgen/schema_extraction/
+"#)]
 struct Args {
     /// Output directory for generated schema files
     #[arg(short, long, default_value = "lexicons")]
···
 fn main() -> Result<()> {
     let args = Args::parse();
 
+    // Simple case: use convenience function
+    if !args.watch && args.filter.is_none() && args.validate && args.pretty {
+        return schema_extraction::run(&args.output, args.verbose);
+    }
+
+    // Advanced case: use full options
     let options = ExtractOptions {
         output_dir: args.output.into(),
         verbose: args.verbose,

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
+//! - [`schema_extraction`] - Extract lexicon schemas from Rust types via inventory (link-time discovery)
+//! - [`schema_discovery`] - Discover schemas by scanning workspace source files (no linking required)
 
 pub mod cli;
 pub mod fetch;
+pub mod schema_discovery;
 pub mod schema_extraction;
 #[cfg(any(test, debug_assertions))]
 pub mod test_schemas;

crates/jacquard-lexgen/src/schema_discovery.rs

···
+//! # Workspace Schema Discovery
+//!
+//! Alternative to inventory-based discovery that scans workspace source files directly.
+//! This avoids the link-time limitation and can discover schemas across the entire workspace.
+//!
+//! ## Usage
+//!
+//! ```rust,no_run
+//! use jacquard_lexgen::schema_discovery::WorkspaceDiscovery;
+//!
+//! fn main() -> miette::Result<()> {
+//!     // Discover all schemas in workspace
+//!     let schemas = WorkspaceDiscovery::new()
+//!         .scan()?;
+//!
+//!     println!("Found {} schemas", schemas.len());
+//!
+//!     for schema in schemas {
+//!         println!("  {}: {}", schema.nsid, schema.source_path.display());
+//!     }
+//!
+//!     Ok(())
+//! }
+//! ```
+
+use miette::{IntoDiagnostic, Result};
+use std::path::{Path, PathBuf};
+use syn::{Attribute, Item};
+
+/// Discovered schema type
+#[derive(Debug, Clone)]
+pub struct DiscoveredSchema {
+    /// The NSID from the lexicon attribute
+    pub nsid: String,
+    /// Source file containing this type
+    pub source_path: PathBuf,
+    /// The type name
+    pub type_name: String,
+    /// Whether this is a struct or enum
+    pub kind: SchemaKind,
+    /// Parsed lexicon attributes
+    pub attributes: LexiconAttributes,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum SchemaKind {
+    Struct,
+    Enum,
+}
+
+/// Parsed lexicon attributes from source
+#[derive(Debug, Clone, Default)]
+pub struct LexiconAttributes {
+    pub nsid: Option<String>,
+    pub fragment: Option<String>,
+    pub record: bool,
+    pub query: bool,
+    pub procedure: bool,
+    pub key: Option<String>,
+}
+
+/// Workspace schema discovery via source scanning
+pub struct WorkspaceDiscovery {
+    workspace_root: PathBuf,
+    verbose: bool,
+}
+
+impl WorkspaceDiscovery {
+    /// Create a new workspace discovery
+    ///
+    /// Defaults to current directory as workspace root.
+    pub fn new() -> Self {
+        Self {
+            workspace_root: std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")),
+            verbose: false,
+        }
+    }
+
+    /// Set the workspace root directory
+    pub fn workspace_root(mut self, path: impl Into<PathBuf>) -> Self {
+        self.workspace_root = path.into();
+        self
+    }
+
+    /// Enable verbose output
+    pub fn verbose(mut self, verbose: bool) -> Self {
+        self.verbose = verbose;
+        self
+    }
+
+    /// Scan workspace for schema types
+    pub fn scan(&self) -> Result<Vec<DiscoveredSchema>> {
+        if self.verbose {
+            println!("Scanning workspace at {}", self.workspace_root.display());
+        }
+
+        let members = self.find_workspace_members()?;
+
+        if self.verbose {
+            println!("Found {} workspace members", members.len());
+        }
+
+        let mut schemas = Vec::new();
+
+        for member in members {
+            if self.verbose {
+                println!("Scanning member: {}", member.display());
+            }
+
+            let member_schemas = self.scan_member(&member)?;
+            schemas.extend(member_schemas);
+        }
+
+        if self.verbose {
+            println!("Discovered {} total schemas", schemas.len());
+        }
+
+        Ok(schemas)
+    }
+
+    /// Find workspace members by parsing Cargo.toml
+    fn find_workspace_members(&self) -> Result<Vec<PathBuf>> {
+        let cargo_toml = self.workspace_root.join("Cargo.toml");
+
+        if !cargo_toml.exists() {
+            return Err(miette::miette!(
+                "Cargo.toml not found at {}",
+                cargo_toml.display()
+            ));
+        }
+
+        let contents = std::fs::read_to_string(&cargo_toml).into_diagnostic()?;
+        let manifest: toml::Value = toml::from_str(&contents).into_diagnostic()?;
+
+        let mut members = Vec::new();
+
+        // Check if this is a workspace
+        if let Some(workspace) = manifest.get("workspace") {
+            if let Some(member_list) = workspace.get("members").and_then(|v| v.as_array()) {
+                for member in member_list {
+                    if let Some(pattern) = member.as_str() {
+                        // Handle glob patterns like "crates/*"
+                        let glob_pattern = self.workspace_root.join(pattern).join("Cargo.toml");
+
+                        for entry in glob::glob(glob_pattern.to_str().unwrap()).into_diagnostic()? {
+                            let path = entry.into_diagnostic()?;
+                            if let Some(dir) = path.parent() {
+                                members.push(dir.to_path_buf());
+                            }
+                        }
+                    }
+                }
+            }
+        } else {
+            // Not a workspace - just this crate
+            members.push(self.workspace_root.clone());
+        }
+
+        Ok(members)
+    }
+
+    /// Scan a single workspace member
+    fn scan_member(&self, member_path: &Path) -> Result<Vec<DiscoveredSchema>> {
+        let src_dir = member_path.join("src");
+
+        if !src_dir.exists() {
+            return Ok(Vec::new());
+        }
+
+        let mut schemas = Vec::new();
+
+        // Recursively scan all .rs files
+        for entry in walkdir::WalkDir::new(&src_dir)
+            .into_iter()
+            .filter_map(|e| e.ok())
+        {
+            if entry.path().extension().and_then(|s| s.to_str()) == Some("rs") {
+                if let Ok(file_schemas) = self.scan_file(entry.path()) {
+                    schemas.extend(file_schemas);
+                }
+            }
+        }
+
+        Ok(schemas)
+    }
+
+    /// Scan a single Rust source file
+    fn scan_file(&self, path: &Path) -> Result<Vec<DiscoveredSchema>> {
+        let contents = std::fs::read_to_string(path).into_diagnostic()?;
+        let file = syn::parse_file(&contents).into_diagnostic()?;
+
+        let mut schemas = Vec::new();
+
+        for item in file.items {
+            match item {
+                Item::Struct(item_struct) => {
+                    if let Some(schema) = self.extract_schema_from_attrs(
+                        &item_struct.attrs,
+                        &item_struct.ident.to_string(),
+                        SchemaKind::Struct,
+                        path,
+                    )? {
+                        schemas.push(schema);
+                    }
+                }
+                Item::Enum(item_enum) => {
+                    if let Some(schema) = self.extract_schema_from_attrs(
+                        &item_enum.attrs,
+                        &item_enum.ident.to_string(),
+                        SchemaKind::Enum,
+                        path,
+                    )? {
+                        schemas.push(schema);
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        Ok(schemas)
+    }
+
+    /// Extract schema info from attributes
+    fn extract_schema_from_attrs(
+        &self,
+        attrs: &[Attribute],
+        type_name: &str,
+        kind: SchemaKind,
+        source_path: &Path,
+    ) -> Result<Option<DiscoveredSchema>> {
+        // Check if this type has #[derive(LexiconSchema)]
+        let has_derive = attrs.iter().any(|attr| {
+            if attr.path().is_ident("derive") {
+                if let Ok(meta) = attr.parse_args::<syn::Meta>() {
+                    if let syn::Meta::Path(path) = meta {
+                        return path.is_ident("LexiconSchema");
+                    }
+                }
+            }
+            false
+        });
+
+        if !has_derive {
+            return Ok(None);
+        }
+
+        // Parse #[lexicon(...)] attributes
+        let mut lex_attrs = LexiconAttributes::default();
+
+        for attr in attrs {
+            if attr.path().is_ident("lexicon") {
+                attr.parse_nested_meta(|meta| {
+                    if meta.path.is_ident("nsid") {
+                        let value = meta.value()?;
+                        let lit: syn::LitStr = value.parse()?;
+                        lex_attrs.nsid = Some(lit.value());
+                    } else if meta.path.is_ident("fragment") {
+                        if meta.input.peek(syn::Token![=]) {
+                            let value = meta.value()?;
+                            let lit: syn::LitStr = value.parse()?;
+                            lex_attrs.fragment = Some(lit.value());
+                        } else {
+                            lex_attrs.fragment = Some(String::new());
+                        }
+                    } else if meta.path.is_ident("record") {
+                        lex_attrs.record = true;
+                    } else if meta.path.is_ident("query") {
+                        lex_attrs.query = true;
+                    } else if meta.path.is_ident("procedure") {
+                        lex_attrs.procedure = true;
+                    } else if meta.path.is_ident("key") {
+                        let value = meta.value()?;
+                        let lit: syn::LitStr = value.parse()?;
+                        lex_attrs.key = Some(lit.value());
+                    }
+                    Ok(())
+                }).into_diagnostic()?;
+            }
+        }
+
+        let nsid = lex_attrs.nsid.clone().ok_or_else(|| {
+            miette::miette!(
+                "Type {} has #[derive(LexiconSchema)] but no nsid attribute",
+                type_name
+            )
+        })?;
+
+        Ok(Some(DiscoveredSchema {
+            nsid,
+            source_path: source_path.to_path_buf(),
+            type_name: type_name.to_string(),
+            kind,
+            attributes: lex_attrs,
+        }))
+    }
+}
+
+impl Default for WorkspaceDiscovery {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_simple_struct() {
+        let code = r#"
+            #[derive(LexiconSchema)]
+            #[lexicon(nsid = "com.example.test", record)]
+            struct Test {
+                field: String,
+            }
+        "#;
+
+        let file = syn::parse_file(code).unwrap();
+        let discovery = WorkspaceDiscovery::new();
+
+        if let Item::Struct(item_struct) = &file.items[0] {
+            let schema = discovery
+                .extract_schema_from_attrs(
+                    &item_struct.attrs,
+                    "Test",
+                    SchemaKind::Struct,
+                    Path::new("test.rs"),
+                )
+                .unwrap()
+                .unwrap();
+
+            assert_eq!(schema.nsid, "com.example.test");
+            assert_eq!(schema.type_name, "Test");
+            assert!(schema.attributes.record);
+        } else {
+            panic!("Expected struct");
+        }
+    }
+}

crates/jacquard-lexgen/src/schema_extraction.rs

···
+//! # Schema Extraction
+//!
+//! Extract AT Protocol lexicon schemas from Rust types via `inventory` discovery.
+//!
+//! ## Usage Pattern
+//!
+//! This module provides schema extraction for types implementing `LexiconSchema`.
+//! The extraction binary discovers schemas at **link time** via `inventory`, so you need
+//! to create a binary in your workspace that links your schema types.
+//!
+//! ### Simple Usage
+//!
+//! ```rust,no_run
+//! // bin/extract_schemas.rs
+//! use jacquard_lexgen::schema_extraction;
+//!
+//! // Import your types so they get linked
+//! use my_app::models::*;
+//!
+//! fn main() -> miette::Result<()> {
+//!     schema_extraction::run(
+//!         "lexicons",  // output directory
+//!         true,        // verbose
+//!     )
+//! }
+//! ```
+//!
+//! ### Advanced Usage
+//!
+//! ```rust,no_run
+//! use jacquard_lexgen::schema_extraction::{ExtractOptions, SchemaExtractor};
+//! use my_app::models::*;  // Your schema types
+//!
+//! fn main() -> miette::Result<()> {
+//!     let options = ExtractOptions {
+//!         output_dir: "lexicons".into(),
+//!         verbose: true,
+//!         filter: Some("app.bsky".into()),  // Only extract app.bsky.* schemas
+//!         validate: true,
+//!         pretty: true,
+//!     };
+//!
+//!     SchemaExtractor::new(options).extract_all()
+//! }
+//! ```
+//!
+//! ### Integration with Build Tools
+//!
+//! **Just:**
+//! ```justfile
+//! # Generate lexicon schemas from Rust types
+//! extract-schemas:
+//!     cargo run --bin extract-schemas
+//! ```
+//!
+//! **Cargo xtask:**
+//! ```rust,ignore
+//! // xtask/src/main.rs
+//! match args {
+//!     "codegen" => {
+//!         run_command("cargo", &["run", "--bin", "extract-schemas"])?;
+//!     }
+//! }
+//! ```
+//!
+//! **Pre-commit hook:**
+//! ```bash
+//! #!/bin/bash
+//! # Regenerate schemas when Rust files change
+//! if git diff --cached --name-only | grep -E '\.rs$'; then
+//!     cargo run --bin extract-schemas
+//!     git add lexicons/*.json
+//! fi
+//! ```
+
 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;
+use std::path::{Path, PathBuf};
 
+/// Options for schema extraction
 pub struct ExtractOptions {
+    /// Output directory for generated schema files
     pub output_dir: PathBuf,
+    /// Enable verbose output
     pub verbose: bool,
+    /// Filter by NSID prefix (e.g., "app.bsky")
     pub filter: Option<String>,
+    /// Validate schemas before writing
     pub validate: bool,
+    /// Pretty-print JSON output
     pub pretty: bool,
 }
 
+impl Default for ExtractOptions {
+    fn default() -> Self {
+        Self {
+            output_dir: PathBuf::from("lexicons"),
+            verbose: false,
+            filter: None,
+            validate: true,
+            pretty: true,
+        }
+    }
+}
+
+/// Run schema extraction with simple defaults
+///
+/// Convenience function for the common case. For more control, use [`SchemaExtractor`].
+///
+/// # Arguments
+///
+/// * `output_dir` - Directory to write schema files (will be created if needed)
+/// * `verbose` - Print progress information
+///
+/// # Example
+///
+/// ```rust,no_run
+/// use jacquard_lexgen::schema_extraction;
+/// use my_app::models::*;  // Your types with #[derive(LexiconSchema)]
+///
+/// fn main() -> miette::Result<()> {
+///     schema_extraction::run("lexicons", true)
+/// }
+/// ```
+pub fn run(output_dir: impl AsRef<Path>, verbose: bool) -> Result<()> {
+    let options = ExtractOptions {
+        output_dir: output_dir.as_ref().to_path_buf(),
+        verbose,
+        ..Default::default()
+    };
+
+    SchemaExtractor::new(options).extract_all()
+}
+
 pub struct SchemaExtractor {
     options: ExtractOptions,
 }
···
             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()?
-        };
+        // Serialize to JSON with "main" def first
+        let json = self.serialize_with_main_first(&final_doc)?;
 
         // Write to file
         let filename = base_nsid.replace('.', "_") + ".json";
···
         println!("Watch mode not yet implemented");
         println!("Run with --help to see available options");
         Ok(())
+    }
+
+    /// Serialize a lexicon doc with "main" def first
+    fn serialize_with_main_first(&self, doc: &LexiconDoc) -> Result<String> {
+        use serde_json::{json, Map, Value};
+
+        // Build defs map with main first
+        let mut defs_map = Map::new();
+
+        // Insert main first if it exists
+        if let Some(main_def) = doc.defs.get("main") {
+            let main_value = serde_json::to_value(main_def).into_diagnostic()?;
+            defs_map.insert("main".to_string(), main_value);
+        }
+
+        // Insert all other defs in sorted order
+        for (name, def) in &doc.defs {
+            if name != "main" {
+                let def_value = serde_json::to_value(def).into_diagnostic()?;
+                defs_map.insert(name.to_string(), def_value);
+            }
+        }
+
+        // Build final JSON object
+        let mut obj = Map::new();
+        obj.insert("lexicon".to_string(), json!(1));
+        obj.insert("id".to_string(), json!(doc.id.as_ref()));
+
+        if let Some(rev) = &doc.revision {
+            obj.insert("revision".to_string(), json!(rev));
+        }
+
+        if let Some(desc) = &doc.description {
+            obj.insert("description".to_string(), json!(desc));
+        }
+
+        obj.insert("defs".to_string(), Value::Object(defs_map));
+
+        // Serialize with or without pretty printing
+        if self.options.pretty {
+            serde_json::to_string_pretty(&Value::Object(obj)).into_diagnostic()
+        } else {
+            serde_json::to_string(&Value::Object(obj)).into_diagnostic()
+        }
     }
 }
 

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

···
 //! Implementation of #[derive(LexiconSchema)] macro
 
+use crate::schema::from_ast::{
+    LexiconFieldAttrs, LexiconTypeAttrs, LexiconTypeKind, RenameRule, SerdeAttrs, determine_nsid,
+    extract_option_inner, parse_field_attrs, parse_serde_attrs, parse_serde_rename_all,
+    parse_type_attrs,
+};
 use crate::schema::type_mapping::{LexiconPrimitiveType, StringFormat, rust_type_to_lexicon_type};
 use heck::{ToKebabCase, ToLowerCamelCase, ToPascalCase, ToShoutySnakeCase, ToSnakeCase};
 use proc_macro2::TokenStream;
···
     }
 }
 
-/// Parsed lexicon attributes from type
-#[derive(Debug, Default)]
-struct LexiconTypeAttrs {
-    /// NSID for this type (required for primary types)
-    nsid: Option<String>,
-
-    /// Fragment name (None = not a fragment, Some("") = infer from type name)
-    fragment: Option<String>,
-
-    /// Type kind
-    kind: Option<LexiconTypeKind>,
-
-    /// Record key type (for records)
-    key: Option<String>,
-}
-
-#[derive(Debug, Clone, Copy)]
-enum LexiconTypeKind {
-    Record,
-    Query,
-    Procedure,
-    Subscription,
-    Object,
-    Union,
-}
-
-/// Parse type-level lexicon attributes
-fn parse_type_attrs(attrs: &[Attribute]) -> syn::Result<LexiconTypeAttrs> {
-    let mut result = LexiconTypeAttrs::default();
-
-    for attr in attrs {
-        if !attr.path().is_ident("lexicon") {
-            continue;
-        }
-
-        attr.parse_nested_meta(|meta| {
-            if meta.path.is_ident("nsid") {
-                let value = meta.value()?;
-                let lit: LitStr = value.parse()?;
-                result.nsid = Some(lit.value());
-                Ok(())
-            } else if meta.path.is_ident("fragment") {
-                // Two forms: #[lexicon(fragment)] or #[lexicon(fragment = "name")]
-                if meta.input.peek(syn::Token![=]) {
-                    let value = meta.value()?;
-                    let lit: LitStr = value.parse()?;
-                    result.fragment = Some(lit.value());
-                } else {
-                    result.fragment = Some(String::new()); // Infer from type name
-                }
-                Ok(())
-            } else if meta.path.is_ident("record") {
-                result.kind = Some(LexiconTypeKind::Record);
-                Ok(())
-            } else if meta.path.is_ident("query") {
-                result.kind = Some(LexiconTypeKind::Query);
-                Ok(())
-            } else if meta.path.is_ident("procedure") {
-                result.kind = Some(LexiconTypeKind::Procedure);
-                Ok(())
-            } else if meta.path.is_ident("subscription") {
-                result.kind = Some(LexiconTypeKind::Subscription);
-                Ok(())
-            } else if meta.path.is_ident("key") {
-                let value = meta.value()?;
-                let lit: LitStr = value.parse()?;
-                result.key = Some(lit.value());
-                Ok(())
-            } else {
-                Err(meta.error("unknown lexicon attribute"))
-            }
-        })?;
-    }
-
-    Ok(result)
-}
-
-/// Parsed lexicon attributes from field
-#[derive(Debug, Default)]
-struct LexiconFieldAttrs {
-    max_length: Option<usize>,
-    max_graphemes: Option<usize>,
-    min_length: Option<usize>,
-    min_graphemes: Option<usize>,
-    minimum: Option<i64>,
-    maximum: Option<i64>,
-    explicit_ref: Option<String>,
-    format: Option<String>,
-}
-
-/// Parse field-level lexicon attributes
-fn parse_field_attrs(attrs: &[Attribute]) -> syn::Result<LexiconFieldAttrs> {
-    let mut result = LexiconFieldAttrs::default();
-
-    for attr in attrs {
-        if !attr.path().is_ident("lexicon") {
-            continue;
-        }
-
-        attr.parse_nested_meta(|meta| {
-            if meta.path.is_ident("max_length") {
-                let value = meta.value()?;
-                let lit: syn::LitInt = value.parse()?;
-                result.max_length = Some(lit.base10_parse()?);
-                Ok(())
-            } else if meta.path.is_ident("max_graphemes") {
-                let value = meta.value()?;
-                let lit: syn::LitInt = value.parse()?;
-                result.max_graphemes = Some(lit.base10_parse()?);
-                Ok(())
-            } else if meta.path.is_ident("min_length") {
-                let value = meta.value()?;
-                let lit: syn::LitInt = value.parse()?;
-                result.min_length = Some(lit.base10_parse()?);
-                Ok(())
-            } else if meta.path.is_ident("min_graphemes") {
-                let value = meta.value()?;
-                let lit: syn::LitInt = value.parse()?;
-                result.min_graphemes = Some(lit.base10_parse()?);
-                Ok(())
-            } else if meta.path.is_ident("minimum") {
-                let value = meta.value()?;
-                let lit: syn::LitInt = value.parse()?;
-                result.minimum = Some(lit.base10_parse()?);
-                Ok(())
-            } else if meta.path.is_ident("maximum") {
-                let value = meta.value()?;
-                let lit: syn::LitInt = value.parse()?;
-                result.maximum = Some(lit.base10_parse()?);
-                Ok(())
-            } else if meta.path.is_ident("ref") {
-                let value = meta.value()?;
-                let lit: LitStr = value.parse()?;
-                result.explicit_ref = Some(lit.value());
-                Ok(())
-            } else if meta.path.is_ident("format") {
-                let value = meta.value()?;
-                let lit: LitStr = value.parse()?;
-                result.format = Some(lit.value());
-                Ok(())
-            } else {
-                Err(meta.error("unknown lexicon field attribute"))
-            }
-        })?;
-    }
-
-    Ok(result)
-}
-
-/// Parsed serde attributes relevant to lexicon schema
-#[derive(Debug, Default)]
-struct SerdeAttrs {
-    rename: Option<String>,
-    skip: bool,
-}
-
-/// Parse serde attributes for a field
-fn parse_serde_attrs(attrs: &[Attribute]) -> syn::Result<SerdeAttrs> {
-    let mut result = SerdeAttrs::default();
-
-    for attr in attrs {
-        if !attr.path().is_ident("serde") {
-            continue;
-        }
-
-        attr.parse_nested_meta(|meta| {
-            if meta.path.is_ident("rename") {
-                let value = meta.value()?;
-                let lit: LitStr = value.parse()?;
-                result.rename = Some(lit.value());
-                Ok(())
-            } else if meta.path.is_ident("skip") {
-                result.skip = true;
-                Ok(())
-            } else {
-                // Ignore other serde attributes
-                Ok(())
-            }
-        })?;
-    }
-
-    Ok(result)
-}
-
-/// Parse container-level serde rename_all
-fn parse_serde_rename_all(attrs: &[Attribute]) -> syn::Result<Option<RenameRule>> {
-    for attr in attrs {
-        if !attr.path().is_ident("serde") {
-            continue;
-        }
-
-        let mut found_rule = None;
-        attr.parse_nested_meta(|meta| {
-            if meta.path.is_ident("rename_all") {
-                let value = meta.value()?;
-                let lit: LitStr = value.parse()?;
-                found_rule = RenameRule::from_str(&lit.value());
-                Ok(())
-            } else {
-                Ok(())
-            }
-        })?;
-
-        if found_rule.is_some() {
-            return Ok(found_rule);
-        }
-    }
-
-    // Default to camelCase (lexicon standard)
-    Ok(Some(RenameRule::CamelCase))
-}
-
-#[derive(Debug, Clone, Copy)]
-enum RenameRule {
-    CamelCase,
-    SnakeCase,
-    PascalCase,
-    ScreamingSnakeCase,
-    KebabCase,
-}
-
-impl RenameRule {
-    fn from_str(s: &str) -> Option<Self> {
-        match s {
-            "camelCase" => Some(RenameRule::CamelCase),
-            "snake_case" => Some(RenameRule::SnakeCase),
-            "PascalCase" => Some(RenameRule::PascalCase),
-            "SCREAMING_SNAKE_CASE" => Some(RenameRule::ScreamingSnakeCase),
-            "kebab-case" => Some(RenameRule::KebabCase),
-            _ => None,
-        }
-    }
-
-    fn apply(&self, input: &str) -> String {
-        match self {
-            RenameRule::CamelCase => input.to_lower_camel_case(),
-            RenameRule::SnakeCase => input.to_snake_case(),
-            RenameRule::PascalCase => input.to_pascal_case(),
-            RenameRule::ScreamingSnakeCase => input.to_shouty_snake_case(),
-            RenameRule::KebabCase => input.to_kebab_case(),
-        }
-    }
-}
-
-/// Determine NSID from attributes and context
-fn determine_nsid(attrs: &LexiconTypeAttrs, input: &DeriveInput) -> syn::Result<String> {
-    // Explicit NSID in lexicon attribute
-    if let Some(nsid) = &attrs.nsid {
-        return Ok(nsid.clone());
-    }
-
-    // Fragment - need to find module NSID (not implemented yet)
-    if attrs.fragment.is_some() {
-        return Err(syn::Error::new_spanned(
-            input,
-            "fragments require explicit nsid or module-level primary type (not yet implemented)",
-        ));
-    }
-
-    // Check for XrpcRequest derive with NSID
-    if let Some(nsid) = extract_xrpc_nsid(&input.attrs)? {
-        return Ok(nsid);
-    }
-
-    Err(syn::Error::new_spanned(
-        input,
-        "missing required `nsid` attribute (use #[lexicon(nsid = \"...\")] or #[xrpc(nsid = \"...\")])",
-    ))
-}
-
 /// Extract NSID from XrpcRequest attributes (cross-derive coordination)
 fn extract_xrpc_nsid(attrs: &[Attribute]) -> syn::Result<Option<String>> {
     for attr in attrs {
···
     }
 
     Ok(defs)
-}
-
-/// Extract T from Option<T>, return (type, is_required)
-fn extract_option_inner(ty: &Type) -> (&Type, bool) {
-    if let Type::Path(type_path) = ty {
-        if let Some(segment) = type_path.path.segments.last() {
-            if segment.ident == "Option" {
-                if let syn::PathArguments::AngleBracketed(args) = &segment.arguments {
-                    if let Some(syn::GenericArgument::Type(inner)) = args.args.first() {
-                        return (inner, false);
-                    }
-                }
-            }
-        }
-    }
-    (ty, true)
 }
 
 /// Generate LexObjectProperty tokens for a field

crates/jacquard-lexicon/src/schema.rs

···
 //! - **Validation**: Runtime constraint checking via `validate()` method
 
 pub mod builder;
+pub mod from_ast;
 pub mod type_mapping;
 
 use crate::lexicon::{LexObjectProperty, LexRef, LexUserType, Lexicon, LexiconDoc};

crates/jacquard-lexicon/src/schema/from_ast/builders.rs

···
+//! Top-level builder functions
+
+use super::parse::{determine_nsid, extract_variant_ref, has_open_union_attr, parse_serde_rename_all, parse_type_attrs};
+use super::properties::build_object_properties;
+use super::types::*;
+use crate::lexicon::*;
+use heck::ToLowerCamelCase;
+use jacquard_common::smol_str::SmolStr;
+use std::collections::BTreeMap;
+use syn::DeriveInput;
+
+/// Build schema from a struct
+pub fn build_struct_schema(input: &DeriveInput) -> syn::Result<BuiltSchema> {
+    // Parse type-level attributes
+    let type_attrs = parse_type_attrs(&input.attrs)?;
+
+    // Determine NSID
+    let nsid = determine_nsid(&type_attrs, input)?;
+
+    // Parse fields based on data type
+    let data_struct = match &input.data {
+        syn::Data::Struct(data_struct) => data_struct,
+        _ => {
+            return Err(syn::Error::new_spanned(
+                input,
+                "build_struct_schema requires a struct",
+            ));
+        }
+    };
+
+    // Parse serde container attributes
+    let rename_all = parse_serde_rename_all(&input.attrs)?;
+
+    // Build properties
+    let field_properties = build_object_properties(&data_struct.fields, rename_all)?;
+
+    // Extract properties map, required list, and unresolved refs
+    let mut properties = BTreeMap::new();
+    let mut required = Vec::new();
+    let mut all_validations = Vec::new();
+    let mut all_unresolved = Vec::new();
+
+    for field_prop in field_properties {
+        properties.insert(field_prop.schema_name.clone().into(), field_prop.property);
+        if field_prop.required {
+            required.push(field_prop.schema_name.into());
+        }
+        all_validations.extend(field_prop.validations);
+        all_unresolved.extend(field_prop.unresolved_refs);
+    }
+
+    // Build main def based on kind
+    let user_type = build_user_type(&type_attrs, properties, required)?;
+
+    // Build lexicon doc
+    let mut defs = BTreeMap::new();
+    defs.insert("main".into(), user_type);
+
+    let doc = LexiconDoc {
+        lexicon: Lexicon::Lexicon1,
+        id: nsid.clone().into(),
+        revision: None,
+        description: None,
+        defs,
+    };
+
+    // Determine schema_id (add fragment if needed)
+    let schema_id = if let Some(fragment) = &type_attrs.fragment {
+        let frag_name = if fragment.is_empty() {
+            input.ident.to_string().to_lower_camel_case()
+        } else {
+            fragment.clone()
+        };
+        format!("{}#{}", nsid, frag_name)
+    } else {
+        nsid.clone()
+    };
+
+    Ok(BuiltSchema {
+        nsid,
+        schema_id,
+        doc,
+        validation_checks: all_validations,
+        unresolved_refs: all_unresolved,
+    })
+}
+
+/// Build LexUserType based on kind
+fn build_user_type(
+    type_attrs: &LexiconTypeAttrs,
+    properties: BTreeMap<SmolStr, LexObjectProperty<'static>>,
+    required: Vec<SmolStr>,
+) -> syn::Result<LexUserType<'static>> {
+    let required_field = if required.is_empty() {
+        None
+    } else {
+        Some(required)
+    };
+
+    let obj = LexObject {
+        description: None,
+        required: required_field,
+        nullable: None,
+        properties,
+    };
+
+    match type_attrs.kind {
+        Some(LexiconTypeKind::Record) => Ok(LexUserType::Record(LexRecord {
+            description: None,
+            key: type_attrs.key.clone().map(Into::into),
+            record: LexRecordRecord::Object(obj),
+        })),
+        Some(LexiconTypeKind::Query) => {
+            // Convert properties to parameters
+            let params = LexXrpcParameters {
+                description: None,
+                required: obj.required.clone(),
+                properties: obj
+                    .properties
+                    .into_iter()
+                    .map(|(k, v)| (k, convert_object_prop_to_param_prop(v)))
+                    .collect(),
+            };
+            Ok(LexUserType::XrpcQuery(LexXrpcQuery {
+                description: None,
+                parameters: Some(LexXrpcQueryParameter::Params(params)),
+                output: None,
+                errors: None,
+            }))
+        }
+        Some(LexiconTypeKind::Procedure) => Ok(LexUserType::XrpcProcedure(LexXrpcProcedure {
+            description: None,
+            parameters: None,
+            input: Some(LexXrpcBody {
+                description: None,
+                encoding: "application/json".into(),
+                schema: Some(LexXrpcBodySchema::Object(obj)),
+            }),
+            output: None,
+            errors: None,
+        })),
+        Some(LexiconTypeKind::Subscription) => {
+            let params = LexXrpcParameters {
+                description: None,
+                required: obj.required.clone(),
+                properties: obj
+                    .properties
+                    .into_iter()
+                    .map(|(k, v)| (k, convert_object_prop_to_param_prop(v)))
+                    .collect(),
+            };
+            Ok(LexUserType::XrpcSubscription(LexXrpcSubscription {
+                description: None,
+                parameters: Some(LexXrpcSubscriptionParameter::Params(params)),
+                message: None,
+                infos: None,
+                errors: None,
+            }))
+        }
+        _ => Ok(LexUserType::Object(obj)),
+    }
+}
+
+/// Convert LexObjectProperty to LexXrpcParametersProperty
+fn convert_object_prop_to_param_prop(
+    prop: LexObjectProperty<'static>,
+) -> LexXrpcParametersProperty<'static> {
+    match prop {
+        LexObjectProperty::Boolean(b) => LexXrpcParametersProperty::Boolean(b),
+        LexObjectProperty::Integer(i) => LexXrpcParametersProperty::Integer(i),
+        LexObjectProperty::String(s) => LexXrpcParametersProperty::String(s),
+        LexObjectProperty::Unknown(u) => LexXrpcParametersProperty::Unknown(u),
+        LexObjectProperty::Array(a) => {
+            // Convert LexArray to LexPrimitiveArray
+            let primitive_item = match a.items {
+                LexArrayItem::Boolean(b) => LexPrimitiveArrayItem::Boolean(b),
+                LexArrayItem::Integer(i) => LexPrimitiveArrayItem::Integer(i),
+                LexArrayItem::String(s) => LexPrimitiveArrayItem::String(s),
+                // Non-primitive items become Unknown
+                _ => LexPrimitiveArrayItem::Unknown(LexUnknown { description: None }),
+            };
+            LexXrpcParametersProperty::Array(LexPrimitiveArray {
+                description: a.description,
+                items: primitive_item,
+                min_length: a.min_length,
+                max_length: a.max_length,
+            })
+        }
+        // Other types not valid in parameters - shouldn't happen
+        _ => LexXrpcParametersProperty::Unknown(LexUnknown { description: None }),
+    }
+}
+
+/// Build schema from an enum (union)
+pub fn build_enum_schema(input: &DeriveInput) -> syn::Result<BuiltSchema> {
+    let type_attrs = parse_type_attrs(&input.attrs)?;
+    let nsid = determine_nsid(&type_attrs, input)?;
+
+    let data_enum = match &input.data {
+        syn::Data::Enum(data_enum) => data_enum,
+        _ => {
+            return Err(syn::Error::new_spanned(
+                input,
+                "build_enum_schema requires an enum",
+            ));
+        }
+    };
+
+    // Check if open union
+    let is_open = has_open_union_attr(&input.attrs);
+
+    // Extract variant refs
+    let mut refs = Vec::new();
+    for variant in &data_enum.variants {
+        // Skip Unknown variant (added by #[open_union] macro)
+        if variant.ident == "Unknown" {
+            continue;
+        }
+
+        let variant_ref = extract_variant_ref(variant, &nsid)?;
+        refs.push(variant_ref.into());
+    }
+
+    // Build union
+    let user_type = LexUserType::Union(LexRefUnion {
+        description: None,
+        refs,
+        closed: if is_open { None } else { Some(true) },
+    });
+
+    let mut defs = BTreeMap::new();
+    defs.insert("main".into(), user_type);
+
+    let doc = LexiconDoc {
+        lexicon: Lexicon::Lexicon1,
+        id: nsid.clone().into(),
+        revision: None,
+        description: None,
+        defs,
+    };
+
+    // Unions don't have fragments in typical usage
+    let schema_id = nsid.clone();
+
+    Ok(BuiltSchema {
+        nsid,
+        schema_id,
+        doc,
+        validation_checks: Vec::new(), // Unions don't have validation
+        unresolved_refs: Vec::new(),   // Union variants use explicit refs
+    })
+}

crates/jacquard-lexicon/src/schema/from_ast/mod.rs

···
+//! Build lexicon schemas from Rust AST
+//!
+//! This module contains shared logic for building lexicon schemas from Rust syntax trees.
+//! It returns actual LexiconDoc structs (not tokens), enabling both:
+//! 1. Derive macro path: doc → tokens → compiled code
+//! 2. Workspace discovery path: doc directly → JSON
+
+mod builders;
+mod parse;
+mod properties;
+mod types;
+
+// Re-export public API
+pub use builders::{build_enum_schema, build_struct_schema};
+pub use types::{
+    BuiltSchema, ConstraintCheck, FieldProperty, LexiconFieldAttrs, LexiconTypeAttrs,
+    LexiconTypeKind, RenameRule, SerdeAttrs, UnresolvedRef, ValidationCheck,
+};
+
+// Re-export parsing functions for derive macro
+pub use parse::{
+    determine_nsid, extract_option_inner, extract_variant_ref, has_open_union_attr,
+    parse_field_attrs, parse_serde_attrs, parse_serde_rename_all, parse_type_attrs,
+};

crates/jacquard-lexicon/src/schema/from_ast/parse.rs

···
+//! Attribute parsing functions
+
+use super::types::*;
+use syn::{Attribute, DeriveInput, LitStr};
+
+/// Parse type-level lexicon attributes
+pub fn parse_type_attrs(attrs: &[Attribute]) -> syn::Result<LexiconTypeAttrs> {
+    let mut result = LexiconTypeAttrs::default();
+
+    for attr in attrs {
+        if !attr.path().is_ident("lexicon") {
+            continue;
+        }
+
+        attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident("nsid") {
+                let value = meta.value()?;
+                let lit: LitStr = value.parse()?;
+                result.nsid = Some(lit.value());
+                Ok(())
+            } else if meta.path.is_ident("fragment") {
+                if meta.input.peek(syn::Token![=]) {
+                    let value = meta.value()?;
+                    let lit: LitStr = value.parse()?;
+                    result.fragment = Some(lit.value());
+                } else {
+                    result.fragment = Some(String::new());
+                }
+                Ok(())
+            } else if meta.path.is_ident("record") {
+                result.kind = Some(LexiconTypeKind::Record);
+                Ok(())
+            } else if meta.path.is_ident("query") {
+                result.kind = Some(LexiconTypeKind::Query);
+                Ok(())
+            } else if meta.path.is_ident("procedure") {
+                result.kind = Some(LexiconTypeKind::Procedure);
+                Ok(())
+            } else if meta.path.is_ident("subscription") {
+                result.kind = Some(LexiconTypeKind::Subscription);
+                Ok(())
+            } else if meta.path.is_ident("key") {
+                let value = meta.value()?;
+                let lit: LitStr = value.parse()?;
+                result.key = Some(lit.value());
+                Ok(())
+            } else {
+                Err(meta.error("unknown lexicon attribute"))
+            }
+        })?;
+    }
+
+    Ok(result)
+}
+
+/// Parse field-level lexicon attributes
+pub fn parse_field_attrs(attrs: &[Attribute]) -> syn::Result<LexiconFieldAttrs> {
+    let mut result = LexiconFieldAttrs::default();
+
+    for attr in attrs {
+        if !attr.path().is_ident("lexicon") {
+            continue;
+        }
+
+        attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident("max_length") {
+                let value = meta.value()?;
+                let lit: syn::LitInt = value.parse()?;
+                result.max_length = Some(lit.base10_parse()?);
+                Ok(())
+            } else if meta.path.is_ident("max_graphemes") {
+                let value = meta.value()?;
+                let lit: syn::LitInt = value.parse()?;
+                result.max_graphemes = Some(lit.base10_parse()?);
+                Ok(())
+            } else if meta.path.is_ident("min_length") {
+                let value = meta.value()?;
+                let lit: syn::LitInt = value.parse()?;
+                result.min_length = Some(lit.base10_parse()?);
+                Ok(())
+            } else if meta.path.is_ident("min_graphemes") {
+                let value = meta.value()?;
+                let lit: syn::LitInt = value.parse()?;
+                result.min_graphemes = Some(lit.base10_parse()?);
+                Ok(())
+            } else if meta.path.is_ident("minimum") {
+                let value = meta.value()?;
+                let lit: syn::LitInt = value.parse()?;
+                result.minimum = Some(lit.base10_parse()?);
+                Ok(())
+            } else if meta.path.is_ident("maximum") {
+                let value = meta.value()?;
+                let lit: syn::LitInt = value.parse()?;
+                result.maximum = Some(lit.base10_parse()?);
+                Ok(())
+            } else if meta.path.is_ident("ref") {
+                let value = meta.value()?;
+                let lit: LitStr = value.parse()?;
+                result.explicit_ref = Some(lit.value());
+                Ok(())
+            } else if meta.path.is_ident("format") {
+                let value = meta.value()?;
+                let lit: LitStr = value.parse()?;
+                result.format = Some(lit.value());
+                Ok(())
+            } else {
+                Err(meta.error("unknown lexicon field attribute"))
+            }
+        })?;
+    }
+
+    Ok(result)
+}
+
+/// Parse serde attributes for a field
+pub fn parse_serde_attrs(attrs: &[Attribute]) -> syn::Result<SerdeAttrs> {
+    let mut result = SerdeAttrs::default();
+
+    for attr in attrs {
+        if !attr.path().is_ident("serde") {
+            continue;
+        }
+
+        attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident("rename") {
+                let value = meta.value()?;
+                let lit: LitStr = value.parse()?;
+                result.rename = Some(lit.value());
+                Ok(())
+            } else if meta.path.is_ident("skip") {
+                result.skip = true;
+                Ok(())
+            } else {
+                // Ignore other serde attributes
+                Ok(())
+            }
+        })?;
+    }
+
+    Ok(result)
+}
+
+/// Parse container-level serde rename_all
+pub fn parse_serde_rename_all(attrs: &[Attribute]) -> syn::Result<Option<RenameRule>> {
+    for attr in attrs {
+        if !attr.path().is_ident("serde") {
+            continue;
+        }
+
+        let mut found_rule = None;
+        attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident("rename_all") {
+                let value = meta.value()?;
+                let lit: LitStr = value.parse()?;
+                found_rule = RenameRule::from_str(&lit.value());
+                Ok(())
+            } else {
+                Ok(())
+            }
+        })?;
+
+        if found_rule.is_some() {
+            return Ok(found_rule);
+        }
+    }
+
+    // Default to camelCase (lexicon standard)
+    Ok(Some(RenameRule::CamelCase))
+}
+
+/// Determine NSID from attributes and context
+pub fn determine_nsid(attrs: &LexiconTypeAttrs, input: &DeriveInput) -> syn::Result<String> {
+    if let Some(nsid) = &attrs.nsid {
+        return Ok(nsid.clone());
+    }
+
+    if attrs.fragment.is_some() {
+        return Err(syn::Error::new_spanned(
+            input,
+            "fragments require explicit nsid or module-level primary type (not yet implemented)",
+        ));
+    }
+
+    // Check for XrpcRequest derive with NSID
+    if let Some(nsid) = extract_xrpc_nsid(&input.attrs)? {
+        return Ok(nsid);
+    }
+
+    Err(syn::Error::new_spanned(
+        input,
+        "missing required `nsid` attribute (use #[lexicon(nsid = \"...\")] or #[xrpc(nsid = \"...\")])",
+    ))
+}
+
+/// Extract NSID from XrpcRequest attributes (cross-derive coordination)
+fn extract_xrpc_nsid(attrs: &[Attribute]) -> syn::Result<Option<String>> {
+    for attr in attrs {
+        if !attr.path().is_ident("xrpc") {
+            continue;
+        }
+
+        let mut nsid = None;
+        attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident("nsid") {
+                let value = meta.value()?;
+                let lit: LitStr = value.parse()?;
+                nsid = Some(lit.value());
+            }
+            Ok(())
+        })?;
+
+        if let Some(nsid) = nsid {
+            return Ok(Some(nsid));
+        }
+    }
+    Ok(None)
+}
+
+/// Extract T from Option<T>, return (type, is_required)
+pub fn extract_option_inner(ty: &syn::Type) -> (&syn::Type, bool) {
+    if let syn::Type::Path(type_path) = ty {
+        if let Some(segment) = type_path.path.segments.last() {
+            if segment.ident == "Option" {
+                if let syn::PathArguments::AngleBracketed(args) = &segment.arguments {
+                    if let Some(syn::GenericArgument::Type(inner)) = args.args.first() {
+                        return (inner, false);
+                    }
+                }
+            }
+        }
+    }
+    (ty, true)
+}
+
+/// Check if type has #[open_union] attribute
+pub fn has_open_union_attr(attrs: &[Attribute]) -> bool {
+    attrs.iter().any(|attr| attr.path().is_ident("open_union"))
+}
+
+/// Extract NSID ref for a variant
+pub fn extract_variant_ref(variant: &syn::Variant, base_nsid: &str) -> syn::Result<String> {
+    use heck::ToLowerCamelCase;
+
+    // Priority 1: Check for #[nsid = "..."] attribute
+    for attr in &variant.attrs {
+        if attr.path().is_ident("nsid") {
+            if let syn::Meta::NameValue(meta) = &attr.meta {
+                if let syn::Expr::Lit(expr_lit) = &meta.value {
+                    if let syn::Lit::Str(lit_str) = &expr_lit.lit {
+                        return Ok(lit_str.value());
+                    }
+                }
+            }
+        }
+    }
+
+    // Priority 2: Check for #[serde(rename = "...")] attribute
+    for attr in &variant.attrs {
+        if !attr.path().is_ident("serde") {
+            continue;
+        }
+
+        let mut rename = None;
+        let _ = attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident("rename") {
+                let value = meta.value()?;
+                let lit: LitStr = value.parse()?;
+                rename = Some(lit.value());
+            }
+            Ok(())
+        });
+
+        if let Some(rename) = rename {
+            return Ok(rename);
+        }
+    }
+
+    // Priority 3: Generate fragment ref for unit variants
+    match &variant.fields {
+        syn::Fields::Unit => {
+            let variant_name = variant.ident.to_string().to_lower_camel_case();
+            Ok(format!("{}#{}", base_nsid, variant_name))
+        }
+        syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
+            Err(syn::Error::new_spanned(
+                variant,
+                "union variants with non-primitive types must use #[nsid] or #[serde(rename)] attribute to specify the ref",
+            ))
+        }
+        _ => Err(syn::Error::new_spanned(
+            variant,
+            "union variants must be unit variants or have single unnamed field",
+        )),
+    }
+}

crates/jacquard-lexicon/src/schema/from_ast/properties.rs

···
+//! Property building functions
+
+use super::parse::{parse_field_attrs, parse_serde_attrs};
+use super::types::*;
+use crate::lexicon::*;
+use crate::schema::type_mapping::{rust_type_to_lexicon_type, LexiconPrimitiveType};
+use heck::ToLowerCamelCase;
+use std::collections::BTreeMap;
+use syn::Type;
+
+/// Build object properties from struct fields
+pub fn build_object_properties(
+    fields: &syn::Fields,
+    rename_rule: Option<RenameRule>,
+) -> syn::Result<Vec<FieldProperty>> {
+    let named_fields = match fields {
+        syn::Fields::Named(fields) => &fields.named,
+        _ => {
+            return Err(syn::Error::new_spanned(
+                fields,
+                "LexiconSchema only supports structs with named fields",
+            ));
+        }
+    };
+
+    let mut properties = Vec::new();
+
+    for field in named_fields {
+        let field_name = field.ident.as_ref().unwrap().to_string();
+
+        // Skip extra_data field (added by #[lexicon] attribute macro)
+        if field_name == "extra_data" {
+            continue;
+        }
+
+        // Parse attributes
+        let serde_attrs = parse_serde_attrs(&field.attrs)?;
+        let lex_attrs = parse_field_attrs(&field.attrs)?;
+
+        // Skip if serde(skip)
+        if serde_attrs.skip {
+            continue;
+        }
+
+        // Determine schema name
+        let schema_name = if let Some(rename) = serde_attrs.rename {
+            rename
+        } else if let Some(rule) = rename_rule {
+            rule.apply(&field_name)
+        } else {
+            field_name.clone()
+        };
+
+        // Determine if required (Option<T> = optional)
+        let (inner_type, required) = super::parse::extract_option_inner(&field.ty);
+
+        // Build property and validations
+        let field_prop =
+            build_field_property(&field_name, &schema_name, inner_type, required, &lex_attrs)?;
+
+        properties.push(field_prop);
+    }
+
+    Ok(properties)
+}
+
+/// Build a single field property
+fn build_field_property(
+    field_name: &str,
+    schema_name: &str,
+    rust_type: &Type,
+    required: bool,
+    constraints: &LexiconFieldAttrs,
+) -> syn::Result<FieldProperty> {
+    // Build the lexicon property
+    let (property, mut unresolved_refs) = build_lex_property(rust_type, constraints)?;
+
+    // Update field paths in unresolved refs
+    for uref in &mut unresolved_refs {
+        uref.field_path = format!("main.properties.{}", schema_name);
+    }
+
+    // Build validation checks
+    let validations = build_validations(field_name, schema_name, rust_type, required, constraints)?;
+
+    Ok(FieldProperty {
+        field_name: field_name.to_string(),
+        schema_name: schema_name.to_string(),
+        rust_type: rust_type.clone(),
+        property,
+        required,
+        validations,
+        unresolved_refs,
+    })
+}
+
+/// Build LexObjectProperty from Rust type and constraints
+/// Returns (property, unresolved_refs)
+fn build_lex_property(
+    rust_type: &Type,
+    constraints: &LexiconFieldAttrs,
+) -> syn::Result<(LexObjectProperty<'static>, Vec<UnresolvedRef>)> {
+    // Try to detect primitive type
+    let lex_type = rust_type_to_lexicon_type(rust_type);
+
+    match lex_type {
+        Some(LexiconPrimitiveType::Boolean) => Ok((LexObjectProperty::Boolean(LexBoolean {
+            description: None,
+            default: None,
+            r#const: None,
+        }), Vec::new())),
+        Some(LexiconPrimitiveType::Integer) => Ok((LexObjectProperty::Integer(LexInteger {
+            description: None,
+            default: None,
+            minimum: constraints.minimum,
+            maximum: constraints.maximum,
+            r#enum: None,
+            r#const: None,
+        }), Vec::new())),
+        Some(LexiconPrimitiveType::String(format)) => Ok((LexObjectProperty::String(
+            build_string_property(format, constraints),
+        ), Vec::new())),
+        Some(LexiconPrimitiveType::Bytes) => Ok((LexObjectProperty::Bytes(LexBytes {
+            description: None,
+            max_length: constraints.max_length,
+            min_length: constraints.min_length,
+        }), Vec::new())),
+        Some(LexiconPrimitiveType::CidLink) => {
+            Ok((LexObjectProperty::CidLink(LexCidLink { description: None }), Vec::new()))
+        }
+        Some(LexiconPrimitiveType::Blob) => Ok((LexObjectProperty::Blob(LexBlob {
+            description: None,
+            accept: None,
+            max_size: None,
+        }), Vec::new())),
+        Some(LexiconPrimitiveType::Unknown) => {
+            Ok((LexObjectProperty::Unknown(LexUnknown { description: None }), Vec::new()))
+        }
+        Some(LexiconPrimitiveType::Array(item_type)) => {
+            let (item_prop, unresolved) = build_array_item(*item_type)?;
+            Ok((LexObjectProperty::Array(LexArray {
+                description: None,
+                items: item_prop,
+                min_length: constraints.min_length,
+                max_length: constraints.max_length,
+            }), unresolved))
+        }
+        Some(LexiconPrimitiveType::Object) => {
+            // Nested object - shouldn't typically happen, use Unknown
+            Ok((LexObjectProperty::Unknown(LexUnknown { description: None }), Vec::new()))
+        }
+        Some(LexiconPrimitiveType::Ref(ref_nsid)) => Ok((LexObjectProperty::Ref(LexRef {
+            description: None,
+            r#ref: ref_nsid.into(),
+        }), Vec::new())),
+        Some(LexiconPrimitiveType::Union(_refs)) => {
+            // Union types detected - would need to be generated differently
+            // For now, use Unknown
+            Ok((LexObjectProperty::Unknown(LexUnknown { description: None }), Vec::new()))
+        }
+        None => {
+            // Not a primitive - check for explicit ref
+            if let Some(ref_nsid) = &constraints.explicit_ref {
+                Ok((LexObjectProperty::Ref(LexRef {
+                    description: None,
+                    r#ref: ref_nsid.clone().into(),
+                }), Vec::new()))
+            } else {
+                // Type doesn't have explicit ref - create placeholder and track as unresolved
+                let type_str = quote::quote!(#rust_type).to_string();
+                let placeholder = format!("#unresolved:{}", extract_type_name(&type_str));
+
+                let unresolved = UnresolvedRef {
+                    rust_type: type_str,
+                    field_path: String::new(), // Will be filled in by caller
+                    placeholder_ref: placeholder.clone(),
+                };
+
+                Ok((LexObjectProperty::Ref(LexRef {
+                    description: None,
+                    r#ref: placeholder.into(),
+                }), vec![unresolved]))
+            }
+        }
+    }
+}
+
+/// Extract simple type name from type path (e.g., "FeedViewPost" from "app::bsky::FeedViewPost")
+fn extract_type_name(type_str: &str) -> String {
+    type_str
+        .split("::")
+        .last()
+        .unwrap_or(type_str)
+        .trim_matches(|c| c == '<' || c == '>' || c == ' ')
+        .to_string()
+        .to_lower_camel_case()
+}
+
+/// Build array item property
+/// Returns (item, unresolved_refs)
+fn build_array_item(item_type: LexiconPrimitiveType) -> syn::Result<(LexArrayItem<'static>, Vec<UnresolvedRef>)> {
+    match item_type {
+        LexiconPrimitiveType::String(format) => {
+            let format_enum = match format {
+                crate::schema::type_mapping::StringFormat::Plain => None,
+                crate::schema::type_mapping::StringFormat::Did => Some(LexStringFormat::Did),
+                crate::schema::type_mapping::StringFormat::Handle => Some(LexStringFormat::Handle),
+                crate::schema::type_mapping::StringFormat::AtUri => Some(LexStringFormat::AtUri),
+                crate::schema::type_mapping::StringFormat::Nsid => Some(LexStringFormat::Nsid),
+                crate::schema::type_mapping::StringFormat::Cid => Some(LexStringFormat::Cid),
+                crate::schema::type_mapping::StringFormat::Datetime => {
+                    Some(LexStringFormat::Datetime)
+                }
+                crate::schema::type_mapping::StringFormat::Language => {
+                    Some(LexStringFormat::Language)
+                }
+                crate::schema::type_mapping::StringFormat::Tid => Some(LexStringFormat::Tid),
+                crate::schema::type_mapping::StringFormat::RecordKey => {
+                    Some(LexStringFormat::RecordKey)
+                }
+                crate::schema::type_mapping::StringFormat::AtIdentifier => {
+                    Some(LexStringFormat::AtIdentifier)
+                }
+                crate::schema::type_mapping::StringFormat::Uri => Some(LexStringFormat::Uri),
+            };
+            Ok((LexArrayItem::String(LexString {
+                description: None,
+                format: format_enum,
+                default: None,
+                min_length: None,
+                max_length: None,
+                min_graphemes: None,
+                max_graphemes: None,
+                r#enum: None,
+                r#const: None,
+                known_values: None,
+            }), Vec::new()))
+        }
+        LexiconPrimitiveType::Integer => Ok((LexArrayItem::Integer(LexInteger {
+            description: None,
+            default: None,
+            minimum: None,
+            maximum: None,
+            r#enum: None,
+            r#const: None,
+        }), Vec::new())),
+        LexiconPrimitiveType::Boolean => Ok((LexArrayItem::Boolean(LexBoolean {
+            description: None,
+            default: None,
+            r#const: None,
+        }), Vec::new())),
+        LexiconPrimitiveType::Bytes => Ok((LexArrayItem::Bytes(LexBytes {
+            description: None,
+            max_length: None,
+            min_length: None,
+        }), Vec::new())),
+        LexiconPrimitiveType::CidLink => {
+            Ok((LexArrayItem::CidLink(LexCidLink { description: None }), Vec::new()))
+        }
+        LexiconPrimitiveType::Blob => Ok((LexArrayItem::Blob(LexBlob {
+            description: None,
+            accept: None,
+            max_size: None,
+        }), Vec::new())),
+        LexiconPrimitiveType::Unknown => {
+            Ok((LexArrayItem::Unknown(LexUnknown { description: None }), Vec::new()))
+        }
+        LexiconPrimitiveType::Ref(ref_nsid) => Ok((LexArrayItem::Ref(LexRef {
+            description: None,
+            r#ref: ref_nsid.into(),
+        }), Vec::new())),
+        LexiconPrimitiveType::Object => {
+            // Object in array - return empty object
+            Ok((LexArrayItem::Object(LexObject {
+                description: None,
+                required: None,
+                nullable: None,
+                properties: BTreeMap::new(),
+            }), Vec::new()))
+        }
+        LexiconPrimitiveType::Union(refs) => {
+            // Union in array - create union with refs
+            Ok((LexArrayItem::Union(LexRefUnion {
+                description: None,
+                refs: refs.into_iter().map(Into::into).collect(),
+                closed: None,
+            }), Vec::new()))
+        }
+        LexiconPrimitiveType::Array(_) => {
+            // Nested arrays not supported in lexicon - return Unknown
+            Ok((LexArrayItem::Unknown(LexUnknown {
+                description: None,
+            }), Vec::new()))
+        }
+    }
+}
+
+/// Build string property with format
+fn build_string_property(
+    format: crate::schema::type_mapping::StringFormat,
+    constraints: &LexiconFieldAttrs,
+) -> LexString<'static> {
+    use crate::schema::type_mapping::StringFormat;
+
+    let format_enum = match format {
+        StringFormat::Plain => None,
+        StringFormat::Did => Some(LexStringFormat::Did),
+        StringFormat::Handle => Some(LexStringFormat::Handle),
+        StringFormat::AtUri => Some(LexStringFormat::AtUri),
+        StringFormat::Nsid => Some(LexStringFormat::Nsid),
+        StringFormat::Cid => Some(LexStringFormat::Cid),
+        StringFormat::Datetime => Some(LexStringFormat::Datetime),
+        StringFormat::Language => Some(LexStringFormat::Language),
+        StringFormat::Tid => Some(LexStringFormat::Tid),
+        StringFormat::RecordKey => Some(LexStringFormat::RecordKey),
+        StringFormat::AtIdentifier => Some(LexStringFormat::AtIdentifier),
+        StringFormat::Uri => Some(LexStringFormat::Uri),
+    };
+
+    LexString {
+        description: None,
+        format: format_enum,
+        default: None,
+        min_length: constraints.min_length,
+        max_length: constraints.max_length,
+        min_graphemes: constraints.min_graphemes,
+        max_graphemes: constraints.max_graphemes,
+        r#enum: None,
+        r#const: None,
+        known_values: None,
+    }
+}
+
+/// Build validation checks for a field
+fn build_validations(
+    field_name: &str,
+    schema_name: &str,
+    field_type: &Type,
+    is_required: bool,
+    constraints: &LexiconFieldAttrs,
+) -> syn::Result<Vec<ValidationCheck>> {
+    let mut checks = Vec::new();
+    let lex_type = rust_type_to_lexicon_type(field_type);
+
+    let field_type_str = quote::quote!(#field_type).to_string();
+
+    match lex_type {
+        Some(LexiconPrimitiveType::String(_)) => {
+            if let Some(max) = constraints.max_length {
+                checks.push(ValidationCheck {
+                    field_name: field_name.to_string(),
+                    schema_name: schema_name.to_string(),
+                    field_type: field_type_str.clone(),
+                    is_required,
+                    check: ConstraintCheck::MaxLength { max },
+                });
+            }
+            if let Some(max) = constraints.max_graphemes {
+                checks.push(ValidationCheck {
+                    field_name: field_name.to_string(),
+                    schema_name: schema_name.to_string(),
+                    field_type: field_type_str.clone(),
+                    is_required,
+                    check: ConstraintCheck::MaxGraphemes { max },
+                });
+            }
+            if let Some(min) = constraints.min_length {
+                checks.push(ValidationCheck {
+                    field_name: field_name.to_string(),
+                    schema_name: schema_name.to_string(),
+                    field_type: field_type_str.clone(),
+                    is_required,
+                    check: ConstraintCheck::MinLength { min },
+                });
+            }
+            if let Some(min) = constraints.min_graphemes {
+                checks.push(ValidationCheck {
+                    field_name: field_name.to_string(),
+                    schema_name: schema_name.to_string(),
+                    field_type: field_type_str,
+                    is_required,
+                    check: ConstraintCheck::MinGraphemes { min },
+                });
+            }
+        }
+        Some(LexiconPrimitiveType::Integer) => {
+            if let Some(max) = constraints.maximum {
+                checks.push(ValidationCheck {
+                    field_name: field_name.to_string(),
+                    schema_name: schema_name.to_string(),
+                    field_type: field_type_str.clone(),
+                    is_required,
+                    check: ConstraintCheck::Maximum { max },
+                });
+            }
+            if let Some(min) = constraints.minimum {
+                checks.push(ValidationCheck {
+                    field_name: field_name.to_string(),
+                    schema_name: schema_name.to_string(),
+                    field_type: field_type_str,
+                    is_required,
+                    check: ConstraintCheck::Minimum { min },
+                });
+            }
+        }
+        Some(LexiconPrimitiveType::Array(_)) => {
+            if let Some(max) = constraints.max_length {
+                checks.push(ValidationCheck {
+                    field_name: field_name.to_string(),
+                    schema_name: schema_name.to_string(),
+                    field_type: field_type_str.clone(),
+                    is_required,
+                    check: ConstraintCheck::MaxLength { max },
+                });
+            }
+            if let Some(min) = constraints.min_length {
+                checks.push(ValidationCheck {
+                    field_name: field_name.to_string(),
+                    schema_name: schema_name.to_string(),
+                    field_type: field_type_str,
+                    is_required,
+                    check: ConstraintCheck::MinLength { min },
+                });
+            }
+        }
+        _ => {
+            // No validation for other types
+        }
+    }
+
+    Ok(checks)
+}

crates/jacquard-lexicon/src/schema/from_ast/types.rs

···
+//! Type definitions for schema building
+
+use crate::lexicon::*;
+use syn::Type;
+
+/// Result of building a schema from AST
+#[derive(Debug, Clone)]
+pub struct BuiltSchema {
+    /// Base NSID (without fragment)
+    pub nsid: String,
+    /// Full schema ID (NSID + fragment if applicable)
+    pub schema_id: String,
+    /// The lexicon document
+    pub doc: LexiconDoc<'static>,
+    /// Runtime validation checks
+    pub validation_checks: Vec<ValidationCheck>,
+    /// Unresolved type refs (for two-pass resolution in workspace discovery)
+    pub unresolved_refs: Vec<UnresolvedRef>,
+}
+
+/// A reference to a type that couldn't be resolved at build time
+#[derive(Debug, Clone)]
+pub struct UnresolvedRef {
+    /// The Rust type that needs resolution
+    pub rust_type: String,
+    /// Field path where this ref appears (e.g., "main.properties.author")
+    pub field_path: String,
+    /// Placeholder ref currently in the schema (will be replaced)
+    pub placeholder_ref: String,
+}
+
+/// A runtime validation requirement
+#[derive(Debug, Clone)]
+pub struct ValidationCheck {
+    /// Field name (Rust identifier)
+    pub field_name: String,
+    /// Schema field name (JSON name after serde rename)
+    pub schema_name: String,
+    /// Rust type path (for diagnostic purposes)
+    pub field_type: String,
+    /// Is this field required (not Option<T>)?
+    pub is_required: bool,
+    /// The specific constraint to check
+    pub check: ConstraintCheck,
+}
+
+/// Specific constraint checks
+#[derive(Debug, Clone)]
+pub enum ConstraintCheck {
+    MaxLength { max: usize },
+    MaxGraphemes { max: usize },
+    MinLength { min: usize },
+    MinGraphemes { min: usize },
+    Maximum { max: i64 },
+    Minimum { min: i64 },
+}
+
+/// Parsed lexicon attributes from type
+#[derive(Debug, Default)]
+pub struct LexiconTypeAttrs {
+    /// NSID for this type (required for primary types)
+    pub nsid: Option<String>,
+    /// Fragment name (None = not a fragment, Some("") = infer from type name)
+    pub fragment: Option<String>,
+    /// Type kind
+    pub kind: Option<LexiconTypeKind>,
+    /// Record key type (for records)
+    pub key: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum LexiconTypeKind {
+    Record,
+    Query,
+    Procedure,
+    Subscription,
+    Object,
+    Union,
+}
+
+/// Parsed lexicon attributes from field
+#[derive(Debug, Default, Clone)]
+pub struct LexiconFieldAttrs {
+    pub max_length: Option<usize>,
+    pub max_graphemes: Option<usize>,
+    pub min_length: Option<usize>,
+    pub min_graphemes: Option<usize>,
+    pub minimum: Option<i64>,
+    pub maximum: Option<i64>,
+    pub explicit_ref: Option<String>,
+    pub format: Option<String>,
+}
+
+/// Parsed serde attributes relevant to lexicon schema
+#[derive(Debug, Default)]
+pub struct SerdeAttrs {
+    pub rename: Option<String>,
+    pub skip: bool,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum RenameRule {
+    CamelCase,
+    SnakeCase,
+    PascalCase,
+    ScreamingSnakeCase,
+    KebabCase,
+}
+
+impl RenameRule {
+    pub fn from_str(s: &str) -> Option<Self> {
+        match s {
+            "camelCase" => Some(RenameRule::CamelCase),
+            "snake_case" => Some(RenameRule::SnakeCase),
+            "PascalCase" => Some(RenameRule::PascalCase),
+            "SCREAMING_SNAKE_CASE" => Some(RenameRule::ScreamingSnakeCase),
+            "kebab-case" => Some(RenameRule::KebabCase),
+            _ => None,
+        }
+    }
+
+    pub fn apply(&self, input: &str) -> String {
+        use heck::*;
+        match self {
+            RenameRule::CamelCase => input.to_lower_camel_case(),
+            RenameRule::SnakeCase => input.to_snake_case(),
+            RenameRule::PascalCase => input.to_pascal_case(),
+            RenameRule::ScreamingSnakeCase => input.to_shouty_snake_case(),
+            RenameRule::KebabCase => input.to_kebab_case(),
+        }
+    }
+}
+
+/// Field property (intermediate representation)
+pub struct FieldProperty {
+    /// Rust field name
+    pub field_name: String,
+    /// JSON field name (after serde rename)
+    pub schema_name: String,
+    /// Rust type
+    pub rust_type: Type,
+    /// Lexicon property
+    pub property: LexObjectProperty<'static>,
+    /// Is required?
+    pub required: bool,
+    /// Validation checks
+    pub validations: Vec<ValidationCheck>,
+    /// Unresolved refs from this field
+    pub unresolved_refs: Vec<UnresolvedRef>,
+}