feature: Adding facets to lexicon community calendar events

crates/atproto-record/src/lexicon/app_bsky_richtext_facet.rs

···
+//! AT Protocol rich text facet types.
+//!
+//! This module provides types for annotating rich text content with semantic
+//! meaning, based on the `app.bsky.richtext.facet` lexicon. Facets enable
+//! mentions, links, hashtags, and other structured metadata to be attached
+//! to specific byte ranges within text content.
+//!
+//! # Overview
+//!
+//! Facets consist of:
+//! - A byte range (start/end indices in UTF-8 encoded text)
+//! - One or more features (mention, link, tag) that apply to that range
+//!
+//! # Example
+//!
+//! ```ignore
+//! use atproto_record::lexicon::app::bsky::richtext::facet::{Facet, ByteSlice, FacetFeature, Mention};
+//!
+//! // Create a mention facet for "@alice.bsky.social"
+//! let facet = Facet {
+//!     index: ByteSlice { byte_start: 0, byte_end: 19 },
+//!     features: vec![
+//!         FacetFeature::Mention(Mention {
+//!             did: "did:plc:alice123".to_string(),
+//!         })
+//!     ],
+//! };
+//! ```
+
+use serde::{Deserialize, Serialize};
+
+/// Byte range specification for facet features.
+///
+/// Specifies the sub-string range a facet feature applies to using
+/// zero-indexed byte offsets in UTF-8 encoded text. Start index is
+/// inclusive, end index is exclusive.
+///
+/// # Example
+///
+/// ```ignore
+/// use atproto_record::lexicon::app::bsky::richtext::facet::ByteSlice;
+///
+/// // Represents bytes 0-5 of the text
+/// let slice = ByteSlice {
+///     byte_start: 0,
+///     byte_end: 5,
+/// };
+/// ```
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct ByteSlice {
+    /// Starting byte index (inclusive)
+    pub byte_start: usize,
+
+    /// Ending byte index (exclusive)
+    pub byte_end: usize,
+}
+
+/// Mention facet feature for referencing another account.
+///
+/// The text content typically displays a handle with '@' prefix (e.g., "@alice.bsky.social"),
+/// but the facet reference must use the account's DID for stable identification.
+///
+/// # Example
+///
+/// ```ignore
+/// use atproto_record::lexicon::app::bsky::richtext::facet::Mention;
+///
+/// let mention = Mention {
+///     did: "did:plc:alice123".to_string(),
+/// };
+/// ```
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub struct Mention {
+    /// DID of the mentioned account
+    pub did: String,
+}
+
+/// Link facet feature for URL references.
+///
+/// The text content may be simplified or truncated for display purposes,
+/// but the facet reference should contain the complete, valid URL.
+///
+/// # Example
+///
+/// ```ignore
+/// use atproto_record::lexicon::app::bsky::richtext::facet::Link;
+///
+/// let link = Link {
+///     uri: "https://example.com/full/path".to_string(),
+/// };
+/// ```
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub struct Link {
+    /// Complete URI/URL for the link
+    pub uri: String,
+}
+
+/// Tag facet feature for hashtags.
+///
+/// The text content typically includes a '#' prefix for display,
+/// but the facet reference should contain only the tag text without the prefix.
+///
+/// # Example
+///
+/// ```ignore
+/// use atproto_record::lexicon::app::bsky::richtext::facet::Tag;
+///
+/// // For text "#atproto", store just "atproto"
+/// let tag = Tag {
+///     tag: "atproto".to_string(),
+/// };
+/// ```
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub struct Tag {
+    /// Tag text without '#' prefix
+    pub tag: String,
+}
+
+/// Discriminated union of facet feature types.
+///
+/// Represents the different types of semantic annotations that can be
+/// applied to text ranges. Each variant corresponds to a specific lexicon
+/// type in the `app.bsky.richtext.facet` namespace.
+///
+/// # Example
+///
+/// ```ignore
+/// use atproto_record::lexicon::app::bsky::richtext::facet::{FacetFeature, Mention, Link, Tag};
+///
+/// // Create different feature types
+/// let mention = FacetFeature::Mention(Mention {
+///     did: "did:plc:alice123".to_string(),
+/// });
+///
+/// let link = FacetFeature::Link(Link {
+///     uri: "https://example.com".to_string(),
+/// });
+///
+/// let tag = FacetFeature::Tag(Tag {
+///     tag: "rust".to_string(),
+/// });
+/// ```
+#[derive(Serialize, Deserialize, Clone, PartialEq)]
+#[cfg_attr(debug_assertions, derive(Debug))]
+#[serde(tag = "$type")]
+pub enum FacetFeature {
+    /// Account mention feature
+    #[serde(rename = "app.bsky.richtext.facet#mention")]
+    Mention(Mention),
+
+    /// URL link feature
+    #[serde(rename = "app.bsky.richtext.facet#link")]
+    Link(Link),
+
+    /// Hashtag feature
+    #[serde(rename = "app.bsky.richtext.facet#tag")]
+    Tag(Tag),
+}
+
+/// Rich text facet annotation.
+///
+/// Associates one or more semantic features with a specific byte range
+/// within text content. Multiple features can apply to the same range
+/// (e.g., a URL that is also a hashtag).
+///
+/// # Example
+///
+/// ```ignore
+/// use atproto_record::lexicon::app::bsky::richtext::facet::{
+///     Facet, ByteSlice, FacetFeature, Mention, Link
+/// };
+///
+/// // Annotate "@alice.bsky.social" at bytes 0-19
+/// let facet = Facet {
+///     index: ByteSlice { byte_start: 0, byte_end: 19 },
+///     features: vec![
+///         FacetFeature::Mention(Mention {
+///             did: "did:plc:alice123".to_string(),
+///         }),
+///     ],
+/// };
+///
+/// // Multiple features for the same range
+/// let multi_facet = Facet {
+///     index: ByteSlice { byte_start: 20, byte_end: 35 },
+///     features: vec![
+///         FacetFeature::Link(Link {
+///             uri: "https://example.com".to_string(),
+///         }),
+///         FacetFeature::Tag(Tag {
+///             tag: "example".to_string(),
+///         }),
+///     ],
+/// };
+/// ```
+#[derive(Serialize, Deserialize, Clone, PartialEq)]
+#[cfg_attr(debug_assertions, derive(Debug))]
+pub struct Facet {
+    /// Byte range this facet applies to
+    pub index: ByteSlice,
+
+    /// Semantic features applied to this range
+    pub features: Vec<FacetFeature>,
+}

