fix cross-lexicon reference resolution in union types, bump to 0.2.3

Fixes validation error where local references in unions weren't resolved
correctly after following cross-lexicon references. Also updates README
title and adds repository URL to Cargo.toml.

api/Cargo.lock

···
 
 [[package]]
 name = "slices"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "anyhow",
  "async-graphql",
···
 
 [[package]]
 name = "slices-lexicon"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "base64 0.21.7",
  "chrono",

crates/slices-lexicon/Cargo.lock

···
 
 [[package]]
 name = "slices-lexicon"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "base64",
  "chrono",

crates/slices-lexicon/Cargo.toml

···
 [package]
 name = "slices-lexicon"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 description = "AT Protocol lexicon validation library for Slices"
 license = "MIT"
+repository = "https://tangled.org/@slices.network/slices/tree/main/crates/slices-lexicon"
 documentation = "https://docs.rs/slices-lexicon"
 readme = "README.md"
 keywords = ["atproto", "lexicon", "validation", "wasm", "bluesky"]

crates/slices-lexicon/README.md

···
-# lexicon-rs
+# slices-lexicon
 
 Rust implementation of AT Protocol lexicon validation.
 

crates/slices-lexicon/src/validation/context.rs

···
     /// Creates a new context with the reference added to the resolution stack
     ///
     /// This is used during recursive reference resolution to detect circular references.
+    /// Also updates the current lexicon context to the referenced lexicon, ensuring that
+    /// local references within the resolved schema are resolved in the correct lexicon.
     ///
     /// # Arguments
     ///
···
     ///
     /// # Returns
     ///
-    /// A new `ValidationContext` with the reference added to the stack
+    /// A new `ValidationContext` with the reference added to the stack and current lexicon updated
     pub fn with_reference(&self, reference: &str) -> Self {
         let mut reference_stack = self.reference_stack.clone();
         reference_stack.insert(reference.to_string());
 
+        // Parse the reference to extract the target lexicon ID
+        // This ensures local references in the resolved schema are resolved in the correct context
+        let new_current_lexicon_id = if let Ok((lexicon_id, _def_name)) = self.parse_reference(reference) {
+            Some(lexicon_id)
+        } else {
+            // If parsing fails, keep the current lexicon ID
+            self.current_lexicon_id.clone()
+        };
+
         Self {
             lexicons: self.lexicons.clone(),
             path: self.path.clone(),
             strict_mode: self.strict_mode,
-            current_lexicon_id: self.current_lexicon_id.clone(),
+            current_lexicon_id: new_current_lexicon_id,
             reference_stack,
         }
     }
···
         let image_schema = ctx.resolve_reference("com.example.media#image").unwrap();
         assert_eq!(image_schema.get("type").and_then(|t| t.as_str()), Some("object"));
         assert!(image_schema.get("required").is_some());
