-m fixed bug with STI and different type shapes that don't require kind discrimination

src/tests/fixtures.rs

@@ -1559,6 +1559,24 @@ fn test_polymorphism_4_1() {
     crate::tests::runner::run_test_case(&path, 4, 1).unwrap();
 }
 
+#[test]
+fn test_polymorphism_5_0() {
+    let path = format!("{}/fixtures/polymorphism.json", env!("CARGO_MANIFEST_DIR"));
+    crate::tests::runner::run_test_case(&path, 5, 0).unwrap();
+}
+
+#[test]
+fn test_polymorphism_5_1() {
+    let path = format!("{}/fixtures/polymorphism.json", env!("CARGO_MANIFEST_DIR"));
+    crate::tests::runner::run_test_case(&path, 5, 1).unwrap();
+}
+
+#[test]
+fn test_polymorphism_5_2() {
+    let path = format!("{}/fixtures/polymorphism.json", env!("CARGO_MANIFEST_DIR"));
+    crate::tests::runner::run_test_case(&path, 5, 2).unwrap();
+}
+
 #[test]
 fn test_not_0_0() {
     let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));

src/validator/rules/extensible.rs

@@ -24,9 +24,6 @@ impl<'a> ValidationContext<'a> {
 
     if let Some(obj) = self.instance.as_object() {
       for key in obj.keys() {
-        if key == "type" || key == "kind" {
-          continue; // Reserved keywords implicitly allowed
-        }
         if !result.evaluated_keys.contains(key) && !self.overrides.contains(key) {
           result.errors.push(ValidationError {
             code: "STRICT_PROPERTY_VIOLATION".to_string(),

src/validator/rules/object.rs

@@ -54,14 +54,19 @@ impl<'a> ValidationContext<'a> {
 
           // If the target mathematically declares a horizontal structural STI variation natively
           if schema_identifier_str.contains('.') {
-            if obj.get("kind").is_none() {
-              result.errors.push(ValidationError {
-                code: "MISSING_KIND".to_string(),
-                message: "Schema mechanically requires horizontal kind discrimination".to_string(),
-                path: self.path.clone(),
-              });
-            } else {
-              result.evaluated_keys.insert("kind".to_string());
+            let requires_kind = self.schema.compiled_properties.get()
+                .map_or(false, |p| p.contains_key("kind"));
+            
+            if requires_kind {
+              if obj.get("kind").is_none() {
+                result.errors.push(ValidationError {
+                  code: "MISSING_KIND".to_string(),
+                  message: "Schema mechanically requires horizontal kind discrimination".to_string(),
+                  path: self.path.clone(),
+                });
+              } else {
+                result.evaluated_keys.insert("kind".to_string());
+              }
             }
           }
         } else {