fix: detects nested objects with colliding keys.

src/Library/Container.php

@@ -97,7 +97,7 @@ public function __construct(Settings $settings)
                 $builder = new TypeNodeBuilder(
                     new ArrayNodeBuilder(),
                     new ListNodeBuilder(),
-                    new ShapedArrayNodeBuilder(),
+                    new ShapedArrayNodeBuilder($this->get(ClassDefinitionRepository::class)),
                     new ScalarNodeBuilder(),
                     new UnionNodeBuilder(),
                     new NullNodeBuilder(),

src/Mapper/Tree/Builder/ShapedArrayNodeBuilder.php

@@ -4,14 +4,21 @@
 
 namespace CuyZ\Valinor\Mapper\Tree\Builder;
 
+use CuyZ\Valinor\Definition\Repository\ClassDefinitionRepository;
 use CuyZ\Valinor\Mapper\Tree\Exception\SourceMustBeIterable;
 use CuyZ\Valinor\Mapper\Tree\Exception\UnexpectedKeyInSource;
 use CuyZ\Valinor\Mapper\Tree\Shell;
+use CuyZ\Valinor\Type\ObjectType;
 use CuyZ\Valinor\Type\Types\ShapedArrayType;
 use CuyZ\Valinor\Type\Types\UnresolvableType;
 
+use Throwable;
+
+use function array_diff;
 use function array_diff_key;
 use function array_key_exists;
+use function array_keys;
+use function array_values;
 use function assert;
 use function is_array;
 use function is_iterable;
@@ -20,6 +27,9 @@
 /** @internal */
 final class ShapedArrayNodeBuilder implements NodeBuilder
 {
+    public function __construct(
+        private ClassDefinitionRepository|null $classDefinitionRepository = null,
+    ) {}
     public function build(Shell $shell): Node
     {
         $type = $shell->type;
@@ -45,8 +55,11 @@
                 ->child((string)$key, $element->type())
                 ->withAttributes($element->attributes());
 
+            $consumedKeys = [];
             if (array_key_exists($key, $value)) {
-                $child = $child->withValue($value[$key]);
+                $result = $this->resolveNestedKeys($key, $value, $element->type());
+                $child = $child->withValue($result['value']);
+                $consumedKeys = $result['consumed_keys'];
             } elseif ($element->isOptional()) {
                 continue;
             }
@@ -60,6 +73,9 @@
             }
 
             unset($value[$key]);
+            foreach ($consumedKeys as $consumedKey) {
+                unset($value[$consumedKey]);
+            }
         }
 
         // Second phase: if the shaped array is unsealed, we take the remaining
@@ -95,4 +111,64 @@
 
         return $shell->errors($errors);
     }
+
+    /**
+     * @param array<mixed> $parentValue
+     * @return array{value: mixed, consumed_keys: list<string>}
+     */
+    private function resolveNestedKeys(int|string $key, array $parentValue, mixed $type): array
+    {
+        if (! $type instanceof ObjectType || $this->classDefinitionRepository === null) {
+            return ['value' => $parentValue[$key], 'consumed_keys' => []];
+        }
+
+        if (is_array($parentValue[$key])) {
+            return ['value' => $parentValue[$key], 'consumed_keys' => []];
+        }
+
+        try {
+            $classDefinition = $this->classDefinitionRepository->for($type);
+            $parentKeys = array_keys($parentValue);
+
+            foreach ($classDefinition->methods as $method) {
+                if ($method->name !== '__construct'
+                    && !$method->attributes->has(\CuyZ\Valinor\Mapper\Object\Constructor::class)) {
+                    continue;
+                }
+
+                $paramNames = [];
+                $hasAllRequired = true;
+                $hasAtLeastOneParam = false;
+
+                foreach ($method->parameters as $parameter) {
+                    $paramNames[] = $parameter->name;
+                    if (array_key_exists($parameter->name, $parentValue)) {
+                        $hasAtLeastOneParam = true;
+                    }
+                    if (!$parameter->isOptional && !array_key_exists($parameter->name, $parentValue)) {
+                        $hasAllRequired = false;
+                    }
+                }
+
+                if ($hasAllRequired && $hasAtLeastOneParam) {
+                    // Extract only the keys needed for this nested object
+                    $nestedValue = [];
+                    foreach ($paramNames as $paramName) {
+                        if (array_key_exists($paramName, $parentValue)) {
+                            $nestedValue[$paramName] = $parentValue[$paramName];
+                        }
+                    }
+
+                    return [
+                        'value' => $nestedValue,
+                        'consumed_keys' => array_values(array_diff($paramNames, [$key]))
+                    ];
+                }
+            }
+        } catch (Throwable) {
+            return ['value' => $parentValue[$key], 'consumed_keys' => []];
+        }
+
+        return ['value' => $parentValue[$key], 'consumed_keys' => []];
+    }
 }