+    }
+
+    #[test]
+    fn test_cross_lexicon_union_with_local_refs() {
+        // Regression test for bug where local references in a union weren't resolved
+        // in the correct lexicon context after a cross-lexicon reference.
+        // This mirrors the pub.leaflet.blocks.text -> pub.leaflet.richtext.facet scenario
+
+        let ctx = ValidationContext::builder()
+            .with_lexicons(vec![
+                json!({
+                    "lexicon": 1,
+                    "id": "pub.leaflet.blocks.text",
+                    "defs": {
+                        "main": {
+                            "type": "object",
+                            "required": ["plaintext"],
+                            "properties": {
+                                "plaintext": {"type": "string"},
+                                "facets": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "ref",
+                                        "ref": "pub.leaflet.richtext.facet"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }),
+                json!({
+                    "lexicon": 1,
+                    "id": "pub.leaflet.richtext.facet",
+                    "defs": {
+                        "main": {
+                            "type": "object",
+                            "required": ["index", "features"],
+                            "properties": {
+                                "index": {"type": "ref", "ref": "#byteSlice"},
+                                "features": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "union",
+                                        "refs": ["#bold", "#italic", "#link"]
+                                    }
+                                }
+                            }
+                        },
+                        "byteSlice": {
+                            "type": "object",
+                            "required": ["byteStart", "byteEnd"],
+                            "properties": {
+                                "byteStart": {"type": "integer", "minimum": 0},
+                                "byteEnd": {"type": "integer", "minimum": 0}
+                            }
+                        },
+                        "bold": {
+                            "type": "object",
+                            "description": "Facet feature for bold text",
+                            "properties": {}
+                        },
+                        "italic": {
+                            "type": "object",
+                            "description": "Facet feature for italic text",
+                            "properties": {}
+                        },
+                        "link": {
+                            "type": "object",
+                            "required": ["uri"],
+                            "properties": {
+                                "uri": {"type": "string", "format": "uri"}
+                            }
+                        }
+                    }
+                })
+            ])
+            .unwrap()
+            .build()
+            .unwrap()
+            .with_current_lexicon("pub.leaflet.blocks.text");
+
+        // Test 1: Verify we can resolve the cross-lexicon reference
+        let facet_schema = ctx.resolve_reference("pub.leaflet.richtext.facet").unwrap();
+        assert_eq!(facet_schema.get("type").and_then(|t| t.as_str()), Some("object"));
+
+        // Test 2: Verify that with_reference updates the current lexicon context correctly
+        let ref_ctx = ctx.with_reference("pub.leaflet.richtext.facet");
+        assert_eq!(ref_ctx.current_lexicon_id(), Some("pub.leaflet.richtext.facet"));
+
+        // Test 3: Most importantly - verify local references resolve in the TARGET lexicon
+        // This is the bug we fixed: #bold should resolve in pub.leaflet.richtext.facet, not pub.leaflet.blocks.text
+        let bold_schema = ref_ctx.resolve_reference("#bold").unwrap();
+        assert_eq!(bold_schema.get("type").and_then(|t| t.as_str()), Some("object"));
+        assert_eq!(bold_schema.get("description").and_then(|d| d.as_str()), Some("Facet feature for bold text"));
+
+        // Test 4: Verify other local references in the union also work
+        let italic_schema = ref_ctx.resolve_reference("#italic").unwrap();
+        assert_eq!(italic_schema.get("description").and_then(|d| d.as_str()), Some("Facet feature for italic text"));
+
+        let link_schema = ref_ctx.resolve_reference("#link").unwrap();
+        assert!(link_schema.get("required").is_some());
     }
 
 }

crates/slices-lexicon/src/validation/field/array.rs

···
             })])
             .unwrap()
             .build()
-            .unwrap();
+            .unwrap()
+            .with_current_lexicon("com.example.test");
 
         let validator = ArrayValidator;
         assert!(validator.validate(&array_def, &ctx).is_ok());

crates/slices-lexicon/src/validation/field/union.rs

···
             .with_lexicons(vec![json!({
                 "lexicon": 1,
                 "id": "com.example.test",
-                "defs": { "main": union_def.clone() }
+                "defs": {
+                    "main": union_def.clone(),
+                    "post": { "type": "object", "properties": {} },
+                    "repost": { "type": "object", "properties": {} }
+                }
             })])
             .unwrap()
             .build()
-            .unwrap();
+            .unwrap()
+            .with_current_lexicon("com.example.test");
 
         let validator = UnionValidator;
         assert!(validator.validate(&union_def, &ctx).is_ok());

crates/slices-lexicon/src/validation/primary/record.rs

···
             })])
             .unwrap()
             .build()
-            .unwrap();
+            .unwrap()
+            .with_current_lexicon("com.example.test");
 
         let validator = RecordValidator;
         assert!(validator.validate(&schema, &ctx).is_ok());

crates/slices-lexicon/src/validation/primary/subscription.rs

···
             .with_lexicons(vec![json!({
                 "lexicon": 1,
                 "id": "com.example.test",
-                "defs": { "main": subscription.clone() }
+                "defs": {
+                    "main": subscription.clone(),
+                    "post": { "type": "object", "properties": {} },
+                    "like": { "type": "object", "properties": {} }
+                }
             })])
             .unwrap()
             .build()
-            .unwrap();
+            .unwrap()
+            .with_current_lexicon("com.example.test");
 
         let validator = SubscriptionValidator;
         assert!(validator.validate(&subscription, &ctx).is_ok());