fix validation error message formatting

- Fix double colon bug when validation path is empty
- Add defs.main prefix to data validation errors for clarity
- Add comprehensive tests for error message formats
- Schema validation errors show definition via #defName prefix
- Data validation errors include defs.main in path

src/honk.gleam

···
       case json_helpers.get_field(lexicon.defs, "main") {
         Some(main_def) -> {
           let lex_ctx = context.with_current_lexicon(ctx, collection)
+          // Set the path to include the definition name
+          let def_ctx = context.with_path(lex_ctx, "defs.main")
           // Validate the record data against the main definition
-          validation_primary_record.validate_data(record, main_def, lex_ctx)
+          validation_primary_record.validate_data(record, main_def, def_ctx)
         }
         None ->
           Error(errors.invalid_schema(

src/honk/validation/field.gleam

···
   list.try_fold(field_names, Nil, fn(_, field_name) {
     case json_helpers.get_field(data, field_name) {
       Some(_) -> Ok(Nil)
-      None ->
-        Error(errors.data_validation(
-          def_name <> ": required field '" <> field_name <> "' is missing",
-        ))
+      None -> {
+        let message = case def_name {
+          "" -> "required field '" <> field_name <> "' is missing"
+          _ -> def_name <> ": required field '" <> field_name <> "' is missing"
+        }
+        Error(errors.data_validation(message))
+      }
     }
   })
 }

test/end_to_end_test.gleam

···
 import gleeunit
 import gleeunit/should
 import honk
+import honk/errors
 import honk/types.{DateTime, Uri}
 
 pub fn main() {
···
   honk.validate([lexicon])
   |> should.be_ok
 }
+
+// Test missing required field error message with full defs.main path
+pub fn validate_record_missing_required_field_message_test() {
+  let lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.post")),
+      #(
+        "defs",
+        json.object([
+          #(
+            "main",
+            json.object([
+              #("type", json.string("record")),
+              #("key", json.string("tid")),
+              #(
+                "record",
+                json.object([
+                  #("type", json.string("object")),
+                  #("required", json.array([json.string("title")], fn(x) { x })),
+                  #(
+                    "properties",
+                    json.object([
+                      #(
+                        "title",
+                        json.object([#("type", json.string("string"))]),
+                      ),
+                    ]),
+                  ),
+                ]),
+              ),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let data = json.object([#("description", json.string("No title"))])
+
+  let assert Error(error) =
+    honk.validate_record([lexicon], "com.example.post", data)
+
+  let error_message = errors.to_string(error)
+  error_message
+  |> should.equal(
+    "Data validation failed: defs.main: required field 'title' is missing",
+  )
+}
+
+// Test missing required field in nested object with full path
+pub fn validate_record_nested_missing_required_field_message_test() {
+  let lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.post")),
+      #(
+        "defs",
+        json.object([
+          #(
+            "main",
+            json.object([
+              #("type", json.string("record")),
+              #("key", json.string("tid")),
+              #(
+                "record",
+                json.object([
+                  #("type", json.string("object")),
+                  #(
+                    "properties",
+                    json.object([
+                      #(
+                        "title",
+                        json.object([#("type", json.string("string"))]),
+                      ),
+                      #(
+                        "metadata",
+                        json.object([
+                          #("type", json.string("object")),
+                          #(
+                            "required",
+                            json.array([json.string("author")], fn(x) { x }),
+                          ),
+                          #(
+                            "properties",
+                            json.object([
+                              #(
+                                "author",
+                                json.object([#("type", json.string("string"))]),
+                              ),
+                            ]),
+                          ),
+                        ]),
+                      ),
+                    ]),
+                  ),
+                ]),
+              ),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let data =
+    json.object([
+      #("title", json.string("My Post")),
+      #("metadata", json.object([#("tags", json.string("tech"))])),
+    ])
+
+  let assert Error(error) =
+    honk.validate_record([lexicon], "com.example.post", data)
+
+  let error_message = errors.to_string(error)
+  error_message
+  |> should.equal(
+    "Data validation failed: defs.main.metadata: required field 'author' is missing",
+  )
+}
+
+// Test schema validation error for non-main definition includes correct path
+pub fn validate_schema_non_main_definition_error_test() {
+  let lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.test")),
+      #(
+        "defs",
+        json.object([
+          #(
+            "objectDef",
+            json.object([
+              #("type", json.string("object")),
+              #(
+                "properties",
+                json.object([
+                  #(
+                    "fieldA",
+                    json.object([
+                      #("type", json.string("string")),
+                      // Invalid: maxLength must be an integer, not a string
+                      #("maxLength", json.string("300")),
+                    ]),
+                  ),
+                ]),
+              ),
+            ]),
+          ),
+          #(
+            "recordDef",
+            json.object([
+              #("type", json.string("record")),
+              #("key", json.string("tid")),
+              #(
+                "record",
+                json.object([
+                  #("type", json.string("object")),
+                  #(
+                    "properties",
+                    json.object([
+                      #(
+                        "fieldB",
+                        json.object([
+                          #("type", json.string("ref")),
+                          // Invalid: missing required "ref" field for ref type
+                        ]),
+                      ),
+                    ]),
+                  ),
+                ]),
+              ),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let result = honk.validate([lexicon])
+
+  // Should have errors
+  result |> should.be_error
+
+  case result {
+    Error(error_map) -> {
+      // Get errors for this lexicon
+      case dict.get(error_map, "com.example.test") {
+        Ok(error_list) -> {
+          // Should have exactly one error from the recordDef (ref missing 'ref' field)
+          error_list
+          |> should.equal([
+            "com.example.test#recordDef: .record.properties.fieldB: ref missing required 'ref' field",
+          ])
+        }
+        Error(_) -> should.fail()
+      }
+    }
+    Ok(_) -> should.fail()
+  }
+}

test/integration_test.gleam

···
 import gleam/json
 import gleeunit
 import gleeunit/should
+import honk/errors
 import honk/validation/context
 import honk/validation/primary/record
 
···
   let result = record.validate_schema(schema, ctx)
   result |> should.be_ok
 }
+
+// Test missing required field error message at record root level
+pub fn record_missing_required_field_message_test() {
+  let schema =
+    json.object([
+      #("type", json.string("record")),
+      #("key", json.string("tid")),
+      #(
+        "record",
+        json.object([
+          #("type", json.string("object")),
+          #("required", json.array([json.string("title")], fn(x) { x })),
+          #(
+            "properties",
+            json.object([
+              #("title", json.object([#("type", json.string("string"))])),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let data = json.object([#("description", json.string("No title"))])
+
+  let assert Ok(ctx) = context.builder() |> context.build
+  let assert Error(error) = record.validate_data(data, schema, ctx)
+
+  let error_message = errors.to_string(error)
+  error_message
+  |> should.equal("Data validation failed: required field 'title' is missing")
+}
+
+// Test missing required field error message in nested object
+pub fn record_nested_missing_required_field_message_test() {
+  let schema =
+    json.object([
+      #("type", json.string("record")),
+      #("key", json.string("tid")),
+      #(
+        "record",
+        json.object([
+          #("type", json.string("object")),
+          #(
+            "properties",
+            json.object([
+              #("title", json.object([#("type", json.string("string"))])),
+              #(
+                "metadata",
+                json.object([
+                  #("type", json.string("object")),
+                  #(
+                    "required",
+                    json.array([json.string("author")], fn(x) { x }),
+                  ),
+                  #(
+                    "properties",
+                    json.object([
+                      #(
+                        "author",
+                        json.object([#("type", json.string("string"))]),
+                      ),
+                      #("tags", json.object([#("type", json.string("string"))])),
+                    ]),
+                  ),
+                ]),
+              ),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  let data =
+    json.object([
+      #("title", json.string("My Post")),
+      #("metadata", json.object([#("tags", json.string("tech"))])),
+    ])
+
+  let assert Ok(ctx) = context.builder() |> context.build
+  let assert Error(error) = record.validate_data(data, schema, ctx)
+
+  let error_message = errors.to_string(error)
+  error_message
+  |> should.equal(
+    "Data validation failed: metadata: required field 'author' is missing",
+  )
+}

test/object_validator_test.gleam

···
 import gleam/json
 import gleeunit
 import gleeunit/should
+import honk/errors
 import honk/validation/context
 import honk/validation/field
 
···
   let result = field.validate_object_data(data, schema, ctx)
   result |> should.be_error
 }
+
+// Test missing required field error message at root level (no path)
+pub fn missing_required_field_message_root_test() {
+  let schema =
+    json.object([
+      #("type", json.string("object")),
+      #(
+        "properties",
+        json.object([
+          #("title", json.object([#("type", json.string("string"))])),
+        ]),
+      ),
+      #("required", json.array([json.string("title")], fn(x) { x })),
+    ])
+
+  let data = json.object([#("other", json.string("value"))])
+
+  let assert Ok(ctx) = context.builder() |> context.build
+  let assert Error(error) = field.validate_object_data(data, schema, ctx)
+
+  let error_message = errors.to_string(error)
+  error_message
+  |> should.equal("Data validation failed: required field 'title' is missing")
+}

test/params_validator_test.gleam

···
 
   let data =
     json.object([
-      #("tags", json.array([json.string("foo"), json.string("bar")], fn(x) {
-        x
-      })),
+      #(
+        "tags",
+        json.array([json.string("foo"), json.string("bar")], fn(x) { x }),
+      ),
     ])
 
   let assert Ok(c) = context.builder() |> context.build()
···
   // Array contains strings instead of integers
   let data =
     json.object([
-      #("ids", json.array([json.string("one"), json.string("two")], fn(x) {
-        x
-      })),
+      #(
+        "ids",
+        json.array([json.string("one"), json.string("two")], fn(x) { x }),
+      ),
     ])
 
   let assert Ok(c) = context.builder() |> context.build()