update union validation and test coverage

- Fix union validator to properly validate local references through
resolution instead of skipping validation
- Add 6 new union tests with full lexicon catalog integration:
* All primitive non-object types validation
* Empty refs in data validation context
* Comprehensive reference matching (local, global main, fragments)
* Schema resolution with constraint validation
* Open vs closed union comparison
* Basic union with full context
- Implement complete params data validation with property type checking
- Add proper data validator to union tests via dispatch_data_validation
- Tests now validate required fields, constraints, and full resolution chain
- All 220 tests passing with full property schema resolution

Test coverage now aligns with reference implementations.

README.md

···
 
 When validating a directory, all lexicons are loaded together to resolve cross-lexicon references
 
-## API Overview
-
-### Main Functions
-
-- `validate(lexicons: List(Json))` - Validates one or more lexicon schemas
-- `validate_record(lexicons, nsid, data)` - Validates record data against a schema
-- `is_valid_nsid(value)` - Checks if a string is a valid NSID
-- `validate_string_format(value, format)` - Validates string against a format
-
-### Context Builder Pattern
-
-```gleam
-import validation/context
-import validation/field
-
-let assert Ok(ctx) =
-  context.builder()
-  |> context.with_validator(field.dispatch_data_validation)
-  |> context.with_lexicons([lexicon])
-  |> context.build
-```
-
 ## Testing
 
 ```sh

src/honk/validation/field.gleam

···
 
   use _ <- result.try(properties)
 
+  // Get properties for validation
+  let properties_json = json_helpers.get_field(schema, "properties")
+
   // Validate required fields reference existing properties
   use _ <- result.try(case json_helpers.get_array(schema, "required") {
-    Some(required_array) -> validate_required_fields(def_name, required_array)
+    Some(required_array) ->
+      validate_required_fields(def_name, required_array, properties_json)
     None -> Ok(Nil)
   })
 
   // Validate nullable fields reference existing properties
   use _ <- result.try(case json_helpers.get_array(schema, "nullable") {
-    Some(nullable_array) -> validate_nullable_fields(def_name, nullable_array)
+    Some(nullable_array) ->
+      validate_nullable_fields(def_name, nullable_array, properties_json)
     None -> Ok(Nil)
   })
 
   // Validate each property schema recursively
-  case json_helpers.get_field(schema, "properties") {
+  case properties_json {
     Some(properties) -> {
       case json_helpers.is_object(properties) {
         True -> {
···
 fn validate_required_fields(
   def_name: String,
   required: List(Dynamic),
+  properties: option.Option(Json),
 ) -> Result(Nil, errors.ValidationError) {
   // Convert dynamics to strings
   let field_names =
     list.filter_map(required, fn(item) { decode.run(item, decode.string) })
 
-  // Each required field should be validated against properties
-  // Simplified: just check they're strings
-  case list.length(field_names) == list.length(required) {
+  // Check all items are strings
+  use _ <- result.try(case list.length(field_names) == list.length(required) {
     True -> Ok(Nil)
     False ->
       Error(errors.invalid_schema(
         def_name <> ": required fields must be strings",
       ))
+  })
+
+  // Validate each required field exists in properties
+  case properties {
+    Some(props) -> {
+      case json_helpers.json_to_dict(props) {
+        Ok(props_dict) -> {
+          list.try_fold(field_names, Nil, fn(_, field_name) {
+            case json_helpers.dict_has_key(props_dict, field_name) {
+              True -> Ok(Nil)
+              False ->
+                Error(errors.invalid_schema(
+                  def_name
+                  <> ": required field '"
+                  <> field_name
+                  <> "' not found in properties",
+                ))
+            }
+          })
+        }
+        Error(_) -> Ok(Nil)
+      }
+    }
+    None -> {
+      // No properties defined, but required fields specified - this is an error
+      case list.is_empty(field_names) {
+        True -> Ok(Nil)
+        False ->
+          Error(errors.invalid_schema(
+            def_name <> ": required fields specified but no properties defined",
+          ))
+      }
+    }
   }
 }
 
···
 fn validate_nullable_fields(
   def_name: String,
   nullable: List(Dynamic),
+  properties: option.Option(Json),
 ) -> Result(Nil, errors.ValidationError) {
   // Convert dynamics to strings
   let field_names =
     list.filter_map(nullable, fn(item) { decode.run(item, decode.string) })
 
-  // Each nullable field should be validated against properties
-  // Simplified: just check they're strings
-  case list.length(field_names) == list.length(nullable) {
+  // Check all items are strings
+  use _ <- result.try(case list.length(field_names) == list.length(nullable) {
     True -> Ok(Nil)
     False ->
       Error(errors.invalid_schema(
         def_name <> ": nullable fields must be strings",
       ))
+  })
+
+  // Validate each nullable field exists in properties
+  case properties {
+    Some(props) -> {
+      case json_helpers.json_to_dict(props) {
+        Ok(props_dict) -> {
+          list.try_fold(field_names, Nil, fn(_, field_name) {
+            case json_helpers.dict_has_key(props_dict, field_name) {
+              True -> Ok(Nil)
+              False ->
+                Error(errors.invalid_schema(
+                  def_name
+                  <> ": nullable field '"
+                  <> field_name
+                  <> "' not found in properties",
+                ))
+            }
+          })
+        }
+        Error(_) -> Ok(Nil)
+      }
+    }
+    None -> {
+      // No properties defined, but nullable fields specified - this is an error
+      case list.is_empty(field_names) {
+        True -> Ok(Nil)
+        False ->
+          Error(errors.invalid_schema(
+            def_name <> ": nullable fields specified but no properties defined",
+          ))
+      }
+    }
   }
 }
 
···
 
   // Check each required field exists in data
   list.try_fold(field_names, Nil, fn(_, field_name) {
-    case json_helpers.get_string(data, field_name) {
+    case json_helpers.get_field(data, field_name) {
       Some(_) -> Ok(Nil)
       None ->
-        // Field might not be a string, check if it exists at all
-        // Simplified: just report missing
         Error(errors.data_validation(
           def_name <> ": required field '" <> field_name <> "' is missing",
         ))

src/honk/validation/field/union.gleam

···
 import honk/errors
 import honk/internal/constraints
 import honk/internal/json_helpers
+import honk/internal/resolution
 import honk/validation/context.{type ValidationContext}
 
 const allowed_fields = ["type", "refs", "closed", "description"]
···
   })
 
   // Empty refs array is only allowed for open unions
-  case list.is_empty(refs_array) {
+  use _ <- result.try(case list.is_empty(refs_array) {
     True -> {
       case json_helpers.get_bool(schema, "closed") {
         Some(True) ->
···
       }
     }
     False -> Ok(Nil)
-  }
-  // Note: Full implementation would validate that each reference can be resolved
+  })
+
+  // Validate that each reference can be resolved
+  validate_refs_resolvable(refs_array, ctx, def_name)
+}
+
+/// Validates that all references in the refs array can be resolved
+fn validate_refs_resolvable(
+  refs_array: List(decode.Dynamic),
+  ctx: ValidationContext,
+  def_name: String,
+) -> Result(Nil, errors.ValidationError) {
+  // Convert refs to strings
+  let ref_strings =
+    list.filter_map(refs_array, fn(r) { decode.run(r, decode.string) })
+
+  // Check each reference can be resolved (both local and global refs)
+  list.try_fold(ref_strings, Nil, fn(_, ref_str) {
+    case context.current_lexicon_id(ctx) {
+      Some(lex_id) -> {
+        // We have a full validation context, so validate reference resolution
+        // This works for both local refs (#def) and global refs (nsid#def)
+        use resolved <- result.try(resolution.resolve_reference(
+          ref_str,
+          ctx,
+          lex_id,
+        ))
+
+        case resolved {
+          Some(_) -> Ok(Nil)
+          None ->
+            Error(errors.invalid_schema(
+              def_name <> ": reference not found: " <> ref_str,
+            ))
+        }
+      }
+      None -> {
+        // No current lexicon (e.g., unit test context)
+        // Just validate syntax, can't check if reference exists
+        Ok(Nil)
+      }
+    }
+  })
 }
 
 /// Validates union data against schema
···
               refs_contain_type(ref_str, type_name)
             })
           {
-            Ok(_matching_ref) -> {
-              // Found matching ref
-              // In full implementation, would validate against the resolved schema
-              Ok(Nil)
+            Ok(matching_ref) -> {
+              // Found matching ref - validate data against the resolved schema
+              validate_against_resolved_ref(data, matching_ref, ctx, def_name)
             }
             Error(Nil) -> {
               // No matching ref found
···
           }
         }
       }
+    }
+  }
+}
+
+/// Validates data against a resolved reference from the union
+fn validate_against_resolved_ref(
+  data: Json,
+  ref_str: String,
+  ctx: ValidationContext,
+  def_name: String,
+) -> Result(Nil, errors.ValidationError) {
+  // Get current lexicon ID to resolve the reference
+  case context.current_lexicon_id(ctx) {
+    Some(lex_id) -> {
+      // We have a validation context, try to resolve and validate
+      use resolved_opt <- result.try(resolution.resolve_reference(
+        ref_str,
+        ctx,
+        lex_id,
+      ))
+
+      case resolved_opt {
+        Some(resolved_schema) -> {
+          // Successfully resolved - validate data against the resolved schema
+          let validator = ctx.validator
+          validator(data, resolved_schema, ctx)
+        }
+        None -> {
+          // Reference couldn't be resolved
+          // This shouldn't happen as schema validation should have caught it,
+          // but handle gracefully
+          Error(errors.data_validation(
+            def_name <> ": reference not found: " <> ref_str,
+          ))
+        }
+      }
+    }
+    None -> {
+      // No lexicon context (e.g., unit test)
+      // Can't validate against resolved schema, just accept the data
+      Ok(Nil)
     }
   }
 }

src/honk/validation/primary/params.gleam

···
 // Params type validator
-// Mirrors the Go implementation's validation/primary/params
 // Params define query/procedure/subscription parameters (XRPC endpoint arguments)
 
 import gleam/dynamic/decode
···
 
 /// Validates params data against schema
 pub fn validate_data(
-  _data: Json,
-  _schema: Json,
-  _ctx: ValidationContext,
+  data: Json,
+  schema: Json,
+  ctx: ValidationContext,
 ) -> Result(Nil, errors.ValidationError) {
-  // Params data validation would check that all required parameters are present
-  // and that each parameter value matches its schema
-  // For now, simplified implementation
-  Ok(Nil)
+  let def_name = context.path(ctx)
+
+  // Get data as dict
+  use data_dict <- result.try(json_helpers.json_to_dict(data))
+
+  // Get properties and required from params schema
+  let properties_dict = case json_helpers.get_field(schema, "properties") {
+    Some(props) -> json_helpers.json_to_dict(props)
+    None -> Ok(json_helpers.empty_dict())
+  }
+
+  let required_array = json_helpers.get_array(schema, "required")
+
+  use props_dict <- result.try(properties_dict)
+
+  // Check all required parameters are present
+  use _ <- result.try(case required_array {
+    Some(required) -> {
+      list.try_fold(required, Nil, fn(_, item) {
+        case decode.run(item, decode.string) {
+          Ok(param_name) -> {
+            case json_helpers.dict_has_key(data_dict, param_name) {
+              True -> Ok(Nil)
+              False ->
+                Error(errors.data_validation(
+                  def_name
+                  <> ": missing required parameter '"
+                  <> param_name
+                  <> "'",
+                ))
+            }
+          }
+          Error(_) -> Ok(Nil)
+        }
+      })
+    }
+    None -> Ok(Nil)
+  })
+
+  // Validate each parameter in data
+  json_helpers.dict_fold(data_dict, Ok(Nil), fn(acc, param_name, param_value) {
+    case acc {
+      Error(e) -> Error(e)
+      Ok(_) -> {
+        // Get the schema for this parameter
+        case json_helpers.dict_get(props_dict, param_name) {
+          Some(param_schema_dyn) -> {
+            // Convert dynamic to JSON
+            case json_helpers.dynamic_to_json(param_schema_dyn) {
+              Ok(param_schema) -> {
+                // Convert param value to JSON
+                case json_helpers.dynamic_to_json(param_value) {
+                  Ok(param_json) -> {
+                    // Validate the parameter value against its schema
+                    let param_ctx = context.with_path(ctx, param_name)
+                    validate_parameter_value(
+                      param_json,
+                      param_schema,
+                      param_ctx,
+                    )
+                  }
+                  Error(e) -> Error(e)
+                }
+              }
+              Error(e) -> Error(e)
+            }
+          }
+          None -> {
+            // Parameter not in schema - could warn or allow
+            // For now, allow unknown parameters
+            Ok(Nil)
+          }
+        }
+      }
+    }
+  })
+}
+
+/// Validates a single parameter value against its schema
+fn validate_parameter_value(
+  value: Json,
+  schema: Json,
+  ctx: ValidationContext,
+) -> Result(Nil, errors.ValidationError) {
+  // Dispatch based on schema type
+  case json_helpers.get_string(schema, "type") {
+    Some("boolean") ->
+      validation_primitive_boolean.validate_data(value, schema, ctx)
+    Some("integer") ->
+      validation_primitive_integer.validate_data(value, schema, ctx)
+    Some("string") ->
+      validation_primitive_string.validate_data(value, schema, ctx)
+    Some("unknown") -> validation_meta_unknown.validate_data(value, schema, ctx)
+    Some("array") -> validation_field.validate_array_data(value, schema, ctx)
+    Some(other_type) ->
+      Error(errors.data_validation(
+        context.path(ctx)
+        <> ": unsupported parameter type '"
+        <> other_type
+        <> "'",
+      ))
+    None ->
+      Error(errors.data_validation(
+        context.path(ctx) <> ": parameter schema missing type field",
+      ))
+  }
 }

test/params_validator_test.gleam

···
     Error(_) -> should.fail()
   }
 }
+
+// ==================== DATA VALIDATION TESTS ====================
+
+// Test valid data with required parameters
+pub fn valid_data_with_required_params_test() {
+  let schema =
+    json.object([
+      #("type", json.string("params")),
+      #(
+        "properties",
+        json.object([
+          #("repo", json.object([#("type", json.string("string"))])),
+          #("limit", json.object([#("type", json.string("integer"))])),
+        ]),
+      ),
+      #(
+        "required",
+        json.array([json.string("repo"), json.string("limit")], fn(x) { x }),
+      ),
+    ])
+
+  let data =
+    json.object([
+      #("repo", json.string("alice.bsky.social")),
+      #("limit", json.int(50)),
+    ])
+
+  let assert Ok(c) = context.builder() |> context.build()
+  params.validate_data(data, schema, c) |> should.be_ok
+}
+
+// Test valid data with optional parameters
+pub fn valid_data_with_optional_params_test() {
+  let schema =
+    json.object([
+      #("type", json.string("params")),
+      #(
+        "properties",
+        json.object([
+          #("repo", json.object([#("type", json.string("string"))])),
+          #("cursor", json.object([#("type", json.string("string"))])),
+        ]),
+      ),
+      #("required", json.array([json.string("repo")], fn(x) { x })),
+    ])
+
+  // Data has required param but not optional cursor
+  let data = json.object([#("repo", json.string("alice.bsky.social"))])
+
+  let assert Ok(c) = context.builder() |> context.build()
+  params.validate_data(data, schema, c) |> should.be_ok
+}
+
+// Test valid data with all parameter types
+pub fn valid_data_all_types_test() {
+  let schema =
+    json.object([
+      #("type", json.string("params")),
+      #(
+        "properties",
+        json.object([
+          #("name", json.object([#("type", json.string("string"))])),
+          #("count", json.object([#("type", json.string("integer"))])),
+          #("enabled", json.object([#("type", json.string("boolean"))])),
+          #("metadata", json.object([#("type", json.string("unknown"))])),
+        ]),
+      ),
+    ])
+
+  let data =
+    json.object([
+      #("name", json.string("test")),
+      #("count", json.int(42)),
+      #("enabled", json.bool(True)),
+      #("metadata", json.object([#("key", json.string("value"))])),
+    ])
+
+  let assert Ok(c) = context.builder() |> context.build()
+  params.validate_data(data, schema, c) |> should.be_ok
+}
+
+// Test valid data with array parameter
+pub fn valid_data_with_array_test() {
+  let schema =
+    json.object([
+      #("type", json.string("params")),
+      #(
+        "properties",
+        json.object([
+          #(
+            "tags",
+            json.object([
+              #("type", json.string("array")),
+              #("items", json.object([#("type", json.string("string"))])),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let data =
+    json.object([
+      #("tags", json.array([json.string("foo"), json.string("bar")], fn(x) {
+        x
+      })),
+    ])
+
+  let assert Ok(c) = context.builder() |> context.build()
+  params.validate_data(data, schema, c) |> should.be_ok
+}
+
+// Test invalid data: missing required parameter
+pub fn invalid_data_missing_required_test() {
+  let schema =
+    json.object([
+      #("type", json.string("params")),
+      #(
+        "properties",
+        json.object([
+          #("repo", json.object([#("type", json.string("string"))])),
+          #("limit", json.object([#("type", json.string("integer"))])),
+        ]),
+      ),
+      #("required", json.array([json.string("repo")], fn(x) { x })),
+    ])
+
+  // Data is missing required "repo" parameter
+  let data = json.object([#("limit", json.int(50))])
+
+  let assert Ok(c) = context.builder() |> context.build()
+  params.validate_data(data, schema, c) |> should.be_error
+}
+
+// Test invalid data: wrong type for parameter
+pub fn invalid_data_wrong_type_test() {
+  let schema =
+    json.object([
+      #("type", json.string("params")),
+      #(
+        "properties",
+        json.object([
+          #("limit", json.object([#("type", json.string("integer"))])),
+        ]),
+      ),
+    ])
+
+  // limit should be integer but is string
+  let data = json.object([#("limit", json.string("not a number"))])
+
+  let assert Ok(c) = context.builder() |> context.build()
+  params.validate_data(data, schema, c) |> should.be_error
+}
+
+// Test invalid data: string exceeds maxLength
+pub fn invalid_data_string_too_long_test() {
+  let schema =
+    json.object([
+      #("type", json.string("params")),
+      #(
+        "properties",
+        json.object([
+          #(
+            "name",
+            json.object([
+              #("type", json.string("string")),
+              #("maxLength", json.int(5)),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  // name is longer than maxLength of 5
+  let data = json.object([#("name", json.string("toolongname"))])
+
+  let assert Ok(c) = context.builder() |> context.build()
+  params.validate_data(data, schema, c) |> should.be_error
+}
+
+// Test invalid data: integer below minimum
+pub fn invalid_data_integer_below_minimum_test() {
+  let schema =
+    json.object([
+      #("type", json.string("params")),
+      #(
+        "properties",
+        json.object([
+          #(
+            "count",
+            json.object([
+              #("type", json.string("integer")),
+              #("minimum", json.int(1)),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  // count is below minimum of 1
+  let data = json.object([#("count", json.int(0))])
+
+  let assert Ok(c) = context.builder() |> context.build()
+  params.validate_data(data, schema, c) |> should.be_error
+}
+
+// Test invalid data: array with wrong item type
+pub fn invalid_data_array_wrong_item_type_test() {
+  let schema =
+    json.object([
+      #("type", json.string("params")),
+      #(
+        "properties",
+        json.object([
+          #(
+            "ids",
+            json.object([
+              #("type", json.string("array")),
+              #("items", json.object([#("type", json.string("integer"))])),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  // Array contains strings instead of integers
+  let data =
+    json.object([
+      #("ids", json.array([json.string("one"), json.string("two")], fn(x) {
+        x
+      })),
+    ])
+
+  let assert Ok(c) = context.builder() |> context.build()
+  params.validate_data(data, schema, c) |> should.be_error
+}
+
+// Test valid data with no properties defined (empty schema)
+pub fn valid_data_empty_schema_test() {
+  let schema = json.object([#("type", json.string("params"))])
+
+  let data = json.object([])
+
+  let assert Ok(c) = context.builder() |> context.build()
+  params.validate_data(data, schema, c) |> should.be_ok
+}
+
+// Test valid data allows unknown parameters not in schema
+pub fn valid_data_unknown_parameters_allowed_test() {
+  let schema =
+    json.object([
+      #("type", json.string("params")),
+      #(
+        "properties",
+        json.object([
+          #("repo", json.object([#("type", json.string("string"))])),
+        ]),
+      ),
+    ])
+
+  // Data has "extra" parameter not in schema
+  let data =
+    json.object([
+      #("repo", json.string("alice.bsky.social")),
+      #("extra", json.string("allowed")),
+    ])
+
+  let assert Ok(c) = context.builder() |> context.build()
+  params.validate_data(data, schema, c) |> should.be_ok
+}

test/union_validator_test.gleam

···
 import gleeunit
 import gleeunit/should
 import honk/validation/context
+import honk/validation/field
 import honk/validation/field/union
 
 pub fn main() {
   gleeunit.main()
 }
 
-// Test valid union schema with refs
-pub fn valid_union_schema_test() {
-  let schema =
-    json.object([
-      #("type", json.string("union")),
-      #(
-        "refs",
-        json.array([json.string("#post"), json.string("#repost")], fn(x) { x }),
-      ),
-    ])
-
-  let assert Ok(ctx) = context.builder() |> context.build
-  let result = union.validate_schema(schema, ctx)
-  result |> should.be_ok
-}
-
-// Test union schema with closed flag
-pub fn closed_union_schema_test() {
-  let schema =
-    json.object([
-      #("type", json.string("union")),
-      #("refs", json.array([json.string("#post")], fn(x) { x })),
-      #("closed", json.bool(True)),
-    ])
-
-  let assert Ok(ctx) = context.builder() |> context.build
-  let result = union.validate_schema(schema, ctx)
-  result |> should.be_ok
-}
-
 // Test open union with empty refs
 pub fn open_union_empty_refs_test() {
   let schema =
···
   result |> should.be_error
 }
 
-// Test valid union data with $type
+// Test valid union data with $type matching global ref
 pub fn valid_union_data_test() {
   let schema =
     json.object([
       #("type", json.string("union")),
-      #("refs", json.array([json.string("app.bsky.feed.post")], fn(x) { x })),
+      #("refs", json.array([json.string("com.example.post")], fn(x) { x })),
     ])
 
   let data =
     json.object([
-      #("$type", json.string("app.bsky.feed.post")),
+      #("$type", json.string("com.example.post")),
       #("text", json.string("Hello world")),
     ])
 
···
   let schema =
     json.object([
       #("type", json.string("union")),
-      #("refs", json.array([json.string("#post")], fn(x) { x })),
+      #("refs", json.array([json.string("com.example.post")], fn(x) { x })),
     ])
 
   let data = json.object([#("text", json.string("Hello"))])
···
   let schema =
     json.object([
       #("type", json.string("union")),
-      #("refs", json.array([json.string("#post")], fn(x) { x })),
+      #("refs", json.array([json.string("com.example.post")], fn(x) { x })),
     ])
 
   let data = json.string("not an object")
···
   result |> should.be_error
 }
 
-// Test union data with $type not in refs
+// Test closed union rejects $type not in refs
 pub fn union_data_type_not_in_refs_test() {
   let schema =
     json.object([
       #("type", json.string("union")),
-      #("refs", json.array([json.string("app.bsky.feed.post")], fn(x) { x })),
+      #("refs", json.array([json.string("com.example.typeA")], fn(x) { x })),
       #("closed", json.bool(True)),
     ])
 
   let data =
     json.object([
-      #("$type", json.string("app.bsky.feed.repost")),
+      #("$type", json.string("com.example.typeB")),
+      #("data", json.string("some data")),
+    ])
+
+  let assert Ok(ctx) = context.builder() |> context.build
+  let result = union.validate_data(data, schema, ctx)
+  result |> should.be_error
+}
+
+// Test union with invalid ref (non-string in array)
+pub fn union_with_invalid_ref_type_test() {
+  let schema =
+    json.object([
+      #("type", json.string("union")),
+      #(
+        "refs",
+        json.array([json.int(123), json.string("com.example.post")], fn(x) { x }),
+      ),
+    ])
+
+  let assert Ok(ctx) = context.builder() |> context.build
+  let result = union.validate_schema(schema, ctx)
+  result |> should.be_error
+}
+
+// Test local ref matching in data validation
+pub fn union_data_local_ref_matching_test() {
+  let schema =
+    json.object([
+      #("type", json.string("union")),
+      #(
+        "refs",
+        json.array([json.string("#post"), json.string("#reply")], fn(x) { x }),
+      ),
+    ])
+
+  // Data with $type matching local ref pattern
+  let data =
+    json.object([
+      #("$type", json.string("post")),
       #("text", json.string("Hello")),
     ])
 
   let assert Ok(ctx) = context.builder() |> context.build
   let result = union.validate_data(data, schema, ctx)
+  // Should pass because local ref #post matches bare name "post"
+  result |> should.be_ok
+}
+
+// Test local ref with NSID in data
+pub fn union_data_local_ref_with_nsid_test() {
+  let schema =
+    json.object([
+      #("type", json.string("union")),
+      #("refs", json.array([json.string("#view")], fn(x) { x })),
+    ])
+
+  // Data with $type as full NSID#fragment
+  let data =
+    json.object([
+      #("$type", json.string("com.example.feed#view")),
+      #("uri", json.string("at://did:plc:abc/com.example.feed/123")),
+    ])
+
+  let assert Ok(ctx) = context.builder() |> context.build
+  let result = union.validate_data(data, schema, ctx)
+  // Should pass because local ref #view matches NSID with #view fragment
+  result |> should.be_ok
+}
+
+// Test multiple local refs in schema
+pub fn union_with_multiple_local_refs_test() {
+  let schema =
+    json.object([
+      #("type", json.string("union")),
+      #(
+        "refs",
+        json.array(
+          [json.string("#post"), json.string("#repost"), json.string("#reply")],
+          fn(x) { x },
+        ),
+      ),
+    ])
+
+  let assert Ok(ctx) = context.builder() |> context.build
+  let result = union.validate_schema(schema, ctx)
+  // In test context without lexicon catalog, local refs are syntactically valid
+  result |> should.be_ok
+}
+
+// Test mixed global and local refs
+pub fn union_with_mixed_refs_test() {
+  let schema =
+    json.object([
+      #("type", json.string("union")),
+      #(
+        "refs",
+        json.array(
+          [json.string("com.example.post"), json.string("#localDef")],
+          fn(x) { x },
+        ),
+      ),
+    ])
+
+  let assert Ok(ctx) = context.builder() |> context.build
+  let result = union.validate_schema(schema, ctx)
+  // In test context without lexicon catalog, both types are syntactically valid
+  result |> should.be_ok
+}
+
+// Test all primitive types for non-object validation
+pub fn union_data_all_non_object_types_test() {
+  let schema =
+    json.object([
+      #("type", json.string("union")),
+      #("refs", json.array([json.string("com.example.post")], fn(x) { x })),
+    ])
+
+  let assert Ok(ctx) = context.builder() |> context.build
+
+  // Test number
+  let number_data = json.int(123)
+  union.validate_data(number_data, schema, ctx) |> should.be_error
+
+  // Test string
+  let string_data = json.string("not an object")
+  union.validate_data(string_data, schema, ctx) |> should.be_error
+
+  // Test null
+  let null_data = json.null()
+  union.validate_data(null_data, schema, ctx) |> should.be_error
+
+  // Test array
+  let array_data = json.array([json.string("item")], fn(x) { x })
+  union.validate_data(array_data, schema, ctx) |> should.be_error
+
+  // Test boolean
+  let bool_data = json.bool(True)
+  union.validate_data(bool_data, schema, ctx) |> should.be_error
+}
+
+// Test empty refs in data validation context
+pub fn union_data_empty_refs_test() {
+  let schema =
+    json.object([
+      #("type", json.string("union")),
+      #("refs", json.array([], fn(x) { x })),
+    ])
+
+  let data =
+    json.object([
+      #("$type", json.string("any.type")),
+      #("data", json.string("some data")),
+    ])
+
+  let assert Ok(ctx) = context.builder() |> context.build
+  let result = union.validate_data(data, schema, ctx)
+  // Data validation should fail with empty refs array
   result |> should.be_error
 }
+
+// Test comprehensive reference matching with full lexicon catalog
+pub fn union_data_reference_matching_test() {
+  // Set up lexicons with local, global main, and fragment refs
+  let main_lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.test")),
+      #(
+        "defs",
+        json.object([
+          #(
+            "main",
+            json.object([
+              #("type", json.string("union")),
+              #(
+                "refs",
+                json.array(
+                  [
+                    json.string("#localType"),
+                    json.string("com.example.global#main"),
+                    json.string("com.example.types#fragmentType"),
+                  ],
+                  fn(x) { x },
+                ),
+              ),
+            ]),
+          ),
+          #(
+            "localType",
+            json.object([
+              #("type", json.string("object")),
+              #("properties", json.object([])),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let global_lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.global")),
+      #(
+        "defs",
+        json.object([
+          #(
+            "main",
+            json.object([
+              #("type", json.string("object")),
+              #("properties", json.object([])),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let types_lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.types")),
+      #(
+        "defs",
+        json.object([
+          #(
+            "fragmentType",
+            json.object([
+              #("type", json.string("object")),
+              #("properties", json.object([])),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let assert Ok(builder) =
+    context.builder()
+    |> context.with_validator(field.dispatch_data_validation)
+    |> context.with_lexicons([main_lexicon, global_lexicon, types_lexicon])
+
+  let assert Ok(ctx) = builder |> context.build()
+  let ctx = context.with_current_lexicon(ctx, "com.example.test")
+
+  let schema =
+    json.object([
+      #("type", json.string("union")),
+      #(
+        "refs",
+        json.array(
+          [
+            json.string("#localType"),
+            json.string("com.example.global#main"),
+            json.string("com.example.types#fragmentType"),
+          ],
+          fn(x) { x },
+        ),
+      ),
+    ])
+
+  // Test local reference match
+  let local_data = json.object([#("$type", json.string("localType"))])
+  union.validate_data(local_data, schema, ctx) |> should.be_ok
+
+  // Test global main reference match
+  let global_data =
+    json.object([#("$type", json.string("com.example.global#main"))])
+  union.validate_data(global_data, schema, ctx) |> should.be_ok
+
+  // Test global fragment reference match
+  let fragment_data =
+    json.object([#("$type", json.string("com.example.types#fragmentType"))])
+  union.validate_data(fragment_data, schema, ctx) |> should.be_ok
+}
+
+// Test full schema resolution with constraint validation
+pub fn union_data_with_schema_resolution_test() {
+  let main_lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.feed")),
+      #(
+        "defs",
+        json.object([
+          #(
+            "main",
+            json.object([
+              #("type", json.string("union")),
+              #(
+                "refs",
+                json.array(
+                  [
+                    json.string("#post"),
+                    json.string("#repost"),
+                    json.string("com.example.types#like"),
+                  ],
+                  fn(x) { x },
+                ),
+              ),
+            ]),
+          ),
+          #(
+            "post",
+            json.object([
+              #("type", json.string("object")),
+              #(
+                "properties",
+                json.object([
+                  #(
+                    "title",
+                    json.object([
+                      #("type", json.string("string")),
+                      #("maxLength", json.int(100)),
+                    ]),
+                  ),
+                  #("content", json.object([#("type", json.string("string"))])),
+                ]),
+              ),
+              #("required", json.array([json.string("title")], fn(x) { x })),
+            ]),
+          ),
+          #(
+            "repost",
+            json.object([
+              #("type", json.string("object")),
+              #(
+                "properties",
+                json.object([
+                  #("original", json.object([#("type", json.string("string"))])),
+                  #("comment", json.object([#("type", json.string("string"))])),
+                ]),
+              ),
+              #("required", json.array([json.string("original")], fn(x) { x })),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let types_lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.types")),
+      #(
+        "defs",
+        json.object([
+          #(
+            "like",
+            json.object([
+              #("type", json.string("object")),
+              #(
+                "properties",
+                json.object([
+                  #("target", json.object([#("type", json.string("string"))])),
+                  #(
+                    "emoji",
+                    json.object([
+                      #("type", json.string("string")),
+                      #("maxLength", json.int(10)),
+                    ]),
+                  ),
+                ]),
+              ),
+              #("required", json.array([json.string("target")], fn(x) { x })),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let assert Ok(builder) =
+    context.builder()
+    |> context.with_validator(field.dispatch_data_validation)
+    |> context.with_lexicons([main_lexicon, types_lexicon])
+
+  let assert Ok(ctx) = builder |> context.build()
+  let ctx = context.with_current_lexicon(ctx, "com.example.feed")
+
+  let union_schema =
+    json.object([
+      #("type", json.string("union")),
+      #(
+        "refs",
+        json.array(
+          [
+            json.string("#post"),
+            json.string("#repost"),
+            json.string("com.example.types#like"),
+          ],
+          fn(x) { x },
+        ),
+      ),
+    ])
+
+  // Test valid post data (with all required fields)
+  let valid_post =
+    json.object([
+      #("$type", json.string("post")),
+      #("title", json.string("My Post")),
+      #("content", json.string("This is my post content")),
+    ])
+  union.validate_data(valid_post, union_schema, ctx) |> should.be_ok
+
+  // Test invalid post data (missing required field)
+  let invalid_post =
+    json.object([
+      #("$type", json.string("post")),
+      #("content", json.string("This is missing a title")),
+    ])
+  union.validate_data(invalid_post, union_schema, ctx) |> should.be_error
+
+  // Test valid repost data (with all required fields)
+  let valid_repost =
+    json.object([
+      #("$type", json.string("repost")),
+      #("original", json.string("original-post-uri")),
+      #("comment", json.string("Great post!")),
+    ])
+  union.validate_data(valid_repost, union_schema, ctx) |> should.be_ok
+
+  // Test valid like data (global reference with all required fields)
+  let valid_like =
+    json.object([
+      #("$type", json.string("com.example.types#like")),
+      #("target", json.string("post-uri")),
+      #("emoji", json.string("👍")),
+    ])
+  union.validate_data(valid_like, union_schema, ctx) |> should.be_ok
+
+  // Test invalid like data (missing required field)
+  let invalid_like =
+    json.object([
+      #("$type", json.string("com.example.types#like")),
+      #("emoji", json.string("👍")),
+    ])
+  union.validate_data(invalid_like, union_schema, ctx) |> should.be_error
+}
+
+// Test open vs closed union comparison
+pub fn union_data_open_vs_closed_test() {
+  let lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.test")),
+      #(
+        "defs",
+        json.object([
+          #(
+            "main",
+            json.object([
+              #("type", json.string("union")),
+              #("refs", json.array([json.string("#post")], fn(x) { x })),
+              #("closed", json.bool(False)),
+            ]),
+          ),
+          #(
+            "post",
+            json.object([
+              #("type", json.string("object")),
+              #(
+                "properties",
+                json.object([
+                  #("title", json.object([#("type", json.string("string"))])),
+                ]),
+              ),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let assert Ok(builder) =
+    context.builder()
+    |> context.with_validator(field.dispatch_data_validation)
+    |> context.with_lexicons([lexicon])
+  let assert Ok(ctx) = builder |> context.build()
+  let ctx = context.with_current_lexicon(ctx, "com.example.test")
+
+  let open_union_schema =
+    json.object([
+      #("type", json.string("union")),
+      #("refs", json.array([json.string("#post")], fn(x) { x })),
+      #("closed", json.bool(False)),
+    ])
+
+  let closed_union_schema =
+    json.object([
+      #("type", json.string("union")),
+      #("refs", json.array([json.string("#post")], fn(x) { x })),
+      #("closed", json.bool(True)),
+    ])
+
+  // Known $type should work in both
+  let known_type =
+    json.object([
+      #("$type", json.string("post")),
+      #("title", json.string("Test")),
+    ])
+  union.validate_data(known_type, open_union_schema, ctx) |> should.be_ok
+  union.validate_data(known_type, closed_union_schema, ctx) |> should.be_ok
+
+  // Unknown $type - behavior differs between open/closed
+  let unknown_type =
+    json.object([
+      #("$type", json.string("unknown_type")),
+      #("data", json.string("test")),
+    ])
+  // Open union should accept unknown types
+  union.validate_data(unknown_type, open_union_schema, ctx) |> should.be_ok
+  // Closed union should reject unknown types
+  union.validate_data(unknown_type, closed_union_schema, ctx) |> should.be_error
+}
+
+// Test basic union with full lexicon context
+pub fn union_data_basic_with_full_context_test() {
+  let main_lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.test")),
+      #(
+        "defs",
+        json.object([
+          #(
+            "main",
+            json.object([
+              #("type", json.string("union")),
+              #(
+                "refs",
+                json.array(
+                  [
+                    json.string("#post"),
+                    json.string("#repost"),
+                    json.string("com.example.like#main"),
+                  ],
+                  fn(x) { x },
+                ),
+              ),
+            ]),
+          ),
+          #(
+            "post",
+            json.object([
+              #("type", json.string("object")),
+              #(
+                "properties",
+                json.object([
+                  #("title", json.object([#("type", json.string("string"))])),
+                  #("content", json.object([#("type", json.string("string"))])),
+                ]),
+              ),
+            ]),
+          ),
+          #(
+            "repost",
+            json.object([
+              #("type", json.string("object")),
+              #(
+                "properties",
+                json.object([
+                  #("original", json.object([#("type", json.string("string"))])),
+                ]),
+              ),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let like_lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.like")),
+      #(
+        "defs",
+        json.object([
+          #(
+            "main",
+            json.object([
+              #("type", json.string("object")),
+              #(
+                "properties",
+                json.object([
+                  #("target", json.object([#("type", json.string("string"))])),
+                ]),
+              ),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let assert Ok(builder) =
+    context.builder()
+    |> context.with_validator(field.dispatch_data_validation)
+    |> context.with_lexicons([main_lexicon, like_lexicon])
+
+  let assert Ok(ctx) = builder |> context.build()
+  let ctx = context.with_current_lexicon(ctx, "com.example.test")
+
+  let schema =
+    json.object([
+      #("type", json.string("union")),
+      #(
+        "refs",
+        json.array(
+          [
+            json.string("#post"),
+            json.string("#repost"),
+            json.string("com.example.like#main"),
+          ],
+          fn(x) { x },
+        ),
+      ),
+    ])
+
+  // Valid union data with local reference
+  let post_data =
+    json.object([
+      #("$type", json.string("post")),
+      #("title", json.string("My Post")),
+      #("content", json.string("Post content")),
+    ])
+  union.validate_data(post_data, schema, ctx) |> should.be_ok
+
+  // Valid union data with global reference
+  let like_data =
+    json.object([
+      #("$type", json.string("com.example.like#main")),
+      #("target", json.string("some-target")),
+    ])
+  union.validate_data(like_data, schema, ctx) |> should.be_ok
+}