fix graphql schema builder to handle local and external lexicon refs

- Handle local refs starting with # (e.g., #image)
- Handle external refs with specific def (e.g., app.bsky.embed.defs#aspectRatio)
- Handle external refs to main def (e.g., community.lexicon.location.hthree)
- Add extract_fields_from_properties() to extract fields from lexicon def properties
- Add capitalize_first() helper function
- Pass current lexicon NSID through resolve chain to support local ref resolution
- Generate proper type names: AppBskyEmbedImagesImage, AppBskyEmbedDefsAspectRatio, etc.
- Fixes schema build error for slices using AT Protocol standard lexicons with local refs

api/src/graphql/schema_builder.rs

···
 /// Returns the generated type name
 fn resolve_lexicon_ref_type(
     ref_nsid: &str,
+    current_lexicon_nsid: &str,
     all_lexicons: &[serde_json::Value],
     type_registry: &mut TypeRegistry,
     database: &Database,
 ) -> String {
-    // Generate type name from NSID
-    let type_name = nsid_to_type_name(ref_nsid);
+    // Handle different ref formats:
+    // 1. Local ref: #image
+    // 2. External ref with specific def: app.bsky.embed.defs#aspectRatio
+    // 3. External ref to main: community.lexicon.location.hthree
+    let (target_nsid, def_name) = if ref_nsid.starts_with('#') {
+        // Local ref - use current lexicon NSID and the def name without #
+        (current_lexicon_nsid, &ref_nsid[1..])
+    } else if let Some(hash_pos) = ref_nsid.find('#') {
+        // External ref with specific def - split on #
+        (&ref_nsid[..hash_pos], &ref_nsid[hash_pos + 1..])
+    } else {
+        // External ref to main def
+        (ref_nsid, "main")
+    };
+
+    // Generate type name from NSID and def name
+    let type_name = if def_name == "main" {
+        // For refs to main: CommunityLexiconLocationHthree
+        nsid_to_type_name(target_nsid)
+    } else {
+        // For refs to specific def: AppBskyEmbedDefsAspectRatio
+        format!("{}{}", nsid_to_type_name(target_nsid), capitalize_first(def_name))
+    };
 
     // Check if already generated
     if type_registry.contains_key(&type_name) {
···
 
     // Find the lexicon definition
     let lexicon = all_lexicons.iter().find(|lex| {
-        lex.get("id").and_then(|id| id.as_str()) == Some(ref_nsid)
+        lex.get("id").and_then(|id| id.as_str()) == Some(target_nsid)
     });
 
     if let Some(lex) = lexicon {
-        // Extract the main definition
+        // Extract the definition (either "main" or specific def like "image")
         if let Some(defs) = lex.get("defs") {
-            let fields = extract_collection_fields(defs);
+            if let Some(def) = defs.get(def_name) {
+                // Extract fields from this specific definition
+                if let Some(properties) = def.get("properties") {
+                    let fields = extract_fields_from_properties(properties);
 
-            if !fields.is_empty() {
-                // Generate the type using existing nested object generator
-                generate_nested_object_type(&type_name, &fields, type_registry, database);
-                return type_name;
+                    if !fields.is_empty() {
+                        // Generate the type using existing nested object generator
+                        generate_nested_object_type(&type_name, &fields, type_registry, database);
+                        return type_name;
+                    }
+                }
             }
         }
     }
 
     // Fallback: couldn't resolve the ref, will use JSON
-    tracing::warn!("Could not resolve lexicon ref: {}", ref_nsid);
+    tracing::warn!("Could not resolve lexicon ref: {} (target: {}, def: {})", ref_nsid, target_nsid, def_name);
     type_name
+}
+
+/// Capitalizes the first character of a string
+fn capitalize_first(s: &str) -> String {
+    let mut chars = s.chars();
+    match chars.next() {
+        None => String::new(),
+        Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
+    }
+}
+
+/// Extracts fields from a lexicon properties object
+fn extract_fields_from_properties(properties: &serde_json::Value) -> Vec<GraphQLField> {
+    let mut fields = Vec::new();
+
+    if let Some(props) = properties.as_object() {
+        for (field_name, field_def) in props {
+            let field_type_str = field_def.get("type").and_then(|t| t.as_str()).unwrap_or("unknown");
+            let field_type = crate::graphql::types::map_lexicon_type_to_graphql(field_type_str, field_def);
+
+            // Check if field is required
+            let is_required = false; // We'd need the parent's "required" array to know this
+
+            // Extract format if present
+            let format = field_def.get("format").and_then(|f| f.as_str()).map(|s| s.to_string());
+
+            fields.push(GraphQLField {
+                name: field_name.clone(),
+                field_type,
+                is_required,
+                format,
+            });
+        }
+    }
+
+    fields
 }
 
 /// Recursively generates GraphQL object types for nested objects
···
                 auth_base_url.clone(),
                 &mut type_registry,
                 &lexicons,
+                nsid,
             );
 
             // Create edge and connection types for this collection (Relay standard)
···
     auth_base_url: String,
     type_registry: &mut TypeRegistry,
     all_lexicons: &[serde_json::Value],
+    lexicon_nsid: &str,
 ) -> Object {
     let mut object = Object::new(type_name);
 
···
                 // Resolve lexicon ref and generate type for it
                 let resolved_type_name = resolve_lexicon_ref_type(
                     ref_nsid,
+                    lexicon_nsid,
                     all_lexicons,
                     type_registry,
                     &database,
···
                         // Resolve lexicon ref for array items
                         let resolved_type_name = resolve_lexicon_ref_type(
                             ref_nsid,
+                            lexicon_nsid,
                             all_lexicons,
                             type_registry,
                             &database,