fix issues with ref validation for query, procedure, and subscription type lexicons

packages/cli/src/generated_client.ts

···
 // Generated TypeScript client for AT Protocol records
-// Generated at: 2025-09-28 21:51:06 UTC
-// Lexicons: 41
+// Generated at: 2025-09-28 23:51:18 UTC
+// Lexicons: 42
 
 /**
  * @example Usage
···
   connected: boolean;
 }
 
+export interface NetworkSlicesSliceGetSyncSummaryParams {
+  slice: string;
+  collections?: string[];
+  externalCollections?: string[];
+  repos?: string[];
+  maxRepos?: number;
+}
+
+export interface NetworkSlicesSliceGetSyncSummaryOutput {
+  totalRepos: number;
+  cappedRepos: number;
+  collectionsSummary: unknown[];
+  wouldBeCapped: boolean;
+  appliedLimit: number;
+}
+
+export interface NetworkSlicesSliceGetSyncSummaryCollectionSummary {
+  collection: string;
+  estimatedRepos: number;
+  isExternal: boolean;
+}
+
 export interface NetworkSlicesSlice {
   /** Name of the slice */
   name: string;
···
 
 export interface NetworkSlicesSliceGetJobLogs {
   readonly LogEntry: NetworkSlicesSliceGetJobLogsLogEntry;
+}
+
+export interface NetworkSlicesSliceGetSyncSummary {
+  readonly CollectionSummary: NetworkSlicesSliceGetSyncSummaryCollectionSummary;
 }
 
 export interface NetworkSlicesSliceGetJobStatus {
···
     return await this.client.makeRequest<
       NetworkSlicesSliceGetJetstreamStatusOutput
     >("network.slices.slice.getJetstreamStatus", "GET", {});
+  }
+
+  async getSyncSummary(
+    params?: NetworkSlicesSliceGetSyncSummaryParams,
+  ): Promise<NetworkSlicesSliceGetSyncSummaryOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceGetSyncSummaryOutput
+    >("network.slices.slice.getSyncSummary", "GET", params);
   }
 
   async getJobStatus(

packages/lexicon-rs/src/lib.rs

···
         use crate::validation::primitive::string::StringValidator;
         use crate::StringFormat;
 
-        let format_enum = StringFormat::from_str(format)
-            .ok_or_else(|| JsValue::from_str(&format!("Unknown format: {}", format)))?;
+        let format_enum = format.parse::<StringFormat>()
+            .map_err(|_| JsValue::from_str(&format!("Unknown format: {}", format)))?;
 
         let validator = StringValidator;
 
···
                 assert_eq!(total_errors, 5, "Should have collected all 5 errors total");
                 assert_eq!(errors.len(), 2, "Should have errors for exactly 2 lexicons");
             }
+        }
+    }
+
+    #[test]
+    fn test_broken_reference_validation() {
+        let broken_lexicon = json!({
+            "lexicon": 1,
+            "id": "test.broken.ref",
+            "defs": {
+                "main": {
+                    "type": "object",
+                    "properties": {
+                        "items": {
+                            "type": "array",
+                            "items": {
+                                "type": "ref",
+                                "ref": "#nonExistentDef"
+                            }
+                        }
+                    }
+                },
+                "existingDef": {
+                    "type": "string"
+                }
+            }
+        });
+
+        let result = validate(vec![broken_lexicon]);
+
+        // Should fail because #nonExistentDef doesn't exist
+        assert!(result.is_err(), "Validation should fail for broken reference");
+
+        if let Err(errors) = result {
+            assert!(errors.contains_key("test.broken.ref"), "Should have errors for the test lexicon");
+            let error_messages = errors.get("test.broken.ref").unwrap();
+            assert!(!error_messages.is_empty(), "Should have at least one error");
+
+            // Check that at least one error mentions the non-existent reference
+            let has_ref_error = error_messages.iter().any(|msg|
+                msg.contains("non-existent") || msg.contains("nonExistentDef")
+            );
+            assert!(has_ref_error, "Should have error about non-existent reference. Got: {:?}", error_messages);
         }
     }
 }

packages/lexicon-rs/src/types.rs

···
     RecordKey,
 }
 