crates/atproto-record/src/lexicon/community_lexicon_attestation.rs

···
 ///
 /// // Inline signature
 /// let inline = SignatureOrRef::Inline(create_typed_signature(
-///     "did:plc:issuer".to_string(),
 ///     Bytes { bytes: b"signature".to_vec() },
 /// ));
 ///
···
 
 /// Cryptographic signature structure.
 ///
-/// Represents a signature created by an issuer (identified by DID) over
-/// some data. The signature can be used to verify authenticity, authorization,
-/// or other properties of the signed content.
+/// Represents a cryptographic signature over some data. The signature can be
+/// used to verify authenticity, authorization, or other properties of the
+/// signed content.
 ///
 /// # Fields
 ///
-/// - `issuer`: DID of the entity that created the signature
 /// - `signature`: The actual signature bytes
 /// - `extra`: Additional fields that may be present in the signature
 ///
···
 /// use std::collections::HashMap;
 ///
 /// let sig = Signature {
-///     issuer: "did:plc:example".to_string(),
 ///     signature: Bytes { bytes: b"signature_bytes".to_vec() },
 ///     extra: HashMap::new(),
 /// };
···
 #[derive(Deserialize, Serialize, Clone, PartialEq)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub struct Signature {
-    /// DID of the entity that created this signature
-    pub issuer: String,
-
     /// The cryptographic signature bytes
     pub signature: Bytes,
 
