fixes in the derive macro

crates/jacquard-common/src/types/value.rs

···
         Data::from_json(&json).map(|data| data.into_static())
     }
 
+    /// Get as object if this is an Object variant
+    pub fn as_object(&self) -> Option<&Object<'s>> {
+        if let Data::Object(obj) = self {
+            Some(obj)
+        } else {
+            None
+        }
+    }
+
+    /// Get as array if this is an Array variant
+    pub fn as_array(&self) -> Option<&Array<'s>> {
+        if let Data::Array(arr) = self {
+            Some(arr)
+        } else {
+            None
+        }
+    }
+
+    /// Get as string if this is a String variant
+    pub fn as_str(&self) -> Option<&str> {
+        if let Data::String(s) = self {
+            Some(s.as_str())
+        } else {
+            None
+        }
+    }
+
+    /// Get as integer if this is an Integer variant
+    pub fn as_integer(&self) -> Option<i64> {
+        if let Data::Integer(i) = self {
+            Some(*i)
+        } else {
+            None
+        }
+    }
+
+    /// Get as boolean if this is a Boolean variant
+    pub fn as_boolean(&self) -> Option<bool> {
+        if let Data::Boolean(b) = self {
+            Some(*b)
+        } else {
+            None
+        }
+    }
+
+    /// Check if this is a null value
+    pub fn is_null(&self) -> bool {
+        matches!(self, Data::Null)
+    }
+
+    /// Serialize to canonical DAG-CBOR bytes for CID computation
+    ///
+    /// This produces the deterministic CBOR encoding used for content-addressing.
+    pub fn to_dag_cbor(
+        &self,
+    ) -> Result<Vec<u8>, serde_ipld_dagcbor::EncodeError<std::collections::TryReserveError>> {
+        serde_ipld_dagcbor::to_vec(self)
+    }
+
     /// Parse a Data value from an IPLD value (CBOR)
     pub fn from_cbor(cbor: &'s Ipld) -> Result<Self, AtDataError> {
         Ok(match cbor {
···
 }
 
 impl<'d> RawData<'d> {
+    /// Get as object if this is an Object variant
+    pub fn as_object(&self) -> Option<&BTreeMap<SmolStr, RawData<'d>>> {
+        if let RawData::Object(obj) = self {
+            Some(obj)
+        } else {
+            None
+        }
+    }
+
+    /// Get as array if this is an Array variant
+    pub fn as_array(&self) -> Option<&Vec<RawData<'d>>> {
+        if let RawData::Array(arr) = self {
+            Some(arr)
+        } else {
+            None
+        }
+    }
+
+    /// Get as string if this is a String variant
+    pub fn as_str(&self) -> Option<&str> {
+        if let RawData::String(s) = self {
+            Some(s.as_ref())
+        } else {
+            None
+        }
+    }
+
+    /// Get as boolean if this is a Boolean variant
+    pub fn as_boolean(&self) -> Option<bool> {
+        if let RawData::Boolean(b) = self {
+            Some(*b)
+        } else {
+            None
+        }
+    }
+
+    /// Check if this is a null value
+    pub fn is_null(&self) -> bool {
+        matches!(self, RawData::Null)
+    }
+
+    /// Serialize to canonical DAG-CBOR bytes for CID computation
+    ///
+    /// This produces the deterministic CBOR encoding used for content-addressing.
+    pub fn to_dag_cbor(
+        &self,
+    ) -> Result<Vec<u8>, serde_ipld_dagcbor::EncodeError<std::collections::TryReserveError>> {
+        serde_ipld_dagcbor::to_vec(self)
+    }
+
     /// Convert a CBOR-encoded byte slice into a `RawData` value.
     /// Parse a Data value from an IPLD value (CBOR)
     pub fn from_cbor(cbor: &'d Ipld) -> Result<Self, AtDataError> {

crates/jacquard-common/src/types/value/tests.rs

···
     assert_eq!(result.text, "null test");
     assert_eq!(result.langs, None);
 }
+
+#[test]
+fn test_data_accessors() {
+    // Test as_object
+    let mut map = BTreeMap::new();
+    map.insert(SmolStr::new_static("key"), Data::Integer(42));
+    let obj_data = Data::Object(Object(map.clone()));
+    assert!(obj_data.as_object().is_some());
+    assert_eq!(obj_data.as_object().unwrap().0.len(), 1);
+    assert!(Data::Null.as_object().is_none());
+
+    // Test as_array
+    let arr_data = Data::Array(Array(vec![Data::Integer(1), Data::Integer(2)]));
+    assert!(arr_data.as_array().is_some());
+    assert_eq!(arr_data.as_array().unwrap().0.len(), 2);
+    assert!(Data::Null.as_array().is_none());
+
+    // Test as_str
+    let str_data = Data::String(AtprotoStr::String("hello".into()));
+    assert_eq!(str_data.as_str(), Some("hello"));
+    assert!(Data::Null.as_str().is_none());
+
+    // Test as_integer
+    let int_data = Data::Integer(42);
+    assert_eq!(int_data.as_integer(), Some(42));
+    assert!(Data::Null.as_integer().is_none());
+
+    // Test as_boolean
+    let bool_data = Data::Boolean(true);
+    assert_eq!(bool_data.as_boolean(), Some(true));
+    assert!(Data::Null.as_boolean().is_none());
+
+    // Test is_null
+    assert!(Data::Null.is_null());
+    assert!(!Data::Integer(0).is_null());
+}
+
+#[test]
+fn test_rawdata_accessors() {
+    // Test as_object
+    let mut map = BTreeMap::new();
+    map.insert(SmolStr::new_static("key"), RawData::SignedInt(42));
+    let obj_data = RawData::Object(map.clone());
+    assert!(obj_data.as_object().is_some());
+    assert_eq!(obj_data.as_object().unwrap().len(), 1);
+    assert!(RawData::Null.as_object().is_none());
+
+    // Test as_array
+    let arr_data = RawData::Array(vec![RawData::SignedInt(1), RawData::SignedInt(2)]);
+    assert!(arr_data.as_array().is_some());
+    assert_eq!(arr_data.as_array().unwrap().len(), 2);
+    assert!(RawData::Null.as_array().is_none());
+
+    // Test as_str
+    let str_data = RawData::String("hello".into());
+    assert_eq!(str_data.as_str(), Some("hello"));
+    assert!(RawData::Null.as_str().is_none());
+
+    // Test as_boolean
+    let bool_data = RawData::Boolean(true);
+    assert_eq!(bool_data.as_boolean(), Some(true));
+    assert!(RawData::Null.as_boolean().is_none());
+
+    // Test is_null
+    assert!(RawData::Null.is_null());
+    assert!(!RawData::SignedInt(0).is_null());
+}
+
+#[test]
+fn test_data_to_dag_cbor() {
+    // Test simple types
+    let null_data = Data::Null;
+    assert!(null_data.to_dag_cbor().is_ok());
+
+    let int_data = Data::Integer(42);
+    assert!(int_data.to_dag_cbor().is_ok());
+
+    let str_data = Data::String(AtprotoStr::String("hello".into()));
+    assert!(str_data.to_dag_cbor().is_ok());
+
+    // Test complex types
+    let mut map = BTreeMap::new();
+    map.insert(SmolStr::new_static("num"), Data::Integer(42));
+    map.insert(SmolStr::new_static("text"), Data::String(AtprotoStr::String("test".into())));
+    let obj_data = Data::Object(Object(map));
+    let cbor_result = obj_data.to_dag_cbor();
+    assert!(cbor_result.is_ok());
+    assert!(!cbor_result.unwrap().is_empty());
+
+    // Test array
+    let arr_data = Data::Array(Array(vec![Data::Integer(1), Data::Integer(2), Data::Integer(3)]));
+    let arr_cbor = arr_data.to_dag_cbor();
+    assert!(arr_cbor.is_ok());
+    assert!(!arr_cbor.unwrap().is_empty());
+}
+
+#[test]
+fn test_rawdata_to_dag_cbor() {
+    // Test simple types
+    let null_data = RawData::Null;
+    assert!(null_data.to_dag_cbor().is_ok());
+
+    let int_data = RawData::SignedInt(42);
+    assert!(int_data.to_dag_cbor().is_ok());
+
+    let str_data = RawData::String("hello".into());
+    assert!(str_data.to_dag_cbor().is_ok());
+
+    // Test complex types
+    let mut map = BTreeMap::new();
+    map.insert(SmolStr::new_static("num"), RawData::SignedInt(42));
+    map.insert(SmolStr::new_static("text"), RawData::String("test".into()));
+    let obj_data = RawData::Object(map);
+    let cbor_result = obj_data.to_dag_cbor();
+    assert!(cbor_result.is_ok());
+    assert!(!cbor_result.unwrap().is_empty());
+}

crates/jacquard-derive/src/lib.rs

···
 /// **What it generates:**
 /// - `impl LexiconSchema` with `nsid()`, `schema_id()`, and `lexicon_doc()` methods
 /// - `validate()` method that checks constraints at runtime
-/// - `inventory::submit!` registration for schema discovery (Phase 3)
+/// - `inventory::submit!` registration for schema discovery
 ///
 /// **Attributes:** `#[lexicon(...)]` and `#[nsid = "..."]` on types and fields.
 /// See crate docs for full attribute reference and examples.

crates/jacquard-derive/tests/lexicon_schema_derive.rs

···
 use jacquard_common::CowStr;
 use jacquard_common::types::string::Datetime;
 use jacquard_derive::{LexiconSchema, open_union};
-use jacquard_lexicon::schema::{LexiconGenerator, LexiconSchema as LexiconSchemaTrait};
+use jacquard_lexicon::schema::LexiconSchema as LexiconSchemaTrait;
 use serde::{Deserialize, Serialize};
 
 #[test]
···
     assert_eq!(SimpleRecord::nsid(), "com.example.simple");
     assert_eq!(SimpleRecord::schema_id().as_ref(), "com.example.simple");
 
-    let mut generator = LexiconGenerator::new(SimpleRecord::nsid());
     let doc = SimpleRecord::lexicon_doc();
 
     assert_eq!(doc.id.as_ref(), "com.example.simple");
···
         pub score: i64,
     }
 
