Undefined array key "compound" on liform->transform($form)

[OliverOlesen]

Been trying for the longest time to solve this without any luck, so I'm writing this here as a last stand.

The following is one of the first controllers I've made, which is where i would be using Liform

class CreateController extends AbstractController
{

    public function __construct(private readonly CategoryProjector $categoryProjector, private readonly Liform $liform)
    {
    }

    #[Route('/api/management/categories/create', name: 'management.categories.create', methods:['get', 'post'])]
    public function __invoke(Request $request, EntityManagerInterface $entityManager): Response
    {
        $categoryModel = new CategoryModel();

        $form = $this->createForm(CategoryCreateType::class, $categoryModel, );

       if ($form->isSubmitted() && $form->isValid()) {
           $event = new CategoryCreated($categoryModel);
           $this->categoryProjector->ApplyCategoryCreated($event);
           return new Response(Response::HTTP_OK);
       }

        if ($request->isMethod('GET')) {
            return new Response(json_encode($this->liform->transform($form)));
        }

        return new Response(Response::HTTP_BAD_REQUEST);
    }
}

But no matter what i try, it always comes back to the same error Undefined array key "compound" when i use $liform->transform.

I then went to the line where the issue happened and for some reason the types are not what I at least expected them to be.
So just for context, this is the function in resolver where it breaks. specifically here 'transformer' => $this->transformers['compound']['transformer'], which when looking at what it receives makes sense, if it's supposed to be an array of the different types anyway.

public function resolve(FormInterface $form)
    {
        $types = FormUtil::typeAncestry($form);

        foreach ($types as $type) {
            if (isset($this->transformers[$type])) {
                return $this->transformers[$type];
            }
        }

        // Perhaps a compound we don't have a specific transformer for
        if (FormUtil::isCompound($form)) {
            return [
                'transformer' => $this->transformers['compound']['transformer'],
                'widget' => null,
            ];
        }

        throw new TransformerException(
            sprintf(
                'Could not find a transformer for any of these types (%s)',
                implode(', ', $types)
            )
        );
    }

for further context, this is the Form which i am trying to transform.

class CategoryCreateType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
            $builder
                ->add('type', TextType::class, [
                    'required' => false,
                    'attr' => [
                        'placeholder' => 'Category Type',
                    ]
                ]);
            $builder
                ->add('name', TextType::class, [
                    'required' => true,
                ]);
            $builder
                ->add('description', TextType::class, [
                    'required' => false,
                ]);
            $builder
                ->add('image', FileType::class, [
                    'required' => true,
                ]);
    }
}

But for some reason in Resolver.php, the $types array gets the following, instead of the actual types in the form.
[0]: 'category_create',
[1]: 'form'

If i am lucky enough to have anyone read this that might have an idea as to what could be the issue, please let me know, i am utterly lost.

[tacman]

I forget when the ?? (null coalese) operator was introduced, but a simple fix would be

 $this->transformers['compound']['transformer']??null

[tacman]

I've tracked this down to the transformers not being loaded during the compiler pass. I haven't solved it, and when I try to replicate the problem is a small and concise test it, it works. I hope to find it though, it's maddening.

I'll also update the documentation at that time.