···
 ///
 /// # Arguments
 ///
-/// * `issuer` - DID of the signature issuer
 /// * `signature` - The signature bytes
 ///
 /// # Example
···
 /// use atproto_record::lexicon::Bytes;
 ///
 /// let sig = create_typed_signature(
-///     "did:plc:issuer".to_string(),
 ///     Bytes { bytes: b"sig_data".to_vec() },
 /// );
 /// ```
-pub fn create_typed_signature(issuer: String, signature: Bytes) -> TypedSignature {
+pub fn create_typed_signature(signature: Bytes) -> TypedSignature {
     TypedLexicon::new(Signature {
-        issuer,
         signature,
         extra: HashMap::new(),
     })
···
         let json_str = r#"{
             "$type": "community.lexicon.attestation.signature",
             "issuedAt": "2025-08-19T20:17:17.133Z",
-            "issuer": "did:web:acudo-dev.smokesignal.tools",
             "signature": {
                 "$bytes": "mr9c0MCu3g6SXNQ25JFhzfX1ecYgK9k1Kf6OZI2p2AlQRoQu09dOE7J5uaeilIx/UFCjJErO89C/uBBb9ANmUA"
             }
···
         let typed_sig_result: Result<TypedSignature, _> = serde_json::from_str(json_str);
         match &typed_sig_result {
             Ok(sig) => {
-                println!("TypedSignature OK: issuer={}", sig.inner.issuer);
-                assert_eq!(sig.inner.issuer, "did:web:acudo-dev.smokesignal.tools");
+                println!("TypedSignature OK: signature bytes len={}", sig.inner.signature.bytes.len());
+                assert_eq!(sig.inner.signature.bytes.len(), 64);
             }
             Err(e) => {
                 eprintln!("TypedSignature deserialization error: {}", e);
···
         let sig_or_ref_result: Result<SignatureOrRef, _> = serde_json::from_str(json_str);
         match &sig_or_ref_result {
             Ok(SignatureOrRef::Inline(sig)) => {
-                println!("SignatureOrRef OK (Inline): issuer={}", sig.inner.issuer);
-                assert_eq!(sig.inner.issuer, "did:web:acudo-dev.smokesignal.tools");
+                println!("SignatureOrRef OK (Inline): signature bytes len={}", sig.inner.signature.bytes.len());
+                assert_eq!(sig.inner.signature.bytes.len(), 64);
             }
             Ok(SignatureOrRef::Reference(_)) => {
                 panic!("Expected Inline signature, got Reference");
···
         // Try without $type field
         let json_no_type = r#"{
             "issuedAt": "2025-08-19T20:17:17.133Z",
-            "issuer": "did:web:acudo-dev.smokesignal.tools",
             "signature": {
                 "$bytes": "mr9c0MCu3g6SXNQ25JFhzfX1ecYgK9k1Kf6OZI2p2AlQRoQu09dOE7J5uaeilIx/UFCjJErO89C/uBBb9ANmUA"
             }
···
         let no_type_result: Result<Signature, _> = serde_json::from_str(json_no_type);
         match &no_type_result {
             Ok(sig) => {
-                println!("Signature (no type) OK: issuer={}", sig.issuer);
-                assert_eq!(sig.issuer, "did:web:acudo-dev.smokesignal.tools");
+                println!("Signature (no type) OK: signature bytes len={}", sig.signature.bytes.len());
                 assert_eq!(sig.signature.bytes.len(), 64);
 
                 // Now wrap it in TypedLexicon and try as SignatureOrRef
···
     fn test_signature_deserialization() {
         let json_str = r#"{
             "$type": "community.lexicon.attestation.signature",
-            "issuer": "did:plc:test123",
             "signature": {"$bytes": "dGVzdCBzaWduYXR1cmU="}
         }"#;
 
         let signature: Signature = serde_json::from_str(json_str).unwrap();
 
-        assert_eq!(signature.issuer, "did:plc:test123");
         assert_eq!(signature.signature.bytes, b"test signature");
         // The $type field will be captured in extra due to #[serde(flatten)]
         assert_eq!(signature.extra.len(), 1);
···
     fn test_signature_deserialization_with_extra_fields() {
         let json_str = r#"{
             "$type": "community.lexicon.attestation.signature",
-            "issuer": "did:plc:test123",
             "signature": {"$bytes": "dGVzdCBzaWduYXR1cmU="},
             "issuedAt": "2024-01-01T00:00:00.000Z",
             "purpose": "verification"
···
 
         let signature: Signature = serde_json::from_str(json_str).unwrap();
 
-        assert_eq!(signature.issuer, "did:plc:test123");
         assert_eq!(signature.signature.bytes, b"test signature");
         // 3 extra fields: $type, issuedAt, purpose
         assert_eq!(signature.extra.len(), 3);
···
         extra.insert("custom_field".to_string(), json!("custom_value"));
 
         let signature = Signature {
-            issuer: "did:plc:serializer".to_string(),
             signature: Bytes {
                 bytes: b"hello world".to_vec(),
             },
···
 
         // Without custom Serialize impl, $type is not automatically added
         assert!(!json.as_object().unwrap().contains_key("$type"));
-        assert_eq!(json["issuer"], "did:plc:serializer");
         // "hello world" base64 encoded is "aGVsbG8gd29ybGQ="
         assert_eq!(json["signature"]["$bytes"], "aGVsbG8gd29ybGQ=");
         assert_eq!(json["custom_field"], "custom_value");
···
     #[test]
     fn test_signature_round_trip() {
         let original = Signature {
-            issuer: "did:plc:roundtrip".to_string(),
             signature: Bytes {
                 bytes: b"round trip test".to_vec(),
             },
···
         // Deserialize back
         let deserialized: Signature = serde_json::from_str(&json).unwrap();
 
-        assert_eq!(original.issuer, deserialized.issuer);
         assert_eq!(original.signature.bytes, deserialized.signature.bytes);
         // Without the custom Serialize impl, no $type is added
         // so the round-trip preserves the empty extra map
···
         extra.insert("tags".to_string(), json!(["tag1", "tag2", "tag3"]));
 
         let signature = Signature {
-            issuer: "did:plc:complex".to_string(),
             signature: Bytes {
                 bytes: vec![0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA],
             },
···
 
         // Without custom Serialize impl, $type is not automatically added
         assert!(!json.as_object().unwrap().contains_key("$type"));
-        assert_eq!(json["issuer"], "did:plc:complex");
         assert_eq!(json["timestamp"], 1234567890);
         assert_eq!(json["metadata"]["version"], "1.0");
         assert_eq!(json["metadata"]["algorithm"], "ES256");
···
     #[test]
     fn test_empty_signature() {
         let signature = Signature {
-            issuer: String::new(),
             signature: Bytes { bytes: Vec::new() },
             extra: HashMap::new(),
         };
···
 
         // Without custom Serialize impl, $type is not automatically added
         assert!(!json.as_object().unwrap().contains_key("$type"));
-        assert_eq!(json["issuer"], "");
         assert_eq!(json["signature"]["$bytes"], ""); // Empty bytes encode to empty string
     }
 
···
         // Test with plain Vec<Signature> for basic signature serialization
         let signatures: Vec<Signature> = vec![
             Signature {
-                issuer: "did:plc:first".to_string(),
                 signature: Bytes {
                     bytes: b"first".to_vec(),
                 },
                 extra: HashMap::new(),
             },
             Signature {
-                issuer: "did:plc:second".to_string(),
                 signature: Bytes {
                     bytes: b"second".to_vec(),
                 },
···
 
         assert!(json.is_array());
         assert_eq!(json.as_array().unwrap().len(), 2);
-        assert_eq!(json[0]["issuer"], "did:plc:first");
-        assert_eq!(json[1]["issuer"], "did:plc:second");
+        assert_eq!(json[0]["signature"]["$bytes"], "Zmlyc3Q="); // "first" in base64
+        assert_eq!(json[1]["signature"]["$bytes"], "c2Vjb25k"); // "second" in base64
     }
 
     #[test]
···
         // Test the new Signatures type with inline signatures
         let signatures: Signatures = vec![
             SignatureOrRef::Inline(create_typed_signature(
-                "did:plc:first".to_string(),
                 Bytes {
                     bytes: b"first".to_vec(),
                 },
             )),
             SignatureOrRef::Inline(create_typed_signature(
-                "did:plc:second".to_string(),
                 Bytes {
                     bytes: b"second".to_vec(),
                 },
···
         assert!(json.is_array());
         assert_eq!(json.as_array().unwrap().len(), 2);
         assert_eq!(json[0]["$type"], "community.lexicon.attestation.signature");
-        assert_eq!(json[0]["issuer"], "did:plc:first");
+        assert_eq!(json[0]["signature"]["$bytes"], "Zmlyc3Q="); // "first" in base64
         assert_eq!(json[1]["$type"], "community.lexicon.attestation.signature");
-        assert_eq!(json[1]["issuer"], "did:plc:second");
+        assert_eq!(json[1]["signature"]["$bytes"], "c2Vjb25k"); // "second" in base64
     }
 
     #[test]
     fn test_typed_signature_serialization() {
         let typed_sig = create_typed_signature(
-            "did:plc:typed".to_string(),
             Bytes {
                 bytes: b"typed signature".to_vec(),
             },
···
         let json = serde_json::to_value(&typed_sig).unwrap();
 
         assert_eq!(json["$type"], "community.lexicon.attestation.signature");
-        assert_eq!(json["issuer"], "did:plc:typed");
         // "typed signature" base64 encoded
         assert_eq!(json["signature"]["$bytes"], "dHlwZWQgc2lnbmF0dXJl");
     }
···
     fn test_typed_signature_deserialization() {
         let json = json!({
             "$type": "community.lexicon.attestation.signature",
-            "issuer": "did:plc:typed",
             "signature": {"$bytes": "dHlwZWQgc2lnbmF0dXJl"}
         });
 
         let typed_sig: TypedSignature = serde_json::from_value(json).unwrap();
 
-        assert_eq!(typed_sig.inner.issuer, "did:plc:typed");
         assert_eq!(typed_sig.inner.signature.bytes, b"typed signature");
         assert!(typed_sig.has_type_field());
         assert!(typed_sig.validate().is_ok());
···
     #[test]
     fn test_typed_signature_without_type_field() {
         let json = json!({
-            "issuer": "did:plc:notype",
             "signature": {"$bytes": "bm8gdHlwZQ=="}  // "no type" in base64
         });
 
         let typed_sig: TypedSignature = serde_json::from_value(json).unwrap();
 
-        assert_eq!(typed_sig.inner.issuer, "did:plc:notype");
         assert_eq!(typed_sig.inner.signature.bytes, b"no type");
         assert!(!typed_sig.has_type_field());
         // Validation should still pass because type_required() returns false for Signature
···
     #[test]
     fn test_typed_signature_with_extra_fields() {
         let mut sig = Signature {
-            issuer: "did:plc:extra".to_string(),
             signature: Bytes {
                 bytes: b"extra test".to_vec(),
             },
···
         let json = serde_json::to_value(&typed_sig).unwrap();
 
         assert_eq!(json["$type"], "community.lexicon.attestation.signature");
-        assert_eq!(json["issuer"], "did:plc:extra");
         assert_eq!(json["customField"], "customValue");
         assert_eq!(json["timestamp"], 1234567890);
     }
···
     #[test]
     fn test_typed_signature_round_trip() {
         let original = Signature {
-            issuer: "did:plc:roundtrip2".to_string(),
             signature: Bytes {
                 bytes: b"round trip typed".to_vec(),
             },
···
         let json = serde_json::to_string(&typed).unwrap();
         let deserialized: TypedSignature = serde_json::from_str(&json).unwrap();
 
-        assert_eq!(deserialized.inner.issuer, original.issuer);
         assert_eq!(deserialized.inner.signature.bytes, original.signature.bytes);
         assert!(deserialized.has_type_field());
     }
···
     fn test_typed_signatures_vec() {
         let typed_sigs: Vec<TypedSignature> = vec![
             create_typed_signature(
-                "did:plc:first".to_string(),
                 Bytes {
                     bytes: b"first".to_vec(),
                 },
             ),
             create_typed_signature(
-                "did:plc:second".to_string(),
                 Bytes {
                     bytes: b"second".to_vec(),
                 },
···
 
         assert!(json.is_array());
         assert_eq!(json[0]["$type"], "community.lexicon.attestation.signature");
-        assert_eq!(json[0]["issuer"], "did:plc:first");
+        assert_eq!(json[0]["signature"]["$bytes"], "Zmlyc3Q="); // "first" in base64
         assert_eq!(json[1]["$type"], "community.lexicon.attestation.signature");
-        assert_eq!(json[1]["issuer"], "did:plc:second");
+        assert_eq!(json[1]["signature"]["$bytes"], "c2Vjb25k"); // "second" in base64
     }
 
     #[test]
     fn test_plain_vs_typed_signature() {
         // Plain Signature doesn't include $type field
         let plain_sig = Signature {
-            issuer: "did:plc:plain".to_string(),
             signature: Bytes {
                 bytes: b"plain sig".to_vec(),
             },
···
         );
 
         // Both have the same core data
-        assert_eq!(plain_json["issuer"], typed_json["issuer"]);
         assert_eq!(plain_json["signature"], typed_json["signature"]);
     }
 
···
     fn test_signature_or_ref_inline() {
         // Test inline signature
         let inline_sig = create_typed_signature(
-            "did:plc:inline".to_string(),
             Bytes {
                 bytes: b"inline signature".to_vec(),
             },
···
         // Serialize
         let json = serde_json::to_value(&sig_or_ref).unwrap();
         assert_eq!(json["$type"], "community.lexicon.attestation.signature");
-        assert_eq!(json["issuer"], "did:plc:inline");
         assert_eq!(json["signature"]["$bytes"], "aW5saW5lIHNpZ25hdHVyZQ=="); // "inline signature" in base64
 
         // Deserialize
         let deserialized: SignatureOrRef = serde_json::from_value(json.clone()).unwrap();
         match deserialized {
             SignatureOrRef::Inline(sig) => {
-                assert_eq!(sig.inner.issuer, "did:plc:inline");
                 assert_eq!(sig.inner.signature.bytes, b"inline signature");
             }
             _ => panic!("Expected inline signature"),
···
         let signatures: Signatures = vec![
             // Inline signature
             SignatureOrRef::Inline(create_typed_signature(
-                "did:plc:signer1".to_string(),
                 Bytes {
                     bytes: b"sig1".to_vec(),
                 },
···
             })),
             // Another inline signature
             SignatureOrRef::Inline(create_typed_signature(
-                "did:plc:signer3".to_string(),
                 Bytes {
                     bytes: b"sig3".to_vec(),
                 },
···
 
         // First element should be inline signature
         assert_eq!(array[0]["$type"], "community.lexicon.attestation.signature");
-        assert_eq!(array[0]["issuer"], "did:plc:signer1");
+        assert_eq!(array[0]["signature"]["$bytes"], "c2lnMQ=="); // "sig1" in base64
 
         // Second element should be reference
         assert_eq!(array[1]["$type"], "com.atproto.repo.strongRef");
···
 
         // Third element should be inline signature
         assert_eq!(array[2]["$type"], "community.lexicon.attestation.signature");
-        assert_eq!(array[2]["issuer"], "did:plc:signer3");
+        assert_eq!(array[2]["signature"]["$bytes"], "c2lnMw=="); // "sig3" in base64
 
         // Deserialize back
         let deserialized: Signatures = serde_json::from_value(json).unwrap();
···
 
         // Verify each element
         match &deserialized[0] {
-            SignatureOrRef::Inline(sig) => assert_eq!(sig.inner.issuer, "did:plc:signer1"),
+            SignatureOrRef::Inline(sig) => assert_eq!(sig.inner.signature.bytes, b"sig1"),
             _ => panic!("Expected inline signature at index 0"),
         }
 
···
         }
 
         match &deserialized[2] {
-            SignatureOrRef::Inline(sig) => assert_eq!(sig.inner.issuer, "did:plc:signer3"),
+            SignatureOrRef::Inline(sig) => assert_eq!(sig.inner.signature.bytes, b"sig3"),
             _ => panic!("Expected inline signature at index 2"),
         }
     }
···
         // Inline signature JSON
         let inline_json = r#"{
             "$type": "community.lexicon.attestation.signature",
-            "issuer": "did:plc:testinline",
             "signature": {"$bytes": "aGVsbG8="}
         }"#;
 
         let inline_deser: SignatureOrRef = serde_json::from_str(inline_json).unwrap();
         match inline_deser {
             SignatureOrRef::Inline(sig) => {
-                assert_eq!(sig.inner.issuer, "did:plc:testinline");
                 assert_eq!(sig.inner.signature.bytes, b"hello");
             }
             _ => panic!("Expected inline signature"),

crates/atproto-record/src/lexicon/community_lexicon_badge.rs

···
                 // The signature should be inline in this test
                 match sig_or_ref {
                     crate::lexicon::community_lexicon_attestation::SignatureOrRef::Inline(sig) => {
-                        assert_eq!(sig.issuer, "did:plc:issuer");
                         // The bytes should match the decoded base64 value
                         // "dGVzdCBzaWduYXR1cmU=" decodes to "test signature"
-                        assert_eq!(sig.signature.bytes, b"test signature".to_vec());
+                        assert_eq!(sig.inner.signature.bytes, b"test signature".to_vec());
                     }
                     _ => panic!("Expected inline signature"),
                 }

crates/atproto-record/src/lexicon/community_lexicon_calendar_event.rs

···
 
 use crate::datetime::format as datetime_format;
 use crate::datetime::optional_format as optional_datetime_format;
+use crate::lexicon::app::bsky::richtext::facet::Facet;
 use crate::lexicon::TypedBlob;
 use crate::lexicon::community::lexicon::location::Locations;
 use crate::typed::{LexiconType, TypedLexicon};
 
-/// The namespace identifier for events
+/// Lexicon namespace identifier for calendar events.
+///
+/// Used as the `$type` field value for event records in the AT Protocol.
 pub const NSID: &str = "community.lexicon.calendar.event";
 
 /// Event status enumeration.
···
     Hybrid,
 }
 
-/// The namespace identifier for named URIs
+/// Lexicon namespace identifier for named URIs in calendar events.
+///
+/// Used as the `$type` field value for URI references associated with events.
 pub const NAMED_URI_NSID: &str = "community.lexicon.calendar.event#uri";
 
 /// Named URI structure.
···
     }
 }
 
-/// Type alias for NamedUri with automatic $type field handling
+/// Type alias for NamedUri with automatic $type field handling.
+///
+/// Wraps `NamedUri` in `TypedLexicon` to ensure proper serialization
+/// and deserialization of the `$type` field.
 pub type TypedNamedUri = TypedLexicon<NamedUri>;
 
-/// The namespace identifier for event links
+/// Lexicon namespace identifier for event links.
+///
+/// Used as the `$type` field value for event link references.
+/// Note: This shares the same NSID as `NAMED_URI_NSID` for compatibility.
 pub const EVENT_LINK_NSID: &str = "community.lexicon.calendar.event#uri";
 
 /// Event link structure.
···
     }
 }
 
-/// Type alias for EventLink with automatic $type field handling
+/// Type alias for EventLink with automatic $type field handling.
+///
+/// Wraps `EventLink` in `TypedLexicon` to ensure proper serialization
+/// and deserialization of the `$type` field.
 pub type TypedEventLink = TypedLexicon<EventLink>;
 
-/// A vector of typed event links
+/// Collection of typed event links.
+///
+/// Represents multiple URI references associated with an event,
+/// such as registration pages, live streams, or related content.
 pub type EventLinks = Vec<TypedEventLink>;
 
 /// Aspect ratio for media content.
···
     pub height: u64,
 }
 
-/// The namespace identifier for media
+/// Lexicon namespace identifier for event media.
+///
+/// Used as the `$type` field value for media attachments associated with events.
 pub const MEDIA_NSID: &str = "community.lexicon.calendar.event#media";
 
 /// Media structure for event-related visual content.
···
     }
 }
 
-/// Type alias for Media with automatic $type field handling
+/// Type alias for Media with automatic $type field handling.
+///
+/// Wraps `Media` in `TypedLexicon` to ensure proper serialization
+/// and deserialization of the `$type` field.
 pub type TypedMedia = TypedLexicon<Media>;
 
-/// A vector of typed media items
+/// Collection of typed media items.
+///
+/// Represents multiple media attachments for an event, such as banners,
+/// posters, thumbnails, or promotional images.
 pub type MediaList = Vec<TypedMedia>;
 
 /// Calendar event structure.
···
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
     pub media: MediaList,
 
+    /// Rich text facets for semantic annotations in description field.
+    ///
+    /// Enables mentions, links, and hashtags to be embedded in the event
+    /// description text with proper semantic metadata.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub facets: Option<Vec<Facet>>,
+
     /// Extension fields for forward compatibility.
     /// This catch-all allows unknown fields to be preserved and indexed
     /// for potential future use without requiring re-indexing.
···
             locations: vec![],
             uris: vec![],
             media: vec![],
+            facets: None,
             extra: HashMap::new(),
         };
 
···
             locations: vec![],
             uris: vec![TypedLexicon::new(event_link)],
             media: vec![TypedLexicon::new(media)],
+            facets: None,
             extra: HashMap::new(),
         };
 

crates/atproto-record/src/lexicon/community_lexicon_calendar_rsvp.rs

···
         assert_eq!(typed_rsvp.inner.signatures.len(), 1);
         match &typed_rsvp.inner.signatures[0] {
             SignatureOrRef::Inline(sig) => {
-                assert_eq!(sig.inner.issuer, "did:plc:issuer");
                 assert_eq!(sig.inner.signature.bytes, b"test signature");
             }
             _ => panic!("Expected inline signature"),
···
         assert_eq!(typed_rsvp.inner.signatures.len(), 1);
         match &typed_rsvp.inner.signatures[0] {
             SignatureOrRef::Inline(sig) => {
-                assert_eq!(sig.inner.issuer, "did:web:acudo-dev.smokesignal.tools");
-
                 // Verify the issuedAt field if present
                 if let Some(issued_at_value) = sig.inner.extra.get("issuedAt") {
                     assert_eq!(issued_at_value, "2025-08-19T20:17:17.133Z");

crates/atproto-record/src/lexicon/mod.rs

···
 mod community_lexicon_calendar_event;
 mod community_lexicon_calendar_rsvp;
 mod community_lexicon_location;
+mod app_bsky_richtext_facet;
 mod primatives;
 
+// Re-export primitive types for convenience
 pub use primatives::*;
+
+/// Bluesky application namespace.
+///
+/// Contains lexicon types specific to the Bluesky application,
+/// including rich text formatting and social features.
+pub mod app {
+    /// Bluesky namespace.
+    pub mod bsky {
+        /// Rich text formatting types.
+        pub mod richtext {
+            /// Facet types for semantic text annotations.
+            ///
+            /// Provides types for mentions, links, hashtags, and other
+            /// structured metadata that can be attached to text content.
+            pub mod facet {
+                pub use crate::lexicon::app_bsky_richtext_facet::*;
+            }
+        }
+    }
+}
 
 /// AT Protocol core types namespace
 pub mod com {