-impl StringFormat {
-    pub fn from_str(s: &str) -> Option<Self> {
+use std::str::FromStr;
+
+impl FromStr for StringFormat {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "datetime" => Some(Self::DateTime),
-            "uri" => Some(Self::Uri),
-            "at-uri" => Some(Self::AtUri),
-            "did" => Some(Self::Did),
-            "handle" => Some(Self::Handle),
-            "at-identifier" => Some(Self::AtIdentifier),
-            "nsid" => Some(Self::Nsid),
-            "cid" => Some(Self::Cid),
-            "language" => Some(Self::Language),
-            "tid" => Some(Self::Tid),
-            "record-key" => Some(Self::RecordKey),
-            _ => None,
+            "datetime" => Ok(Self::DateTime),
+            "uri" => Ok(Self::Uri),
+            "at-uri" => Ok(Self::AtUri),
+            "did" => Ok(Self::Did),
+            "handle" => Ok(Self::Handle),
+            "at-identifier" => Ok(Self::AtIdentifier),
+            "nsid" => Ok(Self::Nsid),
+            "cid" => Ok(Self::Cid),
+            "language" => Ok(Self::Language),
+            "tid" => Ok(Self::Tid),
+            "record-key" => Ok(Self::RecordKey),
+            _ => Err(format!("Unknown string format: {}", s)),
         }
     }
 }

packages/lexicon-rs/src/validation/context.rs

···
     /// - Global: `com.example.ns#defName` -> uses specified lexicon ID
     /// - Global main: `com.example.ns` -> uses "main" as def name
     fn parse_reference(&self, reference: &str) -> Result<(String, String), ValidationError> {
-        if reference.starts_with('#') {
+        if let Some(def_name) = reference.strip_prefix('#') {
             // Local reference - use current lexicon
             let current_lexicon = self.current_lexicon_id.as_ref().ok_or_else(|| {
                 ValidationError::InvalidSchema(format!(
···
                 ))
             })?;
 
-            let def_name = reference[1..].to_string(); // Remove the '#'
+            let def_name = def_name.to_string(); // Remove the '#'
             if def_name.is_empty() {
                 return Err(ValidationError::InvalidSchema(format!(
                     "Invalid local reference '{}': definition name cannot be empty",

packages/lexicon-rs/src/validation/field/reference.rs

···
             return Err("Reference cannot be empty".to_string());
         }
 
-        if ref_str.starts_with('#') {
+        if let Some(def_name) = ref_str.strip_prefix('#') {
             // Local reference
-            let def_name = &ref_str[1..];
             if def_name.is_empty() {
                 return Err("Local reference must have a definition name after #".to_string());
             }
···
         // First validate syntax
         Self::validate_ref_syntax(ref_str)?;
 
-        if ref_str.starts_with('#') {
+        if let Some(def_name) = ref_str.strip_prefix('#') {
             // Local reference
-            let def_name = ref_str[1..].to_string();
+            let def_name = def_name.to_string();
             Ok(ParsedReference::Local(def_name))
         } else if ref_str.contains('#') {
             // Global reference with fragment
···
             ))
         })?;
 
-        // TODO: Validate that the reference can be resolved
-        // This would require access to the reference resolution system
+        // Parse and validate that the reference can be resolved
+        let parsed_ref = Self::parse_reference(ref_str).map_err(|e| {
+            ValidationError::InvalidSchema(format!(
+                "Ref '{}' has invalid reference: {}",
+                def_name, e
+            ))
+        })?;
+
+        // Attempt to resolve the reference to verify it exists
+        // Ensure we have a current lexicon context for resolving local references
+        ctx.current_lexicon_id()
+            .ok_or_else(|| {
+                ValidationError::InvalidSchema(format!(
+                    "Cannot validate ref '{}': no current lexicon context",
+                    def_name
+                ))
+            })?;
 
-        Ok(())
+        match Self::resolve_reference(&parsed_ref, ctx) {
+            Ok(_) => Ok(()), // Reference resolved successfully
+            Err(ValidationError::DataValidation(msg)) if msg.contains("not found") => {
+                // Convert data validation error to schema validation error for definition validation
+                Err(ValidationError::InvalidSchema(format!(
+                    "Ref '{}' references non-existent definition: {}",
+                    def_name, ref_str
+                )))
+            }
+            Err(e) => Err(e), // Pass through other errors
+        }
     }
 
     /// Validates runtime data against a reference schema definition
···
             .with_lexicons(vec![json!({
                 "lexicon": 1,
                 "id": "com.example.test",
-                "defs": { "main": ref_def.clone() }
+                "defs": {
+                    "main": ref_def.clone(),
+                    "commonObject": {
+                        "type": "object",
+                        "properties": {}
+                    }
+                }
             })])
             .unwrap()
             .build()
-            .unwrap();
+            .unwrap()
+            .with_current_lexicon("com.example.test");
 
         let validator = RefValidator;
         assert!(validator.validate(&ref_def, &ctx).is_ok());
···
         });
 
         let ctx = ValidationContext::builder()
-            .with_lexicons(vec![json!({
-                "lexicon": 1,
-                "id": "com.example.test",
-                "defs": { "main": ref_def.clone() }
-            })])
+            .with_lexicons(vec![
+                json!({
+                    "lexicon": 1,
+                    "id": "com.example.test",
+                    "defs": { "main": ref_def.clone() }
+                }),
+                json!({
+                    "lexicon": 1,
+                    "id": "com.example.defs",
+                    "defs": {
+                        "main": { "type": "object" },
+                        "commonObject": {
+                            "type": "object",
+                            "properties": {}
+                        }
+                    }
+                })
+            ])
             .unwrap()
             .build()
-            .unwrap();
+            .unwrap()
+            .with_current_lexicon("com.example.test");
 
         let validator = RefValidator;
         assert!(validator.validate(&ref_def, &ctx).is_ok());
···
         });
 
         let ctx = ValidationContext::builder()
+            .with_lexicons(vec![
+                json!({
+                    "lexicon": 1,
+                    "id": "com.example.test",
+                    "defs": { "main": ref_def.clone() }
+                }),
+                json!({
+                    "lexicon": 1,
+                    "id": "com.example.record",
+                    "defs": {
+                        "main": {
+                            "type": "record",
+                            "record": {
+                                "type": "object",
+                                "properties": {}
+                            }
+                        }
+                    }
+                })
+            ])
+            .unwrap()
+            .build()
+            .unwrap()
+            .with_current_lexicon("com.example.test");
+
+        let validator = RefValidator;
+        assert!(validator.validate(&ref_def, &ctx).is_ok());
+    }
+
+    #[test]
+    fn test_missing_ref_field() {
+        let ref_def = json!({
+            "type": "ref"
+        });
+
+        let ctx = ValidationContext::builder()
             .with_lexicons(vec![json!({
                 "lexicon": 1,
                 "id": "com.example.test",
···
             })])
             .unwrap()
             .build()
-            .unwrap();
+            .unwrap()
+            .with_current_lexicon("com.example.test");
 
         let validator = RefValidator;
-        assert!(validator.validate(&ref_def, &ctx).is_ok());
+        assert!(validator.validate(&ref_def, &ctx).is_err());
     }
 
     #[test]
