refactor(api) : remove TypeMachine skeleton system, fix ModelType serialization

- Remove TypeMachine, TypeMachineComponentRequirement, TypeMachinePieceRequirement,
  TypeMachineProductRequirement entities and related repositories/state processor
- Replace MachineSkeletonController with MachineStructureController
- Link CustomField directly to Machine instead of TypeMachine
- Add migration to drop TypeMachine tables and migrate custom fields to machines
- Fix ModelType serialization: Annotation\Groups → Attribute\Groups (Symfony 8 compat)
  and add product:read, composant:read, piece:read groups for embedded category display
- Fix Profile: same Annotation → Attribute import
- Fix SearchFilter: partial → ipartial on Comment and Document
- Update frontend submodule (remove skeleton pages/components, simplify machine creation)

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

src/Controller/MachineCustomFieldsController.php

@@ -33,12 +33,7 @@ class MachineCustomFieldsController extends AbstractController
             return $this->json(['success' => false, 'error' => 'Machine not found.'], 404);
         }
 
-        $typeMachine = $machine->getTypeMachine();
-        if (!$typeMachine) {
-            return $this->json(['success' => true, 'machineId' => $machine->getId(), 'customFieldValues' => []]);
-        }
-
-        foreach ($typeMachine->getCustomFields() as $customField) {
+        foreach ($machine->getCustomFields() as $customField) {
             if (!$customField instanceof CustomField) {
                 continue;
             }

src/Controller/MachineStructureController.php

@@ -6,6 +6,7 @@ namespace App\Controller;
 
 use App\Entity\Composant;
 use App\Entity\CustomField;
+use App\Entity\CustomFieldValue;
 use App\Entity\Machine;
 use App\Entity\MachineComponentLink;
 use App\Entity\MachinePieceLink;
@@ -13,9 +14,6 @@ use App\Entity\MachineProductLink;
 use App\Entity\ModelType;
 use App\Entity\Piece;
 use App\Entity\Product;
-use App\Entity\TypeMachineComponentRequirement;
-use App\Entity\TypeMachinePieceRequirement;
-use App\Entity\TypeMachineProductRequirement;
 use App\Repository\ComposantRepository;
 use App\Repository\MachineComponentLinkRepository;
 use App\Repository\MachinePieceLinkRepository;
@@ -23,9 +21,6 @@ use App\Repository\MachineProductLinkRepository;
 use App\Repository\MachineRepository;
 use App\Repository\PieceRepository;
 use App\Repository\ProductRepository;
-use App\Repository\TypeMachineComponentRequirementRepository;
-use App\Repository\TypeMachinePieceRequirementRepository;
-use App\Repository\TypeMachineProductRequirementRepository;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\EntityManagerInterface;
 use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
@@ -34,7 +29,7 @@ use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\Routing\Attribute\Route;
 
 #[Route('/api/machines')]
-class MachineSkeletonController extends AbstractController
+class MachineStructureController extends AbstractController
 {
     public function __construct(
         private readonly EntityManagerInterface $entityManager,
@@ -45,13 +40,10 @@ class MachineSkeletonController extends AbstractController
         private readonly ComposantRepository $composantRepository,
         private readonly PieceRepository $pieceRepository,
         private readonly ProductRepository $productRepository,
-        private readonly TypeMachineComponentRequirementRepository $componentRequirementRepository,
-        private readonly TypeMachinePieceRequirementRepository $pieceRequirementRepository,
-        private readonly TypeMachineProductRequirementRepository $productRequirementRepository,
     ) {}
 
-    #[Route('/{id}/skeleton', name: 'machine_skeleton_get', methods: ['GET'])]
-    public function getSkeleton(string $id): JsonResponse
+    #[Route('/{id}/structure', name: 'machine_structure_get', methods: ['GET'])]
+    public function getStructure(string $id): JsonResponse
     {
         $this->denyAccessUnlessGranted('ROLE_VIEWER');
 
@@ -64,7 +56,7 @@ class MachineSkeletonController extends AbstractController
         $pieceLinks     = $this->machinePieceLinkRepository->findBy(['machine' => $machine]);
         $productLinks   = $this->machineProductLinkRepository->findBy(['machine' => $machine]);
 
-        return $this->json($this->normalizeMachineSkeletonResponse(
+        return $this->json($this->normalizeStructureResponse(
             $machine,
             $componentLinks,
             $pieceLinks,
@@ -72,8 +64,8 @@ class MachineSkeletonController extends AbstractController
         ));
     }
 
-    #[Route('/{id}/skeleton', name: 'machine_skeleton_update', methods: ['PATCH'])]
-    public function updateSkeleton(string $id, Request $request): JsonResponse
+    #[Route('/{id}/structure', name: 'machine_structure_update', methods: ['PATCH'])]
+    public function updateStructure(string $id, Request $request): JsonResponse
     {
         $this->denyAccessUnlessGranted('ROLE_GESTIONNAIRE');
 
@@ -108,7 +100,7 @@ class MachineSkeletonController extends AbstractController
 
         $this->entityManager->flush();
 
-        return $this->json($this->normalizeMachineSkeletonResponse(
+        return $this->json($this->normalizeStructureResponse(
             $machine,
             $componentLinks,
             $pieceLinks,
@@ -116,6 +108,194 @@ class MachineSkeletonController extends AbstractController
         ));
     }
 
+    #[Route('/{id}/clone', name: 'machine_clone', methods: ['POST'])]
+    public function cloneMachine(string $id, Request $request): JsonResponse
+    {
+        $this->denyAccessUnlessGranted('ROLE_GESTIONNAIRE');
+
+        $source = $this->machineRepository->find($id);
+        if (!$source instanceof Machine) {
+            return $this->json(['success' => false, 'error' => 'Machine source introuvable.'], 404);
+        }
+
+        $payload = json_decode($request->getContent(), true);
+        if (!is_array($payload) || empty($payload['name']) || empty($payload['siteId'])) {
+            return $this->json(['success' => false, 'error' => 'name et siteId sont requis.'], 400);
+        }
+
+        $site = $this->entityManager->getRepository(\App\Entity\Site::class)->find($payload['siteId']);
+        if (!$site) {
+            return $this->json(['success' => false, 'error' => 'Site introuvable.'], 404);
+        }
+
+        // Create new machine
+        $newMachine = new Machine();
+        $newMachine->setName($payload['name']);
+        $newMachine->setSite($site);
+        if (!empty($payload['reference'])) {
+            $newMachine->setReference($payload['reference']);
+        }
+        $newMachine->setPrix($source->getPrix());
+
+        // Copy constructeurs
+        foreach ($source->getConstructeurs() as $constructeur) {
+            $newMachine->getConstructeurs()->add($constructeur);
+        }
+
+        $this->entityManager->persist($newMachine);
+
+        // Copy custom fields and values
+        $this->cloneCustomFields($source, $newMachine);
+
+        // Copy component links (preserving hierarchy)
+        $componentLinkMap = $this->cloneComponentLinks($source, $newMachine);
+
+        // Copy piece links
+        $pieceLinkMap = $this->clonePieceLinks($source, $newMachine, $componentLinkMap);
+
+        // Copy product links
+        $this->cloneProductLinks($source, $newMachine, $componentLinkMap, $pieceLinkMap);
+
+        $this->entityManager->flush();
+
+        $componentLinks = $this->machineComponentLinkRepository->findBy(['machine' => $newMachine]);
+        $pieceLinks     = $this->machinePieceLinkRepository->findBy(['machine' => $newMachine]);
+        $productLinks   = $this->machineProductLinkRepository->findBy(['machine' => $newMachine]);
+
+        return $this->json($this->normalizeStructureResponse(
+            $newMachine,
+            $componentLinks,
+            $pieceLinks,
+            $productLinks
+        ), 201);
+    }
+
+    private function cloneCustomFields(Machine $source, Machine $target): void
+    {
+        foreach ($source->getCustomFields() as $cf) {
+            $newCf = new CustomField();
+            $newCf->setName($cf->getName());
+            $newCf->setType($cf->getType());
+            $newCf->setRequired($cf->isRequired());
+            $newCf->setDefaultValue($cf->getDefaultValue());
+            $newCf->setOptions($cf->getOptions());
+            $newCf->setOrderIndex($cf->getOrderIndex());
+            $newCf->setMachine($target);
+            $this->entityManager->persist($newCf);
+        }
+
+        foreach ($source->getCustomFieldValues() as $cfv) {
+            $newValue = new CustomFieldValue();
+            $newValue->setMachine($target);
+            $newValue->setCustomField($cfv->getCustomField());
+            $newValue->setValue($cfv->getValue());
+            $this->entityManager->persist($newValue);
+        }
+    }
+
+    /**
+     * @return array<string, MachineComponentLink> Map of old link ID → new link
+     */
+    private function cloneComponentLinks(Machine $source, Machine $target): array
+    {
+        $sourceLinks = $this->machineComponentLinkRepository->findBy(['machine' => $source]);
+        $linkMap     = [];
+
+        // First pass: create all links without parent relationships
+        foreach ($sourceLinks as $link) {
+            $newLink = new MachineComponentLink();
+            $newLink->setMachine($target);
+            $newLink->setComposant($link->getComposant());
+            $newLink->setNameOverride($link->getNameOverride());
+            $newLink->setReferenceOverride($link->getReferenceOverride());
+            $newLink->setPrixOverride($link->getPrixOverride());
+            $this->entityManager->persist($newLink);
+            $linkMap[$link->getId()] = $newLink;
+        }
+
+        // Second pass: set parent relationships
+        foreach ($sourceLinks as $link) {
+            $parent = $link->getParentLink();
+            if ($parent && isset($linkMap[$parent->getId()])) {
+                $linkMap[$link->getId()]->setParentLink($linkMap[$parent->getId()]);
+            }
+        }
+
+        return $linkMap;
+    }
+
+    /**
+     * @param array<string, MachineComponentLink> $componentLinkMap
+     *
+     * @return array<string, MachinePieceLink> Map of old link ID → new link
+     */
+    private function clonePieceLinks(Machine $source, Machine $target, array $componentLinkMap): array
+    {
+        $sourceLinks = $this->machinePieceLinkRepository->findBy(['machine' => $source]);
+        $linkMap     = [];
+
+        foreach ($sourceLinks as $link) {
+            $newLink = new MachinePieceLink();
+            $newLink->setMachine($target);
+            $newLink->setPiece($link->getPiece());
+            $newLink->setNameOverride($link->getNameOverride());
+            $newLink->setReferenceOverride($link->getReferenceOverride());
+            $newLink->setPrixOverride($link->getPrixOverride());
+
+            $parent = $link->getParentLink();
+            if ($parent && isset($componentLinkMap[$parent->getId()])) {
+                $newLink->setParentLink($componentLinkMap[$parent->getId()]);
+            }
+
+            $this->entityManager->persist($newLink);
+            $linkMap[$link->getId()] = $newLink;
+        }
+
+        return $linkMap;
+    }
+
+    /**
+     * @param array<string, MachineComponentLink> $componentLinkMap
+     * @param array<string, MachinePieceLink>     $pieceLinkMap
+     */
+    private function cloneProductLinks(
+        Machine $source,
+        Machine $target,
+        array $componentLinkMap,
+        array $pieceLinkMap,
+    ): void {
+        $sourceLinks = $this->machineProductLinkRepository->findBy(['machine' => $source]);
+        $linkMap     = [];
+
+        // First pass: create all links
+        foreach ($sourceLinks as $link) {
+            $newLink = new MachineProductLink();
+            $newLink->setMachine($target);
+            $newLink->setProduct($link->getProduct());
+
+            $parentComponent = $link->getParentComponentLink();
+            if ($parentComponent && isset($componentLinkMap[$parentComponent->getId()])) {
+                $newLink->setParentComponentLink($componentLinkMap[$parentComponent->getId()]);
+            }
+
+            $parentPiece = $link->getParentPieceLink();
+            if ($parentPiece && isset($pieceLinkMap[$parentPiece->getId()])) {
+                $newLink->setParentPieceLink($pieceLinkMap[$parentPiece->getId()]);
+            }
+
+            $this->entityManager->persist($newLink);
+            $linkMap[$link->getId()] = $newLink;
+        }
+
+        // Second pass: set parent product link relationships
+        foreach ($sourceLinks as $link) {
+            $parent = $link->getParentLink();
+            if ($parent && isset($linkMap[$parent->getId()])) {
+                $linkMap[$link->getId()]->setParentLink($linkMap[$parent->getId()]);
+            }
+        }
+    }
+
     private function normalizePayloadList(mixed $value): array
     {
         if (!is_array($value)) {
@@ -144,7 +324,7 @@ class MachineSkeletonController extends AbstractController
 
             $composantId = $this->resolveIdentifier($entry, ['composantId', 'componentId', 'idComposant']);
             if (!$composantId) {
-                return $this->json(['success' => false, 'error' => 'Composant requis pour le squelette.'], 400);
+                return $this->json(['success' => false, 'error' => 'Composant requis.'], 400);
             }
             $composant = $this->composantRepository->find($composantId);
             if (!$composant instanceof Composant) {
@@ -154,14 +334,6 @@ class MachineSkeletonController extends AbstractController
             $link->setMachine($machine);
             $link->setComposant($composant);
 
-            $requirementId = $this->resolveIdentifier($entry, ['requirementId', 'typeMachineComponentRequirementId']);
-            if ($requirementId) {
-                $requirement = $this->componentRequirementRepository->find($requirementId);
-                if ($requirement instanceof TypeMachineComponentRequirement) {
-                    $link->setTypeMachineComponentRequirement($requirement);
-                }
-            }
-
             $this->applyOverrides($link, $entry['overrides'] ?? null);
 
             $pendingParents[$linkId] = $this->resolveIdentifier($entry, [
@@ -176,10 +348,7 @@ class MachineSkeletonController extends AbstractController
         }
 
         foreach ($pendingParents as $linkId => $parentId) {
-            if (!$parentId) {
-                continue;
-            }
-            if (!isset($links[$linkId])) {
+            if (!$parentId || !isset($links[$linkId])) {
                 continue;
             }
             $parent = $links[$parentId] ?? $existing[$parentId] ?? null;
@@ -213,7 +382,7 @@ class MachineSkeletonController extends AbstractController
 
             $pieceId = $this->resolveIdentifier($entry, ['pieceId']);
             if (!$pieceId) {
-                return $this->json(['success' => false, 'error' => 'Pièce requise pour le squelette.'], 400);
+                return $this->json(['success' => false, 'error' => 'Pièce requise.'], 400);
             }
             $piece = $this->pieceRepository->find($pieceId);
             if (!$piece instanceof Piece) {
@@ -223,14 +392,6 @@ class MachineSkeletonController extends AbstractController
             $link->setMachine($machine);
             $link->setPiece($piece);
 
-            $requirementId = $this->resolveIdentifier($entry, ['requirementId', 'typeMachinePieceRequirementId']);
-            if ($requirementId) {
-                $requirement = $this->pieceRequirementRepository->find($requirementId);
-                if ($requirement instanceof TypeMachinePieceRequirement) {
-                    $link->setTypeMachinePieceRequirement($requirement);
-                }
-            }
-
             $this->applyOverrides($link, $entry['overrides'] ?? null);
 
             $pendingParents[$linkId] = $this->resolveIdentifier($entry, [
@@ -245,10 +406,7 @@ class MachineSkeletonController extends AbstractController
         }
 
         foreach ($pendingParents as $linkId => $parentId) {
-            if (!$parentId) {
-                continue;
-            }
-            if (!isset($links[$linkId])) {
+            if (!$parentId || !isset($links[$linkId])) {
                 continue;
             }
             $parent = $componentIndex[$parentId] ?? null;
@@ -287,7 +445,7 @@ class MachineSkeletonController extends AbstractController
 
             $productId = $this->resolveIdentifier($entry, ['productId']);
             if (!$productId) {
-                return $this->json(['success' => false, 'error' => 'Produit requis pour le squelette.'], 400);
+                return $this->json(['success' => false, 'error' => 'Produit requis.'], 400);
             }
             $product = $this->productRepository->find($productId);
             if (!$product instanceof Product) {
@@ -297,14 +455,6 @@ class MachineSkeletonController extends AbstractController
             $link->setMachine($machine);
             $link->setProduct($product);
 
-            $requirementId = $this->resolveIdentifier($entry, ['requirementId', 'typeMachineProductRequirementId']);
-            if ($requirementId) {
-                $requirement = $this->productRequirementRepository->find($requirementId);
-                if ($requirement instanceof TypeMachineProductRequirement) {
-                    $link->setTypeMachineProductRequirement($requirement);
-                }
-            }
-
             $pendingParents[$linkId] = [
                 'parentComponentLinkId' => $this->resolveIdentifier($entry, ['parentComponentLinkId']),
                 'parentPieceLinkId'     => $this->resolveIdentifier($entry, ['parentPieceLinkId']),
@@ -336,7 +486,7 @@ class MachineSkeletonController extends AbstractController
         return array_values($links);
     }
 
-    private function normalizeMachineSkeletonResponse(
+    private function normalizeStructureResponse(
         Machine $machine,
         array $componentLinks,
         array $pieceLinks,
@@ -346,7 +496,6 @@ class MachineSkeletonController extends AbstractController
         $componentIndex           = $this->indexNormalizedLinks($normalizedComponentLinks);
         $normalizedPieceLinks     = $this->normalizePieceLinks($pieceLinks);
 
-        // Build component hierarchy – track which IDs are children
         $childIds = [];
         foreach ($normalizedComponentLinks as $link) {
             $parentId = $link['parentComponentLinkId'] ?? null;
@@ -356,10 +505,8 @@ class MachineSkeletonController extends AbstractController
             }
         }
 
-        // Add pieces to components recursively
         $this->attachPiecesToComponents($componentIndex, $normalizedPieceLinks);
 
-        // Only return root-level components (exclude children already nested)
         $rootComponents = array_filter(
             $componentIndex,
             static fn (array $link) => !isset($childIds[$link['id']]),
@@ -382,7 +529,6 @@ class MachineSkeletonController extends AbstractController
             }
         }
 
-        // Recursively attach to child components
         foreach ($componentIndex as &$component) {
             if (!empty($component['childLinks'])) {
                 $this->attachPiecesToChildComponents($component['childLinks'], $pieceLinks);
@@ -403,7 +549,6 @@ class MachineSkeletonController extends AbstractController
                 }
             }
 
-            // Recursively process nested children
             if (!empty($child['childLinks'])) {
                 $this->attachPiecesToChildComponents($child['childLinks'], $pieceLinks);
             }
@@ -412,8 +557,7 @@ class MachineSkeletonController extends AbstractController
 
     private function normalizeMachine(Machine $machine): array
     {
-        $site        = $machine->getSite();
-        $typeMachine = $machine->getTypeMachine();
+        $site = $machine->getSite();
 
         return [
             'id'        => $machine->getId(),
@@ -425,24 +569,8 @@ class MachineSkeletonController extends AbstractController
                 'id'   => $site->getId(),
                 'name' => $site->getName(),
             ],
-            'typeMachineId' => $typeMachine?->getId(),
-            'typeMachine'   => $typeMachine ? [
-                'id'                    => $typeMachine->getId(),
-                'name'                  => $typeMachine->getName(),
-                'category'              => $typeMachine->getCategory(),
-                'description'           => $typeMachine->getDescription(),
-                'customFields'          => $this->normalizeCustomFields($typeMachine->getCustomFields()),
-                'componentRequirements' => $typeMachine->getComponentRequirements()
-                    ->map(fn (TypeMachineComponentRequirement $req) => $this->normalizeComponentRequirement($req))
-                    ->toArray(),
-                'pieceRequirements' => $typeMachine->getPieceRequirements()
-                    ->map(fn (TypeMachinePieceRequirement $req) => $this->normalizePieceRequirement($req))
-                    ->toArray(),
-                'productRequirements' => $typeMachine->getProductRequirements()
-                    ->map(fn (TypeMachineProductRequirement $req) => $this->normalizeProductRequirement($req))
-                    ->toArray(),
-            ] : null,
             'constructeurs'     => $this->normalizeConstructeurs($machine->getConstructeurs()),
+            'customFields'      => $this->normalizeCustomFields($machine->getCustomFields()),
             'documents'         => null,
             'customFieldValues' => null,
         ];
@@ -472,26 +600,21 @@ class MachineSkeletonController extends AbstractController
     private function normalizeComponentLinks(array $links): array
     {
         return array_map(function (MachineComponentLink $link): array {
-            $composant           = $link->getComposant();
-            $requirement         = $link->getTypeMachineComponentRequirement();
-            $parentLink          = $link->getParentLink();
-            $parentRequirementId = $parentLink?->getTypeMachineComponentRequirement()?->getId();
+            $composant  = $link->getComposant();
+            $parentLink = $link->getParentLink();
 
             return [
-                'id'                                  => $link->getId(),
-                'linkId'                              => $link->getId(),
-                'machineId'                           => $link->getMachine()->getId(),
-                'composantId'                         => $composant->getId(),
-                'composant'                           => $this->normalizeComposant($composant),
-                'typeMachineComponentRequirementId'   => $requirement?->getId(),
-                'typeMachineComponentRequirement'     => $requirement ? $this->normalizeComponentRequirement($requirement) : null,
-                'parentLinkId'                        => $parentLink?->getId(),
-                'parentComponentLinkId'               => $parentLink?->getId(),
-                'parentComponentId'                   => $parentLink?->getComposant()->getId(),
-                'parentMachineComponentRequirementId' => $parentRequirementId,
-                'overrides'                           => $this->normalizeOverrides($link),
-                'childLinks'                          => [],
-                'pieceLinks'                          => [],
+                'id'                    => $link->getId(),
+                'linkId'                => $link->getId(),
+                'machineId'             => $link->getMachine()->getId(),
+                'composantId'           => $composant->getId(),
+                'composant'             => $this->normalizeComposant($composant),
+                'parentLinkId'          => $parentLink?->getId(),
+                'parentComponentLinkId' => $parentLink?->getId(),
+                'parentComponentId'     => $parentLink?->getComposant()->getId(),
+                'overrides'             => $this->normalizeOverrides($link),
+                'childLinks'            => [],
+                'pieceLinks'            => [],
             ];
         }, $links);
     }
@@ -499,24 +622,19 @@ class MachineSkeletonController extends AbstractController
     private function normalizePieceLinks(array $links): array
     {
         return array_map(function (MachinePieceLink $link): array {
-            $piece               = $link->getPiece();
-            $requirement         = $link->getTypeMachinePieceRequirement();
-            $parentLink          = $link->getParentLink();
-            $parentRequirementId = $parentLink?->getTypeMachineComponentRequirement()?->getId();
+            $piece      = $link->getPiece();
+            $parentLink = $link->getParentLink();
 
             return [
-                'id'                                  => $link->getId(),
-                'linkId'                              => $link->getId(),
-                'machineId'                           => $link->getMachine()->getId(),
-                'pieceId'                             => $piece->getId(),
-                'piece'                               => $this->normalizePiece($piece),
-                'typeMachinePieceRequirementId'       => $requirement?->getId(),
-                'typeMachinePieceRequirement'         => $requirement ? $this->normalizePieceRequirement($requirement) : null,
-                'parentLinkId'                        => $parentLink?->getId(),
-                'parentComponentLinkId'               => $parentLink?->getId(),
-                'parentComponentId'                   => $parentLink?->getComposant()->getId(),
-                'parentMachineComponentRequirementId' => $parentRequirementId,
-                'overrides'                           => $this->normalizeOverrides($link),
+                'id'                    => $link->getId(),
+                'linkId'                => $link->getId(),
+                'machineId'             => $link->getMachine()->getId(),
+                'pieceId'               => $piece->getId(),
+                'piece'                 => $this->normalizePiece($piece),
+                'parentLinkId'          => $parentLink?->getId(),
+                'parentComponentLinkId' => $parentLink?->getId(),
+                'parentComponentId'     => $parentLink?->getComposant()->getId(),
+                'overrides'             => $this->normalizeOverrides($link),
             ];
         }, $links);
     }
@@ -524,55 +642,58 @@ class MachineSkeletonController extends AbstractController
     private function normalizeProductLinks(array $links): array
     {
         return array_map(function (MachineProductLink $link): array {
-            $product     = $link->getProduct();
-            $requirement = $link->getTypeMachineProductRequirement();
+            $product = $link->getProduct();
 
             return [
-                'id'                              => $link->getId(),
-                'linkId'                          => $link->getId(),
-                'machineId'                       => $link->getMachine()->getId(),
-                'productId'                       => $product->getId(),
-                'product'                         => $this->normalizeProduct($product),
-                'typeMachineProductRequirementId' => $requirement?->getId(),
-                'typeMachineProductRequirement'   => $requirement ? $this->normalizeProductRequirement($requirement) : null,
-                'parentLinkId'                    => $link->getParentLink()?->getId(),
-                'parentComponentLinkId'           => $link->getParentComponentLink()?->getId(),
-                'parentPieceLinkId'               => $link->getParentPieceLink()?->getId(),
+                'id'                    => $link->getId(),
+                'linkId'                => $link->getId(),
+                'machineId'             => $link->getMachine()->getId(),
+                'productId'             => $product->getId(),
+                'product'               => $this->normalizeProduct($product),
+                'parentLinkId'          => $link->getParentLink()?->getId(),
+                'parentComponentLinkId' => $link->getParentComponentLink()?->getId(),
+                'parentPieceLinkId'     => $link->getParentPieceLink()?->getId(),
             ];
         }, $links);
     }
 
     private function normalizeComposant(Composant $composant): array
     {
+        $type = $composant->getTypeComposant();
+
         return [
-            'id'              => $composant->getId(),
-            'name'            => $composant->getName(),
-            'reference'       => $composant->getReference(),
-            'prix'            => $composant->getPrix(),
-            'typeComposantId' => $composant->getTypeComposant()?->getId(),
-            'typeComposant'   => $this->normalizeModelType($composant->getTypeComposant()),
-            'productId'       => $composant->getProduct()?->getId(),
-            'product'         => $composant->getProduct() ? $this->normalizeProduct($composant->getProduct()) : null,
-            'constructeurs'   => $this->normalizeConstructeurs($composant->getConstructeurs()),
-            'documents'       => [],
-            'customFields'    => [],
+            'id'                => $composant->getId(),
+            'name'              => $composant->getName(),
+            'reference'         => $composant->getReference(),
+            'prix'              => $composant->getPrix(),
+            'typeComposantId'   => $type?->getId(),
+            'typeComposant'     => $this->normalizeModelType($type),
+            'productId'         => $composant->getProduct()?->getId(),
+            'product'           => $composant->getProduct() ? $this->normalizeProduct($composant->getProduct()) : null,
+            'constructeurs'     => $this->normalizeConstructeurs($composant->getConstructeurs()),
+            'documents'         => [],
+            'customFields'      => $type ? $this->normalizeCustomFieldDefinitions($type->getComponentCustomFields()) : [],
+            'customFieldValues' => $this->normalizeCustomFieldValues($composant->getCustomFieldValues()),
         ];
     }
 
     private function normalizePiece(Piece $piece): array
     {
+        $type = $piece->getTypePiece();
+
         return [
-            'id'            => $piece->getId(),
-            'name'          => $piece->getName(),
-            'reference'     => $piece->getReference(),
-            'prix'          => $piece->getPrix(),
-            'typePieceId'   => $piece->getTypePiece()?->getId(),
-            'typePiece'     => $this->normalizeModelType($piece->getTypePiece()),
-            'productId'     => $piece->getProduct()?->getId(),
-            'product'       => $piece->getProduct() ? $this->normalizeProduct($piece->getProduct()) : null,
-            'constructeurs' => $this->normalizeConstructeurs($piece->getConstructeurs()),
-            'documents'     => [],
-            'customFields'  => [],
+            'id'                => $piece->getId(),
+            'name'              => $piece->getName(),
+            'reference'         => $piece->getReference(),
+            'prix'              => $piece->getPrix(),
+            'typePieceId'       => $type?->getId(),
+            'typePiece'         => $this->normalizeModelType($type),
+            'productId'         => $piece->getProduct()?->getId(),
+            'product'           => $piece->getProduct() ? $this->normalizeProduct($piece->getProduct()) : null,
+            'constructeurs'     => $this->normalizeConstructeurs($piece->getConstructeurs()),
+            'documents'         => [],
+            'customFields'      => $type ? $this->normalizeCustomFieldDefinitions($type->getPieceCustomFields()) : [],
+            'customFieldValues' => $this->normalizeCustomFieldValues($piece->getCustomFieldValues()),
         ];
     }
 
@@ -598,49 +719,11 @@ class MachineSkeletonController extends AbstractController
         }
 
         return [
-            'id'       => $type->getId(),
-            'name'     => $type->getName(),
-            'code'     => $type->getCode(),
-            'category' => $type->getCategory()->value,
-        ];
-    }
-
-    private function normalizeComponentRequirement(TypeMachineComponentRequirement $requirement): array
-    {
-        return [
-            'id'              => $requirement->getId(),
-            'label'           => $requirement->getLabel(),
-            'minCount'        => $requirement->getMinCount(),
-            'maxCount'        => $requirement->getMaxCount(),
-            'required'        => $requirement->isRequired(),
-            'typeComposantId' => $requirement->getTypeComposant()->getId(),
-            'typeComposant'   => $this->normalizeModelType($requirement->getTypeComposant()),
-        ];
-    }
-
-    private function normalizePieceRequirement(TypeMachinePieceRequirement $requirement): array
-    {
-        return [
-            'id'          => $requirement->getId(),
-            'label'       => $requirement->getLabel(),
-            'minCount'    => $requirement->getMinCount(),
-            'maxCount'    => $requirement->getMaxCount(),
-            'required'    => $requirement->isRequired(),
-            'typePieceId' => $requirement->getTypePiece()->getId(),
-            'typePiece'   => $this->normalizeModelType($requirement->getTypePiece()),
-        ];
-    }
-
-    private function normalizeProductRequirement(TypeMachineProductRequirement $requirement): array
-    {
-        return [
-            'id'            => $requirement->getId(),
-            'label'         => $requirement->getLabel(),
-            'minCount'      => $requirement->getMinCount(),
-            'maxCount'      => $requirement->getMaxCount(),
-            'required'      => $requirement->isRequired(),
-            'typeProductId' => $requirement->getTypeProduct()->getId(),
-            'typeProduct'   => $this->normalizeModelType($requirement->getTypeProduct()),
+            'id'        => $type->getId(),
+            'name'      => $type->getName(),
+            'code'      => $type->getCode(),
+            'category'  => $type->getCategory()->value,
+            'structure' => $type->getStructure(),
         ];
     }
 
@@ -659,6 +742,55 @@ class MachineSkeletonController extends AbstractController
         return $items;
     }
 
+    private function normalizeCustomFieldDefinitions(Collection $customFields): array
+    {
+        $items = [];
+        foreach ($customFields as $cf) {
+            if (!$cf instanceof CustomField) {
+                continue;
+            }
+            $items[] = [
+                'id'           => $cf->getId(),
+                'name'         => $cf->getName(),
+                'type'         => $cf->getType(),
+                'required'     => $cf->isRequired(),
+                'options'      => $cf->getOptions(),
+                'defaultValue' => $cf->getDefaultValue(),
+                'orderIndex'   => $cf->getOrderIndex(),
+            ];
+        }
+
+        usort($items, static fn (array $a, array $b) => $a['orderIndex'] <=> $b['orderIndex']);
+
+        return $items;
+    }
+
+    private function normalizeCustomFieldValues(Collection $customFieldValues): array
+    {
+        $items = [];
+        foreach ($customFieldValues as $cfv) {
+            if (!$cfv instanceof CustomFieldValue) {
+                continue;
+            }
+            $cf = $cfv->getCustomField();
+            $items[] = [
+                'id'          => $cfv->getId(),
+                'value'       => $cfv->getValue(),
+                'customField' => [
+                    'id'           => $cf->getId(),
+                    'name'         => $cf->getName(),
+                    'type'         => $cf->getType(),
+                    'required'     => $cf->isRequired(),
+                    'options'      => $cf->getOptions(),
+                    'defaultValue' => $cf->getDefaultValue(),
+                    'orderIndex'   => $cf->getOrderIndex(),
+                ],
+            ];
+        }
+
+        return $items;
+    }
+
     private function normalizeOverrides(object $link): ?array
     {
         $name      = method_exists($link, 'getNameOverride') ? $link->getNameOverride() : null;