-    let mut generator = LexiconGenerator::new(ConstrainedRecord::nsid());
     let doc = ConstrainedRecord::lexicon_doc();
 
     let json = serde_json::to_string_pretty(&doc).unwrap();
···
         pub some_field: i64,
         pub another_field: i64,
     }
-
-    let mut generator = LexiconGenerator::new(RenamedRecord::nsid());
     let doc = RenamedRecord::lexicon_doc();
 
     let json = serde_json::to_string_pretty(&doc).unwrap();
···
         Unknown(jacquard_common::types::value::Data<'a>),
     }
 
-    let mut generator = LexiconGenerator::new(OpenUnion::nsid());
     let doc = OpenUnion::lexicon_doc();
 
     let json = serde_json::to_string_pretty(&doc).unwrap();
···
         Video,
     }
 
-    let mut generator = LexiconGenerator::new(RenamedUnion::nsid());
     let doc = RenamedUnion::lexicon_doc();
 
     let json = serde_json::to_string_pretty(&doc).unwrap();
···
         #[allow(dead_code)]
         VariantTwo,
     }
-
-    let mut generator = LexiconGenerator::new(FragmentUnion::nsid());
     let doc = FragmentUnion::lexicon_doc();
 
     let json = serde_json::to_string_pretty(&doc).unwrap();