-    fn test_missing_ref_field() {
+    fn test_ref_to_nonexistent_definition() {
         let ref_def = json!({
-            "type": "ref"
+            "type": "ref",
+            "ref": "#nonExistentDef"
         });
 
         let ctx = ValidationContext::builder()
···
             })])
             .unwrap()
             .build()
-            .unwrap();
+            .unwrap()
+            .with_current_lexicon("com.example.test");
 
         let validator = RefValidator;
-        assert!(validator.validate(&ref_def, &ctx).is_err());
+        let result = validator.validate(&ref_def, &ctx);
+        assert!(result.is_err());
+
+        // Check that the error message mentions the non-existent definition
+        if let Err(ValidationError::InvalidSchema(msg)) = result {
+            assert!(msg.contains("non-existent definition"));
+            assert!(msg.contains("#nonExistentDef"));
+        } else {
+            panic!("Expected InvalidSchema error for non-existent reference");
+        }
     }
 
     #[test]

packages/lexicon-rs/src/validation/field/union.rs

···
         }
 
         // Handle local reference patterns (#ref)
-        if reference.starts_with('#') {
-            let ref_name = &reference[1..];
+        if let Some(ref_name) = reference.strip_prefix('#') {
             // Match bare name against local ref
             if type_name == ref_name {
                 return true;
···
         }
 
         // Handle implicit #main patterns
-        if type_name.ends_with("#main") {
-            let base_type = &type_name[..type_name.len() - 5]; // Remove "#main"
+        if let Some(base_type) = type_name.strip_suffix("#main") {
+            // Remove "#main"
             if reference == base_type {
                 return true;
             }
···
             }
         }
 
-        // TODO: Validate that each reference can be resolved
-        // This would require access to the reference resolution system
+        // Validate that each reference can be resolved
+        use crate::validation::field::reference::RefValidator;
+        let ref_validator = RefValidator;
+
+        for (i, ref_item) in refs_array.iter().enumerate() {
+            if let Some(ref_str) = ref_item.as_str() {
+                // Create a temporary ref schema for validation
+                let temp_ref_schema = serde_json::json!({
+                    "type": "ref",
+                    "ref": ref_str
+                });
+
+                let ref_ctx = ctx.with_path(&format!("{}.refs[{}]", def_name, i));
+                ref_validator.validate(&temp_ref_schema, &ref_ctx)?;
+            }
+        }
 
         Ok(())
     }
···
 
         // String that should violate shortString maxLength constraint
         // Currently passes because ObjectValidator doesn't validate property constraints yet
-        let invalid_short = json!({
+        let _invalid_short = json!({
             "$type": "shortString",
             "text": "This string is way too long for the short constraint"
         });
         // assert!(validator.validate_data(&invalid_short, &union_schema, &ctx).is_err()); // TODO: Enable when ObjectValidator supports constraints
 
         // String that should violate longString minLength constraint
-        let invalid_long = json!({
+        let _invalid_long = json!({
             "$type": "longString",
             "text": "short"
         });

packages/lexicon-rs/src/validation/primary/procedure.rs

···
 use serde_json::Value;
 use crate::errors::ValidationError;
 use crate::validation::{Validator, ValidationContext};
+use crate::validation::{
+    field::{object::ObjectValidator, array::ArrayValidator, union::UnionValidator, reference::RefValidator},
+    primitive::{string::StringValidator, integer::IntegerValidator, boolean::BooleanValidator, bytes::BytesValidator, blob::BlobValidator, cid_link::CidLinkValidator, null::NullValidator},
+    meta::{token::TokenValidator, unknown::UnknownValidator},
+};
 
 /// Validator for `procedure` type Lexicon definitions
 ///
···
 pub struct ProcedureValidator;
 
 impl ProcedureValidator {
+    /// Validates a schema by dispatching to the appropriate validator
+    fn validate_schema_by_type(
+        &self,
+        schema: &Value,
+        schema_type: &str,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
+        match schema_type {
+            // Field types
+            "object" => ObjectValidator.validate(schema, ctx),
+            "array" => ArrayValidator.validate(schema, ctx),
+            "union" => UnionValidator.validate(schema, ctx),
+            "ref" => RefValidator.validate(schema, ctx),
+
+            // Primitive types
+            "string" => StringValidator.validate(schema, ctx),
+            "integer" => IntegerValidator.validate(schema, ctx),
+            "boolean" => BooleanValidator.validate(schema, ctx),
+            "bytes" => BytesValidator.validate(schema, ctx),
+            "blob" => BlobValidator.validate(schema, ctx),
+            "cid-link" => CidLinkValidator.validate(schema, ctx),
+            "null" => NullValidator.validate(schema, ctx),
+
+            // Meta types
+            "token" => TokenValidator.validate(schema, ctx),
+            "unknown" => UnknownValidator.validate(schema, ctx),
+
+            _ => Err(ValidationError::InvalidSchema(format!(
+                "Unknown schema type '{}' in procedure", schema_type
+            ))),
+        }
+    }
+
     /// Validates procedure input data against input definition
     ///
     /// This method performs validation of procedure input against its schema.
···
             }
         }
 
-        // TODO: Validate parameters, input, output, and errors
+        // Validate parameters if present (must be type "params")
+        if let Some(parameters) = value.get("parameters") {
+            let params_ctx = ctx.with_path(&format!("{}.parameters", def_name));
+            ObjectValidator.validate(parameters, &params_ctx)?;
+        }
+
+        // Validate input if present (must have encoding, optional schema)
+        if let Some(input) = value.get("input") {
+            if let Some(input_obj) = input.as_object() {
+                // Validate required encoding field
+                if !input_obj.contains_key("encoding") {
+                    return Err(ValidationError::InvalidSchema(format!(
+                        "Procedure '{}' input missing required 'encoding' field",
+                        def_name
+                    )));
+                }
+
+                // Validate optional schema field
+                if let Some(schema) = input_obj.get("schema") {
+                    if let Some(schema_type) = schema.get("type").and_then(|t| t.as_str()) {
+                        let schema_ctx = ctx.with_path(&format!("{}.input.schema", def_name));
+                        self.validate_schema_by_type(schema, schema_type, &schema_ctx)?;
+                    }
+                }
+            } else {
+                return Err(ValidationError::InvalidSchema(format!(
+                    "Procedure '{}' input must be an object",
+                    def_name
+                )));
+            }
+        }
+
+        // Validate output if present (must have encoding, optional schema)
+        if let Some(output) = value.get("output") {
+            if let Some(output_obj) = output.as_object() {
+                // Validate required encoding field
+                if !output_obj.contains_key("encoding") {
+                    return Err(ValidationError::InvalidSchema(format!(
+                        "Procedure '{}' output missing required 'encoding' field",
+                        def_name
+                    )));
+                }
+
+                // Validate optional schema field
+                if let Some(schema) = output_obj.get("schema") {
+                    if let Some(schema_type) = schema.get("type").and_then(|t| t.as_str()) {
+                        let schema_ctx = ctx.with_path(&format!("{}.output.schema", def_name));
+                        self.validate_schema_by_type(schema, schema_type, &schema_ctx)?;
+                    }
+                }
+            } else {
+                return Err(ValidationError::InvalidSchema(format!(
+                    "Procedure '{}' output must be an object",
+                    def_name
+                )));
+            }
+        }
+
+        // TODO: Validate errors if present (array of objects with name field)
 
         Ok(())
     }
···
 
         let invalid_data = json!({"content": "Content"});
         assert!(validator.validate_data(&invalid_data, &schema, &ctx).is_err());
+    }
+
+    #[test]
+    fn test_procedure_with_broken_reference_in_output() {
+        let procedure = json!({
+            "type": "procedure",
+            "description": "Test procedure with broken reference in output",
+            "output": {
+                "encoding": "application/json",
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "result": {
+                            "type": "ref",
+                            "ref": "#nonExistentDef"
+                        }
+                    }
+                }
+            }
+        });
+
+        let ctx = ValidationContext::builder()
+            .with_lexicons(vec![json!({
+                "lexicon": 1,
+                "id": "test.broken.ref",
+                "defs": {
+                    "main": procedure.clone(),
+                    "existingDef": {
+                        "type": "string"
+                    }
+                }
+            })])
+            .unwrap()
+            .build()
+            .unwrap()
+            .with_current_lexicon("test.broken.ref");
+
+        let validator = ProcedureValidator;
+        let result = validator.validate(&procedure, &ctx);
+
+        // Should fail because #nonExistentDef doesn't exist
+        assert!(result.is_err(), "Procedure validation should fail for broken reference in output schema");
+
+        if let Err(error) = result {
+            let error_msg = format!("{:?}", error);
+            assert!(
+                error_msg.contains("non-existent") || error_msg.contains("nonExistentDef"),
+                "Error should mention the non-existent reference. Got: {}",
+                error_msg
+            );
+        }
+    }
+
+    #[test]
+    fn test_procedure_with_broken_reference_in_input() {
+        let procedure = json!({
+            "type": "procedure",
+            "description": "Test procedure with broken reference in input",
+            "input": {
+                "encoding": "application/json",
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "data": {
+                            "type": "ref",
+                            "ref": "#nonExistentDef"
+                        }
+                    }
+                }
+            }
+        });
+
+        let ctx = ValidationContext::builder()
+            .with_lexicons(vec![json!({
+                "lexicon": 1,
+                "id": "test.broken.ref",
+                "defs": {
+                    "main": procedure.clone(),
+                    "existingDef": {
+                        "type": "string"
+                    }
+                }
+            })])
+            .unwrap()
+            .build()
+            .unwrap()
+            .with_current_lexicon("test.broken.ref");
+
+        let validator = ProcedureValidator;
+        let result = validator.validate(&procedure, &ctx);
+
+        // Should fail because #nonExistentDef doesn't exist
+        assert!(result.is_err(), "Procedure validation should fail for broken reference in input schema");
+
+        if let Err(error) = result {
+            let error_msg = format!("{:?}", error);
+            assert!(
+                error_msg.contains("non-existent") || error_msg.contains("nonExistentDef"),
+                "Error should mention the non-existent reference. Got: {}",
+                error_msg
+            );
+        }
     }
 }

