update validator to validate all defs not just main

src/honk.gleam

···
 
 import gleam/dict.{type Dict}
 import gleam/json.{type Json}
+import gleam/list
 import gleam/option.{None, Some}
 import gleam/result
 import honk/errors
···
 pub type ValidationError =
   errors.ValidationError
 
-/// Main validation function for lexicon documents
-/// Returns Ok(Nil) if all lexicons are valid
-/// Returns Error with a map of lexicon ID to list of error messages
+/// Validates lexicon documents
+///
+/// Validates lexicon structure (id, defs) and ALL definitions within each lexicon.
+/// Each definition in the defs object is validated according to its type.
+///
+/// Returns Ok(Nil) if all lexicons and their definitions are valid.
+/// Returns Error with a map of lexicon ID to list of error messages.
+/// Error messages include the definition name (e.g., "lex.id#defName: error").
 pub fn validate(lexicons: List(Json)) -> Result(Nil, Dict(String, List(String))) {
   // Build validation context
   let builder_result =
···
     Ok(builder) ->
       case context.build(builder) {
         Ok(ctx) -> {
-          // Validate each lexicon's main definition
+          // Validate ALL definitions in each lexicon
           let error_map =
             dict.fold(ctx.lexicons, dict.new(), fn(errors, lex_id, lexicon) {
-              // Validate the main definition if it exists
-              case json_helpers.get_field(lexicon.defs, "main") {
-                Some(main_def) -> {
-                  let lex_ctx = context.with_current_lexicon(ctx, lex_id)
-                  case validate_definition(main_def, lex_ctx) {
-                    Ok(_) -> errors
-                    Error(e) ->
-                      dict.insert(errors, lex_id, [errors.to_string(e)])
+              // Get all definition names from the defs object
+              let def_keys = json_helpers.get_keys(lexicon.defs)
+              let lex_ctx = context.with_current_lexicon(ctx, lex_id)
+
+              // Validate each definition
+              list.fold(def_keys, errors, fn(errors_acc, def_name) {
+                case json_helpers.get_field(lexicon.defs, def_name) {
+                  Some(def) -> {
+                    case validate_definition(def, lex_ctx) {
+                      Ok(_) -> errors_acc
+                      Error(e) -> {
+                        // Include def name in error for better context
+                        let error_msg =
+                          lex_id
+                          <> "#"
+                          <> def_name
+                          <> ": "
+                          <> errors.to_string(e)
+                        case dict.get(errors_acc, lex_id) {
+                          Ok(existing_errors) ->
+                            dict.insert(errors_acc, lex_id, [
+                              error_msg,
+                              ..existing_errors
+                            ])
+                          Error(_) ->
+                            dict.insert(errors_acc, lex_id, [error_msg])
+                        }
+                      }
+                    }
                   }
+                  None -> errors_acc
                 }
-                None -> errors
-                // No main definition is OK
-              }
+              })
             })
 
           case dict.is_empty(error_map) {

test/end_to_end_test.gleam

···
+import gleam/dict
 import gleam/json
+import gleam/list
+import gleam/string
 import gleeunit
 import gleeunit/should
 import honk
···
   honk.validate_string_format("https://example.com", Uri)
   |> should.be_ok
 }
+
+// Test lexicon with multiple valid definitions
+pub fn validate_lexicon_multiple_defs_test() {
+  let lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.multi")),
+      #(
+        "defs",
+        json.object([
+          #(
+            "main",
+            json.object([
+              #("type", json.string("record")),
+              #("key", json.string("tid")),
+              #(
+                "record",
+                json.object([
+                  #("type", json.string("object")),
+                  #("properties", json.object([])),
+                ]),
+              ),
+            ]),
+          ),
+          #(
+            "stringFormats",
+            json.object([
+              #("type", json.string("object")),
+              #("properties", json.object([])),
+            ]),
+          ),
+          #("additionalType", json.object([#("type", json.string("string"))])),
+        ]),
+      ),
+    ])
+
+  honk.validate([lexicon])
+  |> should.be_ok
+}
+
+// Test lexicon with only non-main definitions
+pub fn validate_lexicon_no_main_def_test() {
+  let lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.nomain")),
+      #(
+        "defs",
+        json.object([
+          #("customType", json.object([#("type", json.string("string"))])),
+          #("anotherType", json.object([#("type", json.string("integer"))])),
+        ]),
+      ),
+    ])
+
+  honk.validate([lexicon])
+  |> should.be_ok
+}
+
+// Test lexicon with invalid non-main definition
+pub fn validate_lexicon_invalid_non_main_def_test() {
+  let lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.invalid")),
+      #(
+        "defs",
+        json.object([
+          #(
+            "main",
+            json.object([
+              #("type", json.string("record")),
+              #("key", json.string("tid")),
+              #(
+                "record",
+                json.object([
+                  #("type", json.string("object")),
+                  #("properties", json.object([])),
+                ]),
+              ),
+            ]),
+          ),
+          #(
+            "badDef",
+            json.object([
+              #("type", json.string("string")),
+              #("minLength", json.int(10)),
+              #("maxLength", json.int(5)),
+            ]),
+          ),
+        ]),
+      ),
+    ])
+
+  case honk.validate([lexicon]) {
+    Error(error_map) -> {
+      // Should have error for this lexicon
+      case dict.get(error_map, "com.example.invalid") {
+        Ok(errors) -> {
+          // Error message should include the def name
+          list.any(errors, fn(msg) { string.contains(msg, "#badDef") })
+          |> should.be_true
+        }
+        Error(_) -> panic as "Expected error for com.example.invalid"
+      }
+    }
+    Ok(_) -> panic as "Expected validation to fail"
+  }
+}
+
+// Test empty defs object
+pub fn validate_lexicon_empty_defs_test() {
+  let lexicon =
+    json.object([
+      #("lexicon", json.int(1)),
+      #("id", json.string("com.example.empty")),
+      #("defs", json.object([])),
+    ])
+
+  honk.validate([lexicon])
+  |> should.be_ok
+}