recursive if then structure failing

[dagda1]

I have created this stackblitz which has a failing test to show the problem.

I have this schema which has this schema

import { z } from 'zod';

const parameterTypes = z.union([
  z.literal('string'),
  z.literal('number'),
  z.literal('boolean'),
  z.literal('array'),
]);

const parameterFormat = z.union([
  z.literal('password'),
]);

export const parameterTypeSchema = z.object({
  title: z.string().optional(),
  description: z.string().optional().nullable(),
  required: z.boolean().optional(),
  type: parameterTypes,
  format: parameterFormat.optional(),
  minLength: z.coerce.number().optional(),
  maxLength: z.coerce.number().optional(),
  default: z.any().optional(),
  field: z.string().optional(),
  disabled: z.boolean().default(false).optional(),
  enum: z.array(z.string()).optional(),
  valueProviderName: z.string().optional(),
});

export type ConditionalParameter = {
  if: Record<string, string | number | boolean>;
  else?:
    | Record<string, z.infer<typeof parameterTypeSchema>>
    | { allOf: ConditionalParameter[] };
  then:
    | Record<string, z.infer<typeof parameterTypeSchema>>
    | { allOf: ConditionalParameter[] };
};

const baseConditionalParameterSchema = z.object({
  if: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])),
  then: z.lazy(() =>
    z.union([
      z.record(z.string(), parameterTypeSchema),
      z.object({ allOf: z.array(conditionalParameterSchema) }),
    ])
  ),
});

export const conditionalParameterSchema: z.ZodType<
  ConditionalParameter,
  z.ZodTypeDef
> = z.lazy(() => baseConditionalParameterSchema);

export const conditionalParameters = z.object({
  allOf: z.array(conditionalParameterSchema),
});

export type ConditionalParameterSchema = z.infer<
  typeof conditionalParameterSchema
>;

export type Parameter = z.infer<typeof parameterTypeSchema>;

Given an object like this:

{
    const cps: ConditionalParameterSchema = {
      allOf: [
        {
          if: {
            requester_if_need_affiliate: 'true',
          },
          then: {
            requester_affiliates: {
              format: 'select',
              description: null,
              disabled: false,
              type: 'string',
              title: 'Please specify Affiliates',
              required: true,
              enum: [
                'Partner Solutions Inc',
                'Cime',
                'Royal Sun Alliance',
                'Intact Public Entities',
                'Coast',
                'Intact Specialty Lines',
                'On Side restoration',
                'Other',
              ],
            },
            allOf: [
              {
                if: {
                  requester_affiliates: 'Other',
                },
                then: {
                  requester_other_affiliate_company: {
                    format: 'text',
                    description: null,
                    disabled: false,
                    type: 'string',
                    title: "Please provide the other affiliate's company name",
                    required: true,
                  },
                },
              },
            ],
          },
        },
      ],
    };

It should maintain the original structure with the allOf fields at the same level but unfortunately, it appears to be parsing the allOf first and then making everything a child of allOf and outputs this which is a different structure than the input:

{
    allOf: [
      {
        if: { requester_if_need_affiliate: 'true' },
        then: {
          allOf: [
            {
              if: { requester_affiliates: 'Other' },
              then: {
                requester_other_affiliate_company: {
                  title: "Please provide the other affiliate's company name",
                  description: null,
                  required: true,
                  type: 'string',
                  format: 'text',
                  disabled: false
                }
              }
            }
          ]
        }
      }
    ]
  }

Can anyone spot what is wrong with my recursive schema?

const baseConditionalParameterSchema = z.object({
  if: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])),
  then: z.lazy(() =>
    z.union([
      z.record(z.string(), parameterTypeSchema),
      z.object({ allOf: z.array(conditionalParameterSchema) }),
    ])
  ),
});