packages/lexicon-rs/src/validation/primary/query.rs

···
 use serde_json::Value;
 use crate::errors::ValidationError;
 use crate::validation::{Validator, ValidationContext};
+use crate::validation::{
+    field::{object::ObjectValidator, array::ArrayValidator, union::UnionValidator, reference::RefValidator},
+    primitive::{string::StringValidator, integer::IntegerValidator, boolean::BooleanValidator, bytes::BytesValidator, blob::BlobValidator, cid_link::CidLinkValidator, null::NullValidator},
+    meta::{token::TokenValidator, unknown::UnknownValidator},
+};
 
 /// Validator for `query` type Lexicon definitions
 ///
···
             }
         }
 
-        // TODO: Validate parameters if present (must be type "params")
-        // TODO: Validate output if present (must have encoding, optional schema)
+        // Validate parameters if present (must be type "params")
+        if let Some(parameters) = value.get("parameters") {
+            // Parameters should be validated as a "params" type schema
+            let params_ctx = ctx.with_path(&format!("{}.parameters", def_name));
+            ObjectValidator.validate(parameters, &params_ctx)?;
+        }
+
+        // Validate output if present (must have encoding, optional schema)
+        if let Some(output) = value.get("output") {
+            let _output_ctx = ctx.with_path(&format!("{}.output", def_name));
+
+            if let Some(output_obj) = output.as_object() {
+                // Validate required encoding field
+                if !output_obj.contains_key("encoding") {
+                    return Err(ValidationError::InvalidSchema(format!(
+                        "Query '{}' output missing required 'encoding' field",
+                        def_name
+                    )));
+                }
+
+                // Validate optional schema field
+                if let Some(schema) = output_obj.get("schema") {
+                    // Recursively validate the schema using the appropriate validator
+                    if let Some(schema_type) = schema.get("type").and_then(|t| t.as_str()) {
+                        let schema_ctx = ctx.with_path(&format!("{}.output.schema", def_name));
+
+                        let validation_result = match schema_type {
+                            // Field types
+                            "object" => ObjectValidator.validate(schema, &schema_ctx),
+                            "array" => ArrayValidator.validate(schema, &schema_ctx),
+                            "union" => UnionValidator.validate(schema, &schema_ctx),
+                            "ref" => RefValidator.validate(schema, &schema_ctx),
+
+                            // Primitive types
+                            "string" => StringValidator.validate(schema, &schema_ctx),
+                            "integer" => IntegerValidator.validate(schema, &schema_ctx),
+                            "boolean" => BooleanValidator.validate(schema, &schema_ctx),
+                            "bytes" => BytesValidator.validate(schema, &schema_ctx),
+                            "blob" => BlobValidator.validate(schema, &schema_ctx),
+                            "cid-link" => CidLinkValidator.validate(schema, &schema_ctx),
+                            "null" => NullValidator.validate(schema, &schema_ctx),
+
+                            // Meta types
+                            "token" => TokenValidator.validate(schema, &schema_ctx),
+                            "unknown" => UnknownValidator.validate(schema, &schema_ctx),
+
+                            _ => Err(ValidationError::InvalidSchema(format!(
+                                "Unknown schema type '{}' in query output", schema_type
+                            ))),
+                        };
+
+                        validation_result?;
+                    }
+                }
+            } else {
+                return Err(ValidationError::InvalidSchema(format!(
+                    "Query '{}' output must be an object",
+                    def_name
+                )));
+            }
+        }
+
         // TODO: Validate errors if present (array of objects with name field)
 
         Ok(())