crates/jacquard-lexicon/src/codegen/schema_impl.rs

···
 
 use crate::derive_impl::doc_to_tokens;
 use crate::lexicon::{
-    LexArrayItem, LexInteger, LexObject, LexObjectProperty, LexRecord, LexRecordRecord, LexString,
+    LexInteger, LexObject, LexObjectProperty, LexRecordRecord, LexString,
     LexUserType, LexiconDoc,
 };
 use crate::schema::from_ast::{ConstraintCheck, ValidationCheck};

crates/jacquard-lexicon/src/codegen/structs.rs

···
 use crate::error::Result;
 use crate::lexicon::{
-    LexArrayItem, LexInteger, LexObject, LexObjectProperty, LexRecord, LexString, LexUserType,
-    Lexicon, LexiconDoc,
+    LexArrayItem, LexInteger, LexObject, LexObjectProperty, LexRecord, LexString,
 };
 use heck::{ToPascalCase, ToSnakeCase};
 use proc_macro2::TokenStream;
 use quote::quote;
-use std::collections::BTreeMap;
 
 use super::CodeGenerator;
 use super::utils::{make_ident, value_to_variant_name};

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

···
             }
 
             fn lexicon_doc(
-                _generator: &mut ::jacquard_lexicon::schema::LexiconGenerator
             ) -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
                 #doc_tokens
             }
···
             ::jacquard_lexicon::schema::LexiconSchemaRef {
                 nsid: #nsid,
                 provider: || {
-                    let mut generator = ::jacquard_lexicon::schema::LexiconGenerator::new(#nsid);
-                    <#name as ::jacquard_lexicon::schema::LexiconSchema>::lexicon_doc(&mut generator)
+                    <#name as ::jacquard_lexicon::schema::LexiconSchema>::lexicon_doc()
                 },
             }
         }
···
             }
 
             fn lexicon_doc(
-                _generator: &mut ::jacquard_lexicon::schema::LexiconGenerator
             ) -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
                 #doc_tokens
             }
···
             ::jacquard_lexicon::schema::LexiconSchemaRef {
                 nsid: #nsid,
                 provider: || {
-                    let mut generator = ::jacquard_lexicon::schema::LexiconGenerator::new(#nsid);
-                    <#name as ::jacquard_lexicon::schema::LexiconSchema>::lexicon_doc(&mut generator)
+                    <#name as ::jacquard_lexicon::schema::LexiconSchema>::lexicon_doc()
                 },
             }
         }

crates/jacquard-lexicon/src/schema.rs

···
 pub mod from_ast;
 pub mod type_mapping;
 
-use crate::lexicon::{LexUserType, Lexicon, LexiconDoc};
+use crate::lexicon::LexiconDoc;
 
 /// Trait for types that can generate lexicon schemas
 pub trait LexiconSchema {