CRITICAL FIX: Service Provider Inheritance System

Fixed inheritance bugs preventing field types from accepting attribute children:

1. TypeDefinitionBuilder.from() - Now copies ALL requirements (including inherited ones) instead of only direct requirements, preserving wildcard inheritance when service providers extend types

2. TypeDefinition.acceptsChild() - Fixed inherited wildcard filtering to check all inherited requirements instead of incorrectly filtering by name="*"

3. Wildcard requirement handling - Proper unique key generation for multiple wildcard requirements (attr.*, validator.*, view.*) prevents overwrites in Map storage

RESULTS:
✅ UnifiedRegistrySchemaIntegrationTest now passes (was failing on field inheritance)
✅ All 193 metadata tests pass
✅ All field types properly inherit wildcard attribute acceptance from field.base
✅ Service provider extensions preserve base type capabilities
✅ All modules compile successfully

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: dmealing

metadata/src/main/java/com/draagon/meta/registry/TypeDefinition.java

@@ -246,9 +246,9 @@ public boolean acceptsChild(String childType, String childSubType, String childN
             return inheritedNamedReq.matches(childType, childSubType, childName);
         }
 
-        // Check inherited wildcard requirements
+        // Check all inherited requirements (both named and wildcard)
         for (ChildRequirement inheritedReq : inheritedChildRequirements.values()) {
-            if ("*".equals(inheritedReq.getName()) && inheritedReq.matches(childType, childSubType, childName)) {
+            if (inheritedReq.matches(childType, childSubType, childName)) {
                 return true;
             }
         }

metadata/src/main/java/com/draagon/meta/registry/TypeDefinitionBuilder.java

@@ -77,9 +77,14 @@ public static TypeDefinitionBuilder from(TypeDefinition existing) {
         builder.parentType = existing.getParentType();
         builder.parentSubType = existing.getParentSubType();
 
-        // Copy direct child requirements (not inherited ones)
-        for (ChildRequirement req : existing.getDirectChildRequirements()) {
-            builder.childRequirements.put(req.getName(), req);
+        // Copy ALL child requirements (including inherited ones)
+        for (ChildRequirement req : existing.getChildRequirements()) {
+            String keyToUse = req.getName();
+            if ("*".equals(keyToUse)) {
+                // For wildcard requirements, create unique keys to avoid overwrites
+                keyToUse = "*:" + req.getExpectedType() + ":" + req.getExpectedSubType();
+            }
+            builder.childRequirements.put(keyToUse, req);
         }
 
         return builder;

metadata/src/test/java/com/draagon/meta/registry/UnifiedRegistrySchemaIntegrationTest.java

@@ -200,12 +200,55 @@ public void testMultipleMetadataStructures() throws IOException {
     @Test
     public void testRegistrySchemaComplianceMapping() {
         // Test that registry types map correctly to schema expectations
-        
+
+        // Debug registry state
+        System.out.println("=== REGISTRY DEBUG ===");
+        System.out.println("Total types: " + registry.getStats().totalTypes());
+        System.out.println("Registered types: " + registry.getRegisteredTypeNames());
+
+        // Check if field.string is registered
+        boolean stringFieldExists = registry.getRegisteredTypeNames().contains("field.string");
+        System.out.println("field.string registered: " + stringFieldExists);
+
+        // Check if attr.string is registered
+        boolean stringAttrExists = registry.getRegisteredTypeNames().contains("attr.string");
+        System.out.println("attr.string registered: " + stringAttrExists);
+
+        // Check field.base acceptance of attr.string
+        boolean baseAccepts = registry.acceptsChild("field", "base", "attr", "string", "testAttr");
+        System.out.println("field.base accepts attr.string: " + baseAccepts);
+
+        // Get description of what field.base supports
+        String baseDescription = registry.getSupportedChildrenDescription("field", "base");
+        System.out.println("field.base supported children: " + baseDescription);
+
+        // Get description of what field.string supports
+        String description = registry.getSupportedChildrenDescription("field", "string");
+        System.out.println("field.string supported children: " + description);
+
+        // Check if field.string properly inherits from field.base
+        try {
+            java.lang.reflect.Method getTypeDefMethod = registry.getClass().getDeclaredMethod("getTypeDefinition", String.class, String.class);
+            getTypeDefMethod.setAccessible(true);
+            Object baseTypeDef = getTypeDefMethod.invoke(registry, "field", "base");
+            Object stringTypeDef = getTypeDefMethod.invoke(registry, "field", "string");
+
+            if (baseTypeDef != null && stringTypeDef != null) {
+                System.out.println("field.base definition exists: true");
+                System.out.println("field.string definition exists: true");
+                System.out.println("field.string parent: " + stringTypeDef.getClass().getMethod("getParentType").invoke(stringTypeDef) + "." +
+                                 stringTypeDef.getClass().getMethod("getParentSubType").invoke(stringTypeDef));
+            }
+        } catch (Exception e) {
+            System.out.println("Reflection debug failed: " + e.getMessage());
+        }
+
         // Field types that should be supported
         String[] expectedFieldTypes = {"string", "int", "long", "double", "float", "boolean", "date", "timestamp"};
         for (String fieldType : expectedFieldTypes) {
-            assertTrue("Registry should support field type: " + fieldType, 
-                      registry.acceptsChild("field", fieldType, "attr", "string", "testAttr"));
+            boolean accepts = registry.acceptsChild("field", fieldType, "attr", "string", "testAttr");
+            System.out.println("field." + fieldType + " accepts attr.string: " + accepts);
+            assertTrue("Registry should support field type: " + fieldType, accepts);
         }
 
         // Object types that should be supported