anchor.diff:  * `ProcessInjectionTarget` and `ProcessProducer`
   * `ProcessInjectionPoint`
   * `ProcessBeanAttributes`
  -* `ProcessBean`, `ProcessManagedBean`, `ProcessSessionBean`,
  -`ProcessProducerMethod` and `ProcessProducerField`
  -* `ProcessObserverMethod`
  +* `ProcessBean`, `ProcessManagedBean`, `ProcessSessionBean`, `ProcessProducerMethod`, `ProcessProducerField` and `ProcessSyntheticBean`
  +* `ProcessObserverMethod` and `ProcessSyntheticObserverMethod`
   * `AfterBeanDiscovery`
   * `AfterDeploymentValidation`
   
  
positive.code: 
  public class SecurityManagerExtension implements Extension {
  
      void afterBeanDiscovery(@Observes AfterBeanDiscovery abd, BeanManager bm) {
  
          //use this to read annotations of the class
          AnnotatedType<SecurityManager> at = bm.createAnnotatedType(SecurityManager.class);
  
          //use this to instantiate the class and inject dependencies
          final InjectionTarget<SecurityManager> it = bm.createInjectionTarget(at);
  
          abd.addBean( new Bean<SecurityManager>() {
  
              @Override
              public Class<?> getBeanClass() {
                  return SecurityManager.class;
              }
  
              @Override
              public Set<InjectionPoint> getInjectionPoints() {
                  return it.getInjectionPoints();
              }
  
              @Override
              public String getName() {
                  return "securityManager";
              }
  
              @Override
              public Set<Annotation> getQualifiers() {
                  Set<Annotation> qualifiers = new HashSet<Annotation>();
                  qualifiers.add( new AnnotationLiteral<Default>() {} );
                  qualifiers.add( new AnnotationLiteral<Any>() {} );
                  return qualifiers;
              }
  
              @Override
              public Class<? extends Annotation> getScope() {
                  return ApplicationScoped.class;
              }
  
              @Override
              public Set<Class<? extends Annotation>> getStereotypes() {
                  return Collections.emptySet();
              }
  
              @Override
              public Set<Type> getTypes() {
                  Set<Type> types = new HashSet<Type>();
                  types.add(SecurityManager.class);
                  types.add(Object.class);
                  return types;
              }
  
              @Override
              public boolean isAlternative() {
                  return false;
              }
  
              @Override
              public boolean isNullable() {
                  return false;
              }
  
              @Override
              public SecurityManager create(CreationalContext<SecurityManager> ctx) {
                  SecurityManager instance = it.produce(ctx);
                  it.inject(instance, ctx);
                  it.postConstruct(instance);
                  return instance;
              }
  
              @Override
              public void destroy(SecurityManager instance,
                                  CreationalContext<SecurityManager> ctx) {
                  it.preDestroy(instance);
                  it.dispose(instance);
                  ctx.release();
              }
  
          } );
      }
  
  }
  -------------------------------------------------------------------------------------------
  
  But a portable extension can also mess with beans that are discovered
  automatically by the container.
  
  === Wrapping an `AnnotatedType`
  
  One of the most interesting things that an extension class can do is
  process the annotations of a bean class _before_ the container builds
  
negative.code: Let's start with an example of an extension that provides support for
  the use of `@Named` at the package level. The package-level name is used
  to qualify the EL names of all beans defined in that package. The
  portable extension uses the `ProcessAnnotatedType` event to configure the
  `AnnotatedType` object and override the `value()` of the `@Named`
  annotation.
  
  