···
 
         let empty_params = json!({});
         assert!(validator.validate_data(&empty_params, &schema, &ctx).is_ok());
+    }
+
+    #[test]
+    fn test_query_with_broken_reference_in_output() {
+        let query = json!({
+            "type": "query",
+            "description": "Test query with broken reference in output",
+            "output": {
+                "encoding": "application/json",
+                "schema": {
+                    "type": "object",
+                    "properties": {
+                        "items": {
+                            "type": "array",
+                            "items": {
+                                "type": "ref",
+                                "ref": "#nonExistentDef"
+                            }
+                        }
+                    }
+                }
+            }
+        });
+
+        let ctx = ValidationContext::builder()
+            .with_lexicons(vec![json!({
+                "lexicon": 1,
+                "id": "test.broken.ref",
+                "defs": {
+                    "main": query.clone(),
+                    "existingDef": {
+                        "type": "string"
+                    }
+                }
+            })])
+            .unwrap()
+            .build()
+            .unwrap()
+            .with_current_lexicon("test.broken.ref");
+
+        let validator = QueryValidator;
+        let result = validator.validate(&query, &ctx);
+
+        // Should fail because #nonExistentDef doesn't exist
+        assert!(result.is_err(), "Query validation should fail for broken reference in output schema");
+
+        if let Err(error) = result {
+            let error_msg = format!("{:?}", error);
+            assert!(
+                error_msg.contains("non-existent") || error_msg.contains("nonExistentDef"),
+                "Error should mention the non-existent reference. Got: {}",
+                error_msg
+            );
+        }
     }
 }

packages/lexicon-rs/src/validation/primary/subscription.rs

···
 use serde_json::Value;
 use crate::errors::ValidationError;
 use crate::validation::{Validator, ValidationContext};
+use crate::validation::{
+    field::{object::ObjectValidator, union::UnionValidator},
+};
 
 /// Validator for `subscription` type Lexicon definitions
 ///
···
             }
         }
 
+        // Validate parameters if present
+        if let Some(parameters) = value.get("parameters") {
+            let params_ctx = ctx.with_path(&format!("{}.parameters", def_name));
+            ObjectValidator.validate(parameters, &params_ctx)?;
+        }
+
         // Validate message schema must be union if present
         if let Some(message) = value.get("message") {
             if let Some(schema) = message.get("schema") {
···
                         def_name
                     )));
                 }
+
+                // Recursively validate the union schema
+                let schema_ctx = ctx.with_path(&format!("{}.message.schema", def_name));
+                UnionValidator.validate(schema, &schema_ctx)?;
             } else {
                 return Err(ValidationError::InvalidSchema(format!(
                     "Subscription '{}' message must have a schema field",
···
 
         let validator = SubscriptionValidator;
         assert!(validator.validate(&subscription, &ctx).is_ok());
+    }
+
+    #[test]
+    fn test_subscription_with_broken_reference_in_union() {
+        let subscription = json!({
+            "type": "subscription",
+            "description": "Test subscription with broken reference in union",
+            "message": {
+                "schema": {
+                    "type": "union",
+                    "refs": [
+                        "#nonExistentDef",
+                        "#existingDef"
+                    ]
+                }
+            }
+        });
+
+        let ctx = ValidationContext::builder()
+            .with_lexicons(vec![json!({
+                "lexicon": 1,
+                "id": "test.broken.ref",
+                "defs": {
+                    "main": subscription.clone(),
+                    "existingDef": {
+                        "type": "object",
+                        "properties": {
+                            "type": {"type": "string"}
+                        }
+                    }
+                }
+            })])
+            .unwrap()
+            .build()
+            .unwrap()
+            .with_current_lexicon("test.broken.ref");
+
+        let validator = SubscriptionValidator;
+        let result = validator.validate(&subscription, &ctx);
+
+        // Should fail because #nonExistentDef doesn't exist
+        assert!(result.is_err(), "Subscription validation should fail for broken reference in union");
+
+        if let Err(error) = result {
+            let error_msg = format!("{:?}", error);
+            assert!(
+                error_msg.contains("non-existent") || error_msg.contains("nonExistentDef"),
+                "Error should mention the non-existent reference. Got: {}",
+                error_msg
+            );
+        }
     }
 }

packages/lexicon-rs/src/validation/primitive/string.rs

···
     /// * `Ok(StringFormat)` if the format is valid
     /// * `Err(ValidationError)` if the format is unknown
     fn validate_format_constraint(def_name: &str, format_str: &str) -> Result<StringFormat, ValidationError> {
-        StringFormat::from_str(format_str).ok_or_else(|| {
+        format_str.parse::<StringFormat>().map_err(|_| {
             ValidationError::InvalidSchema(format!(
                 "String '{}' has unknown format '{}'. Valid formats: datetime, uri, at-uri, did, handle, at-identifier, nsid, cid, language, tid, record-key",
                 def_name, format_str
···
         // Validate format constraints
         if let Some(format_value) = schema.get("format") {
             if let Some(format_str) = format_value.as_str() {
-                if let Some(format) = StringFormat::from_str(format_str) {
+                if let Ok(format) = format_str.parse::<StringFormat>() {
                     self.validate_string_format(data_str, format, ctx)?;
                 }
             }

packages/lexicon-rs/src/validation/resolution.rs

···
         ));
     }
 
-    let (lexicon_id, def_name) = if reference.starts_with('#') {
+    let (lexicon_id, def_name) = if let Some(def_name) = reference.strip_prefix('#') {
         // Local reference within current lexicon
-        let def_name = &reference[1..];
         if def_name.is_empty() {
             return Err(ValidationError::InvalidSchema(
                 "Local reference cannot be just '#'".to_string()
···
                 .map(|r| {
                     if r.starts_with('#') {
                         format!("{}{}", lexicon_id, r)
-                    } else if !r.contains('#') {
-                        r // Already a full reference to main
                     } else {
                         r // Already a full reference
                     }
···
     let mut rec_stack = HashSet::new();
 
     for def_id in dependency_graph.keys() {
-        if !visited.contains(def_id) {
-            if has_cycle_dfs(def_id, &dependency_graph, &mut visited, &mut rec_stack) {
+        if !visited.contains(def_id)
+            && has_cycle_dfs(def_id, &dependency_graph, &mut visited, &mut rec_stack) {
                 return Err(ValidationError::InvalidSchema(format!(
                     "Circular dependency detected involving definition: {}", def_id
                 )));
             }
-        }
     }
 
     Ok(())

packages/lexicon-rs/test_ref_validation.rs

···
+use serde_json::json;
+use slices_lexicon::validate;
+
+fn main() {
+    let broken_lexicon = json!({
+        "lexicon": 1,
+        "id": "network.slices.slice.getSyncSummary",
+        "defs": {
+            "main": {
+                "type": "query",
+                "description": "Get a summary",
+                "output": {
+                    "encoding": "application/json",
+                    "schema": {
+                        "type": "object",
+                        "required": ["collectionsSummary"],
+                        "properties": {
+                            "collectionsSummary": {
+                                "type": "array",
+                                "items": {
+                                    "type": "ref",
+                                    "ref": "#collectionSummar"
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            "collectionSummary": {
+                "type": "object",
+                "required": ["collection"],
+                "properties": {
+                    "collection": {
+                        "type": "string"
+                    }
+                }
+            }
+        }
+    });
+
+    let lexicons = vec![broken_lexicon];
+
+    match validate(lexicons) {
+        Ok(()) => println!("✅ Validation passed (should NOT happen with broken ref)"),
+        Err(errors) => {
+            println!("❌ Validation failed (expected):");
+            for (lexicon_id, error_list) in errors {
+                println!("  {}: {:?}", lexicon_id, error_list);
+            }
+        }
+    }
+}

packages/lexicon/wasm/README.md

···
-# slices-lexicon
+# lexicon-rs
+
+Rust implementation of AT Protocol lexicon validation.
+
+## Overview
+
+This validation engine can be used in any project that needs AT Protocol lexicon validation. It provides high-performance, spec-compliant validation of AT Protocol lexicon documents and data records. It can also be compiled to WebAssembly for use in JavaScript/TypeScript environments.
+
+## Architecture
 
-AT Protocol lexicon validation library for Rust, compiled to WebAssembly.
+This package serves as the core validation engine and is typically consumed by higher-level packages:
+
+- **`@slices/lexicon`** - TypeScript/Deno package with ergonomic APIs
+- **`lexicon-intellisense`** - VS Code extension for lexicon development
+- **Slices CLI** - Command-line tooling for lexicon management
 
 ## Features
 
-- 🚀 Fast lexicon validation written in Rust
-- 🌐 WebAssembly support for browser and Node.js environments
-- 📦 Zero JavaScript dependencies
-- 🔒 Type-safe validation with comprehensive error messages
-- ✅ Full AT Protocol lexicon specification support
+- High-performance lexicon validation implemented in Rust
+- Comprehensive error reporting with detailed context
+- Full AT Protocol lexicon specification compliance
+- Support for all lexicon types: records, queries, procedures, subscriptions
+- Optional WebAssembly compilation for JavaScript/TypeScript environments
+- Zero JavaScript runtime dependencies when using WebAssembly
+
+## Direct Usage
+
+### Rust Library
 
-## Installation
+Add to your `Cargo.toml`:
 
 ```toml
 [dependencies]
 slices-lexicon = "0.1"
 ```
 
-## Usage
-
-### In Rust
+Basic validation:
 
 ```rust
-use slices_lexicon::{LexiconValidator, ValidationError};
+use slices_lexicon::{validate, validate_record, is_valid_nsid};
 use serde_json::json;
 
+// Define lexicon documents
 let lexicons = vec![
     json!({
         "id": "com.example.post",
+        "lexicon": 1,
         "defs": {
             "main": {
                 "type": "record",
+                "key": "tid",
                 "record": {
                     "type": "object",
+                    "required": ["text"],
                     "properties": {
-                        "text": { "type": "string" }
+                        "text": { "type": "string", "maxLength": 300 }
                     }
                 }
             }
···
     })
 ];
 
-let validator = LexiconValidator::new(lexicons)?;
+// Validate lexicon documents
+match validate(lexicons.clone()) {
+    Ok(()) => println!("All lexicons are valid"),
+    Err(errors) => {
+        for (lexicon_id, error_list) in errors {
+            println!("Errors in {}: {:?}", lexicon_id, error_list);
+        }
+    }
+}
+
+// Validate a data record against the schema
 let record = json!({ "text": "Hello, world!" });
+validate_record(lexicons, "com.example.post", record)?;
 
-validator.validate_record("com.example.post", &record)?;
+// Validate NSID format
+let is_valid = is_valid_nsid("com.example.post");
+println!("NSID valid: {}", is_valid);
 ```
 
-### As WebAssembly
+### WebAssembly
 
-Build with wasm-pack:
+Build the WASM module:
 
 ```bash
-wasm-pack build --target web
+wasm-pack build --target web --features wasm
 ```
 
-Then use in JavaScript/TypeScript:
+Use in JavaScript environments:
 
 ```javascript
-import init, { WasmLexiconValidator } from './pkg/slices_lexicon.js';
+import init, {
+    WasmLexiconValidator,
+    validate_lexicons_and_get_errors,
+    is_valid_nsid
+} from './pkg/slices_lexicon.js';
 
 await init();
 
-const validator = new WasmLexiconValidator(JSON.stringify(lexicons));
-validator.validate_record("com.example.post", JSON.stringify(record));
+// Validate lexicons
+const lexicons = [{
+    id: "com.example.post",
+    lexicon: 1,
+    defs: { /* ... */ }
+}];
+
+const errors = validate_lexicons_and_get_errors(JSON.stringify(lexicons));
+console.log('Validation errors:', JSON.parse(errors));
+
+// Validate NSID format
+const isValid = is_valid_nsid("com.example.post");
 ```
+
+## JavaScript/TypeScript Usage
+
+If you're using JavaScript or TypeScript, use the higher-level packages instead of consuming this library directly:
+
+- **TypeScript/JavaScript**: Use `@slices/lexicon` for ergonomic APIs with automatic resource management
+- **VS Code Development**: Install the `lexicon-intellisense` extension
+- **CLI Tools**: Use the Slices CLI for lexicon management tasks
 
 ## Supported Types